Automatic date update in version.in
[external/binutils.git] / gdb / dtrace-probe.c
1 /* DTrace probe support for GDB.
2
3    Copyright (C) 2014-2018 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               expr = parse_expression_with_language (type_str.c_str (),
490                                                      language_c);
491             }
492           CATCH (ex, RETURN_MASK_ERROR)
493             {
494             }
495           END_CATCH
496
497           if (expr != NULL && expr.get ()->elts[0].opcode == OP_TYPE)
498             type = expr.get ()->elts[1].type;
499
500           args.emplace_back (type, std::move (type_str), std::move (expr));
501         }
502
503       std::vector<struct dtrace_probe_enabler> enablers_copy = enablers;
504       dtrace_probe *ret = new dtrace_probe (std::string (name),
505                                             std::string (probe_provider),
506                                             address, gdbarch,
507                                             std::move (args),
508                                             std::move (enablers_copy));
509
510       /* Successfully created probe.  */
511       probesp->push_back (ret);
512     }
513 }
514
515 /* Helper function to collect the probes described in the DOF program
516    whose header is pointed by DOF and add them to the PROBESP vector.
517    SECT is the ELF section containing the DOF program and OBJFILE is
518    its containing object file.  */
519
520 static void
521 dtrace_process_dof (asection *sect, struct objfile *objfile,
522                     std::vector<probe *> *probesp, struct dtrace_dof_hdr *dof)
523 {
524   struct gdbarch *gdbarch = get_objfile_arch (objfile);
525   struct dtrace_dof_sect *section;
526   int i;
527
528   /* The first step is to check for the DOF magic number.  If no valid
529      DOF data is found in the section then a complaint is issued to
530      the user and the section skipped.  */
531   if (dof->dofh_ident[DTRACE_DOF_ID_MAG0] != 0x7F
532       || dof->dofh_ident[DTRACE_DOF_ID_MAG1] != 'D'
533       || dof->dofh_ident[DTRACE_DOF_ID_MAG2] != 'O'
534       || dof->dofh_ident[DTRACE_DOF_ID_MAG3] != 'F')
535     goto invalid_dof_data;
536
537   /* Make sure the encoding mark is either DTRACE_DOF_ENCODE_LSB or
538      DTRACE_DOF_ENCODE_MSB.  */
539   if (dof->dofh_ident[DTRACE_DOF_ID_ENCODING] != DTRACE_DOF_ENCODE_LSB
540       && dof->dofh_ident[DTRACE_DOF_ID_ENCODING] != DTRACE_DOF_ENCODE_MSB)
541     goto invalid_dof_data;
542
543   /* Make sure this DOF is not an enabling DOF, i.e. there are no ECB
544      Description sections.  */
545   section = (struct dtrace_dof_sect *) DTRACE_DOF_PTR (dof,
546                                                        DOF_UINT (dof, dof->dofh_secoff));
547   for (i = 0; i < DOF_UINT (dof, dof->dofh_secnum); i++, section++)
548     if (section->dofs_type == DTRACE_DOF_SECT_TYPE_ECBDESC)
549       return;
550
551   /* Iterate over any section of type Provider and extract the probe
552      information from them.  If there are no "provider" sections on
553      the DOF then we just return.  */
554   section = (struct dtrace_dof_sect *) DTRACE_DOF_PTR (dof,
555                                                        DOF_UINT (dof, dof->dofh_secoff));
556   for (i = 0; i < DOF_UINT (dof, dof->dofh_secnum); i++, section++)
557     if (DOF_UINT (dof, section->dofs_type) == DTRACE_DOF_SECT_TYPE_PROVIDER)
558       {
559         struct dtrace_dof_provider *provider = (struct dtrace_dof_provider *)
560           DTRACE_DOF_PTR (dof, DOF_UINT (dof, section->dofs_offset));
561         struct dtrace_dof_sect *strtab_s
562           = DTRACE_DOF_SECT (dof, DOF_UINT (dof, provider->dofpv_strtab));
563         struct dtrace_dof_sect *probes_s
564           = DTRACE_DOF_SECT (dof, DOF_UINT (dof, provider->dofpv_probes));
565         struct dtrace_dof_sect *args_s
566           = DTRACE_DOF_SECT (dof, DOF_UINT (dof, provider->dofpv_prargs));
567         struct dtrace_dof_sect *offsets_s
568           = DTRACE_DOF_SECT (dof, DOF_UINT (dof, provider->dofpv_proffs));
569         struct dtrace_dof_sect *eoffsets_s
570           = DTRACE_DOF_SECT (dof, DOF_UINT (dof, provider->dofpv_prenoffs));
571         char *strtab  = DTRACE_DOF_PTR (dof, DOF_UINT (dof, strtab_s->dofs_offset));
572         char *offtab  = DTRACE_DOF_PTR (dof, DOF_UINT (dof, offsets_s->dofs_offset));
573         char *eofftab = DTRACE_DOF_PTR (dof, DOF_UINT (dof, eoffsets_s->dofs_offset));
574         char *argtab  = DTRACE_DOF_PTR (dof, DOF_UINT (dof, args_s->dofs_offset));
575         unsigned int entsize = DOF_UINT (dof, probes_s->dofs_entsize);
576         int num_probes;
577
578         if (DOF_UINT (dof, section->dofs_size)
579             < sizeof (struct dtrace_dof_provider))
580           {
581             /* The section is smaller than expected, so do not use it.
582                This has been observed on x86-solaris 10.  */
583             goto invalid_dof_data;
584           }
585
586         /* Very, unlikely, but could crash gdb if not handled
587            properly.  */
588         if (entsize == 0)
589           goto invalid_dof_data;
590
591         num_probes = DOF_UINT (dof, probes_s->dofs_size) / entsize;
592
593         for (i = 0; i < num_probes; i++)
594           {
595             struct dtrace_dof_probe *probe = (struct dtrace_dof_probe *)
596               DTRACE_DOF_PTR (dof, DOF_UINT (dof, probes_s->dofs_offset)
597                               + (i * DOF_UINT (dof, probes_s->dofs_entsize)));
598
599             dtrace_process_dof_probe (objfile,
600                                       gdbarch, probesp,
601                                       dof, probe,
602                                       provider, strtab, offtab, eofftab, argtab,
603                                       DOF_UINT (dof, strtab_s->dofs_size));
604           }
605       }
606
607   return;
608           
609  invalid_dof_data:
610   complaint (_("skipping section '%s' which does not contain valid DOF data."),
611              sect->name);
612 }
613
614 /* Implementation of 'build_arg_exprs' method.  */
615
616 void
617 dtrace_probe::build_arg_exprs (struct gdbarch *gdbarch)
618 {
619   size_t argc = 0;
620   m_args_expr_built = true;
621
622   /* Iterate over the arguments in the probe and build the
623      corresponding GDB internal expression that will generate the
624      value of the argument when executed at the PC of the probe.  */
625   for (dtrace_probe_arg &arg : m_args)
626     {
627       /* Initialize the expression buffer in the parser state.  The
628          language does not matter, since we are using our own
629          parser.  */
630       parser_state pstate (10, current_language, gdbarch);
631
632       /* The argument value, which is ABI dependent and casted to
633          `long int'.  */
634       gdbarch_dtrace_parse_probe_argument (gdbarch, &pstate, argc);
635
636       /* Casting to the expected type, but only if the type was
637          recognized at probe load time.  Otherwise the argument will
638          be evaluated as the long integer passed to the probe.  */
639       if (arg.type != NULL)
640         {
641           write_exp_elt_opcode (&pstate, UNOP_CAST);
642           write_exp_elt_type (&pstate, arg.type);
643           write_exp_elt_opcode (&pstate, UNOP_CAST);
644         }
645
646       arg.expr = pstate.release ();
647       prefixify_expression (arg.expr.get ());
648       ++argc;
649     }
650 }
651
652 /* Implementation of 'get_arg_by_number' method.  */
653
654 struct dtrace_probe_arg *
655 dtrace_probe::get_arg_by_number (unsigned n, struct gdbarch *gdbarch)
656 {
657   if (!m_args_expr_built)
658     this->build_arg_exprs (gdbarch);
659
660   if (n > m_args.size ())
661     internal_error (__FILE__, __LINE__,
662                     _("Probe '%s' has %d arguments, but GDB is requesting\n"
663                       "argument %u.  This should not happen.  Please\n"
664                       "report this bug."),
665                     this->get_name ().c_str (),
666                     (int) m_args.size (), n);
667
668   return &m_args[n];
669 }
670
671 /* Implementation of the probe is_enabled method.  */
672
673 bool
674 dtrace_probe::is_enabled () const
675 {
676   struct gdbarch *gdbarch = this->get_gdbarch ();
677
678   for (const dtrace_probe_enabler &enabler : m_enablers)
679     if (!gdbarch_dtrace_probe_is_enabled (gdbarch, enabler.address))
680       return false;
681
682   return true;
683 }
684
685 /* Implementation of the get_probe_address method.  */
686
687 CORE_ADDR
688 dtrace_probe::get_relocated_address (struct objfile *objfile)
689 {
690   return this->get_address () + ANOFFSET (objfile->section_offsets,
691                                           SECT_OFF_DATA (objfile));
692 }
693
694 /* Implementation of the get_argument_count method.  */
695
696 unsigned
697 dtrace_probe::get_argument_count (struct frame_info *frame)
698 {
699   return m_args.size ();
700 }
701
702 /* Implementation of the can_evaluate_arguments method.  */
703
704 bool
705 dtrace_probe::can_evaluate_arguments () const
706 {
707   struct gdbarch *gdbarch = this->get_gdbarch ();
708
709   return gdbarch_dtrace_parse_probe_argument_p (gdbarch);
710 }
711
712 /* Implementation of the evaluate_argument method.  */
713
714 struct value *
715 dtrace_probe::evaluate_argument (unsigned n,
716                                  struct frame_info *frame)
717 {
718   struct gdbarch *gdbarch = this->get_gdbarch ();
719   struct dtrace_probe_arg *arg;
720   int pos = 0;
721
722   arg = this->get_arg_by_number (n, gdbarch);
723   return evaluate_subexp_standard (arg->type, arg->expr.get (), &pos,
724                                    EVAL_NORMAL);
725 }
726
727 /* Implementation of the compile_to_ax method.  */
728
729 void
730 dtrace_probe::compile_to_ax (struct agent_expr *expr, struct axs_value *value,
731                              unsigned n)
732 {
733   struct dtrace_probe_arg *arg;
734   union exp_element *pc;
735
736   arg = this->get_arg_by_number (n, expr->gdbarch);
737
738   pc = arg->expr->elts;
739   gen_expr (arg->expr.get (), &pc, expr, value);
740
741   require_rvalue (expr, value);
742   value->type = arg->type;
743 }
744
745 /* Implementation of the 'get_static_ops' method.  */
746
747 const static_probe_ops *
748 dtrace_probe::get_static_ops () const
749 {
750   return &dtrace_static_probe_ops;
751 }
752
753 /* Implementation of the gen_info_probes_table_values method.  */
754
755 std::vector<const char *>
756 dtrace_probe::gen_info_probes_table_values () const
757 {
758   const char *val = NULL;
759
760   if (m_enablers.empty ())
761     val = "always";
762   else if (!gdbarch_dtrace_probe_is_enabled_p (this->get_gdbarch ()))
763     val = "unknown";
764   else if (this->is_enabled ())
765     val = "yes";
766   else
767     val = "no";
768
769   return std::vector<const char *> { val };
770 }
771
772 /* Implementation of the enable method.  */
773
774 void
775 dtrace_probe::enable ()
776 {
777   struct gdbarch *gdbarch = this->get_gdbarch ();
778
779   /* Enabling a dtrace probe implies patching the text section of the
780      running process, so make sure the inferior is indeed running.  */
781   if (inferior_ptid == null_ptid)
782     error (_("No inferior running"));
783
784   /* Fast path.  */
785   if (this->is_enabled ())
786     return;
787
788   /* Iterate over all defined enabler in the given probe and enable
789      them all using the corresponding gdbarch hook.  */
790   for (const dtrace_probe_enabler &enabler : m_enablers)
791     if (gdbarch_dtrace_enable_probe_p (gdbarch))
792       gdbarch_dtrace_enable_probe (gdbarch, enabler.address);
793 }
794
795
796 /* Implementation of the disable_probe method.  */
797
798 void
799 dtrace_probe::disable ()
800 {
801   struct gdbarch *gdbarch = this->get_gdbarch ();
802
803   /* Disabling a dtrace probe implies patching the text section of the
804      running process, so make sure the inferior is indeed running.  */
805   if (inferior_ptid == null_ptid)
806     error (_("No inferior running"));
807
808   /* Fast path.  */
809   if (!this->is_enabled ())
810     return;
811
812   /* Are we trying to disable a probe that does not have any enabler
813      associated?  */
814   if (m_enablers.empty ())
815     error (_("Probe %s:%s cannot be disabled: no enablers."),
816            this->get_provider ().c_str (), this->get_name ().c_str ());
817
818   /* Iterate over all defined enabler in the given probe and disable
819      them all using the corresponding gdbarch hook.  */
820   for (dtrace_probe_enabler &enabler : m_enablers)
821     if (gdbarch_dtrace_disable_probe_p (gdbarch))
822       gdbarch_dtrace_disable_probe (gdbarch, enabler.address);
823 }
824
825 /* Implementation of the is_linespec method.  */
826
827 bool
828 dtrace_static_probe_ops::is_linespec (const char **linespecp) const
829 {
830   static const char *const keywords[] = { "-pdtrace", "-probe-dtrace", NULL };
831
832   return probe_is_linespec_by_keyword (linespecp, keywords);
833 }
834
835 /* Implementation of the get_probes method.  */
836
837 void
838 dtrace_static_probe_ops::get_probes (std::vector<probe *> *probesp,
839                                      struct objfile *objfile) const
840 {
841   bfd *abfd = objfile->obfd;
842   asection *sect = NULL;
843
844   /* Do nothing in case this is a .debug file, instead of the objfile
845      itself.  */
846   if (objfile->separate_debug_objfile_backlink != NULL)
847     return;
848
849   /* Iterate over the sections in OBJFILE looking for DTrace
850      information.  */
851   for (sect = abfd->sections; sect != NULL; sect = sect->next)
852     {
853       if (elf_section_data (sect)->this_hdr.sh_type == SHT_SUNW_dof)
854         {
855           bfd_byte *dof;
856
857           /* Read the contents of the DOF section and then process it to
858              extract the information of any probe defined into it.  */
859           if (!bfd_malloc_and_get_section (abfd, sect, &dof))
860             complaint (_("could not obtain the contents of"
861                          "section '%s' in objfile `%s'."),
862                        sect->name, abfd->filename);
863       
864           dtrace_process_dof (sect, objfile, probesp,
865                               (struct dtrace_dof_hdr *) dof);
866           xfree (dof);
867         }
868     }
869 }
870
871 /* Implementation of the type_name method.  */
872
873 const char *
874 dtrace_static_probe_ops::type_name () const
875 {
876   return "dtrace";
877 }
878
879 /* Implementation of the gen_info_probes_table_header method.  */
880
881 std::vector<struct info_probe_column>
882 dtrace_static_probe_ops::gen_info_probes_table_header () const
883 {
884   struct info_probe_column dtrace_probe_column;
885
886   dtrace_probe_column.field_name = "enabled";
887   dtrace_probe_column.print_name = _("Enabled");
888
889   return std::vector<struct info_probe_column> { dtrace_probe_column };
890 }
891
892 /* Implementation of the `info probes dtrace' command.  */
893
894 static void
895 info_probes_dtrace_command (const char *arg, int from_tty)
896 {
897   info_probes_for_spops (arg, from_tty, &dtrace_static_probe_ops);
898 }
899
900 void
901 _initialize_dtrace_probe (void)
902 {
903   all_static_probe_ops.push_back (&dtrace_static_probe_ops);
904
905   add_cmd ("dtrace", class_info, info_probes_dtrace_command,
906            _("\
907 Show information about DTrace static probes.\n\
908 Usage: info probes dtrace [PROVIDER [NAME [OBJECT]]]\n\
909 Each argument is a regular expression, used to select probes.\n\
910 PROVIDER matches probe provider names.\n\
911 NAME matches the probe names.\n\
912 OBJECT matches the executable or shared library name."),
913            info_probes_cmdlist_get ());
914 }