1 /* DTrace probe support for GDB.
3 Copyright (C) 2014-2015 Free Software Foundation, Inc.
5 Contributed by Oracle, Inc.
7 This file is part of GDB.
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.
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.
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/>. */
29 #include "complaints.h"
34 #include "parser-defs.h"
37 /* The type of the ELF sections where we will find the DOF programs
38 with information about probes. */
41 # define SHT_SUNW_dof 0x6ffffff4
44 /* Forward declaration. */
46 static const struct probe_ops dtrace_probe_ops;
48 /* The following structure represents a single argument for the
51 struct dtrace_probe_arg
53 /* The type of the probe argument. */
56 /* A string describing the type. */
59 /* The argument converted to an internal GDB expression. */
60 struct expression *expr;
63 typedef struct dtrace_probe_arg dtrace_probe_arg_s;
64 DEF_VEC_O (dtrace_probe_arg_s);
66 /* The following structure represents an enabler for a probe. */
68 struct dtrace_probe_enabler
70 /* Program counter where the is-enabled probe is installed. The
71 contents (nops, whatever...) stored at this address are
72 architecture dependent. */
76 typedef struct dtrace_probe_enabler dtrace_probe_enabler_s;
77 DEF_VEC_O (dtrace_probe_enabler_s);
79 /* The following structure represents a dtrace probe. */
83 /* Generic information about the probe. This must be the first
84 element of this struct, in order to maintain binary compatibility
85 with the `struct probe' and be able to fully abstract it. */
88 /* A probe can have zero or more arguments. */
90 VEC (dtrace_probe_arg_s) *args;
92 /* A probe can have zero or more "enablers" associated with it. */
93 VEC (dtrace_probe_enabler_s) *enablers;
95 /* Whether the expressions for the arguments have been built. */
96 unsigned int args_expr_built : 1;
99 /* Implementation of the probe_is_linespec method. */
102 dtrace_probe_is_linespec (const char **linespecp)
104 static const char *const keywords[] = { "-pdtrace", "-probe-dtrace", NULL };
106 return probe_is_linespec_by_keyword (linespecp, keywords);
109 /* DOF programs can contain an arbitrary number of sections of 26
110 different types. In order to support DTrace USDT probes we only
111 need to handle a subset of these section types, fortunately. These
112 section types are defined in the following enumeration.
114 See linux/dtrace/dof_defines.h for a complete list of section types
115 along with their values. */
117 enum dtrace_dof_sect_type
120 DTRACE_DOF_SECT_TYPE_NONE = 0,
121 /* A dof_ecbdesc_t. */
122 DTRACE_DOF_SECT_TYPE_ECBDESC = 3,
123 /* A string table. */
124 DTRACE_DOF_SECT_TYPE_STRTAB = 8,
125 /* A dof_provider_t */
126 DTRACE_DOF_SECT_TYPE_PROVIDER = 15,
127 /* Array of dof_probe_t */
128 DTRACE_DOF_SECT_TYPE_PROBES = 16,
129 /* An array of probe arg mappings. */
130 DTRACE_DOF_SECT_TYPE_PRARGS = 17,
131 /* An array of probe arg offsets. */
132 DTRACE_DOF_SECT_TYPE_PROFFS = 18,
133 /* An array of probe is-enabled offsets. */
134 DTRACE_DOF_SECT_TYPE_PRENOFFS = 26
137 /* The following collection of data structures map the structure of
138 DOF entities. Again, we only cover the subset of DOF used to
139 implement USDT probes.
141 See linux/dtrace/dof.h header for a complete list of data
144 /* Offsets to index the dofh_ident[] array defined below. */
146 enum dtrace_dof_ident
148 /* First byte of the magic number. */
149 DTRACE_DOF_ID_MAG0 = 0,
150 /* Second byte of the magic number. */
151 DTRACE_DOF_ID_MAG1 = 1,
152 /* Third byte of the magic number. */
153 DTRACE_DOF_ID_MAG2 = 2,
154 /* Fourth byte of the magic number. */
155 DTRACE_DOF_ID_MAG3 = 3,
156 /* An enum_dof_encoding value. */
157 DTRACE_DOF_ID_ENCODING = 5
160 /* Possible values for dofh_ident[DOF_ID_ENCODING]. */
162 enum dtrace_dof_encoding
164 /* The DOF program is little-endian. */
165 DTRACE_DOF_ENCODE_LSB = 1,
166 /* The DOF program is big-endian. */
167 DTRACE_DOF_ENCODE_MSB = 2
170 /* A DOF header, which describes the contents of a DOF program: number
171 of sections, size, etc. */
173 struct dtrace_dof_hdr
175 /* Identification bytes (see above). */
176 uint8_t dofh_ident[16];
177 /* File attribute flags (if any). */
179 /* Size of file header in bytes. */
180 uint32_t dofh_hdrsize;
181 /* Size of section header in bytes. */
182 uint32_t dofh_secsize;
183 /* Number of section headers. */
184 uint32_t dofh_secnum;
185 /* File offset of section headers. */
186 uint64_t dofh_secoff;
187 /* File size of loadable portion. */
188 uint64_t dofh_loadsz;
189 /* File size of entire DOF file. */
190 uint64_t dofh_filesz;
191 /* Reserved for future use. */
195 /* A DOF section, whose contents depend on its type. The several
196 supported section types are described in the enum
197 dtrace_dof_sect_type above. */
199 struct dtrace_dof_sect
201 /* Section type (see the define above). */
203 /* Section data memory alignment. */
205 /* Section flags (if any). */
207 /* Size of section entry (if table). */
208 uint32_t dofs_entsize;
209 /* DOF + offset points to the section data. */
210 uint64_t dofs_offset;
211 /* Size of section data in bytes. */
215 /* A DOF provider, which is the provider of a probe. */
217 struct dtrace_dof_provider
219 /* Link to a DTRACE_DOF_SECT_TYPE_STRTAB section. */
220 uint32_t dofpv_strtab;
221 /* Link to a DTRACE_DOF_SECT_TYPE_PROBES section. */
222 uint32_t dofpv_probes;
223 /* Link to a DTRACE_DOF_SECT_TYPE_PRARGS section. */
224 uint32_t dofpv_prargs;
225 /* Link to a DTRACE_DOF_SECT_TYPE_PROFFS section. */
226 uint32_t dofpv_proffs;
227 /* Provider name string. */
229 /* Provider attributes. */
230 uint32_t dofpv_provattr;
231 /* Module attributes. */
232 uint32_t dofpv_modattr;
233 /* Function attributes. */
234 uint32_t dofpv_funcattr;
235 /* Name attributes. */
236 uint32_t dofpv_nameattr;
237 /* Args attributes. */
238 uint32_t dofpv_argsattr;
239 /* Link to a DTRACE_DOF_SECT_PRENOFFS section. */
240 uint32_t dofpv_prenoffs;
243 /* A set of DOF probes and is-enabled probes sharing a base address
244 and several attributes. The particular locations and attributes of
245 each probe are maintained in arrays in several other DOF sections.
246 See the comment in dtrace_process_dof_probe for details on how
247 these attributes are stored. */
249 struct dtrace_dof_probe
251 /* Probe base address or offset. */
253 /* Probe function string. */
255 /* Probe name string. */
257 /* Native argument type strings. */
258 uint32_t dofpr_nargv;
259 /* Translated argument type strings. */
260 uint32_t dofpr_xargv;
261 /* Index of first argument mapping. */
262 uint32_t dofpr_argidx;
263 /* Index of first offset entry. */
264 uint32_t dofpr_offidx;
265 /* Native argument count. */
267 /* Translated argument count. */
269 /* Number of offset entries for probe. */
270 uint16_t dofpr_noffs;
271 /* Index of first is-enabled offset. */
272 uint32_t dofpr_enoffidx;
273 /* Number of is-enabled offsets. */
274 uint16_t dofpr_nenoffs;
275 /* Reserved for future use. */
277 /* Reserved for future use. */
281 /* DOF supports two different encodings: MSB (big-endian) and LSB
282 (little-endian). The encoding is itself encoded in the DOF header.
283 The following function returns an unsigned value in the host
286 #define DOF_UINT(dof, field) \
287 extract_unsigned_integer ((gdb_byte *) &(field), \
289 (((dof)->dofh_ident[DTRACE_DOF_ID_ENCODING] \
290 == DTRACE_DOF_ENCODE_MSB) \
291 ? BFD_ENDIAN_BIG : BFD_ENDIAN_LITTLE))
293 /* The following macro applies a given byte offset to a DOF (a pointer
294 to a dtrace_dof_hdr structure) and returns the resulting
297 #define DTRACE_DOF_PTR(dof, offset) (&((char *) (dof))[(offset)])
299 /* The following macro returns a pointer to the beginning of a given
300 section in a DOF object. The section is referred to by its index
301 in the sections array. */
303 #define DTRACE_DOF_SECT(dof, idx) \
304 ((struct dtrace_dof_sect *) \
305 DTRACE_DOF_PTR ((dof), \
306 DOF_UINT ((dof), (dof)->dofh_secoff) \
307 + ((idx) * DOF_UINT ((dof), (dof)->dofh_secsize))))
309 /* Helper function to examine the probe described by the given PROBE
310 and PROVIDER data structures and add it to the PROBESP vector.
311 STRTAB, OFFTAB, EOFFTAB and ARGTAB are pointers to tables in the
312 DOF program containing the attributes for the probe. */
315 dtrace_process_dof_probe (struct objfile *objfile,
316 struct gdbarch *gdbarch, VEC (probe_p) **probesp,
317 struct dtrace_dof_hdr *dof,
318 struct dtrace_dof_probe *probe,
319 struct dtrace_dof_provider *provider,
320 char *strtab, char *offtab, char *eofftab,
321 char *argtab, uint64_t strtab_size)
323 int i, j, num_probes, num_enablers;
324 struct cleanup *cleanup;
325 VEC (dtrace_probe_enabler_s) *enablers;
328 /* Each probe section can define zero or more probes of two
331 - probe->dofpr_noffs regular probes whose program counters are
332 stored in 32bit words starting at probe->dofpr_addr +
333 offtab[probe->dofpr_offidx].
335 - probe->dofpr_nenoffs is-enabled probes whose program counters
336 are stored in 32bit words starting at probe->dofpr_addr +
337 eofftab[probe->dofpr_enoffidx].
339 However is-enabled probes are not probes per-se, but an
340 optimization hack that is implemented in the kernel in a very
341 similar way than normal probes. This is how we support
342 is-enabled probes on GDB:
344 - Our probes are always DTrace regular probes.
346 - Our probes can be associated with zero or more "enablers". The
347 list of enablers is built from the is-enabled probes defined in
350 - Probes having a non-empty list of enablers can be enabled or
351 disabled using the `enable probe' and `disable probe' commands
352 respectively. The `Enabled' column in the output of `info
353 probes' will read `yes' if the enablers are activated, `no'
356 - Probes having an empty list of enablers are always enabled.
357 The `Enabled' column in the output of `info probes' will
360 It follows that if there are DTrace is-enabled probes defined for
361 some provider/name but no DTrace regular probes defined then the
362 GDB user wont be able to enable/disable these conditionals. */
364 num_probes = DOF_UINT (dof, probe->dofpr_noffs);
368 /* Build the list of enablers for the probes defined in this Probe
372 = make_cleanup (VEC_cleanup (dtrace_probe_enabler_s), &enablers);
373 num_enablers = DOF_UINT (dof, probe->dofpr_nenoffs);
374 for (i = 0; i < num_enablers; i++)
376 struct dtrace_probe_enabler enabler;
377 uint32_t enabler_offset
378 = ((uint32_t *) eofftab)[DOF_UINT (dof, probe->dofpr_enoffidx) + i];
380 enabler.address = DOF_UINT (dof, probe->dofpr_addr)
381 + DOF_UINT (dof, enabler_offset);
382 VEC_safe_push (dtrace_probe_enabler_s, enablers, &enabler);
385 for (i = 0; i < num_probes; i++)
387 uint32_t probe_offset
388 = ((uint32_t *) offtab)[DOF_UINT (dof, probe->dofpr_offidx) + i];
389 struct dtrace_probe *ret
390 = obstack_alloc (&objfile->per_bfd->storage_obstack, sizeof (*ret));
392 ret->p.pops = &dtrace_probe_ops;
393 ret->p.arch = gdbarch;
394 ret->args_expr_built = 0;
396 /* Set the provider and the name of the probe. */
398 = xstrdup (strtab + DOF_UINT (dof, provider->dofpv_name));
399 ret->p.name = xstrdup (strtab + DOF_UINT (dof, probe->dofpr_name));
401 /* The probe address. */
403 = DOF_UINT (dof, probe->dofpr_addr) + DOF_UINT (dof, probe_offset);
405 /* Number of arguments in the probe. */
406 ret->probe_argc = DOF_UINT (dof, probe->dofpr_nargc);
408 /* Store argument type descriptions. A description of the type
409 of the argument is in the (J+1)th null-terminated string
410 starting at 'strtab' + 'probe->dofpr_nargv'. */
412 p = strtab + DOF_UINT (dof, probe->dofpr_nargv);
413 for (j = 0; j < ret->probe_argc; j++)
415 struct dtrace_probe_arg arg;
416 struct expression *expr;
418 arg.type_str = xstrdup (p);
420 /* Use strtab_size as a sentinel. */
421 while (*p++ != '\0' && p - strtab < strtab_size);
423 /* Try to parse a type expression from the type string. If
424 this does not work then we set the type to `long
426 arg.type = builtin_type (gdbarch)->builtin_long;
427 expr = parse_expression (arg.type_str);
428 if (expr->elts[0].opcode == OP_TYPE)
429 arg.type = expr->elts[1].type;
431 VEC_safe_push (dtrace_probe_arg_s, ret->args, &arg);
434 /* Add the vector of enablers to this probe, if any. */
435 ret->enablers = VEC_copy (dtrace_probe_enabler_s, enablers);
437 /* Successfully created probe. */
438 VEC_safe_push (probe_p, *probesp, (struct probe *) ret);
441 do_cleanups (cleanup);
444 /* Helper function to collect the probes described in the DOF program
445 whose header is pointed by DOF and add them to the PROBESP vector.
446 SECT is the ELF section containing the DOF program and OBJFILE is
447 its containing object file. */
450 dtrace_process_dof (asection *sect, struct objfile *objfile,
451 VEC (probe_p) **probesp, struct dtrace_dof_hdr *dof)
453 bfd *abfd = objfile->obfd;
454 int size = bfd_get_arch_size (abfd) / 8;
455 struct gdbarch *gdbarch = get_objfile_arch (objfile);
456 struct dtrace_dof_sect *section;
459 /* The first step is to check for the DOF magic number. If no valid
460 DOF data is found in the section then a complaint is issued to
461 the user and the section skipped. */
462 if (dof->dofh_ident[DTRACE_DOF_ID_MAG0] != 0x7F
463 || dof->dofh_ident[DTRACE_DOF_ID_MAG1] != 'D'
464 || dof->dofh_ident[DTRACE_DOF_ID_MAG2] != 'O'
465 || dof->dofh_ident[DTRACE_DOF_ID_MAG3] != 'F')
466 goto invalid_dof_data;
468 /* Make sure the encoding mark is either DTRACE_DOF_ENCODE_LSB or
469 DTRACE_DOF_ENCODE_MSB. */
470 if (dof->dofh_ident[DTRACE_DOF_ID_ENCODING] != DTRACE_DOF_ENCODE_LSB
471 && dof->dofh_ident[DTRACE_DOF_ID_ENCODING] != DTRACE_DOF_ENCODE_MSB)
472 goto invalid_dof_data;
474 /* Make sure this DOF is not an enabling DOF, i.e. there are no ECB
475 Description sections. */
476 section = (struct dtrace_dof_sect *) DTRACE_DOF_PTR (dof,
477 DOF_UINT (dof, dof->dofh_secoff));
478 for (i = 0; i < DOF_UINT (dof, dof->dofh_secnum); i++, section++)
479 if (section->dofs_type == DTRACE_DOF_SECT_TYPE_ECBDESC)
482 /* Iterate over any section of type Provider and extract the probe
483 information from them. If there are no "provider" sections on
484 the DOF then we just return. */
485 section = (struct dtrace_dof_sect *) DTRACE_DOF_PTR (dof,
486 DOF_UINT (dof, dof->dofh_secoff));
487 for (i = 0; i < DOF_UINT (dof, dof->dofh_secnum); i++, section++)
488 if (DOF_UINT (dof, section->dofs_type) == DTRACE_DOF_SECT_TYPE_PROVIDER)
490 struct dtrace_dof_provider *provider = (struct dtrace_dof_provider *)
491 DTRACE_DOF_PTR (dof, DOF_UINT (dof, section->dofs_offset));
492 struct dtrace_dof_sect *strtab_s
493 = DTRACE_DOF_SECT (dof, DOF_UINT (dof, provider->dofpv_strtab));
494 struct dtrace_dof_sect *probes_s
495 = DTRACE_DOF_SECT (dof, DOF_UINT (dof, provider->dofpv_probes));
496 struct dtrace_dof_sect *args_s
497 = DTRACE_DOF_SECT (dof, DOF_UINT (dof, provider->dofpv_prargs));
498 struct dtrace_dof_sect *offsets_s
499 = DTRACE_DOF_SECT (dof, DOF_UINT (dof, provider->dofpv_proffs));
500 struct dtrace_dof_sect *eoffsets_s
501 = DTRACE_DOF_SECT (dof, DOF_UINT (dof, provider->dofpv_prenoffs));
502 char *strtab = DTRACE_DOF_PTR (dof, DOF_UINT (dof, strtab_s->dofs_offset));
503 char *offtab = DTRACE_DOF_PTR (dof, DOF_UINT (dof, offsets_s->dofs_offset));
504 char *eofftab = DTRACE_DOF_PTR (dof, DOF_UINT (dof, eoffsets_s->dofs_offset));
505 char *argtab = DTRACE_DOF_PTR (dof, DOF_UINT (dof, args_s->dofs_offset));
506 unsigned int entsize = DOF_UINT (dof, probes_s->dofs_entsize);
509 /* Very, unlikely, but could crash gdb if not handled
512 goto invalid_dof_data;
514 num_probes = DOF_UINT (dof, probes_s->dofs_size) / entsize;
516 for (i = 0; i < num_probes; i++)
518 struct dtrace_dof_probe *probe = (struct dtrace_dof_probe *)
519 DTRACE_DOF_PTR (dof, DOF_UINT (dof, probes_s->dofs_offset)
520 + (i * DOF_UINT (dof, probes_s->dofs_entsize)));
522 dtrace_process_dof_probe (objfile,
525 provider, strtab, offtab, eofftab, argtab,
526 DOF_UINT (dof, strtab_s->dofs_size));
533 complaint (&symfile_complaints,
534 _("skipping section '%s' which does not contain valid DOF data."),
538 /* Helper function to build the GDB internal expressiosn that, once
539 evaluated, will calculate the values of the arguments of a given
543 dtrace_build_arg_exprs (struct dtrace_probe *probe,
544 struct gdbarch *gdbarch)
546 struct parser_state pstate;
547 struct dtrace_probe_arg *arg;
550 probe->args_expr_built = 1;
552 /* Iterate over the arguments in the probe and build the
553 corresponding GDB internal expression that will generate the
554 value of the argument when executed at the PC of the probe. */
555 for (i = 0; i < probe->probe_argc; i++)
557 struct cleanup *back_to;
559 arg = VEC_index (dtrace_probe_arg_s, probe->args, i);
561 /* Initialize the expression buffer in the parser state. The
562 language does not matter, since we are using our own
564 initialize_expout (&pstate, 10, current_language, gdbarch);
565 back_to = make_cleanup (free_current_contents, &pstate.expout);
567 /* The argument value, which is ABI dependent and casted to
569 gdbarch_dtrace_parse_probe_argument (gdbarch, &pstate, i);
571 discard_cleanups (back_to);
573 /* Casting to the expected type, but only if the type was
574 recognized at probe load time. Otherwise the argument will
575 be evaluated as the long integer passed to the probe. */
576 if (arg->type != NULL)
578 write_exp_elt_opcode (&pstate, UNOP_CAST);
579 write_exp_elt_type (&pstate, arg->type);
580 write_exp_elt_opcode (&pstate, UNOP_CAST);
583 reallocate_expout (&pstate);
584 arg->expr = pstate.expout;
585 prefixify_expression (arg->expr);
589 /* Helper function to return the Nth argument of a given PROBE. */
591 static struct dtrace_probe_arg *
592 dtrace_get_arg (struct dtrace_probe *probe, unsigned n,
593 struct gdbarch *gdbarch)
595 if (!probe->args_expr_built)
596 dtrace_build_arg_exprs (probe, gdbarch);
598 return VEC_index (dtrace_probe_arg_s, probe->args, n);
601 /* Implementation of the get_probes method. */
604 dtrace_get_probes (VEC (probe_p) **probesp, struct objfile *objfile)
606 bfd *abfd = objfile->obfd;
607 asection *sect = NULL;
609 /* Do nothing in case this is a .debug file, instead of the objfile
611 if (objfile->separate_debug_objfile_backlink != NULL)
614 /* Iterate over the sections in OBJFILE looking for DTrace
616 for (sect = abfd->sections; sect != NULL; sect = sect->next)
618 if (elf_section_data (sect)->this_hdr.sh_type == SHT_SUNW_dof)
620 struct dtrace_dof_hdr *dof;
622 /* Read the contents of the DOF section and then process it to
623 extract the information of any probe defined into it. */
624 if (!bfd_malloc_and_get_section (abfd, sect, (bfd_byte **) &dof))
625 complaint (&symfile_complaints,
626 _("could not obtain the contents of"
627 "section '%s' in objfile `%s'."),
628 sect->name, abfd->filename);
630 dtrace_process_dof (sect, objfile, probesp, dof);
636 /* Helper function to determine whether a given probe is "enabled" or
637 "disabled". A disabled probe is a probe in which one or more
638 enablers are disabled. */
641 dtrace_probe_is_enabled (struct dtrace_probe *probe)
644 struct gdbarch *gdbarch = probe->p.arch;
645 struct dtrace_probe_enabler *enabler;
648 VEC_iterate (dtrace_probe_enabler_s, probe->enablers, i, enabler);
650 if (!gdbarch_dtrace_probe_is_enabled (gdbarch, enabler->address))
656 /* Implementation of the get_probe_address method. */
659 dtrace_get_probe_address (struct probe *probe, struct objfile *objfile)
661 gdb_assert (probe->pops == &dtrace_probe_ops);
662 return probe->address + ANOFFSET (objfile->section_offsets,
663 SECT_OFF_DATA (objfile));
666 /* Implementation of the get_probe_argument_count method. */
669 dtrace_get_probe_argument_count (struct probe *probe_generic,
670 struct frame_info *frame)
672 struct dtrace_probe *dtrace_probe = (struct dtrace_probe *) probe_generic;
674 gdb_assert (probe_generic->pops == &dtrace_probe_ops);
676 return dtrace_probe->probe_argc;
679 /* Implementation of the can_evaluate_probe_arguments method. */
682 dtrace_can_evaluate_probe_arguments (struct probe *probe_generic)
684 struct gdbarch *gdbarch = probe_generic->arch;
686 gdb_assert (probe_generic->pops == &dtrace_probe_ops);
687 return gdbarch_dtrace_parse_probe_argument_p (gdbarch);
690 /* Implementation of the evaluate_probe_argument method. */
692 static struct value *
693 dtrace_evaluate_probe_argument (struct probe *probe_generic, unsigned n,
694 struct frame_info *frame)
696 struct gdbarch *gdbarch = probe_generic->arch;
697 struct dtrace_probe *dtrace_probe = (struct dtrace_probe *) probe_generic;
698 struct dtrace_probe_arg *arg;
701 gdb_assert (probe_generic->pops == &dtrace_probe_ops);
703 arg = dtrace_get_arg (dtrace_probe, n, gdbarch);
704 return evaluate_subexp_standard (arg->type, arg->expr, &pos, EVAL_NORMAL);
707 /* Implementation of the compile_to_ax method. */
710 dtrace_compile_to_ax (struct probe *probe_generic, struct agent_expr *expr,
711 struct axs_value *value, unsigned n)
713 struct dtrace_probe *dtrace_probe = (struct dtrace_probe *) probe_generic;
714 struct dtrace_probe_arg *arg;
715 union exp_element *pc;
717 gdb_assert (probe_generic->pops == &dtrace_probe_ops);
719 arg = dtrace_get_arg (dtrace_probe, n, expr->gdbarch);
721 pc = arg->expr->elts;
722 gen_expr (arg->expr, &pc, expr, value);
724 require_rvalue (expr, value);
725 value->type = arg->type;
728 /* Implementation of the probe_destroy method. */
731 dtrace_probe_destroy (struct probe *probe_generic)
733 struct dtrace_probe *probe = (struct dtrace_probe *) probe_generic;
734 struct dtrace_probe_arg *arg;
737 gdb_assert (probe_generic->pops == &dtrace_probe_ops);
739 for (i = 0; VEC_iterate (dtrace_probe_arg_s, probe->args, i, arg); i++)
741 xfree (arg->type_str);
745 VEC_free (dtrace_probe_enabler_s, probe->enablers);
746 VEC_free (dtrace_probe_arg_s, probe->args);
749 /* Implementation of the type_name method. */
752 dtrace_type_name (struct probe *probe_generic)
754 gdb_assert (probe_generic->pops == &dtrace_probe_ops);
758 /* Implementation of the gen_info_probes_table_header method. */
761 dtrace_gen_info_probes_table_header (VEC (info_probe_column_s) **heads)
763 info_probe_column_s dtrace_probe_column;
765 dtrace_probe_column.field_name = "enabled";
766 dtrace_probe_column.print_name = _("Enabled");
768 VEC_safe_push (info_probe_column_s, *heads, &dtrace_probe_column);
771 /* Implementation of the gen_info_probes_table_values method. */
774 dtrace_gen_info_probes_table_values (struct probe *probe_generic,
775 VEC (const_char_ptr) **ret)
777 struct dtrace_probe *probe = (struct dtrace_probe *) probe_generic;
778 const char *val = NULL;
780 gdb_assert (probe_generic->pops == &dtrace_probe_ops);
782 if (VEC_empty (dtrace_probe_enabler_s, probe->enablers))
784 else if (!gdbarch_dtrace_probe_is_enabled_p (probe_generic->arch))
786 else if (dtrace_probe_is_enabled (probe))
791 VEC_safe_push (const_char_ptr, *ret, val);
794 /* Implementation of the enable_probe method. */
797 dtrace_enable_probe (struct probe *probe)
799 struct gdbarch *gdbarch = probe->arch;
800 struct dtrace_probe *dtrace_probe = (struct dtrace_probe *) probe;
801 struct dtrace_probe_enabler *enabler;
804 gdb_assert (probe->pops == &dtrace_probe_ops);
806 /* Enabling a dtrace probe implies patching the text section of the
807 running process, so make sure the inferior is indeed running. */
808 if (ptid_equal (inferior_ptid, null_ptid))
809 error (_("No inferior running"));
812 if (dtrace_probe_is_enabled (dtrace_probe))
815 /* Iterate over all defined enabler in the given probe and enable
816 them all using the corresponding gdbarch hook. */
819 VEC_iterate (dtrace_probe_enabler_s, dtrace_probe->enablers, i, enabler);
821 if (gdbarch_dtrace_enable_probe_p (gdbarch))
822 gdbarch_dtrace_enable_probe (gdbarch, enabler->address);
826 /* Implementation of the disable_probe method. */
829 dtrace_disable_probe (struct probe *probe)
831 struct gdbarch *gdbarch = probe->arch;
832 struct dtrace_probe *dtrace_probe = (struct dtrace_probe *) probe;
833 struct dtrace_probe_enabler *enabler;
836 gdb_assert (probe->pops == &dtrace_probe_ops);
838 /* Disabling a dtrace probe implies patching the text section of the
839 running process, so make sure the inferior is indeed running. */
840 if (ptid_equal (inferior_ptid, null_ptid))
841 error (_("No inferior running"));
844 if (!dtrace_probe_is_enabled (dtrace_probe))
847 /* Are we trying to disable a probe that does not have any enabler
849 if (VEC_empty (dtrace_probe_enabler_s, dtrace_probe->enablers))
850 error (_("Probe %s:%s cannot be disabled: no enablers."), probe->provider, probe->name);
852 /* Iterate over all defined enabler in the given probe and disable
853 them all using the corresponding gdbarch hook. */
856 VEC_iterate (dtrace_probe_enabler_s, dtrace_probe->enablers, i, enabler);
858 if (gdbarch_dtrace_disable_probe_p (gdbarch))
859 gdbarch_dtrace_disable_probe (gdbarch, enabler->address);
862 /* DTrace probe_ops. */
864 static const struct probe_ops dtrace_probe_ops =
866 dtrace_probe_is_linespec,
868 dtrace_get_probe_address,
869 dtrace_get_probe_argument_count,
870 dtrace_can_evaluate_probe_arguments,
871 dtrace_evaluate_probe_argument,
872 dtrace_compile_to_ax,
873 NULL, /* set_semaphore */
874 NULL, /* clear_semaphore */
875 dtrace_probe_destroy,
877 dtrace_gen_info_probes_table_header,
878 dtrace_gen_info_probes_table_values,
883 /* Implementation of the `info probes dtrace' command. */
886 info_probes_dtrace_command (char *arg, int from_tty)
888 info_probes_for_ops (arg, from_tty, &dtrace_probe_ops);
891 void _initialize_dtrace_probe (void);
894 _initialize_dtrace_probe (void)
896 VEC_safe_push (probe_ops_cp, all_probe_ops, &dtrace_probe_ops);
898 add_cmd ("dtrace", class_info, info_probes_dtrace_command,
900 Show information about DTrace static probes.\n\
901 Usage: info probes dtrace [PROVIDER [NAME [OBJECT]]]\n\
902 Each argument is a regular expression, used to select probes.\n\
903 PROVIDER matches probe provider names.\n\
904 NAME matches the probe names.\n\
905 OBJECT matches the executable or shared library name."),
906 info_probes_cmdlist_get ());