gdb/probe.c

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