gdb/probe.c

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