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
  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       current_uiout->table_header (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     current_uiout->field_string (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         current_uiout->field_skip (column->field_name);
 515       else
 516         current_uiout->field_string (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   current_uiout->table_header (size_type, ui_left, "type", _("Type"));
 656   current_uiout->table_header (size_provider, ui_left, "provider",
 657                                _("Provider"));
 658   current_uiout->table_header (size_name, ui_left, "name", _("Name"));
 659   current_uiout->table_header (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   current_uiout->table_header (size_objname, ui_left, "object", _("Object"));
 677   current_uiout->table_body ();
 678
 679   for (i = 0; VEC_iterate (bound_probe_s, probes, i, probe); ++i)
 680     {
 681       struct cleanup *inner;
 682       const char *probe_type = probe->probe->pops->type_name (probe->probe);
 683
 684       inner = make_cleanup_ui_out_tuple_begin_end (current_uiout, "probe");
 685
 686       current_uiout->field_string ("type",probe_type);
 687       current_uiout->field_string ("provider", probe->probe->provider);
 688       current_uiout->field_string ("name", probe->probe->name);
 689       current_uiout->field_core_addr (
 690         "addr", probe->probe->arch,
 691         get_probe_address (probe->probe, probe->objfile));
 692
 693       if (pops == NULL)
 694         {
 695           const struct probe_ops *po;
 696           int ix;
 697
 698           for (ix = 0; VEC_iterate (probe_ops_cp, all_probe_ops, ix, po);
 699                ++ix)
 700             if (probe->probe->pops == po)
 701               print_ui_out_info (probe->probe);
 702             else if (exists_probe_with_pops (probes, po))
 703               print_ui_out_not_applicables (po);
 704         }
 705       else
 706         print_ui_out_info (probe->probe);
 707
 708       current_uiout->field_string ("object",
 709                            objfile_name (probe->objfile));
 710       current_uiout->text ("\n");
 711
 712       do_cleanups (inner);
 713     }
 714
 715   any_found = !VEC_empty (bound_probe_s, probes);
 716   do_cleanups (cleanup);
 717
 718   if (!any_found)
 719     current_uiout->message (_("No probes matched.\n"));
 720 }
 721
 722 /* Implementation of the `info probes' command.  */
 723
 724 static void
 725 info_probes_command (char *arg, int from_tty)
 726 {
 727   info_probes_for_ops (arg, from_tty, NULL);
 728 }
 729
 730 /* Implementation of the `enable probes' command.  */
 731
 732 static void
 733 enable_probes_command (char *arg, int from_tty)
 734 {
 735   char *provider, *probe_name = NULL, *objname = NULL;
 736   struct cleanup *cleanup = make_cleanup (null_cleanup, NULL);
 737   VEC (bound_probe_s) *probes;
 738   struct bound_probe *probe;
 739   int i;
 740
 741   parse_probe_linespec ((const char *) arg, &provider, &probe_name, &objname);
 742   make_cleanup (xfree, provider);
 743   make_cleanup (xfree, probe_name);
 744   make_cleanup (xfree, objname);
 745
 746   probes = collect_probes (objname, provider, probe_name, NULL);
 747   if (VEC_empty (bound_probe_s, probes))
 748     {
 749       current_uiout->message (_("No probes matched.\n"));
 750       do_cleanups (cleanup);
 751       return;
 752     }
 753
 754   /* Enable the selected probes, provided their backends support the
 755      notion of enabling a probe.  */
 756   for (i = 0; VEC_iterate (bound_probe_s, probes, i, probe); ++i)
 757     {
 758       const struct probe_ops *pops = probe->probe->pops;
 759
 760       if (pops->enable_probe != NULL)
 761         {
 762           pops->enable_probe (probe->probe);
 763           current_uiout->message (_("Probe %s:%s enabled.\n"),
 764                                   probe->probe->provider, probe->probe->name);
 765         }
 766       else
 767         current_uiout->message (_("Probe %s:%s cannot be enabled.\n"),
 768                                 probe->probe->provider, probe->probe->name);
 769     }
 770
 771   do_cleanups (cleanup);
 772 }
 773
 774 /* Implementation of the `disable probes' command.  */
 775
 776 static void
 777 disable_probes_command (char *arg, int from_tty)
 778 {
 779   char *provider, *probe_name = NULL, *objname = NULL;
 780   struct cleanup *cleanup = make_cleanup (null_cleanup, NULL);
 781   VEC (bound_probe_s) *probes;
 782   struct bound_probe *probe;
 783   int i;
 784
 785   parse_probe_linespec ((const char *) arg, &provider, &probe_name, &objname);
 786   make_cleanup (xfree, provider);
 787   make_cleanup (xfree, probe_name);
 788   make_cleanup (xfree, objname);
 789
 790   probes = collect_probes (objname, provider, probe_name, NULL /* pops */);
 791   if (VEC_empty (bound_probe_s, probes))
 792     {
 793       current_uiout->message (_("No probes matched.\n"));
 794       do_cleanups (cleanup);
 795       return;
 796     }
 797
 798   /* Disable the selected probes, provided their backends support the
 799      notion of enabling a probe.  */
 800   for (i = 0; VEC_iterate (bound_probe_s, probes, i, probe); ++i)
 801     {
 802       const struct probe_ops *pops = probe->probe->pops;
 803
 804       if (pops->disable_probe != NULL)
 805         {
 806           pops->disable_probe (probe->probe);
 807           current_uiout->message (_("Probe %s:%s disabled.\n"),
 808                                   probe->probe->provider, probe->probe->name);
 809         }
 810       else
 811         current_uiout->message (_("Probe %s:%s cannot be disabled.\n"),
 812                                 probe->probe->provider, probe->probe->name);
 813     }
 814
 815   do_cleanups (cleanup);
 816 }
 817
 818 /* See comments in probe.h.  */
 819
 820 CORE_ADDR
 821 get_probe_address (struct probe *probe, struct objfile *objfile)
 822 {
 823   return probe->pops->get_probe_address (probe, objfile);
 824 }
 825
 826 /* See comments in probe.h.  */
 827
 828 unsigned
 829 get_probe_argument_count (struct probe *probe, struct frame_info *frame)
 830 {
 831   return probe->pops->get_probe_argument_count (probe, frame);
 832 }
 833
 834 /* See comments in probe.h.  */
 835
 836 int
 837 can_evaluate_probe_arguments (struct probe *probe)
 838 {
 839   return probe->pops->can_evaluate_probe_arguments (probe);
 840 }
 841
 842 /* See comments in probe.h.  */
 843
 844 struct value *
 845 evaluate_probe_argument (struct probe *probe, unsigned n,
 846                          struct frame_info *frame)
 847 {
 848   return probe->pops->evaluate_probe_argument (probe, n, frame);
 849 }
 850
 851 /* See comments in probe.h.  */
 852
 853 struct value *
 854 probe_safe_evaluate_at_pc (struct frame_info *frame, unsigned n)
 855 {
 856   struct bound_probe probe;
 857   unsigned n_args;
 858
 859   probe = find_probe_by_pc (get_frame_pc (frame));
 860   if (!probe.probe)
 861     return NULL;
 862
 863   n_args = get_probe_argument_count (probe.probe, frame);
 864   if (n >= n_args)
 865     return NULL;
 866
 867   return evaluate_probe_argument (probe.probe, n, frame);
 868 }
 869
 870 /* See comment in probe.h.  */
 871
 872 const struct probe_ops *
 873 probe_linespec_to_ops (const char **linespecp)
 874 {
 875   int ix;
 876   const struct probe_ops *probe_ops;
 877
 878   for (ix = 0; VEC_iterate (probe_ops_cp, all_probe_ops, ix, probe_ops); ix++)
 879     if (probe_ops->is_linespec (linespecp))
 880       return probe_ops;
 881
 882   return NULL;
 883 }
 884
 885 /* See comment in probe.h.  */
 886
 887 int
 888 probe_is_linespec_by_keyword (const char **linespecp, const char *const *keywords)
 889 {
 890   const char *s = *linespecp;
 891   const char *const *csp;
 892
 893   for (csp = keywords; *csp; csp++)
 894     {
 895       const char *keyword = *csp;
 896       size_t len = strlen (keyword);
 897
 898       if (strncmp (s, keyword, len) == 0 && isspace (s[len]))
 899         {
 900           *linespecp += len + 1;
 901           return 1;
 902         }
 903     }
 904
 905   return 0;
 906 }
 907
 908 /* Implementation of `is_linespec' method for `struct probe_ops'.  */
 909
 910 static int
 911 probe_any_is_linespec (const char **linespecp)
 912 {
 913   static const char *const keywords[] = { "-p", "-probe", NULL };
 914
 915   return probe_is_linespec_by_keyword (linespecp, keywords);
 916 }
 917
 918 /* Dummy method used for `probe_ops_any'.  */
 919
 920 static void
 921 probe_any_get_probes (VEC (probe_p) **probesp, struct objfile *objfile)
 922 {
 923   /* No probes can be provided by this dummy backend.  */
 924 }
 925
 926 /* Operations associated with a generic probe.  */
 927
 928 const struct probe_ops probe_ops_any =
 929 {
 930   probe_any_is_linespec,
 931   probe_any_get_probes,
 932 };
 933
 934 /* See comments in probe.h.  */
 935
 936 struct cmd_list_element **
 937 info_probes_cmdlist_get (void)
 938 {
 939   static struct cmd_list_element *info_probes_cmdlist;
 940
 941   if (info_probes_cmdlist == NULL)
 942     add_prefix_cmd ("probes", class_info, info_probes_command,
 943                     _("\
 944 Show available static probes.\n\
 945 Usage: info probes [all|TYPE [ARGS]]\n\
 946 TYPE specifies the type of the probe, and can be one of the following:\n\
 947   - stap\n\
 948 If you specify TYPE, there may be additional arguments needed by the\n\
 949 subcommand.\n\
 950 If you do not specify any argument, or specify `all', then the command\n\
 951 will show information about all types of probes."),
 952                     &info_probes_cmdlist, "info probes ",
 953                     0/*allow-unknown*/, &infolist);
 954
 955   return &info_probes_cmdlist;
 956 }
 957
 958 \f
 959
 960 /* This is called to compute the value of one of the $_probe_arg*
 961    convenience variables.  */
 962
 963 static struct value *
 964 compute_probe_arg (struct gdbarch *arch, struct internalvar *ivar,
 965                    void *data)
 966 {
 967   struct frame_info *frame = get_selected_frame (_("No frame selected"));
 968   CORE_ADDR pc = get_frame_pc (frame);
 969   int sel = (int) (uintptr_t) data;
 970   struct bound_probe pc_probe;
 971   const struct sym_probe_fns *pc_probe_fns;
 972   unsigned n_args;
 973
 974   /* SEL == -1 means "_probe_argc".  */
 975   gdb_assert (sel >= -1);
 976
 977   pc_probe = find_probe_by_pc (pc);
 978   if (pc_probe.probe == NULL)
 979     error (_("No probe at PC %s"), core_addr_to_string (pc));
 980
 981   n_args = get_probe_argument_count (pc_probe.probe, frame);
 982   if (sel == -1)
 983     return value_from_longest (builtin_type (arch)->builtin_int, n_args);
 984
 985   if (sel >= n_args)
 986     error (_("Invalid probe argument %d -- probe has %u arguments available"),
 987            sel, n_args);
 988
 989   return evaluate_probe_argument (pc_probe.probe, sel, frame);
 990 }
 991
 992 /* This is called to compile one of the $_probe_arg* convenience
 993    variables into an agent expression.  */
 994
 995 static void
 996 compile_probe_arg (struct internalvar *ivar, struct agent_expr *expr,
 997                    struct axs_value *value, void *data)
 998 {
 999   CORE_ADDR pc = expr->scope;
1000   int sel = (int) (uintptr_t) data;
1001   struct bound_probe pc_probe;
1002   const struct sym_probe_fns *pc_probe_fns;
1003   int n_args;
1004   struct frame_info *frame = get_selected_frame (NULL);
1005
1006   /* SEL == -1 means "_probe_argc".  */
1007   gdb_assert (sel >= -1);
1008
1009   pc_probe = find_probe_by_pc (pc);
1010   if (pc_probe.probe == NULL)
1011     error (_("No probe at PC %s"), core_addr_to_string (pc));
1012
1013   n_args = get_probe_argument_count (pc_probe.probe, frame);
1014
1015   if (sel == -1)
1016     {
1017       value->kind = axs_rvalue;
1018       value->type = builtin_type (expr->gdbarch)->builtin_int;
1019       ax_const_l (expr, n_args);
1020       return;
1021     }
1022
1023   gdb_assert (sel >= 0);
1024   if (sel >= n_args)
1025     error (_("Invalid probe argument %d -- probe has %d arguments available"),
1026            sel, n_args);
1027
1028   pc_probe.probe->pops->compile_to_ax (pc_probe.probe, expr, value, sel);
1029 }
1030
1031 static const struct internalvar_funcs probe_funcs =
1032 {
1033   compute_probe_arg,
1034   compile_probe_arg,
1035   NULL
1036 };
1037
1038
1039 VEC (probe_ops_cp) *all_probe_ops;
1040
1041 void _initialize_probe (void);
1042
1043 void
1044 _initialize_probe (void)
1045 {
1046   VEC_safe_push (probe_ops_cp, all_probe_ops, &probe_ops_any);
1047
1048   create_internalvar_type_lazy ("_probe_argc", &probe_funcs,
1049                                 (void *) (uintptr_t) -1);
1050   create_internalvar_type_lazy ("_probe_arg0", &probe_funcs,
1051                                 (void *) (uintptr_t) 0);
1052   create_internalvar_type_lazy ("_probe_arg1", &probe_funcs,
1053                                 (void *) (uintptr_t) 1);
1054   create_internalvar_type_lazy ("_probe_arg2", &probe_funcs,
1055                                 (void *) (uintptr_t) 2);
1056   create_internalvar_type_lazy ("_probe_arg3", &probe_funcs,
1057                                 (void *) (uintptr_t) 3);
1058   create_internalvar_type_lazy ("_probe_arg4", &probe_funcs,
1059                                 (void *) (uintptr_t) 4);
1060   create_internalvar_type_lazy ("_probe_arg5", &probe_funcs,
1061                                 (void *) (uintptr_t) 5);
1062   create_internalvar_type_lazy ("_probe_arg6", &probe_funcs,
1063                                 (void *) (uintptr_t) 6);
1064   create_internalvar_type_lazy ("_probe_arg7", &probe_funcs,
1065                                 (void *) (uintptr_t) 7);
1066   create_internalvar_type_lazy ("_probe_arg8", &probe_funcs,
1067                                 (void *) (uintptr_t) 8);
1068   create_internalvar_type_lazy ("_probe_arg9", &probe_funcs,
1069                                 (void *) (uintptr_t) 9);
1070   create_internalvar_type_lazy ("_probe_arg10", &probe_funcs,
1071                                 (void *) (uintptr_t) 10);
1072   create_internalvar_type_lazy ("_probe_arg11", &probe_funcs,
1073                                 (void *) (uintptr_t) 11);
1074
1075   add_cmd ("all", class_info, info_probes_command,
1076            _("\
1077 Show information about all type of probes."),
1078            info_probes_cmdlist_get ());
1079
1080   add_cmd ("probes", class_breakpoint, enable_probes_command, _("\
1081 Enable probes.\n\
1082 Usage: enable probes [PROVIDER [NAME [OBJECT]]]\n\
1083 Each argument is a regular expression, used to select probes.\n\
1084 PROVIDER matches probe provider names.\n\
1085 NAME matches the probe names.\n\
1086 OBJECT matches the executable or shared library name.\n\
1087 If you do not specify any argument then the command will enable\n\
1088 all defined probes."),
1089            &enablelist);
1090
1091   add_cmd ("probes", class_breakpoint, disable_probes_command, _("\
1092 Disable probes.\n\
1093 Usage: disable probes [PROVIDER [NAME [OBJECT]]]\n\
1094 Each argument is a regular expression, used to select probes.\n\
1095 PROVIDER matches probe provider names.\n\
1096 NAME matches the probe names.\n\
1097 OBJECT matches the executable or shared library name.\n\
1098 If you do not specify any argument then the command will disable\n\
1099 all defined probes."),
1100            &disablelist);
1101
1102 }