gdb/probe.c

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