gdb/probe.c

   1 /* Generic static probe support for GDB.
   2
   3    Copyright (C) 2012-2021 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 "gdbsupport/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<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
  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<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
 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       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->location = new_probe_location (canon.c_str ());
 208     }
 209
 210   return result;
 211 }
 212
 213 /* See definition in probe.h.  */
 214
 215 std::vector<probe *>
 216 find_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
 242 struct bound_probe
 243 find_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 \f
 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
 278 static std::vector<bound_probe>
 279 collect_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
 331 static bool
 332 compare_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
 353 static void
 354 gen_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
 401 static void
 402 print_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
 414 static void
 415 print_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
 442 static int
 443 get_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
 451 static bool
 452 exists_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
 465 static void
 466 parse_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
 482 void
 483 info_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
 607 static void
 608 info_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
 615 static void
 616 enable_probes_command (const char *arg, int from_tty)
 617 {
 618   std::string provider, probe_name, objname;
 619
 620   parse_probe_linespec ((const char *) 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
 650 static void
 651 disable_probes_command (const char *arg, int from_tty)
 652 {
 653   std::string provider, probe_name, objname;
 654
 655   parse_probe_linespec ((const char *) 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
 685 struct value *
 686 probe_safe_evaluate_at_pc (struct frame_info *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
 704 const struct static_probe_ops *
 705 probe_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
 716 int
 717 probe_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
 739 bool
 740 any_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
 749 void
 750 any_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
 758 const char *
 759 any_static_probe_ops::type_name () const
 760 {
 761   return NULL;
 762 }
 763
 764 /* Implementation of the 'gen_info_probes_table_header' method.  */
 765
 766 std::vector<struct info_probe_column>
 767 any_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
 774 struct cmd_list_element **
 775 info_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                     _("\
 782 Show available static probes.\n\
 783 Usage: info probes [all|TYPE [ARGS]]\n\
 784 TYPE specifies the type of the probe, and can be one of the following:\n\
 785   - stap\n\
 786 If you specify TYPE, there may be additional arguments needed by the\n\
 787 subcommand.\n\
 788 If you do not specify any argument, or specify `all', then the command\n\
 789 will show information about all types of probes."),
 790                     &info_probes_cmdlist, 0/*allow-unknown*/, &infolist);
 791
 792   return &info_probes_cmdlist;
 793 }
 794
 795 \f
 796
 797 /* This is called to compute the value of one of the $_probe_arg*
 798    convenience variables.  */
 799
 800 static struct value *
 801 compute_probe_arg (struct gdbarch *arch, struct internalvar *ivar,
 802                    void *data)
 803 {
 804   struct frame_info *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
 831 static void
 832 compile_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
 865 static const struct internalvar_funcs probe_funcs =
 866 {
 867   compute_probe_arg,
 868   compile_probe_arg,
 869   NULL
 870 };
 871
 872
 873 std::vector<const static_probe_ops *> all_static_probe_ops;
 874
 875 void _initialize_probe ();
 876 void
 877 _initialize_probe ()
 878 {
 879   all_static_probe_ops.push_back (&any_static_probe_ops);
 880
 881   create_internalvar_type_lazy ("_probe_argc", &probe_funcs,
 882                                 (void *) (uintptr_t) -1);
 883   create_internalvar_type_lazy ("_probe_arg0", &probe_funcs,
 884                                 (void *) (uintptr_t) 0);
 885   create_internalvar_type_lazy ("_probe_arg1", &probe_funcs,
 886                                 (void *) (uintptr_t) 1);
 887   create_internalvar_type_lazy ("_probe_arg2", &probe_funcs,
 888                                 (void *) (uintptr_t) 2);
 889   create_internalvar_type_lazy ("_probe_arg3", &probe_funcs,
 890                                 (void *) (uintptr_t) 3);
 891   create_internalvar_type_lazy ("_probe_arg4", &probe_funcs,
 892                                 (void *) (uintptr_t) 4);
 893   create_internalvar_type_lazy ("_probe_arg5", &probe_funcs,
 894                                 (void *) (uintptr_t) 5);
 895   create_internalvar_type_lazy ("_probe_arg6", &probe_funcs,
 896                                 (void *) (uintptr_t) 6);
 897   create_internalvar_type_lazy ("_probe_arg7", &probe_funcs,
 898                                 (void *) (uintptr_t) 7);
 899   create_internalvar_type_lazy ("_probe_arg8", &probe_funcs,
 900                                 (void *) (uintptr_t) 8);
 901   create_internalvar_type_lazy ("_probe_arg9", &probe_funcs,
 902                                 (void *) (uintptr_t) 9);
 903   create_internalvar_type_lazy ("_probe_arg10", &probe_funcs,
 904                                 (void *) (uintptr_t) 10);
 905   create_internalvar_type_lazy ("_probe_arg11", &probe_funcs,
 906                                 (void *) (uintptr_t) 11);
 907
 908   add_cmd ("all", class_info, info_probes_command,
 909            _("\
 910 Show information about all type of probes."),
 911            info_probes_cmdlist_get ());
 912
 913   add_cmd ("probes", class_breakpoint, enable_probes_command, _("\
 914 Enable probes.\n\
 915 Usage: enable probes [PROVIDER [NAME [OBJECT]]]\n\
 916 Each argument is a regular expression, used to select probes.\n\
 917 PROVIDER matches probe provider names.\n\
 918 NAME matches the probe names.\n\
 919 OBJECT matches the executable or shared library name.\n\
 920 If you do not specify any argument then the command will enable\n\
 921 all defined probes."),
 922            &enablelist);
 923
 924   add_cmd ("probes", class_breakpoint, disable_probes_command, _("\
 925 Disable probes.\n\
 926 Usage: disable probes [PROVIDER [NAME [OBJECT]]]\n\
 927 Each argument is a regular expression, used to select probes.\n\
 928 PROVIDER matches probe provider names.\n\
 929 NAME matches the probe names.\n\
 930 OBJECT matches the executable or shared library name.\n\
 931 If you do not specify any argument then the command will disable\n\
 932 all defined probes."),
 933            &disablelist);
 934
 935 }