GDB (xrefs)

/tmp/gdb-8.1/gdb/dtrace-probe.c
Go to the documentation of this file.
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 (&symfile_complaints,
611 _("skipping section '%s' which does not contain valid DOF data."),
612 sect->name);
613 }
614
615 /* Implementation of 'build_arg_exprs' method. */
616
617 void
618 dtrace_probe::build_arg_exprs (struct gdbarch *gdbarch)
619 {
620 size_t argc = 0;
621 m_args_expr_built = true;
622
623 /* Iterate over the arguments in the probe and build the
624 corresponding GDB internal expression that will generate the
625 value of the argument when executed at the PC of the probe. */
626 for (dtrace_probe_arg &arg : m_args)
627 {
628 /* Initialize the expression buffer in the parser state. The
629 language does not matter, since we are using our own
630 parser. */
631 parser_state pstate (10, current_language, gdbarch);
632
633 /* The argument value, which is ABI dependent and casted to
634 `long int'. */
635 gdbarch_dtrace_parse_probe_argument (gdbarch, &pstate, argc);
636
637 /* Casting to the expected type, but only if the type was
638 recognized at probe load time. Otherwise the argument will
639 be evaluated as the long integer passed to the probe. */
640 if (arg.type != NULL)
641 {
642 write_exp_elt_opcode (&pstate, UNOP_CAST);
643 write_exp_elt_type (&pstate, arg.type);
644 write_exp_elt_opcode (&pstate, UNOP_CAST);
645 }
646
647 arg.expr = pstate.release ();
648 prefixify_expression (arg.expr.get ());
649 ++argc;
650 }
651 }
652
653 /* Implementation of 'get_arg_by_number' method. */
654
655 struct dtrace_probe_arg *
656 dtrace_probe::get_arg_by_number (unsigned n, struct gdbarch *gdbarch)
657 {
658 if (!m_args_expr_built)
659 this->build_arg_exprs (gdbarch);
660
661 if (n > m_args.size ())
662 internal_error (__FILE__, __LINE__,
663 _("Probe '%s' has %d arguments, but GDB is requesting\n"
664 "argument %u. This should not happen. Please\n"
665 "report this bug."),
666 this->get_name ().c_str (),
667 (int) m_args.size (), n);
668
669 return &m_args[n];
670 }
671
672 /* Implementation of the probe is_enabled method. */
673
674 bool
675 dtrace_probe::is_enabled () const
676 {
677 struct gdbarch *gdbarch = this->get_gdbarch ();
678
679 for (const dtrace_probe_enabler &enabler : m_enablers)
680 if (!gdbarch_dtrace_probe_is_enabled (gdbarch, enabler.address))
681 return false;
682
683 return true;
684 }
685
686 /* Implementation of the get_probe_address method. */
687
688 CORE_ADDR
689 dtrace_probe::get_relocated_address (struct objfile *objfile)
690 {
691 return this->get_address () + ANOFFSET (objfile->section_offsets,
692 SECT_OFF_DATA (objfile));
693 }
694
695 /* Implementation of the get_argument_count method. */
696
697 unsigned
698 dtrace_probe::get_argument_count (struct frame_info *frame)
699 {
700 return m_args.size ();
701 }
702
703 /* Implementation of the can_evaluate_arguments method. */
704
705 bool
706 dtrace_probe::can_evaluate_arguments () const
707 {
708 struct gdbarch *gdbarch = this->get_gdbarch ();
709
710 return gdbarch_dtrace_parse_probe_argument_p (gdbarch);
711 }
712
713 /* Implementation of the evaluate_argument method. */
714
715 struct value *
716 dtrace_probe::evaluate_argument (unsigned n,
717 struct frame_info *frame)
718 {
719 struct gdbarch *gdbarch = this->get_gdbarch ();
720 struct dtrace_probe_arg *arg;
721 int pos = 0;
722
723 arg = this->get_arg_by_number (n, gdbarch);
724 return evaluate_subexp_standard (arg->type, arg->expr.get (), &pos,
725 EVAL_NORMAL);
726 }
727
728 /* Implementation of the compile_to_ax method. */
729
730 void
731 dtrace_probe::compile_to_ax (struct agent_expr *expr, struct axs_value *value,
732 unsigned n)
733 {
734 struct dtrace_probe_arg *arg;
735 union exp_element *pc;
736
737 arg = this->get_arg_by_number (n, expr->gdbarch);
738
739 pc = arg->expr->elts;
740 gen_expr (arg->expr.get (), &pc, expr, value);
741
742 require_rvalue (expr, value);
743 value->type = arg->type;
744 }
745
746 /* Implementation of the 'get_static_ops' method. */
747
748 const static_probe_ops *
749 dtrace_probe::get_static_ops () const
750 {
751 return &dtrace_static_probe_ops;
752 }
753
754 /* Implementation of the gen_info_probes_table_values method. */
755
756 std::vector<const char *>
757 dtrace_probe::gen_info_probes_table_values () const
758 {
759 const char *val = NULL;
760
761 if (m_enablers.empty ())
762 val = "always";
763 else if (!gdbarch_dtrace_probe_is_enabled_p (this->get_gdbarch ()))
764 val = "unknown";
765 else if (this->is_enabled ())
766 val = "yes";
767 else
768 val = "no";
769
770 return std::vector<const char *> { val };
771 }
772
773 /* Implementation of the enable method. */
774
775 void
776 dtrace_probe::enable ()
777 {
778 struct gdbarch *gdbarch = this->get_gdbarch ();
779
780 /* Enabling a dtrace probe implies patching the text section of the
781 running process, so make sure the inferior is indeed running. */
782 if (ptid_equal (inferior_ptid, null_ptid))
783 error (_("No inferior running"));
784
785 /* Fast path. */
786 if (this->is_enabled ())
787 return;
788
789 /* Iterate over all defined enabler in the given probe and enable
790 them all using the corresponding gdbarch hook. */
791 for (const dtrace_probe_enabler &enabler : m_enablers)
792 if (gdbarch_dtrace_enable_probe_p (gdbarch))
793 gdbarch_dtrace_enable_probe (gdbarch, enabler.address);
794 }
795
796
797 /* Implementation of the disable_probe method. */
798
799 void
800 dtrace_probe::disable ()
801 {
802 struct gdbarch *gdbarch = this->get_gdbarch ();
803
804 /* Disabling a dtrace probe implies patching the text section of the
805 running process, so make sure the inferior is indeed running. */
806 if (ptid_equal (inferior_ptid, null_ptid))
807 error (_("No inferior running"));
808
809 /* Fast path. */
810 if (!this->is_enabled ())
811 return;
812
813 /* Are we trying to disable a probe that does not have any enabler
814 associated? */
815 if (m_enablers.empty ())
816 error (_("Probe %s:%s cannot be disabled: no enablers."),
817 this->get_provider ().c_str (), this->get_name ().c_str ());
818
819 /* Iterate over all defined enabler in the given probe and disable
820 them all using the corresponding gdbarch hook. */
821 for (dtrace_probe_enabler &enabler : m_enablers)
822 if (gdbarch_dtrace_disable_probe_p (gdbarch))
823 gdbarch_dtrace_disable_probe (gdbarch, enabler.address);
824 }
825
826 /* Implementation of the is_linespec method. */
827
828 bool
829 dtrace_static_probe_ops::is_linespec (const char **linespecp) const
830 {
831 static const char *const keywords[] = { "-pdtrace", "-probe-dtrace", NULL };
832
833 return probe_is_linespec_by_keyword (linespecp, keywords);
834 }
835
836 /* Implementation of the get_probes method. */
837
838 void
839 dtrace_static_probe_ops::get_probes (std::vector<probe *> *probesp,
840 struct objfile *objfile) const
841 {
842 bfd *abfd = objfile->obfd;
843 asection *sect = NULL;
844
845 /* Do nothing in case this is a .debug file, instead of the objfile
846 itself. */
847 if (objfile->separate_debug_objfile_backlink != NULL)
848 return;
849
850 /* Iterate over the sections in OBJFILE looking for DTrace
851 information. */
852 for (sect = abfd->sections; sect != NULL; sect = sect->next)
853 {
854 if (elf_section_data (sect)->this_hdr.sh_type == SHT_SUNW_dof)
855 {
856 bfd_byte *dof;
857
858 /* Read the contents of the DOF section and then process it to
859 extract the information of any probe defined into it. */
860 if (!bfd_malloc_and_get_section (abfd, sect, &dof))
861 complaint (&symfile_complaints,
862 _("could not obtain the contents of"
863 "section '%s' in objfile `%s'."),
864 sect->name, abfd->filename);
865
866 dtrace_process_dof (sect, objfile, probesp,
867 (struct dtrace_dof_hdr *) dof);
868 xfree (dof);
869 }
870 }
871 }
872
873 /* Implementation of the type_name method. */
874
875 const char *
876 dtrace_static_probe_ops::type_name () const
877 {
878 return "dtrace";
879 }
880
881 /* Implementation of the gen_info_probes_table_header method. */
882
883 std::vector<struct info_probe_column>
884 dtrace_static_probe_ops::gen_info_probes_table_header () const
885 {
886 struct info_probe_column dtrace_probe_column;
887
888 dtrace_probe_column.field_name = "enabled";
889 dtrace_probe_column.print_name = _("Enabled");
890
891 return std::vector<struct info_probe_column> { dtrace_probe_column };
892 }
893
894 /* Implementation of the `info probes dtrace' command. */
895
896 static void
897 info_probes_dtrace_command (const char *arg, int from_tty)
898 {
899 info_probes_for_spops (arg, from_tty, &dtrace_static_probe_ops);
900 }
901
902 void
903 _initialize_dtrace_probe (void)
904 {
905 all_static_probe_ops.push_back (&dtrace_static_probe_ops);
906
907 add_cmd ("dtrace", class_info, info_probes_dtrace_command,
908 _("\
909 Show information about DTrace static probes.\n\
910 Usage: info probes dtrace [PROVIDER [NAME [OBJECT]]]\n\
911 Each argument is a regular expression, used to select probes.\n\
912 PROVIDER matches probe provider names.\n\
913 NAME matches the probe names.\n\
914 OBJECT matches the executable or shared library name."),
915 info_probes_cmdlist_get ());
916 }
gdbarch
Definition: gdbarch.c:127
string
const char * string
Definition: signals.c:50
probe
Definition: probe.h:112
gdbarch_dtrace_probe_is_enabled_p
int gdbarch_dtrace_probe_is_enabled_p(struct gdbarch *gdbarch)
Definition: gdbarch.c:4530
axs_value
Definition: ax-gdb.h:77
dtrace_dof_sect::dofs_entsize
uint32_t dofs_entsize
Definition: dtrace-probe.c:274
dtrace_dof_sect::dofs_offset
uint64_t dofs_offset
Definition: dtrace-probe.c:276
dtrace_dof_sect::dofs_type
uint32_t dofs_type
Definition: dtrace-probe.c:268
objfile::obfd
bfd * obfd
Definition: objfiles.h:342
dtrace_probe_arg::dtrace_probe_arg
dtrace_probe_arg(struct type *type_, std::string &&type_str_, expression_up &&expr_)
Definition: dtrace-probe.c:49
DTRACE_DOF_PTR
#define DTRACE_DOF_PTR(dof, offset)
Definition: dtrace-probe.c:363
CORE_ADDR
bfd_vma CORE_ADDR
Definition: common-types.h:41
value::type
struct type * type
Definition: value.c:266
gdbarch_dtrace_parse_probe_argument_p
int gdbarch_dtrace_parse_probe_argument_p(struct gdbarch *gdbarch)
Definition: gdbarch.c:4506
expression_up
gdb::unique_xmalloc_ptr< expression > expression_up
Definition: expression.h:87
DTRACE_DOF_ID_MAG1
Definition: dtrace-probe.c:217
xfree
void xfree(void *)
objfile::separate_debug_objfile_backlink
struct objfile * separate_debug_objfile_backlink
Definition: objfiles.h:441
EVAL_NORMAL
Definition: expression.h:125
gdbarch_dtrace_probe_is_enabled
int gdbarch_dtrace_probe_is_enabled(struct gdbarch *gdbarch, CORE_ADDR addr)
Definition: gdbarch.c:4537
dtrace_probe::disable
void disable() override
Definition: dtrace-probe.c:800
DTRACE_DOF_SECT_TYPE_PRARGS
Definition: dtrace-probe.c:196
dtrace_dof_hdr::dofh_secoff
uint64_t dofh_secoff
Definition: dtrace-probe.c:252
dtrace_dof_provider::dofpv_nameattr
uint32_t dofpv_nameattr
Definition: dtrace-probe.c:302
dtrace_dof_sect
Definition: dtrace-probe.c:265
DTRACE_DOF_ENCODE_LSB
Definition: dtrace-probe.c:231
DTRACE_DOF_SECT
#define DTRACE_DOF_SECT(dof, idx)
Definition: dtrace-probe.c:369
dtrace_process_dof
static void dtrace_process_dof(asection *sect, struct objfile *objfile, std::vector< probe *> *probesp, struct dtrace_dof_hdr *dof)
Definition: dtrace-probe.c:521
dtrace_dof_probe::dofpr_func
uint32_t dofpr_func
Definition: dtrace-probe.c:320
gdbarch_dtrace_enable_probe
void gdbarch_dtrace_enable_probe(struct gdbarch *gdbarch, CORE_ADDR addr)
Definition: gdbarch.c:4561
builtin_type
const struct builtin_type * builtin_type(struct gdbarch *gdbarch)
Definition: gdbtypes.c:5217
RETURN_MASK_ERROR
Definition: common-exceptions.h:43
dtrace_probe::dtrace_probe
dtrace_probe(std::string &&name_, std::string &&provider_, CORE_ADDR address_, struct gdbarch *arch_, std::vector< struct dtrace_probe_arg > &&args_, std::vector< struct dtrace_probe_enabler > &&enablers_)
Definition: dtrace-probe.c:111
dtrace_dof_probe::dofpr_nenoffs
uint16_t dofpr_nenoffs
Definition: dtrace-probe.c:340
internal_error
void internal_error(const char *file, int line, const char *fmt,...)
Definition: errors.c:50
info_probes_dtrace_command
static void info_probes_dtrace_command(const char *arg, int from_tty)
Definition: dtrace-probe.c:897
ax-gdb.h
info_probes_cmdlist_get
struct cmd_list_element ** info_probes_cmdlist_get(void)
Definition: probe.c:782
DTRACE_DOF_SECT_TYPE_NONE
Definition: dtrace-probe.c:186
dtrace_dof_provider::dofpv_probes
uint32_t dofpv_probes
Definition: dtrace-probe.c:288
dtrace_static_probe_ops
const dtrace_static_probe_ops dtrace_static_probe_ops
Definition: dtrace-probe.c:103
add_cmd
struct cmd_list_element * add_cmd(const char *name, enum command_class theclass, const char *doc, struct cmd_list_element **list)
Definition: cli-decode.c:262
agent_expr
Definition: ax.h:83
frame_info
Definition: frame.c:85
probe::get_address
CORE_ADDR get_address() const
Definition: probe.h:209
dtrace_dof_hdr::dofh_secsize
uint32_t dofh_secsize
Definition: dtrace-probe.c:248
dtrace_probe::is_enabled
bool is_enabled() const
Definition: dtrace-probe.c:675
dtrace_static_probe_ops::type_name
const char * type_name() const override
Definition: dtrace-probe.c:876
dtrace_dof_provider::dofpv_provattr
uint32_t dofpv_provattr
Definition: dtrace-probe.c:296
agent_expr::gdbarch
struct gdbarch * gdbarch
Definition: ax.h:100
info_probe_column
Definition: probe.h:29
DTRACE_DOF_SECT_TYPE_PROBES
Definition: dtrace-probe.c:194
info_probes_for_spops
void info_probes_for_spops(const char *arg, int from_tty, const static_probe_ops *spops)
Definition: probe.c:489
SHT_SUNW_dof
#define SHT_SUNW_dof
Definition: dtrace-probe.c:41
_
#define _(String)
Definition: gdb_locale.h:35
dtrace_probe::get_relocated_address
CORE_ADDR get_relocated_address(struct objfile *objfile) override
Definition: dtrace-probe.c:689
defs.h
DTRACE_DOF_SECT_TYPE_PROFFS
Definition: dtrace-probe.c:198
dtrace_probe_arg::expr
expression_up expr
Definition: dtrace-probe.c:62
dtrace_dof_hdr
Definition: dtrace-probe.c:239
END_CATCH
#define END_CATCH
Definition: common-exceptions.h:259
ax.h
class_info
Definition: command.h:42
probe::get_provider
const std::string & get_provider() const
Definition: probe.h:203
dtrace_probe_arg::type
struct type * type
Definition: dtrace-probe.c:56
gdbarch_dtrace_disable_probe_p
int gdbarch_dtrace_disable_probe_p(struct gdbarch *gdbarch)
Definition: gdbarch.c:4578
DTRACE_DOF_ID_ENCODING
Definition: dtrace-probe.c:223
dtrace_probe::gen_info_probes_table_values
std::vector< const char * > gen_info_probes_table_values() const override
Definition: dtrace-probe.c:757
DTRACE_DOF_ID_MAG0
Definition: dtrace-probe.c:215
objfiles.h
dtrace_dof_probe
Definition: dtrace-probe.c:315
dtrace_probe::build_arg_exprs
void build_arg_exprs(struct gdbarch *gdbarch)
Definition: dtrace-probe.c:618
dtrace_dof_hdr::dofh_filesz
uint64_t dofh_filesz
Definition: dtrace-probe.c:256
parser-defs.h
TRY
#define TRY
Definition: common-exceptions.h:246
probe_is_linespec_by_keyword
int probe_is_linespec_by_keyword(const char **linespecp, const char *const *keywords)
Definition: probe.c:724
name
const char *const name
Definition: aarch64-tdep.c:76
dtrace_probe
Definition: dtrace-probe.c:107
dtrace_dof_ident
dtrace_dof_ident
Definition: dtrace-probe.c:212
dtrace_dof_sect_type
dtrace_dof_sect_type
Definition: dtrace-probe.c:183
dtrace_dof_sect::dofs_flags
uint32_t dofs_flags
Definition: dtrace-probe.c:272
dtrace_dof_provider::dofpv_proffs
uint32_t dofpv_proffs
Definition: dtrace-probe.c:292
dtrace_dof_hdr::dofh_hdrsize
uint32_t dofh_hdrsize
Definition: dtrace-probe.c:246
CATCH
#define CATCH(EXCEPTION, MASK)
Definition: common-exceptions.h:254
dtrace_dof_probe::dofpr_noffs
uint16_t dofpr_noffs
Definition: dtrace-probe.c:336
dtrace_dof_probe::dofpr_name
uint32_t dofpr_name
Definition: dtrace-probe.c:322
dtrace_dof_hdr::dofh_flags
uint32_t dofh_flags
Definition: dtrace-probe.c:244
dtrace_dof_sect::dofs_align
uint32_t dofs_align
Definition: dtrace-probe.c:270
dtrace_static_probe_ops
Definition: dtrace-probe.c:77
dtrace_probe::get_argument_count
unsigned get_argument_count(struct frame_info *frame) override
Definition: dtrace-probe.c:698
pstate
static struct parser_state * pstate
Definition: ada-exp.c:98
prefixify_expression
int prefixify_expression(struct expression *expr)
Definition: parse.c:789
dtrace_dof_provider::dofpv_strtab
uint32_t dofpv_strtab
Definition: dtrace-probe.c:286
probe::get_name
const std::string & get_name() const
Definition: probe.h:197
dtrace_probe_arg
Definition: dtrace-probe.c:47
DTRACE_DOF_SECT_TYPE_PROVIDER
Definition: dtrace-probe.c:192
dtrace_static_probe_ops::get_probes
void get_probes(std::vector< probe *> *probesp, struct objfile *objfile) const override
Definition: dtrace-probe.c:839
gdbarch_dtrace_disable_probe
void gdbarch_dtrace_disable_probe(struct gdbarch *gdbarch, CORE_ADDR addr)
Definition: gdbarch.c:4585
SECT_OFF_DATA
#define SECT_OFF_DATA(objfile)
Definition: objfiles.h:674
inferior.h
ANOFFSET
#define ANOFFSET(secoff, whichone)
Definition: symtab.h:1276
get_objfile_arch
struct gdbarch * get_objfile_arch(const struct objfile *objfile)
Definition: objfiles.c:445
dtrace_dof_provider::dofpv_modattr
uint32_t dofpv_modattr
Definition: dtrace-probe.c:298
type
Definition: gdbtypes.h:749
DTRACE_DOF_ENCODE_MSB
Definition: dtrace-probe.c:233
language.h
info_probe_column::field_name
const char * field_name
Definition: probe.h:33
complaint
#define complaint(COMPLAINTS, FMT,...)
Definition: complaints.h:40
info_probe_column::print_name
const char * print_name
Definition: probe.h:37
builtin_type::builtin_long
struct type * builtin_long
Definition: gdbtypes.h:1504
dtrace_dof_hdr::dofh_ident
uint8_t dofh_ident[16]
Definition: dtrace-probe.c:242
DTRACE_DOF_SECT_TYPE_PRENOFFS
Definition: dtrace-probe.c:200
dtrace_dof_hdr::dofh_loadsz
uint64_t dofh_loadsz
Definition: dtrace-probe.c:254
static_probe_ops
Definition: probe.h:52
parser_state
Definition: parser-defs.h:38
dtrace_static_probe_ops::gen_info_probes_table_header
std::vector< struct info_probe_column > gen_info_probes_table_header() const override
Definition: dtrace-probe.c:884
DTRACE_DOF_SECT_TYPE_STRTAB
Definition: dtrace-probe.c:190
_initialize_dtrace_probe
void _initialize_dtrace_probe(void)
Definition: dtrace-probe.c:903
dtrace_dof_probe::dofpr_xargc
uint8_t dofpr_xargc
Definition: dtrace-probe.c:334
complaints.h
dtrace_dof_probe::dofpr_nargv
uint32_t dofpr_nargv
Definition: dtrace-probe.c:324
DTRACE_DOF_SECT_TYPE_ECBDESC
Definition: dtrace-probe.c:188
gen_expr
void gen_expr(struct expression *exp, union exp_element **pc, struct agent_expr *ax, struct axs_value *value)
Definition: ax-gdb.c:1806
dtrace_dof_sect::dofs_size
uint64_t dofs_size
Definition: dtrace-probe.c:278
value
Definition: value.c:169
DTRACE_DOF_ID_MAG2
Definition: dtrace-probe.c:219
dtrace_probe_enabler::address
CORE_ADDR address
Definition: dtrace-probe.c:72
parser_state::release
expression_up release()
Definition: parse.c:169
dtrace_probe_arg::type_str
std::string type_str
Definition: dtrace-probe.c:59
gdbarch_dtrace_enable_probe_p
int gdbarch_dtrace_enable_probe_p(struct gdbarch *gdbarch)
Definition: gdbarch.c:4554
dtrace_dof_encoding
dtrace_dof_encoding
Definition: dtrace-probe.c:228
dtrace_probe::evaluate_argument
struct value * evaluate_argument(unsigned n, struct frame_info *frame) override
Definition: dtrace-probe.c:716
all_static_probe_ops
std::vector< const static_probe_ops * > all_static_probe_ops
Definition: probe.c:882
dtrace_dof_probe::dofpr_enoffidx
uint32_t dofpr_enoffidx
Definition: dtrace-probe.c:338
write_exp_elt_opcode
void write_exp_elt_opcode(struct parser_state *ps, enum exp_opcode expelt)
Definition: parse.c:205
objfile
Definition: objfiles.h:286
dtrace_dof_provider::dofpv_prargs
uint32_t dofpv_prargs
Definition: dtrace-probe.c:290
exp_element
Definition: expression.h:62
current_language
const struct language_defn * current_language
Definition: language.c:81
null_ptid
ptid_t null_ptid
Definition: ptid.c:25
dtrace_dof_probe::dofpr_pad1
uint16_t dofpr_pad1
Definition: dtrace-probe.c:342
dtrace_dof_provider::dofpv_argsattr
uint32_t dofpv_argsattr
Definition: dtrace-probe.c:304
dtrace_dof_provider::dofpv_name
uint32_t dofpv_name
Definition: dtrace-probe.c:294
dtrace_probe_enabler
Definition: dtrace-probe.c:67
inferior_ptid
ptid_t inferior_ptid
Definition: infcmd.c:94
dtrace_dof_probe::dofpr_nargc
uint8_t dofpr_nargc
Definition: dtrace-probe.c:332
dtrace_process_dof_probe
static void dtrace_process_dof_probe(struct objfile *objfile, struct gdbarch *gdbarch, std::vector< probe *> *probesp, struct dtrace_dof_hdr *dof, struct dtrace_dof_probe *probe, struct dtrace_dof_provider *provider, char *strtab, char *offtab, char *eofftab, char *argtab, uint64_t strtab_size)
Definition: dtrace-probe.c:381
symfile_complaints
struct complaints * symfile_complaints
Definition: complaints.c:96
dtrace_static_probe_ops::is_linespec
bool is_linespec(const char **linespecp) const override
Definition: dtrace-probe.c:829
dtrace_probe::can_evaluate_arguments
bool can_evaluate_arguments() const override
Definition: dtrace-probe.c:706
dtrace_probe::m_enablers
std::vector< struct dtrace_probe_enabler > m_enablers
Definition: dtrace-probe.c:169
DTRACE_DOF_ID_MAG3
Definition: dtrace-probe.c:221
dtrace_dof_probe::dofpr_xargv
uint32_t dofpr_xargv
Definition: dtrace-probe.c:326
dtrace_static_probe_ops::can_enable
bool can_enable() const override
Definition: dtrace-probe.c:91
probe.h
dtrace_dof_probe::dofpr_argidx
uint32_t dofpr_argidx
Definition: dtrace-probe.c:328
require_rvalue
void require_rvalue(struct agent_expr *ax, struct axs_value *value)
Definition: ax-gdb.c:773
evaluate_subexp_standard
struct value * evaluate_subexp_standard(struct type *expect_type, struct expression *exp, int *pos, enum noside noside)
Definition: eval.c:1240
value.h
ptid_equal
int ptid_equal(const ptid_t &ptid1, const ptid_t &ptid2)
Definition: ptid.c:71
dtrace_probe::get_static_ops
const static_probe_ops * get_static_ops() const override
Definition: dtrace-probe.c:749
gdbtypes.h
dtrace_probe::m_args_expr_built
bool m_args_expr_built
Definition: dtrace-probe.c:172
dtrace_probe::enable
void enable() override
Definition: dtrace-probe.c:776
dtrace_dof_probe::dofpr_pad2
uint32_t dofpr_pad2
Definition: dtrace-probe.c:344
dtrace_probe::m_args
std::vector< struct dtrace_probe_arg > m_args
Definition: dtrace-probe.c:166
DOF_UINT
#define DOF_UINT(dof, field)
Definition: dtrace-probe.c:352
dtrace_dof_provider
Definition: dtrace-probe.c:283
dtrace_dof_provider::dofpv_prenoffs
uint32_t dofpv_prenoffs
Definition: dtrace-probe.c:306
gdbarch_dtrace_parse_probe_argument
void gdbarch_dtrace_parse_probe_argument(struct gdbarch *gdbarch, struct parser_state *pstate, int narg)
Definition: gdbarch.c:4513
objfile::section_offsets
struct section_offsets * section_offsets
Definition: objfiles.h:396
parse_expression_with_language
expression_up parse_expression_with_language(const char *string, enum language lang)
Definition: parse.c:1249
dtrace_probe::compile_to_ax
void compile_to_ax(struct agent_expr *aexpr, struct axs_value *axs_value, unsigned n) override
Definition: dtrace-probe.c:731
dtrace_dof_hdr::dofh_pad
uint64_t dofh_pad
Definition: dtrace-probe.c:258
dtrace_probe::get_arg_by_number
struct dtrace_probe_arg * get_arg_by_number(unsigned n, struct gdbarch *gdbarch)
Definition: dtrace-probe.c:656
write_exp_elt_type
void write_exp_elt_type(struct parser_state *ps, struct type *expelt)
Definition: parse.c:277
error
void error(const char *fmt,...)
Definition: errors.c:38
dtrace_dof_probe::dofpr_addr
uint64_t dofpr_addr
Definition: dtrace-probe.c:318
language_c
Definition: defs.h:207
dtrace_dof_hdr::dofh_secnum
uint32_t dofh_secnum
Definition: dtrace-probe.c:250
dtrace_dof_provider::dofpv_funcattr
uint32_t dofpv_funcattr
Definition: dtrace-probe.c:300
dtrace_dof_probe::dofpr_offidx
uint32_t dofpr_offidx
Definition: dtrace-probe.c:330
probe::get_gdbarch
struct gdbarch * get_gdbarch() const
Definition: probe.h:215
vec.h