1 /* Generic static probe support for GDB.
3 Copyright (C) 2012-2017 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 "common/gdb_optional.h"
41 /* A helper for parse_probes that decodes a probe specification in
42 SEARCH_PSPACE. It appends matching SALs to RESULT. */
45 parse_probes_in_pspace (const struct probe_ops
*probe_ops
,
46 struct program_space
*search_pspace
,
47 const char *objfile_namestr
,
50 std::vector
<symtab_and_line
> *result
)
52 struct objfile
*objfile
;
54 ALL_PSPACE_OBJFILES (search_pspace
, objfile
)
56 if (!objfile
->sf
|| !objfile
->sf
->sym_probe_fns
)
60 && FILENAME_CMP (objfile_name (objfile
), objfile_namestr
) != 0
61 && FILENAME_CMP (lbasename (objfile_name (objfile
)),
62 objfile_namestr
) != 0)
65 const std::vector
<probe
*> &probes
66 = objfile
->sf
->sym_probe_fns
->sym_get_probes (objfile
);
68 for (probe
*p
: probes
)
70 if (probe_ops
!= &probe_ops_any
&& p
->pops
!= probe_ops
)
73 if (provider
&& strcmp (p
->provider
, provider
) != 0)
76 if (strcmp (p
->name
, name
) != 0)
80 sal
.pc
= get_probe_address (p
, objfile
);
82 sal
.section
= find_pc_overlay (sal
.pc
);
83 sal
.pspace
= search_pspace
;
85 sal
.objfile
= objfile
;
87 result
->push_back (std::move (sal
));
92 /* See definition in probe.h. */
94 std::vector
<symtab_and_line
>
95 parse_probes (const struct event_location
*location
,
96 struct program_space
*search_pspace
,
97 struct linespec_result
*canonical
)
100 char *objfile_namestr
= NULL
, *provider
= NULL
, *name
, *p
;
101 const struct probe_ops
*probe_ops
;
102 const char *arg_start
, *cs
;
104 gdb_assert (event_location_type (location
) == PROBE_LOCATION
);
105 arg_start
= get_probe_location (location
);
108 probe_ops
= probe_linespec_to_ops (&cs
);
109 if (probe_ops
== NULL
)
110 error (_("'%s' is not a probe linespec"), arg_start
);
113 arg
= skip_spaces (arg
);
115 error (_("argument to `%s' missing"), arg_start
);
117 arg_end
= skip_to_space (arg
);
119 /* We make a copy here so we can write over parts with impunity. */
120 std::string
copy (arg
, arg_end
- arg
);
123 /* Extract each word from the argument, separated by ":"s. */
124 p
= strchr (arg
, ':');
127 /* This is `-p name'. */
135 p
= strchr (hold
, ':');
138 /* This is `-p provider:name'. */
144 /* This is `-p objfile:provider:name'. */
146 objfile_namestr
= arg
;
153 error (_("no probe name specified"));
154 if (provider
&& *provider
== '\0')
155 error (_("invalid provider name"));
156 if (objfile_namestr
&& *objfile_namestr
== '\0')
157 error (_("invalid objfile name"));
159 std::vector
<symtab_and_line
> result
;
160 if (search_pspace
!= NULL
)
162 parse_probes_in_pspace (probe_ops
, search_pspace
, objfile_namestr
,
163 provider
, name
, &result
);
167 struct program_space
*pspace
;
170 parse_probes_in_pspace (probe_ops
, pspace
, objfile_namestr
,
171 provider
, name
, &result
);
176 throw_error (NOT_FOUND_ERROR
,
177 _("No probe matching objfile=`%s', provider=`%s', name=`%s'"),
178 objfile_namestr
? objfile_namestr
: _("<any>"),
179 provider
? provider
: _("<any>"),
185 std::string
canon (arg_start
, arg_end
- arg_start
);
186 canonical
->special_display
= 1;
187 canonical
->pre_expanded
= 1;
188 canonical
->location
= new_probe_location (canon
.c_str ());
194 /* See definition in probe.h. */
197 find_probes_in_objfile (struct objfile
*objfile
, const char *provider
,
200 VEC (probe_p
) *result
= NULL
;
202 if (!objfile
->sf
|| !objfile
->sf
->sym_probe_fns
)
205 const std::vector
<probe
*> &probes
206 = objfile
->sf
->sym_probe_fns
->sym_get_probes (objfile
);
207 for (probe
*p
: probes
)
209 if (strcmp (p
->provider
, provider
) != 0)
212 if (strcmp (p
->name
, name
) != 0)
215 VEC_safe_push (probe_p
, result
, p
);
221 /* See definition in probe.h. */
224 find_probe_by_pc (CORE_ADDR pc
)
226 struct objfile
*objfile
;
227 struct bound_probe result
;
229 result
.objfile
= NULL
;
232 ALL_OBJFILES (objfile
)
234 if (!objfile
->sf
|| !objfile
->sf
->sym_probe_fns
235 || objfile
->sect_index_text
== -1)
238 /* If this proves too inefficient, we can replace with a hash. */
239 const std::vector
<probe
*> &probes
240 = objfile
->sf
->sym_probe_fns
->sym_get_probes (objfile
);
241 for (probe
*p
: probes
)
242 if (get_probe_address (p
, objfile
) == pc
)
244 result
.objfile
= objfile
;
255 /* Make a vector of probes matching OBJNAME, PROVIDER, and PROBE_NAME.
256 If POPS is not NULL, only probes of this certain probe_ops will match.
257 Each argument is a regexp, or NULL, which matches anything. */
259 static std::vector
<bound_probe
>
260 collect_probes (const std::string
&objname
, const std::string
&provider
,
261 const std::string
&probe_name
, const struct probe_ops
*pops
)
263 struct objfile
*objfile
;
264 std::vector
<bound_probe
> result
;
265 gdb::optional
<compiled_regex
> obj_pat
, prov_pat
, probe_pat
;
267 if (!provider
.empty ())
268 prov_pat
.emplace (provider
.c_str (), REG_NOSUB
,
269 _("Invalid provider regexp"));
270 if (!probe_name
.empty ())
271 probe_pat
.emplace (probe_name
.c_str (), REG_NOSUB
,
272 _("Invalid probe regexp"));
273 if (!objname
.empty ())
274 obj_pat
.emplace (objname
.c_str (), REG_NOSUB
,
275 _("Invalid object file regexp"));
277 ALL_OBJFILES (objfile
)
279 if (! objfile
->sf
|| ! objfile
->sf
->sym_probe_fns
)
284 if (obj_pat
->exec (objfile_name (objfile
), 0, NULL
, 0) != 0)
288 const std::vector
<probe
*> &probes
289 = objfile
->sf
->sym_probe_fns
->sym_get_probes (objfile
);
291 for (probe
*p
: probes
)
293 if (pops
!= NULL
&& p
->pops
!= pops
)
297 && prov_pat
->exec (p
->provider
, 0, NULL
, 0) != 0)
301 && probe_pat
->exec (p
->name
, 0, NULL
, 0) != 0)
304 result
.emplace_back (p
, objfile
);
311 /* A qsort comparison function for bound_probe_s objects. */
314 compare_probes (const bound_probe
&a
, const bound_probe
&b
)
318 v
= strcmp (a
.probe
->provider
, b
.probe
->provider
);
322 v
= strcmp (a
.probe
->name
, b
.probe
->name
);
326 if (a
.probe
->address
!= b
.probe
->address
)
327 return a
.probe
->address
< b
.probe
->address
;
329 return strcmp (objfile_name (a
.objfile
), objfile_name (b
.objfile
)) < 0;
332 /* Helper function that generate entries in the ui_out table being
333 crafted by `info_probes_for_ops'. */
336 gen_ui_out_table_header_info (const std::vector
<bound_probe
> &probes
,
337 const struct probe_ops
*p
)
339 /* `headings' refers to the names of the columns when printing `info
341 VEC (info_probe_column_s
) *headings
= NULL
;
343 info_probe_column_s
*column
;
344 size_t headings_size
;
347 gdb_assert (p
!= NULL
);
349 if (p
->gen_info_probes_table_header
== NULL
350 && p
->gen_info_probes_table_values
== NULL
)
353 gdb_assert (p
->gen_info_probes_table_header
!= NULL
354 && p
->gen_info_probes_table_values
!= NULL
);
356 c
= make_cleanup (VEC_cleanup (info_probe_column_s
), &headings
);
357 p
->gen_info_probes_table_header (&headings
);
359 headings_size
= VEC_length (info_probe_column_s
, headings
);
362 VEC_iterate (info_probe_column_s
, headings
, ix
, column
);
365 size_t size_max
= strlen (column
->print_name
);
367 for (const bound_probe
&probe
: probes
)
369 /* `probe_fields' refers to the values of each new field that this
370 probe will display. */
371 VEC (const_char_ptr
) *probe_fields
= NULL
;
376 if (probe
.probe
->pops
!= p
)
379 c2
= make_cleanup (VEC_cleanup (const_char_ptr
), &probe_fields
);
380 p
->gen_info_probes_table_values (probe
.probe
, &probe_fields
);
382 gdb_assert (VEC_length (const_char_ptr
, probe_fields
)
385 for (kx
= 0; VEC_iterate (const_char_ptr
, probe_fields
, kx
, val
);
388 /* It is valid to have a NULL value here, which means that the
389 backend does not have something to write and this particular
390 field should be skipped. */
394 size_max
= std::max (strlen (val
), size_max
);
399 current_uiout
->table_header (size_max
, ui_left
,
400 column
->field_name
, column
->print_name
);
406 /* Helper function to print not-applicable strings for all the extra
407 columns defined in a probe_ops. */
410 print_ui_out_not_applicables (const struct probe_ops
*pops
)
413 VEC (info_probe_column_s
) *headings
= NULL
;
414 info_probe_column_s
*column
;
417 if (pops
->gen_info_probes_table_header
== NULL
)
420 c
= make_cleanup (VEC_cleanup (info_probe_column_s
), &headings
);
421 pops
->gen_info_probes_table_header (&headings
);
424 VEC_iterate (info_probe_column_s
, headings
, ix
, column
);
426 current_uiout
->field_string (column
->field_name
, _("n/a"));
431 /* Helper function to print extra information about a probe and an objfile
432 represented by PROBE. */
435 print_ui_out_info (struct probe
*probe
)
439 /* `values' refers to the actual values of each new field in the output
440 of `info probe'. `headings' refers to the names of each new field. */
441 VEC (const_char_ptr
) *values
= NULL
;
442 VEC (info_probe_column_s
) *headings
= NULL
;
443 info_probe_column_s
*column
;
446 gdb_assert (probe
!= NULL
);
447 gdb_assert (probe
->pops
!= NULL
);
449 if (probe
->pops
->gen_info_probes_table_header
== NULL
450 && probe
->pops
->gen_info_probes_table_values
== NULL
)
453 gdb_assert (probe
->pops
->gen_info_probes_table_header
!= NULL
454 && probe
->pops
->gen_info_probes_table_values
!= NULL
);
456 c
= make_cleanup (VEC_cleanup (info_probe_column_s
), &headings
);
457 make_cleanup (VEC_cleanup (const_char_ptr
), &values
);
459 probe
->pops
->gen_info_probes_table_header (&headings
);
460 probe
->pops
->gen_info_probes_table_values (probe
, &values
);
462 gdb_assert (VEC_length (info_probe_column_s
, headings
)
463 == VEC_length (const_char_ptr
, values
));
466 VEC_iterate (info_probe_column_s
, headings
, ix
, column
);
469 const char *val
= VEC_index (const_char_ptr
, values
, j
++);
472 current_uiout
->field_skip (column
->field_name
);
474 current_uiout
->field_string (column
->field_name
, val
);
480 /* Helper function that returns the number of extra fields which POPS will
484 get_number_extra_fields (const struct probe_ops
*pops
)
486 VEC (info_probe_column_s
) *headings
= NULL
;
490 if (pops
->gen_info_probes_table_header
== NULL
)
493 c
= make_cleanup (VEC_cleanup (info_probe_column_s
), &headings
);
494 pops
->gen_info_probes_table_header (&headings
);
496 n
= VEC_length (info_probe_column_s
, headings
);
503 /* Helper function that returns 1 if there is a probe in PROBES
504 featuring the given POPS. It returns 0 otherwise. */
507 exists_probe_with_pops (const std::vector
<bound_probe
> &probes
,
508 const struct probe_ops
*pops
)
510 struct bound_probe
*probe
;
513 for (const bound_probe
&probe
: probes
)
514 if (probe
.probe
->pops
== pops
)
520 /* Helper function that parses a probe linespec of the form [PROVIDER
521 [PROBE [OBJNAME]]] from the provided string STR. */
524 parse_probe_linespec (const char *str
, std::string
*provider
,
525 std::string
*probe_name
, std::string
*objname
)
527 *probe_name
= *objname
= "";
529 *provider
= extract_arg (&str
);
530 if (!provider
->empty ())
532 *probe_name
= extract_arg (&str
);
533 if (!probe_name
->empty ())
534 *objname
= extract_arg (&str
);
538 /* See comment in probe.h. */
541 info_probes_for_ops (const char *arg
, int from_tty
,
542 const struct probe_ops
*pops
)
544 std::string provider
, probe_name
, objname
;
546 int ui_out_extra_fields
= 0;
548 size_t size_name
= strlen ("Name");
549 size_t size_objname
= strlen ("Object");
550 size_t size_provider
= strlen ("Provider");
551 size_t size_type
= strlen ("Type");
552 struct gdbarch
*gdbarch
= get_current_arch ();
554 parse_probe_linespec (arg
, &provider
, &probe_name
, &objname
);
556 std::vector
<bound_probe
> probes
557 = collect_probes (objname
, provider
, probe_name
, pops
);
561 /* If the probe_ops is NULL, it means the user has requested a "simple"
562 `info probes', i.e., she wants to print all information about all
563 probes. For that, we have to identify how many extra fields we will
564 need to add in the ui_out table.
566 To do that, we iterate over all probe_ops, querying each one about
567 its extra fields, and incrementing `ui_out_extra_fields' to reflect
568 that number. But note that we ignore the probe_ops for which no probes
569 are defined with the given search criteria. */
571 for (const probe_ops
*po
: all_probe_ops
)
572 if (exists_probe_with_pops (probes
, po
))
573 ui_out_extra_fields
+= get_number_extra_fields (po
);
576 ui_out_extra_fields
= get_number_extra_fields (pops
);
579 ui_out_emit_table
table_emitter (current_uiout
,
580 5 + ui_out_extra_fields
,
581 probes
.size (), "StaticProbes");
583 std::sort (probes
.begin (), probes
.end (), compare_probes
);
585 /* What's the size of an address in our architecture? */
586 size_addr
= gdbarch_addr_bit (gdbarch
) == 64 ? 18 : 10;
588 /* Determining the maximum size of each field (`type', `provider',
589 `name' and `objname'). */
590 for (const bound_probe
&probe
: probes
)
592 const char *probe_type
= probe
.probe
->pops
->type_name (probe
.probe
);
594 size_type
= std::max (strlen (probe_type
), size_type
);
595 size_name
= std::max (strlen (probe
.probe
->name
), size_name
);
596 size_provider
= std::max (strlen (probe
.probe
->provider
), size_provider
);
597 size_objname
= std::max (strlen (objfile_name (probe
.objfile
)),
601 current_uiout
->table_header (size_type
, ui_left
, "type", _("Type"));
602 current_uiout
->table_header (size_provider
, ui_left
, "provider",
604 current_uiout
->table_header (size_name
, ui_left
, "name", _("Name"));
605 current_uiout
->table_header (size_addr
, ui_left
, "addr", _("Where"));
609 /* We have to generate the table header for each new probe type
610 that we will print. Note that this excludes probe types not
611 having any defined probe with the search criteria. */
612 for (const probe_ops
*po
: all_probe_ops
)
613 if (exists_probe_with_pops (probes
, po
))
614 gen_ui_out_table_header_info (probes
, po
);
617 gen_ui_out_table_header_info (probes
, pops
);
619 current_uiout
->table_header (size_objname
, ui_left
, "object", _("Object"));
620 current_uiout
->table_body ();
622 for (const bound_probe
&probe
: probes
)
624 const char *probe_type
= probe
.probe
->pops
->type_name (probe
.probe
);
626 ui_out_emit_tuple
tuple_emitter (current_uiout
, "probe");
628 current_uiout
->field_string ("type",probe_type
);
629 current_uiout
->field_string ("provider", probe
.probe
->provider
);
630 current_uiout
->field_string ("name", probe
.probe
->name
);
631 current_uiout
->field_core_addr ("addr", probe
.probe
->arch
,
632 get_probe_address (probe
.probe
,
637 for (const probe_ops
*po
: all_probe_ops
)
638 if (probe
.probe
->pops
== po
)
639 print_ui_out_info (probe
.probe
);
640 else if (exists_probe_with_pops (probes
, po
))
641 print_ui_out_not_applicables (po
);
644 print_ui_out_info (probe
.probe
);
646 current_uiout
->field_string ("object",
647 objfile_name (probe
.objfile
));
648 current_uiout
->text ("\n");
651 any_found
= !probes
.empty ();
655 current_uiout
->message (_("No probes matched.\n"));
658 /* Implementation of the `info probes' command. */
661 info_probes_command (const char *arg
, int from_tty
)
663 info_probes_for_ops (arg
, from_tty
, NULL
);
666 /* Implementation of the `enable probes' command. */
669 enable_probes_command (const char *arg
, int from_tty
)
671 std::string provider
, probe_name
, objname
;
673 parse_probe_linespec ((const char *) arg
, &provider
, &probe_name
, &objname
);
675 std::vector
<bound_probe
> probes
676 = collect_probes (objname
, provider
, probe_name
, NULL
);
679 current_uiout
->message (_("No probes matched.\n"));
683 /* Enable the selected probes, provided their backends support the
684 notion of enabling a probe. */
685 for (const bound_probe
&probe
: probes
)
687 const struct probe_ops
*pops
= probe
.probe
->pops
;
689 if (pops
->enable_probe
!= NULL
)
691 pops
->enable_probe (probe
.probe
);
692 current_uiout
->message (_("Probe %s:%s enabled.\n"),
693 probe
.probe
->provider
, probe
.probe
->name
);
696 current_uiout
->message (_("Probe %s:%s cannot be enabled.\n"),
697 probe
.probe
->provider
, probe
.probe
->name
);
701 /* Implementation of the `disable probes' command. */
704 disable_probes_command (const char *arg
, int from_tty
)
706 std::string provider
, probe_name
, objname
;
708 parse_probe_linespec ((const char *) arg
, &provider
, &probe_name
, &objname
);
710 std::vector
<bound_probe
> probes
711 = collect_probes (objname
, provider
, probe_name
, NULL
/* pops */);
714 current_uiout
->message (_("No probes matched.\n"));
718 /* Disable the selected probes, provided their backends support the
719 notion of enabling a probe. */
720 for (const bound_probe
&probe
: probes
)
722 const struct probe_ops
*pops
= probe
.probe
->pops
;
724 if (pops
->disable_probe
!= NULL
)
726 pops
->disable_probe (probe
.probe
);
727 current_uiout
->message (_("Probe %s:%s disabled.\n"),
728 probe
.probe
->provider
, probe
.probe
->name
);
731 current_uiout
->message (_("Probe %s:%s cannot be disabled.\n"),
732 probe
.probe
->provider
, probe
.probe
->name
);
736 /* See comments in probe.h. */
739 get_probe_address (struct probe
*probe
, struct objfile
*objfile
)
741 return probe
->pops
->get_probe_address (probe
, objfile
);
744 /* See comments in probe.h. */
747 get_probe_argument_count (struct probe
*probe
, struct frame_info
*frame
)
749 return probe
->pops
->get_probe_argument_count (probe
, frame
);
752 /* See comments in probe.h. */
755 can_evaluate_probe_arguments (struct probe
*probe
)
757 return probe
->pops
->can_evaluate_probe_arguments (probe
);
760 /* See comments in probe.h. */
763 evaluate_probe_argument (struct probe
*probe
, unsigned n
,
764 struct frame_info
*frame
)
766 return probe
->pops
->evaluate_probe_argument (probe
, n
, frame
);
769 /* See comments in probe.h. */
772 probe_safe_evaluate_at_pc (struct frame_info
*frame
, unsigned n
)
774 struct bound_probe probe
;
777 probe
= find_probe_by_pc (get_frame_pc (frame
));
781 n_args
= get_probe_argument_count (probe
.probe
, frame
);
785 return evaluate_probe_argument (probe
.probe
, n
, frame
);
788 /* See comment in probe.h. */
790 const struct probe_ops
*
791 probe_linespec_to_ops (const char **linespecp
)
793 for (const probe_ops
*ops
: all_probe_ops
)
794 if (ops
->is_linespec (linespecp
))
800 /* See comment in probe.h. */
803 probe_is_linespec_by_keyword (const char **linespecp
, const char *const *keywords
)
805 const char *s
= *linespecp
;
806 const char *const *csp
;
808 for (csp
= keywords
; *csp
; csp
++)
810 const char *keyword
= *csp
;
811 size_t len
= strlen (keyword
);
813 if (strncmp (s
, keyword
, len
) == 0 && isspace (s
[len
]))
815 *linespecp
+= len
+ 1;
823 /* Implementation of `is_linespec' method for `struct probe_ops'. */
826 probe_any_is_linespec (const char **linespecp
)
828 static const char *const keywords
[] = { "-p", "-probe", NULL
};
830 return probe_is_linespec_by_keyword (linespecp
, keywords
);
833 /* Dummy method used for `probe_ops_any'. */
836 probe_any_get_probes (std::vector
<probe
*> *probesp
, struct objfile
*objfile
)
838 /* No probes can be provided by this dummy backend. */
841 /* Operations associated with a generic probe. */
843 const struct probe_ops probe_ops_any
=
845 probe_any_is_linespec
,
846 probe_any_get_probes
,
849 /* See comments in probe.h. */
851 struct cmd_list_element
**
852 info_probes_cmdlist_get (void)
854 static struct cmd_list_element
*info_probes_cmdlist
;
856 if (info_probes_cmdlist
== NULL
)
857 add_prefix_cmd ("probes", class_info
, info_probes_command
,
859 Show available static probes.\n\
860 Usage: info probes [all|TYPE [ARGS]]\n\
861 TYPE specifies the type of the probe, and can be one of the following:\n\
863 If you specify TYPE, there may be additional arguments needed by the\n\
865 If you do not specify any argument, or specify `all', then the command\n\
866 will show information about all types of probes."),
867 &info_probes_cmdlist
, "info probes ",
868 0/*allow-unknown*/, &infolist
);
870 return &info_probes_cmdlist
;
875 /* This is called to compute the value of one of the $_probe_arg*
876 convenience variables. */
878 static struct value
*
879 compute_probe_arg (struct gdbarch
*arch
, struct internalvar
*ivar
,
882 struct frame_info
*frame
= get_selected_frame (_("No frame selected"));
883 CORE_ADDR pc
= get_frame_pc (frame
);
884 int sel
= (int) (uintptr_t) data
;
885 struct bound_probe pc_probe
;
886 const struct sym_probe_fns
*pc_probe_fns
;
889 /* SEL == -1 means "_probe_argc". */
890 gdb_assert (sel
>= -1);
892 pc_probe
= find_probe_by_pc (pc
);
893 if (pc_probe
.probe
== NULL
)
894 error (_("No probe at PC %s"), core_addr_to_string (pc
));
896 n_args
= get_probe_argument_count (pc_probe
.probe
, frame
);
898 return value_from_longest (builtin_type (arch
)->builtin_int
, n_args
);
901 error (_("Invalid probe argument %d -- probe has %u arguments available"),
904 return evaluate_probe_argument (pc_probe
.probe
, sel
, frame
);
907 /* This is called to compile one of the $_probe_arg* convenience
908 variables into an agent expression. */
911 compile_probe_arg (struct internalvar
*ivar
, struct agent_expr
*expr
,
912 struct axs_value
*value
, void *data
)
914 CORE_ADDR pc
= expr
->scope
;
915 int sel
= (int) (uintptr_t) data
;
916 struct bound_probe pc_probe
;
917 const struct sym_probe_fns
*pc_probe_fns
;
919 struct frame_info
*frame
= get_selected_frame (NULL
);
921 /* SEL == -1 means "_probe_argc". */
922 gdb_assert (sel
>= -1);
924 pc_probe
= find_probe_by_pc (pc
);
925 if (pc_probe
.probe
== NULL
)
926 error (_("No probe at PC %s"), core_addr_to_string (pc
));
928 n_args
= get_probe_argument_count (pc_probe
.probe
, frame
);
932 value
->kind
= axs_rvalue
;
933 value
->type
= builtin_type (expr
->gdbarch
)->builtin_int
;
934 ax_const_l (expr
, n_args
);
938 gdb_assert (sel
>= 0);
940 error (_("Invalid probe argument %d -- probe has %d arguments available"),
943 pc_probe
.probe
->pops
->compile_to_ax (pc_probe
.probe
, expr
, value
, sel
);
946 static const struct internalvar_funcs probe_funcs
=
954 std::vector
<const probe_ops
*> all_probe_ops
;
957 _initialize_probe (void)
959 all_probe_ops
.push_back (&probe_ops_any
);
961 create_internalvar_type_lazy ("_probe_argc", &probe_funcs
,
962 (void *) (uintptr_t) -1);
963 create_internalvar_type_lazy ("_probe_arg0", &probe_funcs
,
964 (void *) (uintptr_t) 0);
965 create_internalvar_type_lazy ("_probe_arg1", &probe_funcs
,
966 (void *) (uintptr_t) 1);
967 create_internalvar_type_lazy ("_probe_arg2", &probe_funcs
,
968 (void *) (uintptr_t) 2);
969 create_internalvar_type_lazy ("_probe_arg3", &probe_funcs
,
970 (void *) (uintptr_t) 3);
971 create_internalvar_type_lazy ("_probe_arg4", &probe_funcs
,
972 (void *) (uintptr_t) 4);
973 create_internalvar_type_lazy ("_probe_arg5", &probe_funcs
,
974 (void *) (uintptr_t) 5);
975 create_internalvar_type_lazy ("_probe_arg6", &probe_funcs
,
976 (void *) (uintptr_t) 6);
977 create_internalvar_type_lazy ("_probe_arg7", &probe_funcs
,
978 (void *) (uintptr_t) 7);
979 create_internalvar_type_lazy ("_probe_arg8", &probe_funcs
,
980 (void *) (uintptr_t) 8);
981 create_internalvar_type_lazy ("_probe_arg9", &probe_funcs
,
982 (void *) (uintptr_t) 9);
983 create_internalvar_type_lazy ("_probe_arg10", &probe_funcs
,
984 (void *) (uintptr_t) 10);
985 create_internalvar_type_lazy ("_probe_arg11", &probe_funcs
,
986 (void *) (uintptr_t) 11);
988 add_cmd ("all", class_info
, info_probes_command
,
990 Show information about all type of probes."),
991 info_probes_cmdlist_get ());
993 add_cmd ("probes", class_breakpoint
, enable_probes_command
, _("\
995 Usage: enable probes [PROVIDER [NAME [OBJECT]]]\n\
996 Each argument is a regular expression, used to select probes.\n\
997 PROVIDER matches probe provider names.\n\
998 NAME matches the probe names.\n\
999 OBJECT matches the executable or shared library name.\n\
1000 If you do not specify any argument then the command will enable\n\
1001 all defined probes."),
1004 add_cmd ("probes", class_breakpoint
, disable_probes_command
, _("\
1006 Usage: disable probes [PROVIDER [NAME [OBJECT]]]\n\
1007 Each argument is a regular expression, used to select probes.\n\
1008 PROVIDER matches probe provider names.\n\
1009 NAME matches the probe names.\n\
1010 OBJECT matches the executable or shared library name.\n\
1011 If you do not specify any argument then the command will disable\n\
1012 all defined probes."),