1/* Generic static probe support for GDB. 2 3 Copyright (C) 2012-2023 Free Software Foundation, Inc. 4 5 This file is part of GDB. 6 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. 11 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. 16 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/>. */ 19 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 "gdbsupport/gdb_regex.h" 31#include "frame.h" 32#include "arch-utils.h" 33#include "value.h" 34#include "ax.h" 35#include "ax-gdb.h" 36#include "location.h" 37#include <ctype.h> 38#include <algorithm> 39#include "gdbsupport/gdb_optional.h" 40 41/* Class that implements the static probe methods for "any" probe. */ 42 43class any_static_probe_ops : public static_probe_ops 44{ 45public: 46 /* See probe.h. */ 47 bool is_linespec (const char **linespecp) const override; 48 49 /* See probe.h. */ 50 void get_probes (std::vector<std::unique_ptr<probe>> *probesp, 51 struct objfile *objfile) const override; 52 53 /* See probe.h. */ 54 const char *type_name () const override; 55 56 /* See probe.h. */ 57 std::vector<struct info_probe_column> gen_info_probes_table_header 58 () const override; 59}; 60 61/* Static operations associated with a generic probe. */ 62 63const any_static_probe_ops any_static_probe_ops {}; 64 65/* A helper for parse_probes that decodes a probe specification in 66 SEARCH_PSPACE. It appends matching SALs to RESULT. */ 67 68static void 69parse_probes_in_pspace (const static_probe_ops *spops, 70 struct program_space *search_pspace, 71 const char *objfile_namestr, 72 const char *provider, 73 const char *name, 74 std::vector<symtab_and_line> *result) 75{ 76 for (objfile *objfile : search_pspace->objfiles ()) 77 { 78 if (!objfile->sf || !objfile->sf->sym_probe_fns) 79 continue; 80 81 if (objfile_namestr 82 && FILENAME_CMP (objfile_name (objfile), objfile_namestr) != 0 83 && FILENAME_CMP (lbasename (objfile_name (objfile)), 84 objfile_namestr) != 0) 85 continue; 86 87 const std::vector<std::unique_ptr<probe>> &probes 88 = objfile->sf->sym_probe_fns->sym_get_probes (objfile); 89 90 for (auto &p : probes) 91 { 92 if (spops != &any_static_probe_ops && p->get_static_ops () != spops) 93 continue; 94 95 if (provider != NULL && p->get_provider () != provider) 96 continue; 97 98 if (p->get_name () != name) 99 continue; 100 101 symtab_and_line sal; 102 sal.pc = p->get_relocated_address (objfile); 103 sal.explicit_pc = 1; 104 sal.section = find_pc_overlay (sal.pc); 105 sal.pspace = search_pspace; 106 sal.prob = p.get (); 107 sal.objfile = objfile; 108 109 result->push_back (std::move (sal)); 110 } 111 } 112} 113 114/* See definition in probe.h. */ 115 116std::vector<symtab_and_line> 117parse_probes (const location_spec *locspec, 118 struct program_space *search_pspace, 119 struct linespec_result *canonical) 120{ 121 char *arg_end, *arg; 122 char *objfile_namestr = NULL, *provider = NULL, *name, *p; 123 const char *arg_start, *cs; 124 125 gdb_assert (locspec->type () == PROBE_LOCATION_SPEC); 126 arg_start = locspec->to_string (); 127 128 cs = arg_start; 129 const static_probe_ops *spops = probe_linespec_to_static_ops (&cs); 130 if (spops == NULL) 131 error (_("'%s' is not a probe linespec"), arg_start); 132 133 arg = (char *) cs; 134 arg = skip_spaces (arg); 135 if (!*arg) 136 error (_("argument to `%s' missing"), arg_start); 137 138 arg_end = skip_to_space (arg); 139 140 /* We make a copy here so we can write over parts with impunity. */ 141 std::string copy (arg, arg_end - arg); 142 arg = ©[0]; 143 144 /* Extract each word from the argument, separated by ":"s. */ 145 p = strchr (arg, ':'); 146 if (p == NULL) 147 { 148 /* This is `-p name'. */ 149 name = arg; 150 } 151 else 152 { 153 char *hold = p + 1; 154 155 *p = '\0'; 156 p = strchr (hold, ':'); 157 if (p == NULL) 158 { 159 /* This is `-p provider:name'. */ 160 provider = arg; 161 name = hold; 162 } 163 else 164 { 165 /* This is `-p objfile:provider:name'. */ 166 *p = '\0'; 167 objfile_namestr = arg; 168 provider = hold; 169 name = p + 1; 170 } 171 } 172 173 if (*name == '\0') 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")); 179 180 std::vector<symtab_and_line> result; 181 if (search_pspace != NULL) 182 { 183 parse_probes_in_pspace (spops, search_pspace, objfile_namestr, 184 provider, name, &result); 185 } 186 else 187 { 188 for (struct program_space *pspace : program_spaces) 189 parse_probes_in_pspace (spops, pspace, objfile_namestr, 190 provider, name, &result); 191 } 192 193 if (result.empty ()) 194 { 195 throw_error (NOT_FOUND_ERROR, 196 _("No probe matching objfile=`%s', provider=`%s', name=`%s'"), 197 objfile_namestr ? objfile_namestr : _("<any>"), 198 provider ? provider : _("<any>"), 199 name); 200 } 201 202 if (canonical) 203 { 204 std::string canon (arg_start, arg_end - arg_start); 205 canonical->special_display = 1; 206 canonical->pre_expanded = 1; 207 canonical->locspec = new_probe_location_spec (std::move (canon)); 208 } 209 210 return result; 211} 212 213/* See definition in probe.h. */ 214 215std::vector<probe *> 216find_probes_in_objfile (struct objfile *objfile, const char *provider, 217 const char *name) 218{ 219 std::vector<probe *> result; 220 221 if (!objfile->sf || !objfile->sf->sym_probe_fns) 222 return result; 223 224 const std::vector<std::unique_ptr<probe>> &probes 225 = objfile->sf->sym_probe_fns->sym_get_probes (objfile); 226 for (auto &p : probes) 227 { 228 if (p->get_provider () != provider) 229 continue; 230 231 if (p->get_name () != name) 232 continue; 233 234 result.push_back (p.get ()); 235 } 236 237 return result; 238} 239 240/* See definition in probe.h. */ 241 242struct bound_probe 243find_probe_by_pc (CORE_ADDR pc) 244{ 245 struct bound_probe result; 246 247 result.objfile = NULL; 248 result.prob = NULL; 249 250 for (objfile *objfile : current_program_space->objfiles ()) 251 { 252 if (!objfile->sf || !objfile->sf->sym_probe_fns 253 || objfile->sect_index_text == -1) 254 continue; 255 256 /* If this proves too inefficient, we can replace with a hash. */ 257 const std::vector<std::unique_ptr<probe>> &probes 258 = objfile->sf->sym_probe_fns->sym_get_probes (objfile); 259 for (auto &p : probes) 260 if (p->get_relocated_address (objfile) == pc) 261 { 262 result.objfile = objfile; 263 result.prob = p.get (); 264 return result; 265 } 266 } 267 268 return result; 269} 270 271 272 273/* Make a vector of probes matching OBJNAME, PROVIDER, and PROBE_NAME. 274 If SPOPS is not &any_static_probe_ops, only probes related to this 275 specific static probe ops will match. Each argument is a regexp, 276 or NULL, which matches anything. */ 277 278static std::vector<bound_probe> 279collect_probes (const std::string &objname, const std::string &provider, 280 const std::string &probe_name, const static_probe_ops *spops) 281{ 282 std::vector<bound_probe> result; 283 gdb::optional<compiled_regex> obj_pat, prov_pat, probe_pat; 284 285 if (!provider.empty ()) 286 prov_pat.emplace (provider.c_str (), REG_NOSUB, 287 _("Invalid provider regexp")); 288 if (!probe_name.empty ()) 289 probe_pat.emplace (probe_name.c_str (), REG_NOSUB, 290 _("Invalid probe regexp")); 291 if (!objname.empty ()) 292 obj_pat.emplace (objname.c_str (), REG_NOSUB, 293 _("Invalid object file regexp")); 294 295 for (objfile *objfile : current_program_space->objfiles ()) 296 { 297 if (! objfile->sf || ! objfile->sf->sym_probe_fns) 298 continue; 299 300 if (obj_pat) 301 { 302 if (obj_pat->exec (objfile_name (objfile), 0, NULL, 0) != 0) 303 continue; 304 } 305 306 const std::vector<std::unique_ptr<probe>> &probes 307 = objfile->sf->sym_probe_fns->sym_get_probes (objfile); 308 309 for (auto &p : probes) 310 { 311 if (spops != &any_static_probe_ops && p->get_static_ops () != spops) 312 continue; 313 314 if (prov_pat 315 && prov_pat->exec (p->get_provider ().c_str (), 0, NULL, 0) != 0) 316 continue; 317 318 if (probe_pat 319 && probe_pat->exec (p->get_name ().c_str (), 0, NULL, 0) != 0) 320 continue; 321 322 result.emplace_back (p.get (), objfile); 323 } 324 } 325 326 return result; 327} 328 329/* A qsort comparison function for bound_probe_s objects. */ 330 331static bool 332compare_probes (const bound_probe &a, const bound_probe &b) 333{ 334 int v; 335 336 v = a.prob->get_provider ().compare (b.prob->get_provider ()); 337 if (v != 0) 338 return v < 0; 339 340 v = a.prob->get_name ().compare (b.prob->get_name ()); 341 if (v != 0) 342 return v < 0; 343 344 if (a.prob->get_address () != b.prob->get_address ()) 345 return a.prob->get_address () < b.prob->get_address (); 346 347 return strcmp (objfile_name (a.objfile), objfile_name (b.objfile)) < 0; 348} 349 350/* Helper function that generate entries in the ui_out table being 351 crafted by `info_probes_for_ops'. */ 352 353static void 354gen_ui_out_table_header_info (const std::vector<bound_probe> &probes, 355 const static_probe_ops *spops) 356{ 357 /* `headings' refers to the names of the columns when printing `info 358 probes'. */ 359 gdb_assert (spops != NULL); 360 361 std::vector<struct info_probe_column> headings 362 = spops->gen_info_probes_table_header (); 363 364 for (const info_probe_column &column : headings) 365 { 366 size_t size_max = strlen (column.print_name); 367 368 for (const bound_probe &probe : probes) 369 { 370 /* `probe_fields' refers to the values of each new field that this 371 probe will display. */ 372 373 if (probe.prob->get_static_ops () != spops) 374 continue; 375 376 std::vector<const char *> probe_fields 377 = probe.prob->gen_info_probes_table_values (); 378 379 gdb_assert (probe_fields.size () == headings.size ()); 380 381 for (const char *val : probe_fields) 382 { 383 /* It is valid to have a NULL value here, which means that the 384 backend does not have something to write and this particular 385 field should be skipped. */ 386 if (val == NULL) 387 continue; 388 389 size_max = std::max (strlen (val), size_max); 390 } 391 } 392 393 current_uiout->table_header (size_max, ui_left, 394 column.field_name, column.print_name); 395 } 396} 397 398/* Helper function to print not-applicable strings for all the extra 399 columns defined in a static_probe_ops. */ 400 401static void 402print_ui_out_not_applicables (const static_probe_ops *spops) 403{ 404 std::vector<struct info_probe_column> headings 405 = spops->gen_info_probes_table_header (); 406 407 for (const info_probe_column &column : headings) 408 current_uiout->field_string (column.field_name, _("n/a")); 409} 410 411/* Helper function to print extra information about a probe and an objfile 412 represented by PROBE. */ 413 414static void 415print_ui_out_info (probe *probe) 416{ 417 /* `values' refers to the actual values of each new field in the output 418 of `info probe'. `headings' refers to the names of each new field. */ 419 gdb_assert (probe != NULL); 420 std::vector<struct info_probe_column> headings 421 = probe->get_static_ops ()->gen_info_probes_table_header (); 422 std::vector<const char *> values 423 = probe->gen_info_probes_table_values (); 424 425 gdb_assert (headings.size () == values.size ()); 426 427 for (int ix = 0; ix < headings.size (); ++ix) 428 { 429 struct info_probe_column column = headings[ix]; 430 const char *val = values[ix]; 431 432 if (val == NULL) 433 current_uiout->field_skip (column.field_name); 434 else 435 current_uiout->field_string (column.field_name, val); 436 } 437} 438 439/* Helper function that returns the number of extra fields which POPS will 440 need. */ 441 442static int 443get_number_extra_fields (const static_probe_ops *spops) 444{ 445 return spops->gen_info_probes_table_header ().size (); 446} 447 448/* Helper function that returns true if there is a probe in PROBES 449 featuring the given SPOPS. It returns false otherwise. */ 450 451static bool 452exists_probe_with_spops (const std::vector<bound_probe> &probes, 453 const static_probe_ops *spops) 454{ 455 for (const bound_probe &probe : probes) 456 if (probe.prob->get_static_ops () == spops) 457 return true; 458 459 return false; 460} 461 462/* Helper function that parses a probe linespec of the form [PROVIDER 463 [PROBE [OBJNAME]]] from the provided string STR. */ 464 465static void 466parse_probe_linespec (const char *str, std::string *provider, 467 std::string *probe_name, std::string *objname) 468{ 469 *probe_name = *objname = ""; 470 471 *provider = extract_arg (&str); 472 if (!provider->empty ()) 473 { 474 *probe_name = extract_arg (&str); 475 if (!probe_name->empty ()) 476 *objname = extract_arg (&str); 477 } 478} 479 480/* See comment in probe.h. */ 481 482void 483info_probes_for_spops (const char *arg, int from_tty, 484 const static_probe_ops *spops) 485{ 486 std::string provider, probe_name, objname; 487 int any_found; 488 int ui_out_extra_fields = 0; 489 size_t size_addr; 490 size_t size_name = strlen ("Name"); 491 size_t size_objname = strlen ("Object"); 492 size_t size_provider = strlen ("Provider"); 493 size_t size_type = strlen ("Type"); 494 struct gdbarch *gdbarch = get_current_arch (); 495 496 parse_probe_linespec (arg, &provider, &probe_name, &objname); 497 498 std::vector<bound_probe> probes 499 = collect_probes (objname, provider, probe_name, spops); 500 501 if (spops == &any_static_probe_ops) 502 { 503 /* If SPOPS is &any_static_probe_ops, it means the user has 504 requested a "simple" `info probes', i.e., she wants to print 505 all information about all probes. For that, we have to 506 identify how many extra fields we will need to add in the 507 ui_out table. 508 509 To do that, we iterate over all static_probe_ops, querying 510 each one about its extra fields, and incrementing 511 `ui_out_extra_fields' to reflect that number. But note that 512 we ignore the static_probe_ops for which no probes are 513 defined with the given search criteria. */ 514 515 for (const static_probe_ops *po : all_static_probe_ops) 516 if (exists_probe_with_spops (probes, po)) 517 ui_out_extra_fields += get_number_extra_fields (po); 518 } 519 else 520 ui_out_extra_fields = get_number_extra_fields (spops); 521 522 { 523 ui_out_emit_table table_emitter (current_uiout, 524 5 + ui_out_extra_fields, 525 probes.size (), "StaticProbes"); 526 527 std::sort (probes.begin (), probes.end (), compare_probes); 528 529 /* What's the size of an address in our architecture? */ 530 size_addr = gdbarch_addr_bit (gdbarch) == 64 ? 18 : 10; 531 532 /* Determining the maximum size of each field (`type', `provider', 533 `name' and `objname'). */ 534 for (const bound_probe &probe : probes) 535 { 536 const char *probe_type = probe.prob->get_static_ops ()->type_name (); 537 538 size_type = std::max (strlen (probe_type), size_type); 539 size_name = std::max (probe.prob->get_name ().size (), size_name); 540 size_provider = std::max (probe.prob->get_provider ().size (), 541 size_provider); 542 size_objname = std::max (strlen (objfile_name (probe.objfile)), 543 size_objname); 544 } 545 546 current_uiout->table_header (size_type, ui_left, "type", _("Type")); 547 current_uiout->table_header (size_provider, ui_left, "provider", 548 _("Provider")); 549 current_uiout->table_header (size_name, ui_left, "name", _("Name")); 550 current_uiout->table_header (size_addr, ui_left, "addr", _("Where")); 551 552 if (spops == &any_static_probe_ops) 553 { 554 /* We have to generate the table header for each new probe type 555 that we will print. Note that this excludes probe types not 556 having any defined probe with the search criteria. */ 557 for (const static_probe_ops *po : all_static_probe_ops) 558 if (exists_probe_with_spops (probes, po)) 559 gen_ui_out_table_header_info (probes, po); 560 } 561 else 562 gen_ui_out_table_header_info (probes, spops); 563 564 current_uiout->table_header (size_objname, ui_left, "object", _("Object")); 565 current_uiout->table_body (); 566 567 for (const bound_probe &probe : probes) 568 { 569 const char *probe_type = probe.prob->get_static_ops ()->type_name (); 570 571 ui_out_emit_tuple tuple_emitter (current_uiout, "probe"); 572 573 current_uiout->field_string ("type", probe_type); 574 current_uiout->field_string ("provider", probe.prob->get_provider ()); 575 current_uiout->field_string ("name", probe.prob->get_name ()); 576 current_uiout->field_core_addr ("addr", probe.prob->get_gdbarch (), 577 probe.prob->get_relocated_address 578 (probe.objfile)); 579 580 if (spops == &any_static_probe_ops) 581 { 582 for (const static_probe_ops *po : all_static_probe_ops) 583 { 584 if (probe.prob->get_static_ops () == po) 585 print_ui_out_info (probe.prob); 586 else if (exists_probe_with_spops (probes, po)) 587 print_ui_out_not_applicables (po); 588 } 589 } 590 else 591 print_ui_out_info (probe.prob); 592 593 current_uiout->field_string ("object", 594 objfile_name (probe.objfile)); 595 current_uiout->text ("\n"); 596 } 597 598 any_found = !probes.empty (); 599 } 600 601 if (!any_found) 602 current_uiout->message (_("No probes matched.\n")); 603} 604 605/* Implementation of the `info probes' command. */ 606 607static void 608info_probes_command (const char *arg, int from_tty) 609{ 610 info_probes_for_spops (arg, from_tty, &any_static_probe_ops); 611} 612 613/* Implementation of the `enable probes' command. */ 614 615static void 616enable_probes_command (const char *arg, int from_tty) 617{ 618 std::string provider, probe_name, objname; 619 620 parse_probe_linespec (arg, &provider, &probe_name, &objname); 621 622 std::vector<bound_probe> probes 623 = collect_probes (objname, provider, probe_name, &any_static_probe_ops); 624 if (probes.empty ()) 625 { 626 current_uiout->message (_("No probes matched.\n")); 627 return; 628 } 629 630 /* Enable the selected probes, provided their backends support the 631 notion of enabling a probe. */ 632 for (const bound_probe &probe: probes) 633 { 634 if (probe.prob->get_static_ops ()->can_enable ()) 635 { 636 probe.prob->enable (); 637 current_uiout->message (_("Probe %s:%s enabled.\n"), 638 probe.prob->get_provider ().c_str (), 639 probe.prob->get_name ().c_str ()); 640 } 641 else 642 current_uiout->message (_("Probe %s:%s cannot be enabled.\n"), 643 probe.prob->get_provider ().c_str (), 644 probe.prob->get_name ().c_str ()); 645 } 646} 647 648/* Implementation of the `disable probes' command. */ 649 650static void 651disable_probes_command (const char *arg, int from_tty) 652{ 653 std::string provider, probe_name, objname; 654 655 parse_probe_linespec (arg, &provider, &probe_name, &objname); 656 657 std::vector<bound_probe> probes 658 = collect_probes (objname, provider, probe_name, &any_static_probe_ops); 659 if (probes.empty ()) 660 { 661 current_uiout->message (_("No probes matched.\n")); 662 return; 663 } 664 665 /* Disable the selected probes, provided their backends support the 666 notion of enabling a probe. */ 667 for (const bound_probe &probe : probes) 668 { 669 if (probe.prob->get_static_ops ()->can_enable ()) 670 { 671 probe.prob->disable (); 672 current_uiout->message (_("Probe %s:%s disabled.\n"), 673 probe.prob->get_provider ().c_str (), 674 probe.prob->get_name ().c_str ()); 675 } 676 else 677 current_uiout->message (_("Probe %s:%s cannot be disabled.\n"), 678 probe.prob->get_provider ().c_str (), 679 probe.prob->get_name ().c_str ()); 680 } 681} 682 683/* See comments in probe.h. */ 684 685struct value * 686probe_safe_evaluate_at_pc (frame_info_ptr frame, unsigned n) 687{ 688 struct bound_probe probe; 689 unsigned n_args; 690 691 probe = find_probe_by_pc (get_frame_pc (frame)); 692 if (!probe.prob) 693 return NULL; 694 695 n_args = probe.prob->get_argument_count (get_frame_arch (frame)); 696 if (n >= n_args) 697 return NULL; 698 699 return probe.prob->evaluate_argument (n, frame); 700} 701 702/* See comment in probe.h. */ 703 704const struct static_probe_ops * 705probe_linespec_to_static_ops (const char **linespecp) 706{ 707 for (const static_probe_ops *ops : all_static_probe_ops) 708 if (ops->is_linespec (linespecp)) 709 return ops; 710 711 return NULL; 712} 713 714/* See comment in probe.h. */ 715 716int 717probe_is_linespec_by_keyword (const char **linespecp, const char *const *keywords) 718{ 719 const char *s = *linespecp; 720 const char *const *csp; 721 722 for (csp = keywords; *csp; csp++) 723 { 724 const char *keyword = *csp; 725 size_t len = strlen (keyword); 726 727 if (strncmp (s, keyword, len) == 0 && isspace (s[len])) 728 { 729 *linespecp += len + 1; 730 return 1; 731 } 732 } 733 734 return 0; 735} 736 737/* Implementation of `is_linespec' method. */ 738 739bool 740any_static_probe_ops::is_linespec (const char **linespecp) const 741{ 742 static const char *const keywords[] = { "-p", "-probe", NULL }; 743 744 return probe_is_linespec_by_keyword (linespecp, keywords); 745} 746 747/* Implementation of 'get_probes' method. */ 748 749void 750any_static_probe_ops::get_probes (std::vector<std::unique_ptr<probe>> *probesp, 751 struct objfile *objfile) const 752{ 753 /* No probes can be provided by this dummy backend. */ 754} 755 756/* Implementation of the 'type_name' method. */ 757 758const char * 759any_static_probe_ops::type_name () const 760{ 761 return NULL; 762} 763 764/* Implementation of the 'gen_info_probes_table_header' method. */ 765 766std::vector<struct info_probe_column> 767any_static_probe_ops::gen_info_probes_table_header () const 768{ 769 return std::vector<struct info_probe_column> (); 770} 771 772/* See comments in probe.h. */ 773 774struct cmd_list_element ** 775info_probes_cmdlist_get (void) 776{ 777 static struct cmd_list_element *info_probes_cmdlist; 778 779 if (info_probes_cmdlist == NULL) 780 add_prefix_cmd ("probes", class_info, info_probes_command, 781 _("\ 782Show available static probes.\n\ 783Usage: info probes [all|TYPE [ARGS]]\n\ 784TYPE specifies the type of the probe, and can be one of the following:\n\ 785 - stap\n\ 786If you specify TYPE, there may be additional arguments needed by the\n\ 787subcommand.\n\ 788If you do not specify any argument, or specify `all', then the command\n\ 789will show information about all types of probes."), 790 &info_probes_cmdlist, 0/*allow-unknown*/, &infolist); 791 792 return &info_probes_cmdlist; 793} 794 795 796 797/* This is called to compute the value of one of the $_probe_arg* 798 convenience variables. */ 799 800static struct value * 801compute_probe_arg (struct gdbarch *arch, struct internalvar *ivar, 802 void *data) 803{ 804 frame_info_ptr frame = get_selected_frame (_("No frame selected")); 805 CORE_ADDR pc = get_frame_pc (frame); 806 int sel = (int) (uintptr_t) data; 807 struct bound_probe pc_probe; 808 unsigned n_args; 809 810 /* SEL == -1 means "_probe_argc". */ 811 gdb_assert (sel >= -1); 812 813 pc_probe = find_probe_by_pc (pc); 814 if (pc_probe.prob == NULL) 815 error (_("No probe at PC %s"), core_addr_to_string (pc)); 816 817 n_args = pc_probe.prob->get_argument_count (arch); 818 if (sel == -1) 819 return value_from_longest (builtin_type (arch)->builtin_int, n_args); 820 821 if (sel >= n_args) 822 error (_("Invalid probe argument %d -- probe has %u arguments available"), 823 sel, n_args); 824 825 return pc_probe.prob->evaluate_argument (sel, frame); 826} 827 828/* This is called to compile one of the $_probe_arg* convenience 829 variables into an agent expression. */ 830 831static void 832compile_probe_arg (struct internalvar *ivar, struct agent_expr *expr, 833 struct axs_value *value, void *data) 834{ 835 CORE_ADDR pc = expr->scope; 836 int sel = (int) (uintptr_t) data; 837 struct bound_probe pc_probe; 838 int n_args; 839 840 /* SEL == -1 means "_probe_argc". */ 841 gdb_assert (sel >= -1); 842 843 pc_probe = find_probe_by_pc (pc); 844 if (pc_probe.prob == NULL) 845 error (_("No probe at PC %s"), core_addr_to_string (pc)); 846 847 n_args = pc_probe.prob->get_argument_count (expr->gdbarch); 848 849 if (sel == -1) 850 { 851 value->kind = axs_rvalue; 852 value->type = builtin_type (expr->gdbarch)->builtin_int; 853 ax_const_l (expr, n_args); 854 return; 855 } 856 857 gdb_assert (sel >= 0); 858 if (sel >= n_args) 859 error (_("Invalid probe argument %d -- probe has %d arguments available"), 860 sel, n_args); 861 862 pc_probe.prob->compile_to_ax (expr, value, sel); 863} 864 865static const struct internalvar_funcs probe_funcs = 866{ 867 compute_probe_arg, 868 compile_probe_arg, 869}; 870 871 872std::vector<const static_probe_ops *> all_static_probe_ops; 873 874void _initialize_probe (); 875void 876_initialize_probe () 877{ 878 all_static_probe_ops.push_back (&any_static_probe_ops); 879 880 create_internalvar_type_lazy ("_probe_argc", &probe_funcs, 881 (void *) (uintptr_t) -1); 882 create_internalvar_type_lazy ("_probe_arg0", &probe_funcs, 883 (void *) (uintptr_t) 0); 884 create_internalvar_type_lazy ("_probe_arg1", &probe_funcs, 885 (void *) (uintptr_t) 1); 886 create_internalvar_type_lazy ("_probe_arg2", &probe_funcs, 887 (void *) (uintptr_t) 2); 888 create_internalvar_type_lazy ("_probe_arg3", &probe_funcs, 889 (void *) (uintptr_t) 3); 890 create_internalvar_type_lazy ("_probe_arg4", &probe_funcs, 891 (void *) (uintptr_t) 4); 892 create_internalvar_type_lazy ("_probe_arg5", &probe_funcs, 893 (void *) (uintptr_t) 5); 894 create_internalvar_type_lazy ("_probe_arg6", &probe_funcs, 895 (void *) (uintptr_t) 6); 896 create_internalvar_type_lazy ("_probe_arg7", &probe_funcs, 897 (void *) (uintptr_t) 7); 898 create_internalvar_type_lazy ("_probe_arg8", &probe_funcs, 899 (void *) (uintptr_t) 8); 900 create_internalvar_type_lazy ("_probe_arg9", &probe_funcs, 901 (void *) (uintptr_t) 9); 902 create_internalvar_type_lazy ("_probe_arg10", &probe_funcs, 903 (void *) (uintptr_t) 10); 904 create_internalvar_type_lazy ("_probe_arg11", &probe_funcs, 905 (void *) (uintptr_t) 11); 906 907 add_cmd ("all", class_info, info_probes_command, 908 _("\ 909Show information about all type of probes."), 910 info_probes_cmdlist_get ()); 911 912 add_cmd ("probes", class_breakpoint, enable_probes_command, _("\ 913Enable probes.\n\ 914Usage: enable probes [PROVIDER [NAME [OBJECT]]]\n\ 915Each argument is a regular expression, used to select probes.\n\ 916PROVIDER matches probe provider names.\n\ 917NAME matches the probe names.\n\ 918OBJECT matches the executable or shared library name.\n\ 919If you do not specify any argument then the command will enable\n\ 920all defined probes."), 921 &enablelist); 922 923 add_cmd ("probes", class_breakpoint, disable_probes_command, _("\ 924Disable probes.\n\ 925Usage: disable probes [PROVIDER [NAME [OBJECT]]]\n\ 926Each argument is a regular expression, used to select probes.\n\ 927PROVIDER matches probe provider names.\n\ 928NAME matches the probe names.\n\ 929OBJECT matches the executable or shared library name.\n\ 930If you do not specify any argument then the command will disable\n\ 931all defined probes."), 932 &disablelist); 933 934} 935