1 /* Generic static probe support for GDB.
3 Copyright (C) 2012 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"
29 #include "exceptions.h"
31 #include "gdb_regex.h"
33 #include "arch-utils.h"
38 /* See definition in probe.h. */
40 struct symtabs_and_lines
41 parse_probes (char **argptr, struct linespec_result *canonical)
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;
58 probe_ops = probe_linespec_to_ops (&cs);
59 gdb_assert (probe_ops != NULL);
62 arg = skip_spaces (arg);
64 error (_("argument to `%s' missing"), arg_start);
66 arg_end = skip_to_space (arg);
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);
72 /* Extract each word from the argument, separated by ":"s. */
73 p = strchr (arg, ':');
76 /* This is `-p name'. */
84 p = strchr (hold, ':');
87 /* This is `-p provider:name'. */
93 /* This is `-p objfile:provider:name'. */
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"));
109 ALL_PSPACE_OBJFILES (pspace, objfile)
111 VEC (probe_p) *probes;
115 if (!objfile->sf || !objfile->sf->sym_probe_fns)
119 && FILENAME_CMP (objfile->name, objfile_name) != 0
120 && FILENAME_CMP (lbasename (objfile->name), objfile_name) != 0)
123 if (objfile->separate_debug_objfile_backlink != NULL)
126 probes = objfile->sf->sym_probe_fns->sym_get_probes (objfile);
128 for (ix = 0; VEC_iterate (probe_p, probes, ix, probe); ix++)
130 struct symtab_and_line *sal;
132 if (probe_ops != &probe_ops_any && probe->pops != probe_ops)
135 if (provider && strcmp (probe->provider, provider) != 0)
138 if (strcmp (probe->name, name) != 0)
142 result.sals = xrealloc (result.sals,
144 * sizeof (struct symtab_and_line));
145 sal = &result.sals[result.nelts - 1];
149 sal->pc = probe->address;
150 sal->explicit_pc = 1;
151 sal->section = find_pc_overlay (sal->pc);
152 sal->pspace = pspace;
157 if (result.nelts == 0)
159 throw_error (NOT_FOUND_ERROR,
160 _("No probe matching objfile=`%s', provider=`%s', name=`%s'"),
161 objfile_name ? objfile_name : _("<any>"),
162 provider ? provider : _("<any>"),
168 canonical->special_display = 1;
169 canonical->pre_expanded = 1;
170 canonical->addr_string = savestring (*argptr, arg_end - *argptr);
174 do_cleanups (cleanup);
179 /* See definition in probe.h. */
182 find_probes_in_objfile (struct objfile *objfile, const char *provider,
185 VEC (probe_p) *probes, *result = NULL;
189 if (!objfile->sf || !objfile->sf->sym_probe_fns)
192 probes = objfile->sf->sym_probe_fns->sym_get_probes (objfile);
193 for (ix = 0; VEC_iterate (probe_p, probes, ix, probe); ix++)
195 if (strcmp (probe->provider, provider) != 0)
198 if (strcmp (probe->name, name) != 0)
201 VEC_safe_push (probe_p, result, probe);
207 /* See definition in probe.h. */
210 find_probe_by_pc (CORE_ADDR pc, struct objfile **objfile_out)
212 struct objfile *objfile;
214 ALL_OBJFILES (objfile)
216 VEC (probe_p) *probes;
220 if (!objfile->sf || !objfile->sf->sym_probe_fns)
223 /* If this proves too inefficient, we can replace with a hash. */
224 probes = objfile->sf->sym_probe_fns->sym_get_probes (objfile);
225 for (ix = 0; VEC_iterate (probe_p, probes, ix, probe); ix++)
226 if (probe->address == pc)
228 *objfile_out = objfile;
238 /* A utility structure. A VEC of these is built when handling "info
241 struct probe_and_objfile
246 /* The probe's objfile. */
247 struct objfile *objfile;
250 typedef struct probe_and_objfile probe_and_objfile_s;
251 DEF_VEC_O (probe_and_objfile_s);
253 /* A helper function for collect_probes that compiles a regexp and
254 throws an exception on error. This installs a cleanup to free the
255 resulting pattern on success. If RX is NULL, this does nothing. */
258 compile_rx_or_error (regex_t *pattern, const char *rx, const char *message)
265 code = regcomp (pattern, rx, REG_NOSUB);
267 make_regfree_cleanup (pattern);
270 char *err = get_regcomp_error (code, pattern);
272 make_cleanup (xfree, err);
273 error ("%s: %s", message, err);
277 /* Make a vector of probes matching OBJNAME, PROVIDER, and PROBE_NAME.
278 If POPS is not NULL, only probes of this certain probe_ops will match.
279 Each argument is a regexp, or NULL, which matches anything. */
281 static VEC (probe_and_objfile_s) *
282 collect_probes (char *objname, char *provider, char *probe_name,
283 const struct probe_ops *pops)
285 struct objfile *objfile;
286 VEC (probe_and_objfile_s) *result = NULL;
287 struct cleanup *cleanup, *cleanup_temps;
288 regex_t obj_pat, prov_pat, probe_pat;
290 cleanup = make_cleanup (VEC_cleanup (probe_and_objfile_s), &result);
292 cleanup_temps = make_cleanup (null_cleanup, NULL);
293 compile_rx_or_error (&prov_pat, provider, _("Invalid provider regexp"));
294 compile_rx_or_error (&probe_pat, probe_name, _("Invalid probe regexp"));
295 compile_rx_or_error (&obj_pat, objname, _("Invalid object file regexp"));
297 ALL_OBJFILES (objfile)
299 VEC (probe_p) *probes;
303 if (! objfile->sf || ! objfile->sf->sym_probe_fns)
308 if (regexec (&obj_pat, objfile->name, 0, NULL, 0) != 0)
312 probes = objfile->sf->sym_probe_fns->sym_get_probes (objfile);
314 for (ix = 0; VEC_iterate (probe_p, probes, ix, probe); ix++)
316 probe_and_objfile_s entry;
318 if (pops != NULL && probe->pops != pops)
322 && regexec (&prov_pat, probe->provider, 0, NULL, 0) != 0)
326 && regexec (&probe_pat, probe->name, 0, NULL, 0) != 0)
330 entry.objfile = objfile;
331 VEC_safe_push (probe_and_objfile_s, result, &entry);
335 do_cleanups (cleanup_temps);
336 discard_cleanups (cleanup);
340 /* A qsort comparison function for probe_and_objfile_s objects. */
343 compare_entries (const void *a, const void *b)
345 const probe_and_objfile_s *ea = a;
346 const probe_and_objfile_s *eb = b;
349 v = strcmp (ea->probe->provider, eb->probe->provider);
353 v = strcmp (ea->probe->name, eb->probe->name);
357 if (ea->probe->address < eb->probe->address)
359 if (ea->probe->address > eb->probe->address)
362 return strcmp (ea->objfile->name, eb->objfile->name);
365 /* Helper function that generate entries in the ui_out table being
366 crafted by `info_probes_for_ops'. */
369 gen_ui_out_table_header_info (VEC (probe_and_objfile_s) *probes,
370 const struct probe_ops *p)
372 /* `headings' refers to the names of the columns when printing `info
374 VEC (info_probe_column_s) *headings = NULL;
376 info_probe_column_s *column;
377 size_t headings_size;
380 gdb_assert (p != NULL);
382 if (p->gen_info_probes_table_header == NULL
383 && p->gen_info_probes_table_values == NULL)
386 gdb_assert (p->gen_info_probes_table_header != NULL
387 && p->gen_info_probes_table_values != NULL);
389 c = make_cleanup (VEC_cleanup (info_probe_column_s), &headings);
390 p->gen_info_probes_table_header (&headings);
392 headings_size = VEC_length (info_probe_column_s, headings);
395 VEC_iterate (info_probe_column_s, headings, ix, column);
398 probe_and_objfile_s *entry;
400 size_t size_max = strlen (column->print_name);
402 for (jx = 0; VEC_iterate (probe_and_objfile_s, probes, jx, entry); ++jx)
404 /* `probe_fields' refers to the values of each new field that this
405 probe will display. */
406 VEC (const_char_ptr) *probe_fields = NULL;
411 if (entry->probe->pops != p)
414 c2 = make_cleanup (VEC_cleanup (const_char_ptr), &probe_fields);
415 p->gen_info_probes_table_values (entry->probe, entry->objfile,
418 gdb_assert (VEC_length (const_char_ptr, probe_fields)
421 for (kx = 0; VEC_iterate (const_char_ptr, probe_fields, kx, val);
424 /* It is valid to have a NULL value here, which means that the
425 backend does not have something to write and this particular
426 field should be skipped. */
430 size_max = max (strlen (val), size_max);
435 ui_out_table_header (current_uiout, size_max, ui_left,
436 column->field_name, column->print_name);
442 /* Helper function to print extra information about a probe and an objfile
443 represented by ENTRY. */
446 print_ui_out_info (probe_and_objfile_s *entry)
450 /* `values' refers to the actual values of each new field in the output
451 of `info probe'. `headings' refers to the names of each new field. */
452 VEC (const_char_ptr) *values = NULL;
453 VEC (info_probe_column_s) *headings = NULL;
454 info_probe_column_s *column;
457 gdb_assert (entry != NULL);
458 gdb_assert (entry->probe != NULL);
459 gdb_assert (entry->probe->pops != NULL);
461 if (entry->probe->pops->gen_info_probes_table_header == NULL
462 && entry->probe->pops->gen_info_probes_table_values == NULL)
465 gdb_assert (entry->probe->pops->gen_info_probes_table_header != NULL
466 && entry->probe->pops->gen_info_probes_table_values != NULL);
468 c = make_cleanup (VEC_cleanup (info_probe_column_s), &headings);
469 make_cleanup (VEC_cleanup (const_char_ptr), &values);
471 entry->probe->pops->gen_info_probes_table_header (&headings);
472 entry->probe->pops->gen_info_probes_table_values (entry->probe,
473 entry->objfile, &values);
475 gdb_assert (VEC_length (info_probe_column_s, headings)
476 == VEC_length (const_char_ptr, values));
479 VEC_iterate (info_probe_column_s, headings, ix, column);
482 const char *val = VEC_index (const_char_ptr, values, j++);
485 ui_out_field_skip (current_uiout, column->field_name);
487 ui_out_field_string (current_uiout, column->field_name, val);
493 /* Helper function that returns the number of extra fields which POPS will
497 get_number_extra_fields (const struct probe_ops *pops)
499 VEC (info_probe_column_s) *headings = NULL;
503 if (pops->gen_info_probes_table_header == NULL)
506 c = make_cleanup (VEC_cleanup (info_probe_column_s), &headings);
507 pops->gen_info_probes_table_header (&headings);
509 n = VEC_length (info_probe_column_s, headings);
516 /* See comment in probe.h. */
519 info_probes_for_ops (char *arg, int from_tty, const struct probe_ops *pops)
521 char *provider, *probe = NULL, *objname = NULL;
522 struct cleanup *cleanup = make_cleanup (null_cleanup, NULL);
523 VEC (probe_and_objfile_s) *items;
525 int ui_out_extra_fields = 0;
527 size_t size_name = strlen ("Name");
528 size_t size_objname = strlen ("Object");
529 size_t size_provider = strlen ("Provider");
530 probe_and_objfile_s *entry;
531 struct gdbarch *gdbarch = get_current_arch ();
533 /* Do we have a `provider:probe:objfile' style of linespec? */
534 provider = extract_arg (&arg);
537 make_cleanup (xfree, provider);
539 probe = extract_arg (&arg);
542 make_cleanup (xfree, probe);
544 objname = extract_arg (&arg);
546 make_cleanup (xfree, objname);
552 const struct probe_ops *po;
555 /* If the probe_ops is NULL, it means the user has requested a "simple"
556 `info probes', i.e., she wants to print all information about all
557 probes. For that, we have to identify how many extra fields we will
558 need to add in the ui_out table.
560 To do that, we iterate over all probe_ops, querying each one about
561 its extra fields, and incrementing `ui_out_extra_fields' to reflect
564 for (ix = 0; VEC_iterate (probe_ops_cp, all_probe_ops, ix, po); ++ix)
565 ui_out_extra_fields += get_number_extra_fields (po);
568 ui_out_extra_fields = get_number_extra_fields (pops);
570 items = collect_probes (objname, provider, probe, pops);
571 make_cleanup (VEC_cleanup (probe_and_objfile_s), &items);
572 make_cleanup_ui_out_table_begin_end (current_uiout,
573 4 + ui_out_extra_fields,
574 VEC_length (probe_and_objfile_s, items),
577 if (!VEC_empty (probe_and_objfile_s, items))
578 qsort (VEC_address (probe_and_objfile_s, items),
579 VEC_length (probe_and_objfile_s, items),
580 sizeof (probe_and_objfile_s), compare_entries);
582 /* What's the size of an address in our architecture? */
583 size_addr = gdbarch_addr_bit (gdbarch) == 64 ? 18 : 10;
585 /* Determining the maximum size of each field (`provider', `name' and
587 for (i = 0; VEC_iterate (probe_and_objfile_s, items, i, entry); ++i)
589 size_name = max (strlen (entry->probe->name), size_name);
590 size_provider = max (strlen (entry->probe->provider), size_provider);
591 size_objname = max (strlen (entry->objfile->name), size_objname);
594 ui_out_table_header (current_uiout, size_provider, ui_left, "provider",
596 ui_out_table_header (current_uiout, size_name, ui_left, "name", _("Name"));
597 ui_out_table_header (current_uiout, size_addr, ui_left, "addr", _("Where"));
601 const struct probe_ops *po;
604 /* We have to generate the table header for each new probe type that we
606 for (ix = 0; VEC_iterate (probe_ops_cp, all_probe_ops, ix, po); ++ix)
607 gen_ui_out_table_header_info (items, po);
610 gen_ui_out_table_header_info (items, pops);
612 ui_out_table_header (current_uiout, size_objname, ui_left, "object",
614 ui_out_table_body (current_uiout);
616 for (i = 0; VEC_iterate (probe_and_objfile_s, items, i, entry); ++i)
618 struct cleanup *inner;
620 inner = make_cleanup_ui_out_tuple_begin_end (current_uiout, "probe");
622 ui_out_field_string (current_uiout, "provider", entry->probe->provider);
623 ui_out_field_string (current_uiout, "name", entry->probe->name);
624 ui_out_field_core_addr (current_uiout, "addr",
625 get_objfile_arch (entry->objfile),
626 entry->probe->address);
630 const struct probe_ops *po;
633 for (ix = 0; VEC_iterate (probe_ops_cp, all_probe_ops, ix, po);
635 if (entry->probe->pops == po)
636 print_ui_out_info (entry);
639 print_ui_out_info (entry);
641 ui_out_field_string (current_uiout, "object", entry->objfile->name);
642 ui_out_text (current_uiout, "\n");
647 any_found = !VEC_empty (probe_and_objfile_s, items);
648 do_cleanups (cleanup);
651 ui_out_message (current_uiout, 0, _("No probes matched.\n"));
654 /* Implementation of the `info probes' command. */
657 info_probes_command (char *arg, int from_tty)
659 info_probes_for_ops (arg, from_tty, NULL);
662 /* See comments in probe.h. */
665 probe_safe_evaluate_at_pc (struct frame_info *frame, unsigned n)
668 struct objfile *objfile;
671 probe = find_probe_by_pc (get_frame_pc (frame), &objfile);
674 gdb_assert (objfile->sf && objfile->sf->sym_probe_fns);
677 = objfile->sf->sym_probe_fns->sym_get_probe_argument_count (objfile,
682 return objfile->sf->sym_probe_fns->sym_evaluate_probe_argument (objfile,
687 /* See comment in probe.h. */
689 const struct probe_ops *
690 probe_linespec_to_ops (const char **linespecp)
693 const struct probe_ops *probe_ops;
695 for (ix = 0; VEC_iterate (probe_ops_cp, all_probe_ops, ix, probe_ops); ix++)
696 if (probe_ops->is_linespec (linespecp))
702 /* See comment in probe.h. */
705 probe_is_linespec_by_keyword (const char **linespecp, const char *const *keywords)
707 const char *s = *linespecp;
708 const char *const *csp;
710 for (csp = keywords; *csp; csp++)
712 const char *keyword = *csp;
713 size_t len = strlen (keyword);
715 if (strncmp (s, keyword, len) == 0 && isspace (s[len]))
717 *linespecp += len + 1;
725 /* Implementation of `is_linespec' method for `struct probe_ops'. */
728 probe_any_is_linespec (const char **linespecp)
730 static const char *const keywords[] = { "-p", "-probe", NULL };
732 return probe_is_linespec_by_keyword (linespecp, keywords);
735 /* Dummy method used for `probe_ops_any'. */
738 probe_any_get_probes (VEC (probe_p) **probesp, struct objfile *objfile)
740 /* No probes can be provided by this dummy backend. */
743 /* Operations associated with a generic probe. */
745 const struct probe_ops probe_ops_any =
747 probe_any_is_linespec,
748 probe_any_get_probes,
751 /* See comments in probe.h. */
753 struct cmd_list_element **
754 info_probes_cmdlist_get (void)
756 static struct cmd_list_element *info_probes_cmdlist;
758 if (info_probes_cmdlist == NULL)
759 add_prefix_cmd ("probes", class_info, info_probes_command,
761 Show available static probes.\n\
762 Usage: info probes [all|TYPE [ARGS]]\n\
763 TYPE specifies the type of the probe, and can be one of the following:\n\
765 If you specify TYPE, there may be additional arguments needed by the\n\
767 If you do not specify any argument, or specify `all', then the command\n\
768 will show information about all types of probes."),
769 &info_probes_cmdlist, "info probes ",
770 0/*allow-unknown*/, &infolist);
772 return &info_probes_cmdlist;
775 VEC (probe_ops_cp) *all_probe_ops;
777 void _initialize_probe (void);
780 _initialize_probe (void)
782 VEC_safe_push (probe_ops_cp, all_probe_ops, &probe_ops_any);
784 add_cmd ("all", class_info, info_probes_command,
786 Show information about all type of probes."),
787 info_probes_cmdlist_get ());