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