gdb/dtrace-probe.c

   1 /* DTrace probe support for GDB.
   2
   3    Copyright (C) 2014-2017 Free Software Foundation, Inc.
   4
   5    Contributed by Oracle, Inc.
   6
   7    This file is part of GDB.
   8
   9    This program is free software; you can redistribute it and/or modify
  10    it under the terms of the GNU General Public License as published by
  11    the Free Software Foundation; either version 3 of the License, or
  12    (at your option) any later version.
  13
  14    This program is distributed in the hope that it will be useful,
  15    but WITHOUT ANY WARRANTY; without even the implied warranty of
  16    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  17    GNU General Public License for more details.
  18
  19    You should have received a copy of the GNU General Public License
  20    along with this program.  If not, see <http://www.gnu.org/licenses/>.  */
  21
  22 #include "defs.h"
  23 #include "probe.h"
  24 #include "vec.h"
  25 #include "elf-bfd.h"
  26 #include "gdbtypes.h"
  27 #include "obstack.h"
  28 #include "objfiles.h"
  29 #include "complaints.h"
  30 #include "value.h"
  31 #include "ax.h"
  32 #include "ax-gdb.h"
  33 #include "language.h"
  34 #include "parser-defs.h"
  35 #include "inferior.h"
  36
  37 /* The type of the ELF sections where we will find the DOF programs
  38    with information about probes.  */
  39
  40 #ifndef SHT_SUNW_dof
  41 # define SHT_SUNW_dof   0x6ffffff4
  42 #endif
  43
  44 /* The following structure represents a single argument for the
  45    probe.  */
  46
  47 struct dtrace_probe_arg
  48 {
  49   dtrace_probe_arg (struct type *type_, std::string &&type_str_,
  50                     expression_up &&expr_)
  51     : type (type_), type_str (std::move (type_str_)),
  52       expr (std::move (expr_))
  53   {}
  54
  55   /* The type of the probe argument.  */
  56   struct type *type;
  57
  58   /* A string describing the type.  */
  59   std::string type_str;
  60
  61   /* The argument converted to an internal GDB expression.  */
  62   expression_up expr;
  63 };
  64
  65 /* The following structure represents an enabler for a probe.  */
  66
  67 struct dtrace_probe_enabler
  68 {
  69   /* Program counter where the is-enabled probe is installed.  The
  70      contents (nops, whatever...) stored at this address are
  71      architecture dependent.  */
  72   CORE_ADDR address;
  73 };
  74
  75 /* Class that implements the static probe methods for "stap" probes.  */
  76
  77 class dtrace_static_probe_ops : public static_probe_ops
  78 {
  79 public:
  80   /* See probe.h.  */
  81   bool is_linespec (const char **linespecp) const override;
  82
  83   /* See probe.h.  */
  84   void get_probes (std::vector<probe *> *probesp,
  85                    struct objfile *objfile) const override;
  86
  87   /* See probe.h.  */
  88   const char *type_name () const override;
  89
  90   /* See probe.h.  */
  91   bool can_enable () const override
  92   {
  93     return true;
  94   }
  95
  96   /* See probe.h.  */
  97   std::vector<struct info_probe_column> gen_info_probes_table_header
  98     () const override;
  99 };
 100
 101 /* DTrace static_probe_ops.  */
 102
 103 const dtrace_static_probe_ops dtrace_static_probe_ops;
 104
 105 /* The following structure represents a dtrace probe.  */
 106
 107 class dtrace_probe : public probe
 108 {
 109 public:
 110   /* Constructor for dtrace_probe.  */
 111   dtrace_probe (std::string &&name_, std::string &&provider_, CORE_ADDR address_,
 112                 struct gdbarch *arch_,
 113                 std::vector<struct dtrace_probe_arg> &&args_,
 114                 std::vector<struct dtrace_probe_enabler> &&enablers_)
 115     : probe (std::move (name_), std::move (provider_), address_, arch_),
 116       m_args (std::move (args_)),
 117       m_enablers (std::move (enablers_)),
 118       m_args_expr_built (false)
 119   {}
 120
 121   /* See probe.h.  */
 122   CORE_ADDR get_relocated_address (struct objfile *objfile) override;
 123
 124   /* See probe.h.  */
 125   unsigned get_argument_count (struct frame_info *frame) override;
 126
 127   /* See probe.h.  */
 128   bool can_evaluate_arguments () const override;
 129
 130   /* See probe.h.  */
 131   struct value *evaluate_argument (unsigned n,
 132                                    struct frame_info *frame) override;
 133
 134   /* See probe.h.  */
 135   void compile_to_ax (struct agent_expr *aexpr,
 136                       struct axs_value *axs_value,
 137                       unsigned n) override;
 138
 139   /* See probe.h.  */
 140   const static_probe_ops *get_static_ops () const override;
 141
 142   /* See probe.h.  */
 143   std::vector<const char *> gen_info_probes_table_values () const override;
 144
 145   /* See probe.h.  */
 146   void enable () override;
 147
 148   /* See probe.h.  */
 149   void disable () override;
 150
 151   /* Return the Nth argument of the probe.  */
 152   struct dtrace_probe_arg *get_arg_by_number (unsigned n,
 153                                               struct gdbarch *gdbarch);
 154
 155   /* Build the GDB internal expressiosn that, once evaluated, will
 156      calculate the values of the arguments of the probe.  */
 157   void build_arg_exprs (struct gdbarch *gdbarch);
 158
 159   /* Determine whether the probe is "enabled" or "disabled".  A
 160      disabled probe is a probe in which one or more enablers are
 161      disabled.  */
 162   bool is_enabled () const;
 163
 164 private:
 165   /* A probe can have zero or more arguments.  */
 166   std::vector<struct dtrace_probe_arg> m_args;
 167
 168   /* A probe can have zero or more "enablers" associated with it.  */
 169   std::vector<struct dtrace_probe_enabler> m_enablers;
 170
 171   /* Whether the expressions for the arguments have been built.  */
 172   bool m_args_expr_built;
 173 };
 174
 175 /* DOF programs can contain an arbitrary number of sections of 26
 176    different types.  In order to support DTrace USDT probes we only
 177    need to handle a subset of these section types, fortunately.  These
 178    section types are defined in the following enumeration.
 179
 180    See linux/dtrace/dof_defines.h for a complete list of section types
 181    along with their values.  */
 182
 183 enum dtrace_dof_sect_type
 184 {
 185   /* Null section.  */
 186   DTRACE_DOF_SECT_TYPE_NONE = 0,
 187   /* A dof_ecbdesc_t. */
 188   DTRACE_DOF_SECT_TYPE_ECBDESC = 3,
 189   /* A string table.  */
 190   DTRACE_DOF_SECT_TYPE_STRTAB = 8,
 191   /* A dof_provider_t  */
 192   DTRACE_DOF_SECT_TYPE_PROVIDER = 15,
 193   /* Array of dof_probe_t  */
 194   DTRACE_DOF_SECT_TYPE_PROBES = 16,
 195   /* An array of probe arg mappings.  */
 196   DTRACE_DOF_SECT_TYPE_PRARGS = 17,
 197   /* An array of probe arg offsets.  */
 198   DTRACE_DOF_SECT_TYPE_PROFFS = 18,
 199   /* An array of probe is-enabled offsets.  */
 200   DTRACE_DOF_SECT_TYPE_PRENOFFS = 26
 201 };
 202
 203 /* The following collection of data structures map the structure of
 204    DOF entities.  Again, we only cover the subset of DOF used to
 205    implement USDT probes.
 206
 207    See linux/dtrace/dof.h header for a complete list of data
 208    structures.  */
 209
 210 /* Offsets to index the dofh_ident[] array defined below.  */
 211
 212 enum dtrace_dof_ident
 213 {
 214   /* First byte of the magic number.  */
 215   DTRACE_DOF_ID_MAG0 = 0,
 216   /* Second byte of the magic number.  */
 217   DTRACE_DOF_ID_MAG1 = 1,
 218   /* Third byte of the magic number.  */
 219   DTRACE_DOF_ID_MAG2 = 2,
 220   /* Fourth byte of the magic number.  */
 221   DTRACE_DOF_ID_MAG3 = 3,
 222   /* An enum_dof_encoding value.  */
 223   DTRACE_DOF_ID_ENCODING = 5
 224 };
 225
 226 /* Possible values for dofh_ident[DOF_ID_ENCODING].  */
 227
 228 enum dtrace_dof_encoding
 229 {
 230   /* The DOF program is little-endian.  */
 231   DTRACE_DOF_ENCODE_LSB = 1,
 232   /* The DOF program is big-endian.  */
 233   DTRACE_DOF_ENCODE_MSB = 2
 234 };
 235
 236 /* A DOF header, which describes the contents of a DOF program: number
 237    of sections, size, etc.  */
 238
 239 struct dtrace_dof_hdr
 240 {
 241   /* Identification bytes (see above). */
 242   uint8_t dofh_ident[16];
 243   /* File attribute flags (if any). */
 244   uint32_t dofh_flags;
 245   /* Size of file header in bytes. */
 246   uint32_t dofh_hdrsize;
 247   /* Size of section header in bytes. */
 248   uint32_t dofh_secsize;
 249   /* Number of section headers. */
 250   uint32_t dofh_secnum;
 251   /* File offset of section headers. */
 252   uint64_t dofh_secoff;
 253   /* File size of loadable portion. */
 254   uint64_t dofh_loadsz;
 255   /* File size of entire DOF file. */
 256   uint64_t dofh_filesz;
 257   /* Reserved for future use. */
 258   uint64_t dofh_pad;
 259 };
 260
 261 /* A DOF section, whose contents depend on its type.  The several
 262    supported section types are described in the enum
 263    dtrace_dof_sect_type above.  */
 264
 265 struct dtrace_dof_sect
 266 {
 267   /* Section type (see the define above). */
 268   uint32_t dofs_type;
 269   /* Section data memory alignment. */
 270   uint32_t dofs_align;
 271   /* Section flags (if any). */
 272   uint32_t dofs_flags;
 273   /* Size of section entry (if table). */
 274   uint32_t dofs_entsize;
 275   /* DOF + offset points to the section data. */
 276   uint64_t dofs_offset;
 277   /* Size of section data in bytes.  */
 278   uint64_t dofs_size;
 279 };
 280
 281 /* A DOF provider, which is the provider of a probe.  */
 282
 283 struct dtrace_dof_provider
 284 {
 285   /* Link to a DTRACE_DOF_SECT_TYPE_STRTAB section. */
 286   uint32_t dofpv_strtab;
 287   /* Link to a DTRACE_DOF_SECT_TYPE_PROBES section. */
 288   uint32_t dofpv_probes;
 289   /* Link to a DTRACE_DOF_SECT_TYPE_PRARGS section. */
 290   uint32_t dofpv_prargs;
 291   /* Link to a DTRACE_DOF_SECT_TYPE_PROFFS section. */
 292   uint32_t dofpv_proffs;
 293   /* Provider name string. */
 294   uint32_t dofpv_name;
 295   /* Provider attributes. */
 296   uint32_t dofpv_provattr;
 297   /* Module attributes. */
 298   uint32_t dofpv_modattr;
 299   /* Function attributes. */
 300   uint32_t dofpv_funcattr;
 301   /* Name attributes. */
 302   uint32_t dofpv_nameattr;
 303   /* Args attributes. */
 304   uint32_t dofpv_argsattr;
 305   /* Link to a DTRACE_DOF_SECT_PRENOFFS section. */
 306   uint32_t dofpv_prenoffs;
 307 };
 308
 309 /* A set of DOF probes and is-enabled probes sharing a base address
 310    and several attributes.  The particular locations and attributes of
 311    each probe are maintained in arrays in several other DOF sections.
 312    See the comment in dtrace_process_dof_probe for details on how
 313    these attributes are stored.  */
 314
 315 struct dtrace_dof_probe
 316 {
 317   /* Probe base address or offset. */
 318   uint64_t dofpr_addr;
 319   /* Probe function string. */
 320   uint32_t dofpr_func;
 321   /* Probe name string. */
 322   uint32_t dofpr_name;
 323   /* Native argument type strings. */
 324   uint32_t dofpr_nargv;
 325   /* Translated argument type strings. */
 326   uint32_t dofpr_xargv;
 327   /* Index of first argument mapping. */
 328   uint32_t dofpr_argidx;
 329   /* Index of first offset entry. */
 330   uint32_t dofpr_offidx;
 331   /* Native argument count. */
 332   uint8_t  dofpr_nargc;
 333   /* Translated argument count. */
 334   uint8_t  dofpr_xargc;
 335   /* Number of offset entries for probe. */
 336   uint16_t dofpr_noffs;
 337   /* Index of first is-enabled offset. */
 338   uint32_t dofpr_enoffidx;
 339   /* Number of is-enabled offsets. */
 340   uint16_t dofpr_nenoffs;
 341   /* Reserved for future use. */
 342   uint16_t dofpr_pad1;
 343   /* Reserved for future use. */
 344   uint32_t dofpr_pad2;
 345 };
 346
 347 /* DOF supports two different encodings: MSB (big-endian) and LSB
 348    (little-endian).  The encoding is itself encoded in the DOF header.
 349    The following function returns an unsigned value in the host
 350    endianness.  */
 351
 352 #define DOF_UINT(dof, field)                                            \
 353   extract_unsigned_integer ((gdb_byte *) &(field),                      \
 354                             sizeof ((field)),                           \
 355                             (((dof)->dofh_ident[DTRACE_DOF_ID_ENCODING] \
 356                               == DTRACE_DOF_ENCODE_MSB)                 \
 357                              ? BFD_ENDIAN_BIG : BFD_ENDIAN_LITTLE))
 358
 359 /* The following macro applies a given byte offset to a DOF (a pointer
 360    to a dtrace_dof_hdr structure) and returns the resulting
 361    address.  */
 362
 363 #define DTRACE_DOF_PTR(dof, offset) (&((char *) (dof))[(offset)])
 364
 365 /* The following macro returns a pointer to the beginning of a given
 366    section in a DOF object.  The section is referred to by its index
 367    in the sections array.  */
 368
 369 #define DTRACE_DOF_SECT(dof, idx)                                       \
 370   ((struct dtrace_dof_sect *)                                           \
 371    DTRACE_DOF_PTR ((dof),                                               \
 372                    DOF_UINT ((dof), (dof)->dofh_secoff)                 \
 373                    + ((idx) * DOF_UINT ((dof), (dof)->dofh_secsize))))
 374
 375 /* Helper function to examine the probe described by the given PROBE
 376    and PROVIDER data structures and add it to the PROBESP vector.
 377    STRTAB, OFFTAB, EOFFTAB and ARGTAB are pointers to tables in the
 378    DOF program containing the attributes for the probe.  */
 379
 380 static void
 381 dtrace_process_dof_probe (struct objfile *objfile,
 382                           struct gdbarch *gdbarch,
 383                           std::vector<probe *> *probesp,
 384                           struct dtrace_dof_hdr *dof,
 385                           struct dtrace_dof_probe *probe,
 386                           struct dtrace_dof_provider *provider,
 387                           char *strtab, char *offtab, char *eofftab,
 388                           char *argtab, uint64_t strtab_size)
 389 {
 390   int i, j, num_probes, num_enablers;
 391   char *p;
 392
 393   /* Each probe section can define zero or more probes of two
 394      different types:
 395
 396      - probe->dofpr_noffs regular probes whose program counters are
 397        stored in 32bit words starting at probe->dofpr_addr +
 398        offtab[probe->dofpr_offidx].
 399
 400      - probe->dofpr_nenoffs is-enabled probes whose program counters
 401        are stored in 32bit words starting at probe->dofpr_addr +
 402        eofftab[probe->dofpr_enoffidx].
 403
 404      However is-enabled probes are not probes per-se, but an
 405      optimization hack that is implemented in the kernel in a very
 406      similar way than normal probes.  This is how we support
 407      is-enabled probes on GDB:
 408
 409      - Our probes are always DTrace regular probes.
 410
 411      - Our probes can be associated with zero or more "enablers".  The
 412        list of enablers is built from the is-enabled probes defined in
 413        the Probe section.
 414
 415      - Probes having a non-empty list of enablers can be enabled or
 416        disabled using the `enable probe' and `disable probe' commands
 417        respectively.  The `Enabled' column in the output of `info
 418        probes' will read `yes' if the enablers are activated, `no'
 419        otherwise.
 420
 421      - Probes having an empty list of enablers are always enabled.
 422        The `Enabled' column in the output of `info probes' will
 423        read `always'.
 424
 425      It follows that if there are DTrace is-enabled probes defined for
 426      some provider/name but no DTrace regular probes defined then the
 427      GDB user wont be able to enable/disable these conditionals.  */
 428
 429   num_probes = DOF_UINT (dof, probe->dofpr_noffs);
 430   if (num_probes == 0)
 431     return;
 432
 433   /* Build the list of enablers for the probes defined in this Probe
 434      DOF section.  */
 435   std::vector<struct dtrace_probe_enabler> enablers;
 436   num_enablers = DOF_UINT (dof, probe->dofpr_nenoffs);
 437   for (i = 0; i < num_enablers; i++)
 438     {
 439       struct dtrace_probe_enabler enabler;
 440       uint32_t enabler_offset
 441         = ((uint32_t *) eofftab)[DOF_UINT (dof, probe->dofpr_enoffidx) + i];
 442
 443       enabler.address = DOF_UINT (dof, probe->dofpr_addr)
 444         + DOF_UINT (dof, enabler_offset);
 445       enablers.push_back (enabler);
 446     }
 447
 448   for (i = 0; i < num_probes; i++)
 449     {
 450       uint32_t probe_offset
 451         = ((uint32_t *) offtab)[DOF_UINT (dof, probe->dofpr_offidx) + i];
 452
 453       /* Set the provider and the name of the probe.  */
 454       const char *probe_provider
 455         = strtab + DOF_UINT (dof, provider->dofpv_name);
 456       const char *name = strtab + DOF_UINT (dof, probe->dofpr_name);
 457
 458       /* The probe address.  */
 459       CORE_ADDR address
 460         = DOF_UINT (dof, probe->dofpr_addr) + DOF_UINT (dof, probe_offset);
 461
 462       /* Number of arguments in the probe.  */
 463       int probe_argc = DOF_UINT (dof, probe->dofpr_nargc);
 464
 465       /* Store argument type descriptions.  A description of the type
 466          of the argument is in the (J+1)th null-terminated string
 467          starting at 'strtab' + 'probe->dofpr_nargv'.  */
 468       std::vector<struct dtrace_probe_arg> args;
 469       p = strtab + DOF_UINT (dof, probe->dofpr_nargv);
 470       for (j = 0; j < probe_argc; j++)
 471         {
 472           expression_up expr;
 473
 474           /* Set arg.expr to ensure all fields in expr are initialized and
 475              the compiler will not warn when arg is used.  */
 476           std::string type_str (p);
 477
 478           /* Use strtab_size as a sentinel.  */
 479           while (*p++ != '\0' && p - strtab < strtab_size)
 480             ;
 481
 482           /* Try to parse a type expression from the type string.  If
 483              this does not work then we set the type to `long
 484              int'.  */
 485           struct type *type = builtin_type (gdbarch)->builtin_long;
 486
 487           TRY
 488             {
 489               expression_up expr
 490                 = parse_expression_with_language (type_str.c_str (),
 491                                                   language_c);
 492             }
 493           CATCH (ex, RETURN_MASK_ERROR)
 494             {
 495             }
 496           END_CATCH
 497
 498           if (expr != NULL && expr->elts[0].opcode == OP_TYPE)
 499             type = expr->elts[1].type;
 500
 501           args.emplace_back (type, std::move (type_str), std::move (expr));
 502         }
 503
 504       std::vector<struct dtrace_probe_enabler> enablers_copy = enablers;
 505       dtrace_probe *ret = new dtrace_probe (std::string (name),
 506                                             std::string (probe_provider),
 507                                             address, gdbarch,
 508                                             std::move (args),
 509                                             std::move (enablers_copy));
 510
 511       /* Successfully created probe.  */
 512       probesp->push_back (ret);
 513     }
 514 }
 515
 516 /* Helper function to collect the probes described in the DOF program
 517    whose header is pointed by DOF and add them to the PROBESP vector.
 518    SECT is the ELF section containing the DOF program and OBJFILE is
 519    its containing object file.  */
 520
 521 static void
 522 dtrace_process_dof (asection *sect, struct objfile *objfile,
 523                     std::vector<probe *> *probesp, struct dtrace_dof_hdr *dof)
 524 {
 525   struct gdbarch *gdbarch = get_objfile_arch (objfile);
 526   struct dtrace_dof_sect *section;
 527   int i;
 528
 529   /* The first step is to check for the DOF magic number.  If no valid
 530      DOF data is found in the section then a complaint is issued to
 531      the user and the section skipped.  */
 532   if (dof->dofh_ident[DTRACE_DOF_ID_MAG0] != 0x7F
 533       || dof->dofh_ident[DTRACE_DOF_ID_MAG1] != 'D'
 534       || dof->dofh_ident[DTRACE_DOF_ID_MAG2] != 'O'
 535       || dof->dofh_ident[DTRACE_DOF_ID_MAG3] != 'F')
 536     goto invalid_dof_data;
 537
 538   /* Make sure the encoding mark is either DTRACE_DOF_ENCODE_LSB or
 539      DTRACE_DOF_ENCODE_MSB.  */
 540   if (dof->dofh_ident[DTRACE_DOF_ID_ENCODING] != DTRACE_DOF_ENCODE_LSB
 541       && dof->dofh_ident[DTRACE_DOF_ID_ENCODING] != DTRACE_DOF_ENCODE_MSB)
 542     goto invalid_dof_data;
 543
 544   /* Make sure this DOF is not an enabling DOF, i.e. there are no ECB
 545      Description sections.  */
 546   section = (struct dtrace_dof_sect *) DTRACE_DOF_PTR (dof,
 547                                                        DOF_UINT (dof, dof->dofh_secoff));
 548   for (i = 0; i < DOF_UINT (dof, dof->dofh_secnum); i++, section++)
 549     if (section->dofs_type == DTRACE_DOF_SECT_TYPE_ECBDESC)
 550       return;
 551
 552   /* Iterate over any section of type Provider and extract the probe
 553      information from them.  If there are no "provider" sections on
 554      the DOF then we just return.  */
 555   section = (struct dtrace_dof_sect *) DTRACE_DOF_PTR (dof,
 556                                                        DOF_UINT (dof, dof->dofh_secoff));
 557   for (i = 0; i < DOF_UINT (dof, dof->dofh_secnum); i++, section++)
 558     if (DOF_UINT (dof, section->dofs_type) == DTRACE_DOF_SECT_TYPE_PROVIDER)
 559       {
 560         struct dtrace_dof_provider *provider = (struct dtrace_dof_provider *)
 561           DTRACE_DOF_PTR (dof, DOF_UINT (dof, section->dofs_offset));
 562         struct dtrace_dof_sect *strtab_s
 563           = DTRACE_DOF_SECT (dof, DOF_UINT (dof, provider->dofpv_strtab));
 564         struct dtrace_dof_sect *probes_s
 565           = DTRACE_DOF_SECT (dof, DOF_UINT (dof, provider->dofpv_probes));
 566         struct dtrace_dof_sect *args_s
 567           = DTRACE_DOF_SECT (dof, DOF_UINT (dof, provider->dofpv_prargs));
 568         struct dtrace_dof_sect *offsets_s
 569           = DTRACE_DOF_SECT (dof, DOF_UINT (dof, provider->dofpv_proffs));
 570         struct dtrace_dof_sect *eoffsets_s
 571           = DTRACE_DOF_SECT (dof, DOF_UINT (dof, provider->dofpv_prenoffs));
 572         char *strtab  = DTRACE_DOF_PTR (dof, DOF_UINT (dof, strtab_s->dofs_offset));
 573         char *offtab  = DTRACE_DOF_PTR (dof, DOF_UINT (dof, offsets_s->dofs_offset));
 574         char *eofftab = DTRACE_DOF_PTR (dof, DOF_UINT (dof, eoffsets_s->dofs_offset));
 575         char *argtab  = DTRACE_DOF_PTR (dof, DOF_UINT (dof, args_s->dofs_offset));
 576         unsigned int entsize = DOF_UINT (dof, probes_s->dofs_entsize);
 577         int num_probes;
 578
 579         if (DOF_UINT (dof, section->dofs_size)
 580             < sizeof (struct dtrace_dof_provider))
 581           {
 582             /* The section is smaller than expected, so do not use it.
 583                This has been observed on x86-solaris 10.  */
 584             goto invalid_dof_data;
 585           }
 586
 587         /* Very, unlikely, but could crash gdb if not handled
 588            properly.  */
 589         if (entsize == 0)
 590           goto invalid_dof_data;
 591
 592         num_probes = DOF_UINT (dof, probes_s->dofs_size) / entsize;
 593
 594         for (i = 0; i < num_probes; i++)
 595           {
 596             struct dtrace_dof_probe *probe = (struct dtrace_dof_probe *)
 597               DTRACE_DOF_PTR (dof, DOF_UINT (dof, probes_s->dofs_offset)
 598                               + (i * DOF_UINT (dof, probes_s->dofs_entsize)));
 599
 600             dtrace_process_dof_probe (objfile,
 601                                       gdbarch, probesp,
 602                                       dof, probe,
 603                                       provider, strtab, offtab, eofftab, argtab,
 604                                       DOF_UINT (dof, strtab_s->dofs_size));
 605           }
 606       }
 607
 608   return;
 609
 610  invalid_dof_data:
 611   complaint (&symfile_complaints,
 612              _("skipping section '%s' which does not contain valid DOF data."),
 613              sect->name);
 614 }
 615
 616 /* Implementation of 'build_arg_exprs' method.  */
 617
 618 void
 619 dtrace_probe::build_arg_exprs (struct gdbarch *gdbarch)
 620 {
 621   size_t argc = 0;
 622   m_args_expr_built = true;
 623
 624   /* Iterate over the arguments in the probe and build the
 625      corresponding GDB internal expression that will generate the
 626      value of the argument when executed at the PC of the probe.  */
 627   for (struct dtrace_probe_arg &arg : m_args)
 628     {
 629       struct cleanup *back_to;
 630       struct parser_state pstate;
 631
 632       /* Initialize the expression buffer in the parser state.  The
 633          language does not matter, since we are using our own
 634          parser.  */
 635       initialize_expout (&pstate, 10, current_language, gdbarch);
 636       back_to = make_cleanup (free_current_contents, &pstate.expout);
 637
 638       /* The argument value, which is ABI dependent and casted to
 639          `long int'.  */
 640       gdbarch_dtrace_parse_probe_argument (gdbarch, &pstate, argc);
 641
 642       discard_cleanups (back_to);
 643
 644       /* Casting to the expected type, but only if the type was
 645          recognized at probe load time.  Otherwise the argument will
 646          be evaluated as the long integer passed to the probe.  */
 647       if (arg.type != NULL)
 648         {
 649           write_exp_elt_opcode (&pstate, UNOP_CAST);
 650           write_exp_elt_type (&pstate, arg.type);
 651           write_exp_elt_opcode (&pstate, UNOP_CAST);
 652         }
 653
 654       reallocate_expout (&pstate);
 655       arg.expr = expression_up (pstate.expout);
 656       prefixify_expression (arg.expr.get ());
 657       ++argc;
 658     }
 659 }
 660
 661 /* Implementation of 'get_arg_by_number' method.  */
 662
 663 struct dtrace_probe_arg *
 664 dtrace_probe::get_arg_by_number (unsigned n, struct gdbarch *gdbarch)
 665 {
 666   if (!m_args_expr_built)
 667     this->build_arg_exprs (gdbarch);
 668
 669   if (n > m_args.size ())
 670     internal_error (__FILE__, __LINE__,
 671                     _("Probe '%s' has %d arguments, but GDB is requesting\n"
 672                       "argument %u.  This should not happen.  Please\n"
 673                       "report this bug."),
 674                     this->get_name ().c_str (),
 675                     (int) m_args.size (), n);
 676
 677   return &m_args[n];
 678 }
 679
 680 /* Implementation of the probe is_enabled method.  */
 681
 682 bool
 683 dtrace_probe::is_enabled () const
 684 {
 685   struct gdbarch *gdbarch = this->get_gdbarch ();
 686
 687   for (const struct dtrace_probe_enabler &enabler : m_enablers)
 688     if (!gdbarch_dtrace_probe_is_enabled (gdbarch, enabler.address))
 689       return false;
 690
 691   return true;
 692 }
 693
 694 /* Implementation of the get_probe_address method.  */
 695
 696 CORE_ADDR
 697 dtrace_probe::get_relocated_address (struct objfile *objfile)
 698 {
 699   return this->get_address () + ANOFFSET (objfile->section_offsets,
 700                                           SECT_OFF_DATA (objfile));
 701 }
 702
 703 /* Implementation of the get_argument_count method.  */
 704
 705 unsigned
 706 dtrace_probe::get_argument_count (struct frame_info *frame)
 707 {
 708   return m_args.size ();
 709 }
 710
 711 /* Implementation of the can_evaluate_arguments method.  */
 712
 713 bool
 714 dtrace_probe::can_evaluate_arguments () const
 715 {
 716   struct gdbarch *gdbarch = this->get_gdbarch ();
 717
 718   return gdbarch_dtrace_parse_probe_argument_p (gdbarch);
 719 }
 720
 721 /* Implementation of the evaluate_argument method.  */
 722
 723 struct value *
 724 dtrace_probe::evaluate_argument (unsigned n,
 725                                  struct frame_info *frame)
 726 {
 727   struct gdbarch *gdbarch = this->get_gdbarch ();
 728   struct dtrace_probe_arg *arg;
 729   int pos = 0;
 730
 731   arg = this->get_arg_by_number (n, gdbarch);
 732   return evaluate_subexp_standard (arg->type, arg->expr.get (), &pos,
 733                                    EVAL_NORMAL);
 734 }
 735
 736 /* Implementation of the compile_to_ax method.  */
 737
 738 void
 739 dtrace_probe::compile_to_ax (struct agent_expr *expr, struct axs_value *value,
 740                              unsigned n)
 741 {
 742   struct dtrace_probe_arg *arg;
 743   union exp_element *pc;
 744
 745   arg = this->get_arg_by_number (n, expr->gdbarch);
 746
 747   pc = arg->expr->elts;
 748   gen_expr (arg->expr.get (), &pc, expr, value);
 749
 750   require_rvalue (expr, value);
 751   value->type = arg->type;
 752 }
 753
 754 /* Implementation of the 'get_static_ops' method.  */
 755
 756 const static_probe_ops *
 757 dtrace_probe::get_static_ops () const
 758 {
 759   return &dtrace_static_probe_ops;
 760 }
 761
 762 /* Implementation of the gen_info_probes_table_values method.  */
 763
 764 std::vector<const char *>
 765 dtrace_probe::gen_info_probes_table_values () const
 766 {
 767   const char *val = NULL;
 768
 769   if (m_enablers.empty ())
 770     val = "always";
 771   else if (!gdbarch_dtrace_probe_is_enabled_p (this->get_gdbarch ()))
 772     val = "unknown";
 773   else if (this->is_enabled ())
 774     val = "yes";
 775   else
 776     val = "no";
 777
 778   return std::vector<const char *> { val };
 779 }
 780
 781 /* Implementation of the enable method.  */
 782
 783 void
 784 dtrace_probe::enable ()
 785 {
 786   struct gdbarch *gdbarch = this->get_gdbarch ();
 787
 788   /* Enabling a dtrace probe implies patching the text section of the
 789      running process, so make sure the inferior is indeed running.  */
 790   if (ptid_equal (inferior_ptid, null_ptid))
 791     error (_("No inferior running"));
 792
 793   /* Fast path.  */
 794   if (this->is_enabled ())
 795     return;
 796
 797   /* Iterate over all defined enabler in the given probe and enable
 798      them all using the corresponding gdbarch hook.  */
 799   for (const struct dtrace_probe_enabler &enabler : m_enablers)
 800     if (gdbarch_dtrace_enable_probe_p (gdbarch))
 801       gdbarch_dtrace_enable_probe (gdbarch, enabler.address);
 802 }
 803
 804
 805 /* Implementation of the disable_probe method.  */
 806
 807 void
 808 dtrace_probe::disable ()
 809 {
 810   struct gdbarch *gdbarch = this->get_gdbarch ();
 811
 812   /* Disabling a dtrace probe implies patching the text section of the
 813      running process, so make sure the inferior is indeed running.  */
 814   if (ptid_equal (inferior_ptid, null_ptid))
 815     error (_("No inferior running"));
 816
 817   /* Fast path.  */
 818   if (!this->is_enabled ())
 819     return;
 820
 821   /* Are we trying to disable a probe that does not have any enabler
 822      associated?  */
 823   if (m_enablers.empty ())
 824     error (_("Probe %s:%s cannot be disabled: no enablers."),
 825            this->get_provider ().c_str (), this->get_name ().c_str ());
 826
 827   /* Iterate over all defined enabler in the given probe and disable
 828      them all using the corresponding gdbarch hook.  */
 829   for (struct dtrace_probe_enabler &enabler : m_enablers)
 830     if (gdbarch_dtrace_disable_probe_p (gdbarch))
 831       gdbarch_dtrace_disable_probe (gdbarch, enabler.address);
 832 }
 833
 834 /* Implementation of the is_linespec method.  */
 835
 836 bool
 837 dtrace_static_probe_ops::is_linespec (const char **linespecp) const
 838 {
 839   static const char *const keywords[] = { "-pdtrace", "-probe-dtrace", NULL };
 840
 841   return probe_is_linespec_by_keyword (linespecp, keywords);
 842 }
 843
 844 /* Implementation of the get_probes method.  */
 845
 846 void
 847 dtrace_static_probe_ops::get_probes (std::vector<probe *> *probesp,
 848                                      struct objfile *objfile) const
 849 {
 850   bfd *abfd = objfile->obfd;
 851   asection *sect = NULL;
 852
 853   /* Do nothing in case this is a .debug file, instead of the objfile
 854      itself.  */
 855   if (objfile->separate_debug_objfile_backlink != NULL)
 856     return;
 857
 858   /* Iterate over the sections in OBJFILE looking for DTrace
 859      information.  */
 860   for (sect = abfd->sections; sect != NULL; sect = sect->next)
 861     {
 862       if (elf_section_data (sect)->this_hdr.sh_type == SHT_SUNW_dof)
 863         {
 864           bfd_byte *dof;
 865
 866           /* Read the contents of the DOF section and then process it to
 867              extract the information of any probe defined into it.  */
 868           if (!bfd_malloc_and_get_section (abfd, sect, &dof))
 869             complaint (&symfile_complaints,
 870                        _("could not obtain the contents of"
 871                          "section '%s' in objfile `%s'."),
 872                        sect->name, abfd->filename);
 873
 874           dtrace_process_dof (sect, objfile, probesp,
 875                               (struct dtrace_dof_hdr *) dof);
 876           xfree (dof);
 877         }
 878     }
 879 }
 880
 881 /* Implementation of the type_name method.  */
 882
 883 const char *
 884 dtrace_static_probe_ops::type_name () const
 885 {
 886   return "dtrace";
 887 }
 888
 889 /* Implementation of the gen_info_probes_table_header method.  */
 890
 891 std::vector<struct info_probe_column>
 892 dtrace_static_probe_ops::gen_info_probes_table_header () const
 893 {
 894   struct info_probe_column dtrace_probe_column;
 895
 896   dtrace_probe_column.field_name = "enabled";
 897   dtrace_probe_column.print_name = _("Enabled");
 898
 899   return std::vector<struct info_probe_column> { dtrace_probe_column };
 900 }
 901
 902 /* Implementation of the `info probes dtrace' command.  */
 903
 904 static void
 905 info_probes_dtrace_command (const char *arg, int from_tty)
 906 {
 907   info_probes_for_spops (arg, from_tty, &dtrace_static_probe_ops);
 908 }
 909
 910 void
 911 _initialize_dtrace_probe (void)
 912 {
 913   all_static_probe_ops.push_back (&dtrace_static_probe_ops);
 914
 915   add_cmd ("dtrace", class_info, info_probes_dtrace_command,
 916            _("\
 917 Show information about DTrace static probes.\n\
 918 Usage: info probes dtrace [PROVIDER [NAME [OBJECT]]]\n\
 919 Each argument is a regular expression, used to select probes.\n\
 920 PROVIDER matches probe provider names.\n\
 921 NAME matches the probe names.\n\
 922 OBJECT matches the executable or shared library name."),
 923            info_probes_cmdlist_get ());
 924 }