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 probes
= objfile
->sf
->sym_probe_fns
->sym_get_probes (objfile
);
125 for (ix
= 0; VEC_iterate (probe_p
, probes
, ix
, probe
); ix
++)
127 struct symtab_and_line
*sal
;
129 if (probe_ops
!= &probe_ops_any
&& probe
->pops
!= probe_ops
)
132 if (provider
&& strcmp (probe
->provider
, provider
) != 0)
135 if (strcmp (probe
->name
, name
) != 0)
139 result
.sals
= xrealloc (result
.sals
,
141 * sizeof (struct symtab_and_line
));
142 sal
= &result
.sals
[result
.nelts
- 1];
146 sal
->pc
= probe
->address
;
147 sal
->explicit_pc
= 1;
148 sal
->section
= find_pc_overlay (sal
->pc
);
149 sal
->pspace
= pspace
;
154 if (result
.nelts
== 0)
156 throw_error (NOT_FOUND_ERROR
,
157 _("No probe matching objfile=`%s', provider=`%s', name=`%s'"),
158 objfile_name
? objfile_name
: _("<any>"),
159 provider
? provider
: _("<any>"),
165 canonical
->special_display
= 1;
166 canonical
->pre_expanded
= 1;
167 canonical
->addr_string
= savestring (*argptr
, arg_end
- *argptr
);
171 do_cleanups (cleanup
);
176 /* See definition in probe.h. */
179 find_probes_in_objfile (struct objfile
*objfile
, const char *provider
,
182 VEC (probe_p
) *probes
, *result
= NULL
;
186 if (!objfile
->sf
|| !objfile
->sf
->sym_probe_fns
)
189 probes
= objfile
->sf
->sym_probe_fns
->sym_get_probes (objfile
);
190 for (ix
= 0; VEC_iterate (probe_p
, probes
, ix
, probe
); ix
++)
192 if (strcmp (probe
->provider
, provider
) != 0)
195 if (strcmp (probe
->name
, name
) != 0)
198 VEC_safe_push (probe_p
, result
, probe
);
204 /* See definition in probe.h. */
207 find_probe_by_pc (CORE_ADDR pc
, struct objfile
**objfile_out
)
209 struct objfile
*objfile
;
211 ALL_OBJFILES (objfile
)
213 VEC (probe_p
) *probes
;
217 if (!objfile
->sf
|| !objfile
->sf
->sym_probe_fns
)
220 /* If this proves too inefficient, we can replace with a hash. */
221 probes
= objfile
->sf
->sym_probe_fns
->sym_get_probes (objfile
);
222 for (ix
= 0; VEC_iterate (probe_p
, probes
, ix
, probe
); ix
++)
223 if (probe
->address
== pc
)
225 *objfile_out
= objfile
;
235 /* A utility structure. A VEC of these is built when handling "info
238 struct probe_and_objfile
243 /* The probe's objfile. */
244 struct objfile
*objfile
;
247 typedef struct probe_and_objfile probe_and_objfile_s
;
248 DEF_VEC_O (probe_and_objfile_s
);
250 /* A helper function for collect_probes that compiles a regexp and
251 throws an exception on error. This installs a cleanup to free the
252 resulting pattern on success. If RX is NULL, this does nothing. */
255 compile_rx_or_error (regex_t
*pattern
, const char *rx
, const char *message
)
262 code
= regcomp (pattern
, rx
, REG_NOSUB
);
264 make_regfree_cleanup (pattern
);
267 char *err
= get_regcomp_error (code
, pattern
);
269 make_cleanup (xfree
, err
);
270 error (("%s: %s"), message
, err
);
274 /* Make a vector of probes matching OBJNAME, PROVIDER, and PROBE_NAME.
275 If POPS is not NULL, only probes of this certain probe_ops will match.
276 Each argument is a regexp, or NULL, which matches anything. */
278 static VEC (probe_and_objfile_s
) *
279 collect_probes (char *objname
, char *provider
, char *probe_name
,
280 const struct probe_ops
*pops
)
282 struct objfile
*objfile
;
283 VEC (probe_and_objfile_s
) *result
= NULL
;
284 struct cleanup
*cleanup
, *cleanup_temps
;
285 regex_t obj_pat
, prov_pat
, probe_pat
;
287 cleanup
= make_cleanup (VEC_cleanup (probe_and_objfile_s
), &result
);
289 cleanup_temps
= make_cleanup (null_cleanup
, NULL
);
290 compile_rx_or_error (&prov_pat
, provider
, _("Invalid provider regexp"));
291 compile_rx_or_error (&probe_pat
, probe_name
, _("Invalid probe regexp"));
292 compile_rx_or_error (&obj_pat
, objname
, _("Invalid object file regexp"));
294 ALL_OBJFILES (objfile
)
296 VEC (probe_p
) *probes
;
300 if (! objfile
->sf
|| ! objfile
->sf
->sym_probe_fns
)
305 if (regexec (&obj_pat
, objfile
->name
, 0, NULL
, 0) != 0)
309 probes
= objfile
->sf
->sym_probe_fns
->sym_get_probes (objfile
);
311 for (ix
= 0; VEC_iterate (probe_p
, probes
, ix
, probe
); ix
++)
313 probe_and_objfile_s entry
;
315 if (pops
!= NULL
&& probe
->pops
!= pops
)
319 && regexec (&prov_pat
, probe
->provider
, 0, NULL
, 0) != 0)
323 && regexec (&probe_pat
, probe
->name
, 0, NULL
, 0) != 0)
327 entry
.objfile
= objfile
;
328 VEC_safe_push (probe_and_objfile_s
, result
, &entry
);
332 do_cleanups (cleanup_temps
);
333 discard_cleanups (cleanup
);
337 /* A qsort comparison function for probe_and_objfile_s objects. */
340 compare_entries (const void *a
, const void *b
)
342 const probe_and_objfile_s
*ea
= a
;
343 const probe_and_objfile_s
*eb
= b
;
346 v
= strcmp (ea
->probe
->provider
, eb
->probe
->provider
);
350 v
= strcmp (ea
->probe
->name
, eb
->probe
->name
);
354 if (ea
->probe
->address
< eb
->probe
->address
)
356 if (ea
->probe
->address
> eb
->probe
->address
)
359 return strcmp (ea
->objfile
->name
, eb
->objfile
->name
);
362 /* Helper function that generate entries in the ui_out table being
363 crafted by `info_probes_for_ops'. */
366 gen_ui_out_table_header_info (VEC (probe_and_objfile_s
) *probes
,
367 const struct probe_ops
*p
)
369 /* `headings' refers to the names of the columns when printing `info
371 VEC (info_probe_column_s
) *headings
= NULL
;
373 info_probe_column_s
*column
;
374 size_t headings_size
;
377 gdb_assert (p
!= NULL
);
379 if (p
->gen_info_probes_table_header
== NULL
380 && p
->gen_info_probes_table_values
== NULL
)
383 gdb_assert (p
->gen_info_probes_table_header
!= NULL
384 && p
->gen_info_probes_table_values
!= NULL
);
386 c
= make_cleanup (VEC_cleanup (info_probe_column_s
), &headings
);
387 p
->gen_info_probes_table_header (&headings
);
389 headings_size
= VEC_length (info_probe_column_s
, headings
);
392 VEC_iterate (info_probe_column_s
, headings
, ix
, column
);
395 probe_and_objfile_s
*entry
;
397 size_t size_max
= strlen (column
->print_name
);
399 for (jx
= 0; VEC_iterate (probe_and_objfile_s
, probes
, jx
, entry
); ++jx
)
401 /* `probe_fields' refers to the values of each new field that this
402 probe will display. */
403 VEC (const_char_ptr
) *probe_fields
= NULL
;
408 if (entry
->probe
->pops
!= p
)
411 c2
= make_cleanup (VEC_cleanup (const_char_ptr
), &probe_fields
);
412 p
->gen_info_probes_table_values (entry
->probe
, entry
->objfile
,
415 gdb_assert (VEC_length (const_char_ptr
, probe_fields
)
418 for (kx
= 0; VEC_iterate (const_char_ptr
, probe_fields
, kx
, val
);
421 /* It is valid to have a NULL value here, which means that the
422 backend does not have something to write and this particular
423 field should be skipped. */
427 size_max
= max (strlen (val
), size_max
);
432 ui_out_table_header (current_uiout
, size_max
, ui_left
,
433 column
->field_name
, column
->print_name
);
439 /* Helper function to print extra information about a probe and an objfile
440 represented by ENTRY. */
443 print_ui_out_info (probe_and_objfile_s
*entry
)
447 /* `values' refers to the actual values of each new field in the output
448 of `info probe'. `headings' refers to the names of each new field. */
449 VEC (const_char_ptr
) *values
= NULL
;
450 VEC (info_probe_column_s
) *headings
= NULL
;
451 info_probe_column_s
*column
;
454 gdb_assert (entry
!= NULL
);
455 gdb_assert (entry
->probe
!= NULL
);
456 gdb_assert (entry
->probe
->pops
!= NULL
);
458 if (entry
->probe
->pops
->gen_info_probes_table_header
== NULL
459 && entry
->probe
->pops
->gen_info_probes_table_values
== NULL
)
462 gdb_assert (entry
->probe
->pops
->gen_info_probes_table_header
!= NULL
463 && entry
->probe
->pops
->gen_info_probes_table_values
!= NULL
);
465 c
= make_cleanup (VEC_cleanup (info_probe_column_s
), &headings
);
466 make_cleanup (VEC_cleanup (const_char_ptr
), &values
);
468 entry
->probe
->pops
->gen_info_probes_table_header (&headings
);
469 entry
->probe
->pops
->gen_info_probes_table_values (entry
->probe
,
470 entry
->objfile
, &values
);
472 gdb_assert (VEC_length (info_probe_column_s
, headings
)
473 == VEC_length (const_char_ptr
, values
));
476 VEC_iterate (info_probe_column_s
, headings
, ix
, column
);
479 const char *val
= VEC_index (const_char_ptr
, values
, j
++);
482 ui_out_field_skip (current_uiout
, column
->field_name
);
484 ui_out_field_string (current_uiout
, column
->field_name
, val
);
490 /* Helper function that returns the number of extra fields which POPS will
494 get_number_extra_fields (const struct probe_ops
*pops
)
496 VEC (info_probe_column_s
) *headings
= NULL
;
500 if (pops
->gen_info_probes_table_header
== NULL
)
503 c
= make_cleanup (VEC_cleanup (info_probe_column_s
), &headings
);
504 pops
->gen_info_probes_table_header (&headings
);
506 n
= VEC_length (info_probe_column_s
, headings
);
513 /* See comment in probe.h. */
516 info_probes_for_ops (char *arg
, int from_tty
, const struct probe_ops
*pops
)
518 char *provider
, *probe
= NULL
, *objname
= NULL
;
519 struct cleanup
*cleanup
= make_cleanup (null_cleanup
, NULL
);
520 VEC (probe_and_objfile_s
) *items
;
522 int ui_out_extra_fields
= 0;
524 size_t size_name
= strlen ("Name");
525 size_t size_objname
= strlen ("Object");
526 size_t size_provider
= strlen ("Provider");
527 probe_and_objfile_s
*entry
;
528 struct gdbarch
*gdbarch
= get_current_arch ();
530 /* Do we have a `provider:probe:objfile' style of linespec? */
531 provider
= extract_arg (&arg
);
534 make_cleanup (xfree
, provider
);
536 probe
= extract_arg (&arg
);
539 make_cleanup (xfree
, probe
);
541 objname
= extract_arg (&arg
);
543 make_cleanup (xfree
, objname
);
549 const struct probe_ops
*po
;
552 /* If the probe_ops is NULL, it means the user has requested a "simple"
553 `info probes', i.e., she wants to print all information about all
554 probes. For that, we have to identify how many extra fields we will
555 need to add in the ui_out table.
557 To do that, we iterate over all probe_ops, querying each one about
558 its extra fields, and incrementing `ui_out_extra_fields' to reflect
561 for (ix
= 0; VEC_iterate (probe_ops_cp
, all_probe_ops
, ix
, po
); ++ix
)
562 ui_out_extra_fields
+= get_number_extra_fields (po
);
565 ui_out_extra_fields
= get_number_extra_fields (pops
);
567 items
= collect_probes (objname
, provider
, probe
, pops
);
568 make_cleanup (VEC_cleanup (probe_and_objfile_s
), &items
);
569 make_cleanup_ui_out_table_begin_end (current_uiout
,
570 4 + ui_out_extra_fields
,
571 VEC_length (probe_and_objfile_s
, items
),
574 if (!VEC_empty (probe_and_objfile_s
, items
))
575 qsort (VEC_address (probe_and_objfile_s
, items
),
576 VEC_length (probe_and_objfile_s
, items
),
577 sizeof (probe_and_objfile_s
), compare_entries
);
579 /* What's the size of an address in our architecture? */
580 size_addr
= gdbarch_addr_bit (gdbarch
) == 64 ? 18 : 10;
582 /* Determining the maximum size of each field (`provider', `name' and
584 for (i
= 0; VEC_iterate (probe_and_objfile_s
, items
, i
, entry
); ++i
)
586 size_name
= max (strlen (entry
->probe
->name
), size_name
);
587 size_provider
= max (strlen (entry
->probe
->provider
), size_provider
);
588 size_objname
= max (strlen (entry
->objfile
->name
), size_objname
);
591 ui_out_table_header (current_uiout
, size_provider
, ui_left
, "provider",
593 ui_out_table_header (current_uiout
, size_name
, ui_left
, "name", _("Name"));
594 ui_out_table_header (current_uiout
, size_addr
, ui_left
, "addr", _("Where"));
598 const struct probe_ops
*po
;
601 /* We have to generate the table header for each new probe type that we
603 for (ix
= 0; VEC_iterate (probe_ops_cp
, all_probe_ops
, ix
, po
); ++ix
)
604 gen_ui_out_table_header_info (items
, po
);
607 gen_ui_out_table_header_info (items
, pops
);
609 ui_out_table_header (current_uiout
, size_objname
, ui_left
, "object",
611 ui_out_table_body (current_uiout
);
613 for (i
= 0; VEC_iterate (probe_and_objfile_s
, items
, i
, entry
); ++i
)
615 struct cleanup
*inner
;
617 inner
= make_cleanup_ui_out_tuple_begin_end (current_uiout
, "probe");
619 ui_out_field_string (current_uiout
, "provider", entry
->probe
->provider
);
620 ui_out_field_string (current_uiout
, "name", entry
->probe
->name
);
621 ui_out_field_core_addr (current_uiout
, "addr",
622 get_objfile_arch (entry
->objfile
),
623 entry
->probe
->address
);
627 const struct probe_ops
*po
;
630 for (ix
= 0; VEC_iterate (probe_ops_cp
, all_probe_ops
, ix
, po
);
632 if (entry
->probe
->pops
== po
)
633 print_ui_out_info (entry
);
636 print_ui_out_info (entry
);
638 ui_out_field_string (current_uiout
, "object", entry
->objfile
->name
);
639 ui_out_text (current_uiout
, "\n");
644 any_found
= !VEC_empty (probe_and_objfile_s
, items
);
645 do_cleanups (cleanup
);
648 ui_out_message (current_uiout
, 0, _("No probes matched.\n"));
651 /* Implementation of the `info probes' command. */
654 info_probes_command (char *arg
, int from_tty
)
656 info_probes_for_ops (arg
, from_tty
, NULL
);
659 /* See comments in probe.h. */
662 probe_safe_evaluate_at_pc (struct frame_info
*frame
, unsigned n
)
665 struct objfile
*objfile
;
668 probe
= find_probe_by_pc (get_frame_pc (frame
), &objfile
);
671 gdb_assert (objfile
->sf
&& objfile
->sf
->sym_probe_fns
);
674 = objfile
->sf
->sym_probe_fns
->sym_get_probe_argument_count (objfile
,
679 return objfile
->sf
->sym_probe_fns
->sym_evaluate_probe_argument (objfile
,
684 /* See comment in probe.h. */
686 const struct probe_ops
*
687 probe_linespec_to_ops (const char **linespecp
)
690 const struct probe_ops
*probe_ops
;
692 for (ix
= 0; VEC_iterate (probe_ops_cp
, all_probe_ops
, ix
, probe_ops
); ix
++)
693 if (probe_ops
->is_linespec (linespecp
))
699 /* See comment in probe.h. */
702 probe_is_linespec_by_keyword (const char **linespecp
, const char *const *keywords
)
704 const char *s
= *linespecp
;
705 const char *const *csp
;
707 for (csp
= keywords
; *csp
; csp
++)
709 const char *keyword
= *csp
;
710 size_t len
= strlen (keyword
);
712 if (strncmp (s
, keyword
, len
) == 0 && isspace (s
[len
]))
714 *linespecp
+= len
+ 1;
722 /* Implementation of `is_linespec' method for `struct probe_ops'. */
725 probe_any_is_linespec (const char **linespecp
)
727 static const char *const keywords
[] = { "-p", "-probe", NULL
};
729 return probe_is_linespec_by_keyword (linespecp
, keywords
);
732 /* Dummy method used for `probe_ops_any'. */
735 probe_any_get_probes (VEC (probe_p
) **probesp
, struct objfile
*objfile
)
737 /* No probes can be provided by this dummy backend. */
740 /* Operations associated with a generic probe. */
742 const struct probe_ops probe_ops_any
=
744 probe_any_is_linespec
,
745 probe_any_get_probes
,
748 /* See comments in probe.h. */
750 struct cmd_list_element
**
751 info_probes_cmdlist_get (void)
753 static struct cmd_list_element
*info_probes_cmdlist
;
755 if (info_probes_cmdlist
== NULL
)
756 add_prefix_cmd ("probes", class_info
, info_probes_command
,
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\
762 If you specify TYPE, there may be additional arguments needed by the\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
);
769 return &info_probes_cmdlist
;
772 VEC (probe_ops_cp
) *all_probe_ops
;
774 void _initialize_probe (void);
777 _initialize_probe (void)
779 VEC_safe_push (probe_ops_cp
, all_probe_ops
, &probe_ops_any
);
781 add_cmd ("all", class_info
, info_probes_command
,
783 Show information about all type of probes."),
784 info_probes_cmdlist_get ());