GDB (xrefs)

/tmp/gdb-8.1/gdb/stap-probe.c
Go to the documentation of this file.
1 /* SystemTap probe support for GDB.
2
3 Copyright (C) 2012-2018 Free Software Foundation, Inc.
4
5 This file is part of GDB.
6
7 This program is free software; you can redistribute it and/or modify
8 it under the terms of the GNU General Public License as published by
9 the Free Software Foundation; either version 3 of the License, or
10 (at your option) any later version.
11
12 This program is distributed in the hope that it will be useful,
13 but WITHOUT ANY WARRANTY; without even the implied warranty of
14 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
15 GNU General Public License for more details.
16
17 You should have received a copy of the GNU General Public License
18 along with this program. If not, see <http://www.gnu.org/licenses/>. */
19
20 #include "defs.h"
21 #include "stap-probe.h"
22 #include "probe.h"
23 #include "vec.h"
24 #include "ui-out.h"
25 #include "objfiles.h"
26 #include "arch-utils.h"
27 #include "command.h"
28 #include "gdbcmd.h"
29 #include "filenames.h"
30 #include "value.h"
31 #include "ax.h"
32 #include "ax-gdb.h"
33 #include "complaints.h"
34 #include "cli/cli-utils.h"
35 #include "linespec.h"
36 #include "user-regs.h"
37 #include "parser-defs.h"
38 #include "language.h"
39 #include "elf-bfd.h"
40
41 #include <ctype.h>
42
43 /* The name of the SystemTap section where we will find information about
44 the probes. */
45
46 #define STAP_BASE_SECTION_NAME ".stapsdt.base"
47
48 /* Should we display debug information for the probe's argument expression
49 parsing? */
50
51 static unsigned int stap_expression_debug = 0;
52
53 /* The various possibilities of bitness defined for a probe's argument.
54
55 The relationship is:
56
57 - STAP_ARG_BITNESS_UNDEFINED: The user hasn't specified the bitness.
58 - STAP_ARG_BITNESS_8BIT_UNSIGNED: argument string starts with `1@'.
59 - STAP_ARG_BITNESS_8BIT_SIGNED: argument string starts with `-1@'.
60 - STAP_ARG_BITNESS_16BIT_UNSIGNED: argument string starts with `2@'.
61 - STAP_ARG_BITNESS_16BIT_SIGNED: argument string starts with `-2@'.
62 - STAP_ARG_BITNESS_32BIT_UNSIGNED: argument string starts with `4@'.
63 - STAP_ARG_BITNESS_32BIT_SIGNED: argument string starts with `-4@'.
64 - STAP_ARG_BITNESS_64BIT_UNSIGNED: argument string starts with `8@'.
65 - STAP_ARG_BITNESS_64BIT_SIGNED: argument string starts with `-8@'. */
66
67 enum stap_arg_bitness
68 {
69 STAP_ARG_BITNESS_UNDEFINED,
70 STAP_ARG_BITNESS_8BIT_UNSIGNED,
71 STAP_ARG_BITNESS_8BIT_SIGNED,
72 STAP_ARG_BITNESS_16BIT_UNSIGNED,
73 STAP_ARG_BITNESS_16BIT_SIGNED,
74 STAP_ARG_BITNESS_32BIT_UNSIGNED,
75 STAP_ARG_BITNESS_32BIT_SIGNED,
76 STAP_ARG_BITNESS_64BIT_UNSIGNED,
77 STAP_ARG_BITNESS_64BIT_SIGNED,
78 };
79
80 /* The following structure represents a single argument for the probe. */
81
82 struct stap_probe_arg
83 {
84 /* Constructor for stap_probe_arg. */
85 stap_probe_arg (enum stap_arg_bitness bitness_, struct type *atype_,
86 expression_up &&aexpr_)
87 : bitness (bitness_), atype (atype_), aexpr (std::move (aexpr_))
88 {}
89
90 /* The bitness of this argument. */
91 enum stap_arg_bitness bitness;
92
93 /* The corresponding `struct type *' to the bitness. */
94 struct type *atype;
95
96 /* The argument converted to an internal GDB expression. */
97 expression_up aexpr;
98 };
99
100 /* Class that implements the static probe methods for "stap" probes. */
101
102 class stap_static_probe_ops : public static_probe_ops
103 {
104 public:
105 /* See probe.h. */
106 bool is_linespec (const char **linespecp) const override;
107
108 /* See probe.h. */
109 void get_probes (std::vector<probe *> *probesp,
110 struct objfile *objfile) const override;
111
112 /* See probe.h. */
113 const char *type_name () const override;
114
115 /* See probe.h. */
116 std::vector<struct info_probe_column> gen_info_probes_table_header
117 () const override;
118 };
119
120 /* SystemTap static_probe_ops. */
121
122 const stap_static_probe_ops stap_static_probe_ops;
123
124 class stap_probe : public probe
125 {
126 public:
127 /* Constructor for stap_probe. */
128 stap_probe (std::string &&name_, std::string &&provider_, CORE_ADDR address_,
129 struct gdbarch *arch_, CORE_ADDR sem_addr, const char *args_text)
130 : probe (std::move (name_), std::move (provider_), address_, arch_),
131 m_sem_addr (sem_addr),
132 m_have_parsed_args (false), m_unparsed_args_text (args_text)
133 {}
134
135 /* See probe.h. */
136 CORE_ADDR get_relocated_address (struct objfile *objfile) override;
137
138 /* See probe.h. */
139 unsigned get_argument_count (struct frame_info *frame) override;
140
141 /* See probe.h. */
142 bool can_evaluate_arguments () const override;
143
144 /* See probe.h. */
145 struct value *evaluate_argument (unsigned n,
146 struct frame_info *frame) override;
147
148 /* See probe.h. */
149 void compile_to_ax (struct agent_expr *aexpr,
150 struct axs_value *axs_value,
151 unsigned n) override;
152
153 /* See probe.h. */
154 void set_semaphore (struct objfile *objfile,
155 struct gdbarch *gdbarch) override;
156
157 /* See probe.h. */
158 void clear_semaphore (struct objfile *objfile,
159 struct gdbarch *gdbarch) override;
160
161 /* See probe.h. */
162 const static_probe_ops *get_static_ops () const override;
163
164 /* See probe.h. */
165 std::vector<const char *> gen_info_probes_table_values () const override;
166
167 /* Return argument N of probe.
168
169 If the probe's arguments have not been parsed yet, parse them. If
170 there are no arguments, throw an exception (error). Otherwise,
171 return the requested argument. */
172 struct stap_probe_arg *get_arg_by_number (unsigned n,
173 struct gdbarch *gdbarch)
174 {
175 if (!m_have_parsed_args)
176 this->parse_arguments (gdbarch);
177
178 gdb_assert (m_have_parsed_args);
179 if (m_parsed_args.empty ())
180 internal_error (__FILE__, __LINE__,
181 _("Probe '%s' apparently does not have arguments, but \n"
182 "GDB is requesting its argument number %u anyway. "
183 "This should not happen. Please report this bug."),
184 this->get_name ().c_str (), n);
185
186 if (n > m_parsed_args.size ())
187 internal_error (__FILE__, __LINE__,
188 _("Probe '%s' has %d arguments, but GDB is requesting\n"
189 "argument %u. This should not happen. Please\n"
190 "report this bug."),
191 this->get_name ().c_str (),
192 (int) m_parsed_args.size (), n);
193
194 return &m_parsed_args[n];
195 }
196
197 /* Function which parses an argument string from the probe,
198 correctly splitting the arguments and storing their information
199 in properly ways.
200
201 Consider the following argument string (x86 syntax):
202
203 `4@%eax 4@$10'
204
205 We have two arguments, `%eax' and `$10', both with 32-bit
206 unsigned bitness. This function basically handles them, properly
207 filling some structures with this information. */
208 void parse_arguments (struct gdbarch *gdbarch);
209
210 private:
211 /* If the probe has a semaphore associated, then this is the value of
212 it, relative to SECT_OFF_DATA. */
213 CORE_ADDR m_sem_addr;
214
215 /* True if the arguments have been parsed. */
216 bool m_have_parsed_args;
217
218 /* The text version of the probe's arguments, unparsed. */
219 const char *m_unparsed_args_text;
220
221 /* Information about each argument. This is an array of `stap_probe_arg',
222 with each entry representing one argument. This is only valid if
223 M_ARGS_PARSED is true. */
224 std::vector<struct stap_probe_arg> m_parsed_args;
225 };
226
227 /* When parsing the arguments, we have to establish different precedences
228 for the various kinds of asm operators. This enumeration represents those
229 precedences.
230
231 This logic behind this is available at
232 <http://sourceware.org/binutils/docs/as/Infix-Ops.html#Infix-Ops>, or using
233 the command "info '(as)Infix Ops'". */
234
235 enum stap_operand_prec
236 {
237 /* Lowest precedence, used for non-recognized operands or for the beginning
238 of the parsing process. */
239 STAP_OPERAND_PREC_NONE = 0,
240
241 /* Precedence of logical OR. */
242 STAP_OPERAND_PREC_LOGICAL_OR,
243
244 /* Precedence of logical AND. */
245 STAP_OPERAND_PREC_LOGICAL_AND,
246
247 /* Precedence of additive (plus, minus) and comparative (equal, less,
248 greater-than, etc) operands. */
249 STAP_OPERAND_PREC_ADD_CMP,
250
251 /* Precedence of bitwise operands (bitwise OR, XOR, bitwise AND,
252 logical NOT). */
253 STAP_OPERAND_PREC_BITWISE,
254
255 /* Precedence of multiplicative operands (multiplication, division,
256 remainder, left shift and right shift). */
257 STAP_OPERAND_PREC_MUL
258 };
259
260 static void stap_parse_argument_1 (struct stap_parse_info *p, int has_lhs,
261 enum stap_operand_prec prec);
262
263 static void stap_parse_argument_conditionally (struct stap_parse_info *p);
264
265 /* Returns 1 if *S is an operator, zero otherwise. */
266
267 static int stap_is_operator (const char *op);
268
269 static void
270 show_stapexpressiondebug (struct ui_file *file, int from_tty,
271 struct cmd_list_element *c, const char *value)
272 {
273 fprintf_filtered (file, _("SystemTap Probe expression debugging is %s.\n"),
274 value);
275 }
276
277 /* Returns the operator precedence level of OP, or STAP_OPERAND_PREC_NONE
278 if the operator code was not recognized. */
279
280 static enum stap_operand_prec
281 stap_get_operator_prec (enum exp_opcode op)
282 {
283 switch (op)
284 {
285 case BINOP_LOGICAL_OR:
286 return STAP_OPERAND_PREC_LOGICAL_OR;
287
288 case BINOP_LOGICAL_AND:
289 return STAP_OPERAND_PREC_LOGICAL_AND;
290
291 case BINOP_ADD:
292 case BINOP_SUB:
293 case BINOP_EQUAL:
294 case BINOP_NOTEQUAL:
295 case BINOP_LESS:
296 case BINOP_LEQ:
297 case BINOP_GTR:
298 case BINOP_GEQ:
299 return STAP_OPERAND_PREC_ADD_CMP;
300
301 case BINOP_BITWISE_IOR:
302 case BINOP_BITWISE_AND:
303 case BINOP_BITWISE_XOR:
304 case UNOP_LOGICAL_NOT:
305 return STAP_OPERAND_PREC_BITWISE;
306
307 case BINOP_MUL:
308 case BINOP_DIV:
309 case BINOP_REM:
310 case BINOP_LSH:
311 case BINOP_RSH:
312 return STAP_OPERAND_PREC_MUL;
313
314 default:
315 return STAP_OPERAND_PREC_NONE;
316 }
317 }
318
319 /* Given S, read the operator in it and fills the OP pointer with its code.
320 Return 1 on success, zero if the operator was not recognized. */
321
322 static enum exp_opcode
323 stap_get_opcode (const char **s)
324 {
325 const char c = **s;
326 enum exp_opcode op;
327
328 *s += 1;
329
330 switch (c)
331 {
332 case '*':
333 op = BINOP_MUL;
334 break;
335
336 case '/':
337 op = BINOP_DIV;
338 break;
339
340 case '%':
341 op = BINOP_REM;
342 break;
343
344 case '<':
345 op = BINOP_LESS;
346 if (**s == '<')
347 {
348 *s += 1;
349 op = BINOP_LSH;
350 }
351 else if (**s == '=')
352 {
353 *s += 1;
354 op = BINOP_LEQ;
355 }
356 else if (**s == '>')
357 {
358 *s += 1;
359 op = BINOP_NOTEQUAL;
360 }
361 break;
362
363 case '>':
364 op = BINOP_GTR;
365 if (**s == '>')
366 {
367 *s += 1;
368 op = BINOP_RSH;
369 }
370 else if (**s == '=')
371 {
372 *s += 1;
373 op = BINOP_GEQ;
374 }
375 break;
376
377 case '|':
378 op = BINOP_BITWISE_IOR;
379 if (**s == '|')
380 {
381 *s += 1;
382 op = BINOP_LOGICAL_OR;
383 }
384 break;
385
386 case '&':
387 op = BINOP_BITWISE_AND;
388 if (**s == '&')
389 {
390 *s += 1;
391 op = BINOP_LOGICAL_AND;
392 }
393 break;
394
395 case '^':
396 op = BINOP_BITWISE_XOR;
397 break;
398
399 case '!':
400 op = UNOP_LOGICAL_NOT;
401 break;
402
403 case '+':
404 op = BINOP_ADD;
405 break;
406
407 case '-':
408 op = BINOP_SUB;
409 break;
410
411 case '=':
412 gdb_assert (**s == '=');
413 op = BINOP_EQUAL;
414 break;
415
416 default:
417 error (_("Invalid opcode in expression `%s' for SystemTap"
418 "probe"), *s);
419 }
420
421 return op;
422 }
423
424 /* Given the bitness of the argument, represented by B, return the
425 corresponding `struct type *'. */
426
427 static struct type *
428 stap_get_expected_argument_type (struct gdbarch *gdbarch,
429 enum stap_arg_bitness b,
430 const char *probe_name)
431 {
432 switch (b)
433 {
434 case STAP_ARG_BITNESS_UNDEFINED:
435 if (gdbarch_addr_bit (gdbarch) == 32)
436 return builtin_type (gdbarch)->builtin_uint32;
437 else
438 return builtin_type (gdbarch)->builtin_uint64;
439
440 case STAP_ARG_BITNESS_8BIT_UNSIGNED:
441 return builtin_type (gdbarch)->builtin_uint8;
442
443 case STAP_ARG_BITNESS_8BIT_SIGNED:
444 return builtin_type (gdbarch)->builtin_int8;
445
446 case STAP_ARG_BITNESS_16BIT_UNSIGNED:
447 return builtin_type (gdbarch)->builtin_uint16;
448
449 case STAP_ARG_BITNESS_16BIT_SIGNED:
450 return builtin_type (gdbarch)->builtin_int16;
451
452 case STAP_ARG_BITNESS_32BIT_SIGNED:
453 return builtin_type (gdbarch)->builtin_int32;
454
455 case STAP_ARG_BITNESS_32BIT_UNSIGNED:
456 return builtin_type (gdbarch)->builtin_uint32;
457
458 case STAP_ARG_BITNESS_64BIT_SIGNED:
459 return builtin_type (gdbarch)->builtin_int64;
460
461 case STAP_ARG_BITNESS_64BIT_UNSIGNED:
462 return builtin_type (gdbarch)->builtin_uint64;
463
464 default:
465 error (_("Undefined bitness for probe '%s'."), probe_name);
466 break;
467 }
468 }
469
470 /* Helper function to check for a generic list of prefixes. GDBARCH
471 is the current gdbarch being used. S is the expression being
472 analyzed. If R is not NULL, it will be used to return the found
473 prefix. PREFIXES is the list of expected prefixes.
474
475 This function does a case-insensitive match.
476
477 Return 1 if any prefix has been found, zero otherwise. */
478
479 static int
480 stap_is_generic_prefix (struct gdbarch *gdbarch, const char *s,
481 const char **r, const char *const *prefixes)
482 {
483 const char *const *p;
484
485 if (prefixes == NULL)
486 {
487 if (r != NULL)
488 *r = "";
489
490 return 1;
491 }
492
493 for (p = prefixes; *p != NULL; ++p)
494 if (strncasecmp (s, *p, strlen (*p)) == 0)
495 {
496 if (r != NULL)
497 *r = *p;
498
499 return 1;
500 }
501
502 return 0;
503 }
504
505 /* Return 1 if S points to a register prefix, zero otherwise. For a
506 description of the arguments, look at stap_is_generic_prefix. */
507
508 static int
509 stap_is_register_prefix (struct gdbarch *gdbarch, const char *s,
510 const char **r)
511 {
512 const char *const *t = gdbarch_stap_register_prefixes (gdbarch);
513
514 return stap_is_generic_prefix (gdbarch, s, r, t);
515 }
516
517 /* Return 1 if S points to a register indirection prefix, zero
518 otherwise. For a description of the arguments, look at
519 stap_is_generic_prefix. */
520
521 static int
522 stap_is_register_indirection_prefix (struct gdbarch *gdbarch, const char *s,
523 const char **r)
524 {
525 const char *const *t = gdbarch_stap_register_indirection_prefixes (gdbarch);
526
527 return stap_is_generic_prefix (gdbarch, s, r, t);
528 }
529
530 /* Return 1 if S points to an integer prefix, zero otherwise. For a
531 description of the arguments, look at stap_is_generic_prefix.
532
533 This function takes care of analyzing whether we are dealing with
534 an expected integer prefix, or, if there is no integer prefix to be
535 expected, whether we are dealing with a digit. It does a
536 case-insensitive match. */
537
538 static int
539 stap_is_integer_prefix (struct gdbarch *gdbarch, const char *s,
540 const char **r)
541 {
542 const char *const *t = gdbarch_stap_integer_prefixes (gdbarch);
543 const char *const *p;
544
545 if (t == NULL)
546 {
547 /* A NULL value here means that integers do not have a prefix.
548 We just check for a digit then. */
549 if (r != NULL)
550 *r = "";
551
552 return isdigit (*s);
553 }
554
555 for (p = t; *p != NULL; ++p)
556 {
557 size_t len = strlen (*p);
558
559 if ((len == 0 && isdigit (*s))
560 || (len > 0 && strncasecmp (s, *p, len) == 0))
561 {
562 /* Integers may or may not have a prefix. The "len == 0"
563 check covers the case when integers do not have a prefix
564 (therefore, we just check if we have a digit). The call
565 to "strncasecmp" covers the case when they have a
566 prefix. */
567 if (r != NULL)
568 *r = *p;
569
570 return 1;
571 }
572 }
573
574 return 0;
575 }
576
577 /* Helper function to check for a generic list of suffixes. If we are
578 not expecting any suffixes, then it just returns 1. If we are
579 expecting at least one suffix, then it returns 1 if a suffix has
580 been found, zero otherwise. GDBARCH is the current gdbarch being
581 used. S is the expression being analyzed. If R is not NULL, it
582 will be used to return the found suffix. SUFFIXES is the list of
583 expected suffixes. This function does a case-insensitive
584 match. */
585
586 static int
587 stap_generic_check_suffix (struct gdbarch *gdbarch, const char *s,
588 const char **r, const char *const *suffixes)
589 {
590 const char *const *p;
591 int found = 0;
592
593 if (suffixes == NULL)
594 {
595 if (r != NULL)
596 *r = "";
597
598 return 1;
599 }
600
601 for (p = suffixes; *p != NULL; ++p)
602 if (strncasecmp (s, *p, strlen (*p)) == 0)
603 {
604 if (r != NULL)
605 *r = *p;
606
607 found = 1;
608 break;
609 }
610
611 return found;
612 }
613
614 /* Return 1 if S points to an integer suffix, zero otherwise. For a
615 description of the arguments, look at
616 stap_generic_check_suffix. */
617
618 static int
619 stap_check_integer_suffix (struct gdbarch *gdbarch, const char *s,
620 const char **r)
621 {
622 const char *const *p = gdbarch_stap_integer_suffixes (gdbarch);
623
624 return stap_generic_check_suffix (gdbarch, s, r, p);
625 }
626
627 /* Return 1 if S points to a register suffix, zero otherwise. For a
628 description of the arguments, look at
629 stap_generic_check_suffix. */
630
631 static int
632 stap_check_register_suffix (struct gdbarch *gdbarch, const char *s,
633 const char **r)
634 {
635 const char *const *p = gdbarch_stap_register_suffixes (gdbarch);
636
637 return stap_generic_check_suffix (gdbarch, s, r, p);
638 }
639
640 /* Return 1 if S points to a register indirection suffix, zero
641 otherwise. For a description of the arguments, look at
642 stap_generic_check_suffix. */
643
644 static int
645 stap_check_register_indirection_suffix (struct gdbarch *gdbarch, const char *s,
646 const char **r)
647 {
648 const char *const *p = gdbarch_stap_register_indirection_suffixes (gdbarch);
649
650 return stap_generic_check_suffix (gdbarch, s, r, p);
651 }
652
653 /* Function responsible for parsing a register operand according to
654 SystemTap parlance. Assuming:
655
656 RP = register prefix
657 RS = register suffix
658 RIP = register indirection prefix
659 RIS = register indirection suffix
660
661 Then a register operand can be:
662
663 [RIP] [RP] REGISTER [RS] [RIS]
664
665 This function takes care of a register's indirection, displacement and
666 direct access. It also takes into consideration the fact that some
667 registers are named differently inside and outside GDB, e.g., PPC's
668 general-purpose registers are represented by integers in the assembly
669 language (e.g., `15' is the 15th general-purpose register), but inside
670 GDB they have a prefix (the letter `r') appended. */
671
672 static void
673 stap_parse_register_operand (struct stap_parse_info *p)
674 {
675 /* Simple flag to indicate whether we have seen a minus signal before
676 certain number. */
677 int got_minus = 0;
678 /* Flags to indicate whether this register access is being displaced and/or
679 indirected. */
680 int disp_p = 0, indirect_p = 0;
681 struct gdbarch *gdbarch = p->gdbarch;
682 /* Needed to generate the register name as a part of an expression. */
683 struct stoken str;
684 /* Variables used to extract the register name from the probe's
685 argument. */
686 const char *start;
687 char *regname;
688 int len;
689 const char *gdb_reg_prefix = gdbarch_stap_gdb_register_prefix (gdbarch);
690 int gdb_reg_prefix_len = gdb_reg_prefix ? strlen (gdb_reg_prefix) : 0;
691 const char *gdb_reg_suffix = gdbarch_stap_gdb_register_suffix (gdbarch);
692 int gdb_reg_suffix_len = gdb_reg_suffix ? strlen (gdb_reg_suffix) : 0;
693 const char *reg_prefix;
694 const char *reg_ind_prefix;
695 const char *reg_suffix;
696 const char *reg_ind_suffix;
697
698 /* Checking for a displacement argument. */
699 if (*p->arg == '+')
700 {
701 /* If it's a plus sign, we don't need to do anything, just advance the
702 pointer. */
703 ++p->arg;
704 }
705
706 if (*p->arg == '-')
707 {
708 got_minus = 1;
709 ++p->arg;
710 }
711
712 if (isdigit (*p->arg))
713 {
714 /* The value of the displacement. */
715 long displacement;
716 char *endp;
717
718 disp_p = 1;
719 displacement = strtol (p->arg, &endp, 10);
720 p->arg = endp;
721
722 /* Generating the expression for the displacement. */
723 write_exp_elt_opcode (&p->pstate, OP_LONG);
724 write_exp_elt_type (&p->pstate, builtin_type (gdbarch)->builtin_long);
725 write_exp_elt_longcst (&p->pstate, displacement);
726 write_exp_elt_opcode (&p->pstate, OP_LONG);
727 if (got_minus)
728 write_exp_elt_opcode (&p->pstate, UNOP_NEG);
729 }
730
731 /* Getting rid of register indirection prefix. */
732 if (stap_is_register_indirection_prefix (gdbarch, p->arg, &reg_ind_prefix))
733 {
734 indirect_p = 1;
735 p->arg += strlen (reg_ind_prefix);
736 }
737
738 if (disp_p && !indirect_p)
739 error (_("Invalid register displacement syntax on expression `%s'."),
740 p->saved_arg);
741
742 /* Getting rid of register prefix. */
743 if (stap_is_register_prefix (gdbarch, p->arg, &reg_prefix))
744 p->arg += strlen (reg_prefix);
745
746 /* Now we should have only the register name. Let's extract it and get
747 the associated number. */
748 start = p->arg;
749
750 /* We assume the register name is composed by letters and numbers. */
751 while (isalnum (*p->arg))
752 ++p->arg;
753
754 len = p->arg - start;
755
756 regname = (char *) alloca (len + gdb_reg_prefix_len + gdb_reg_suffix_len + 1);
757 regname[0] = '\0';
758
759 /* We only add the GDB's register prefix/suffix if we are dealing with
760 a numeric register. */
761 if (gdb_reg_prefix && isdigit (*start))
762 {
763 strncpy (regname, gdb_reg_prefix, gdb_reg_prefix_len);
764 strncpy (regname + gdb_reg_prefix_len, start, len);
765
766 if (gdb_reg_suffix)
767 strncpy (regname + gdb_reg_prefix_len + len,
768 gdb_reg_suffix, gdb_reg_suffix_len);
769
770 len += gdb_reg_prefix_len + gdb_reg_suffix_len;
771 }
772 else
773 strncpy (regname, start, len);
774
775 regname[len] = '\0';
776
777 /* Is this a valid register name? */
778 if (user_reg_map_name_to_regnum (gdbarch, regname, len) == -1)
779 error (_("Invalid register name `%s' on expression `%s'."),
780 regname, p->saved_arg);
781
782 write_exp_elt_opcode (&p->pstate, OP_REGISTER);
783 str.ptr = regname;
784 str.length = len;
785 write_exp_string (&p->pstate, str);
786 write_exp_elt_opcode (&p->pstate, OP_REGISTER);
787
788 if (indirect_p)
789 {
790 if (disp_p)
791 write_exp_elt_opcode (&p->pstate, BINOP_ADD);
792
793 /* Casting to the expected type. */
794 write_exp_elt_opcode (&p->pstate, UNOP_CAST);
795 write_exp_elt_type (&p->pstate, lookup_pointer_type (p->arg_type));
796 write_exp_elt_opcode (&p->pstate, UNOP_CAST);
797
798 write_exp_elt_opcode (&p->pstate, UNOP_IND);
799 }
800
801 /* Getting rid of the register name suffix. */
802 if (stap_check_register_suffix (gdbarch, p->arg, &reg_suffix))
803 p->arg += strlen (reg_suffix);
804 else
805 error (_("Missing register name suffix on expression `%s'."),
806 p->saved_arg);
807
808 /* Getting rid of the register indirection suffix. */
809 if (indirect_p)
810 {
811 if (stap_check_register_indirection_suffix (gdbarch, p->arg,
812 &reg_ind_suffix))
813 p->arg += strlen (reg_ind_suffix);
814 else
815 error (_("Missing indirection suffix on expression `%s'."),
816 p->saved_arg);
817 }
818 }
819
820 /* This function is responsible for parsing a single operand.
821
822 A single operand can be:
823
824 - an unary operation (e.g., `-5', `~2', or even with subexpressions
825 like `-(2 + 1)')
826 - a register displacement, which will be treated as a register
827 operand (e.g., `-4(%eax)' on x86)
828 - a numeric constant, or
829 - a register operand (see function `stap_parse_register_operand')
830
831 The function also calls special-handling functions to deal with
832 unrecognized operands, allowing arch-specific parsers to be
833 created. */
834
835 static void
836 stap_parse_single_operand (struct stap_parse_info *p)
837 {
838 struct gdbarch *gdbarch = p->gdbarch;
839 const char *int_prefix = NULL;
840
841 /* We first try to parse this token as a "special token". */
842 if (gdbarch_stap_parse_special_token_p (gdbarch))
843 if (gdbarch_stap_parse_special_token (gdbarch, p) != 0)
844 {
845 /* If the return value of the above function is not zero,
846 it means it successfully parsed the special token.
847
848 If it is NULL, we try to parse it using our method. */
849 return;
850 }
851
852 if (*p->arg == '-' || *p->arg == '~' || *p->arg == '+')
853 {
854 char c = *p->arg;
855 /* We use this variable to do a lookahead. */
856 const char *tmp = p->arg;
857 int has_digit = 0;
858
859 /* Skipping signal. */
860 ++tmp;
861
862 /* This is an unary operation. Here is a list of allowed tokens
863 here:
864
865 - numeric literal;
866 - number (from register displacement)
867 - subexpression (beginning with `(')
868
869 We handle the register displacement here, and the other cases
870 recursively. */
871 if (p->inside_paren_p)
872 tmp = skip_spaces (tmp);
873
874 while (isdigit (*tmp))
875 {
876 /* We skip the digit here because we are only interested in
877 knowing what kind of unary operation this is. The digit
878 will be handled by one of the functions that will be
879 called below ('stap_parse_argument_conditionally' or
880 'stap_parse_register_operand'). */
881 ++tmp;
882 has_digit = 1;
883 }
884
885 if (has_digit && stap_is_register_indirection_prefix (gdbarch, tmp,
886 NULL))
887 {
888 /* If we are here, it means it is a displacement. The only
889 operations allowed here are `-' and `+'. */
890 if (c == '~')
891 error (_("Invalid operator `%c' for register displacement "
892 "on expression `%s'."), c, p->saved_arg);
893
894 stap_parse_register_operand (p);
895 }
896 else
897 {
898 /* This is not a displacement. We skip the operator, and
899 deal with it when the recursion returns. */
900 ++p->arg;
901 stap_parse_argument_conditionally (p);
902 if (c == '-')
903 write_exp_elt_opcode (&p->pstate, UNOP_NEG);
904 else if (c == '~')
905 write_exp_elt_opcode (&p->pstate, UNOP_COMPLEMENT);
906 }
907 }
908 else if (isdigit (*p->arg))
909 {
910 /* A temporary variable, needed for lookahead. */
911 const char *tmp = p->arg;
912 char *endp;
913 long number;
914
915 /* We can be dealing with a numeric constant, or with a register
916 displacement. */
917 number = strtol (tmp, &endp, 10);
918 tmp = endp;
919
920 if (p->inside_paren_p)
921 tmp = skip_spaces (tmp);
922
923 /* If "stap_is_integer_prefix" returns true, it means we can
924 accept integers without a prefix here. But we also need to
925 check whether the next token (i.e., "tmp") is not a register
926 indirection prefix. */
927 if (stap_is_integer_prefix (gdbarch, p->arg, NULL)
928 && !stap_is_register_indirection_prefix (gdbarch, tmp, NULL))
929 {
930 const char *int_suffix;
931
932 /* We are dealing with a numeric constant. */
933 write_exp_elt_opcode (&p->pstate, OP_LONG);
934 write_exp_elt_type (&p->pstate,
935 builtin_type (gdbarch)->builtin_long);
936 write_exp_elt_longcst (&p->pstate, number);
937 write_exp_elt_opcode (&p->pstate, OP_LONG);
938
939 p->arg = tmp;
940
941 if (stap_check_integer_suffix (gdbarch, p->arg, &int_suffix))
942 p->arg += strlen (int_suffix);
943 else
944 error (_("Invalid constant suffix on expression `%s'."),
945 p->saved_arg);
946 }
947 else if (stap_is_register_indirection_prefix (gdbarch, tmp, NULL))
948 stap_parse_register_operand (p);
949 else
950 error (_("Unknown numeric token on expression `%s'."),
951 p->saved_arg);
952 }
953 else if (stap_is_integer_prefix (gdbarch, p->arg, &int_prefix))
954 {
955 /* We are dealing with a numeric constant. */
956 long number;
957 char *endp;
958 const char *int_suffix;
959
960 p->arg += strlen (int_prefix);
961 number = strtol (p->arg, &endp, 10);
962 p->arg = endp;
963
964 write_exp_elt_opcode (&p->pstate, OP_LONG);
965 write_exp_elt_type (&p->pstate, builtin_type (gdbarch)->builtin_long);
966 write_exp_elt_longcst (&p->pstate, number);
967 write_exp_elt_opcode (&p->pstate, OP_LONG);
968
969 if (stap_check_integer_suffix (gdbarch, p->arg, &int_suffix))
970 p->arg += strlen (int_suffix);
971 else
972 error (_("Invalid constant suffix on expression `%s'."),
973 p->saved_arg);
974 }
975 else if (stap_is_register_prefix (gdbarch, p->arg, NULL)
976 || stap_is_register_indirection_prefix (gdbarch, p->arg, NULL))
977 stap_parse_register_operand (p);
978 else
979 error (_("Operator `%c' not recognized on expression `%s'."),
980 *p->arg, p->saved_arg);
981 }
982
983 /* This function parses an argument conditionally, based on single or
984 non-single operands. A non-single operand would be a parenthesized
985 expression (e.g., `(2 + 1)'), and a single operand is anything that
986 starts with `-', `~', `+' (i.e., unary operators), a digit, or
987 something recognized by `gdbarch_stap_is_single_operand'. */
988
989 static void
990 stap_parse_argument_conditionally (struct stap_parse_info *p)
991 {
992 gdb_assert (gdbarch_stap_is_single_operand_p (p->gdbarch));
993
994 if (*p->arg == '-' || *p->arg == '~' || *p->arg == '+' /* Unary. */
995 || isdigit (*p->arg)
996 || gdbarch_stap_is_single_operand (p->gdbarch, p->arg))
997 stap_parse_single_operand (p);
998 else if (*p->arg == '(')
999 {
1000 /* We are dealing with a parenthesized operand. It means we
1001 have to parse it as it was a separate expression, without
1002 left-side or precedence. */
1003 ++p->arg;
1004 p->arg = skip_spaces (p->arg);
1005 ++p->inside_paren_p;
1006
1007 stap_parse_argument_1 (p, 0, STAP_OPERAND_PREC_NONE);
1008
1009 --p->inside_paren_p;
1010 if (*p->arg != ')')
1011 error (_("Missign close-paren on expression `%s'."),
1012 p->saved_arg);
1013
1014 ++p->arg;
1015 if (p->inside_paren_p)
1016 p->arg = skip_spaces (p->arg);
1017 }
1018 else
1019 error (_("Cannot parse expression `%s'."), p->saved_arg);
1020 }
1021
1022 /* Helper function for `stap_parse_argument'. Please, see its comments to
1023 better understand what this function does. */
1024
1025 static void
1026 stap_parse_argument_1 (struct stap_parse_info *p, int has_lhs,
1027 enum stap_operand_prec prec)
1028 {
1029 /* This is an operator-precedence parser.
1030
1031 We work with left- and right-sides of expressions, and
1032 parse them depending on the precedence of the operators
1033 we find. */
1034
1035 gdb_assert (p->arg != NULL);
1036
1037 if (p->inside_paren_p)
1038 p->arg = skip_spaces (p->arg);
1039
1040 if (!has_lhs)
1041 {
1042 /* We were called without a left-side, either because this is the
1043 first call, or because we were called to parse a parenthesized
1044 expression. It doesn't really matter; we have to parse the
1045 left-side in order to continue the process. */
1046 stap_parse_argument_conditionally (p);
1047 }
1048
1049 /* Start to parse the right-side, and to "join" left and right sides
1050 depending on the operation specified.
1051
1052 This loop shall continue until we run out of characters in the input,
1053 or until we find a close-parenthesis, which means that we've reached
1054 the end of a sub-expression. */
1055 while (*p->arg != '\0' && *p->arg != ')' && !isspace (*p->arg))
1056 {
1057 const char *tmp_exp_buf;
1058 enum exp_opcode opcode;
1059 enum stap_operand_prec cur_prec;
1060
1061 if (!stap_is_operator (p->arg))
1062 error (_("Invalid operator `%c' on expression `%s'."), *p->arg,
1063 p->saved_arg);
1064
1065 /* We have to save the current value of the expression buffer because
1066 the `stap_get_opcode' modifies it in order to get the current
1067 operator. If this operator's precedence is lower than PREC, we
1068 should return and not advance the expression buffer pointer. */
1069 tmp_exp_buf = p->arg;
1070 opcode = stap_get_opcode (&tmp_exp_buf);
1071
1072 cur_prec = stap_get_operator_prec (opcode);
1073 if (cur_prec < prec)
1074 {
1075 /* If the precedence of the operator that we are seeing now is
1076 lower than the precedence of the first operator seen before
1077 this parsing process began, it means we should stop parsing
1078 and return. */
1079 break;
1080 }
1081
1082 p->arg = tmp_exp_buf;
1083 if (p->inside_paren_p)
1084 p->arg = skip_spaces (p->arg);
1085
1086 /* Parse the right-side of the expression. */
1087 stap_parse_argument_conditionally (p);
1088
1089 /* While we still have operators, try to parse another
1090 right-side, but using the current right-side as a left-side. */
1091 while (*p->arg != '\0' && stap_is_operator (p->arg))
1092 {
1093 enum exp_opcode lookahead_opcode;
1094 enum stap_operand_prec lookahead_prec;
1095
1096 /* Saving the current expression buffer position. The explanation
1097 is the same as above. */
1098 tmp_exp_buf = p->arg;
1099 lookahead_opcode = stap_get_opcode (&tmp_exp_buf);
1100 lookahead_prec = stap_get_operator_prec (lookahead_opcode);
1101
1102 if (lookahead_prec <= prec)
1103 {
1104 /* If we are dealing with an operator whose precedence is lower
1105 than the first one, just abandon the attempt. */
1106 break;
1107 }
1108
1109 /* Parse the right-side of the expression, but since we already
1110 have a left-side at this point, set `has_lhs' to 1. */
1111 stap_parse_argument_1 (p, 1, lookahead_prec);
1112 }
1113
1114 write_exp_elt_opcode (&p->pstate, opcode);
1115 }
1116 }
1117
1118 /* Parse a probe's argument.
1119
1120 Assuming that:
1121
1122 LP = literal integer prefix
1123 LS = literal integer suffix
1124
1125 RP = register prefix
1126 RS = register suffix
1127
1128 RIP = register indirection prefix
1129 RIS = register indirection suffix
1130
1131 This routine assumes that arguments' tokens are of the form:
1132
1133 - [LP] NUMBER [LS]
1134 - [RP] REGISTER [RS]
1135 - [RIP] [RP] REGISTER [RS] [RIS]
1136 - If we find a number without LP, we try to parse it as a literal integer
1137 constant (if LP == NULL), or as a register displacement.
1138 - We count parenthesis, and only skip whitespaces if we are inside them.
1139 - If we find an operator, we skip it.
1140
1141 This function can also call a special function that will try to match
1142 unknown tokens. It will return the expression_up generated from
1143 parsing the argument. */
1144
1145 static expression_up
1146 stap_parse_argument (const char **arg, struct type *atype,
1147 struct gdbarch *gdbarch)
1148 {
1149 /* We need to initialize the expression buffer, in order to begin
1150 our parsing efforts. We use language_c here because we may need
1151 to do pointer arithmetics. */
1152 struct stap_parse_info p (*arg, atype, 10, language_def (language_c),
1153 gdbarch);
1154
1155 stap_parse_argument_1 (&p, 0, STAP_OPERAND_PREC_NONE);
1156
1157 gdb_assert (p.inside_paren_p == 0);
1158
1159 /* Casting the final expression to the appropriate type. */
1160 write_exp_elt_opcode (&p.pstate, UNOP_CAST);
1161 write_exp_elt_type (&p.pstate, atype);
1162 write_exp_elt_opcode (&p.pstate, UNOP_CAST);
1163
1164 p.arg = skip_spaces (p.arg);
1165 *arg = p.arg;
1166
1167 return p.pstate.release ();
1168 }
1169
1170 /* Implementation of 'parse_arguments' method. */
1171
1172 void
1173 stap_probe::parse_arguments (struct gdbarch *gdbarch)
1174 {
1175 const char *cur;
1176
1177 gdb_assert (!m_have_parsed_args);
1178 cur = m_unparsed_args_text;
1179 m_have_parsed_args = true;
1180
1181 if (cur == NULL || *cur == '\0' || *cur == ':')
1182 return;
1183
1184 while (*cur != '\0')
1185 {
1186 enum stap_arg_bitness bitness;
1187 bool got_minus = false;
1188
1189 /* We expect to find something like:
1190
1191 N@OP
1192
1193 Where `N' can be [+,-][1,2,4,8]. This is not mandatory, so
1194 we check it here. If we don't find it, go to the next
1195 state. */
1196 if ((cur[0] == '-' && isdigit (cur[1]) && cur[2] == '@')
1197 || (isdigit (cur[0]) && cur[1] == '@'))
1198 {
1199 if (*cur == '-')
1200 {
1201 /* Discard the `-'. */
1202 ++cur;
1203 got_minus = true;
1204 }
1205
1206 /* Defining the bitness. */
1207 switch (*cur)
1208 {
1209 case '1':
1210 bitness = (got_minus ? STAP_ARG_BITNESS_8BIT_SIGNED
1211 : STAP_ARG_BITNESS_8BIT_UNSIGNED);
1212 break;
1213
1214 case '2':
1215 bitness = (got_minus ? STAP_ARG_BITNESS_16BIT_SIGNED
1216 : STAP_ARG_BITNESS_16BIT_UNSIGNED);
1217 break;
1218
1219 case '4':
1220 bitness = (got_minus ? STAP_ARG_BITNESS_32BIT_SIGNED
1221 : STAP_ARG_BITNESS_32BIT_UNSIGNED);
1222 break;
1223
1224 case '8':
1225 bitness = (got_minus ? STAP_ARG_BITNESS_64BIT_SIGNED
1226 : STAP_ARG_BITNESS_64BIT_UNSIGNED);
1227 break;
1228
1229 default:
1230 {
1231 /* We have an error, because we don't expect anything
1232 except 1, 2, 4 and 8. */
1233 warning (_("unrecognized bitness %s%c' for probe `%s'"),
1234 got_minus ? "`-" : "`", *cur,
1235 this->get_name ().c_str ());
1236 return;
1237 }
1238 }
1239 /* Discard the number and the `@' sign. */
1240 cur += 2;
1241 }
1242 else
1243 bitness = STAP_ARG_BITNESS_UNDEFINED;
1244
1245 struct type *atype
1246 = stap_get_expected_argument_type (gdbarch, bitness,
1247 this->get_name ().c_str ());
1248
1249 expression_up expr = stap_parse_argument (&cur, atype, gdbarch);
1250
1251 if (stap_expression_debug)
1252 dump_raw_expression (expr.get (), gdb_stdlog,
1253 "before conversion to prefix form");
1254
1255 prefixify_expression (expr.get ());
1256
1257 if (stap_expression_debug)
1258 dump_prefix_expression (expr.get (), gdb_stdlog);
1259
1260 m_parsed_args.emplace_back (bitness, atype, std::move (expr));
1261
1262 /* Start it over again. */
1263 cur = skip_spaces (cur);
1264 }
1265 }
1266
1267 /* Helper function to relocate an address. */
1268
1269 static CORE_ADDR
1270 relocate_address (CORE_ADDR address, struct objfile *objfile)
1271 {
1272 return address + ANOFFSET (objfile->section_offsets,
1273 SECT_OFF_DATA (objfile));
1274 }
1275
1276 /* Implementation of the get_relocated_address method. */
1277
1278 CORE_ADDR
1279 stap_probe::get_relocated_address (struct objfile *objfile)
1280 {
1281 return relocate_address (this->get_address (), objfile);
1282 }
1283
1284 /* Given PROBE, returns the number of arguments present in that probe's
1285 argument string. */
1286
1287 unsigned
1288 stap_probe::get_argument_count (struct frame_info *frame)
1289 {
1290 struct gdbarch *gdbarch = get_frame_arch (frame);
1291
1292 if (!m_have_parsed_args)
1293 {
1294 if (this->can_evaluate_arguments ())
1295 this->parse_arguments (gdbarch);
1296 else
1297 {
1298 static int have_warned_stap_incomplete = 0;
1299
1300 if (!have_warned_stap_incomplete)
1301 {
1302 warning (_(
1303 "The SystemTap SDT probe support is not fully implemented on this target;\n"
1304 "you will not be able to inspect the arguments of the probes.\n"
1305 "Please report a bug against GDB requesting a port to this target."));
1306 have_warned_stap_incomplete = 1;
1307 }
1308
1309 /* Marking the arguments as "already parsed". */
1310 m_have_parsed_args = true;
1311 }
1312 }
1313
1314 gdb_assert (m_have_parsed_args);
1315 return m_parsed_args.size ();
1316 }
1317
1318 /* Return 1 if OP is a valid operator inside a probe argument, or zero
1319 otherwise. */
1320
1321 static int
1322 stap_is_operator (const char *op)
1323 {
1324 int ret = 1;
1325
1326 switch (*op)
1327 {
1328 case '*':
1329 case '/':
1330 case '%':
1331 case '^':
1332 case '!':
1333 case '+':
1334 case '-':
1335 case '<':
1336 case '>':
1337 case '|':
1338 case '&':
1339 break;
1340
1341 case '=':
1342 if (op[1] != '=')
1343 ret = 0;
1344 break;
1345
1346 default:
1347 /* We didn't find any operator. */
1348 ret = 0;
1349 }
1350
1351 return ret;
1352 }
1353
1354 /* Implement the `can_evaluate_arguments' method. */
1355
1356 bool
1357 stap_probe::can_evaluate_arguments () const
1358 {
1359 struct gdbarch *gdbarch = this->get_gdbarch ();
1360
1361 /* For SystemTap probes, we have to guarantee that the method
1362 stap_is_single_operand is defined on gdbarch. If it is not, then it
1363 means that argument evaluation is not implemented on this target. */
1364 return gdbarch_stap_is_single_operand_p (gdbarch);
1365 }
1366
1367 /* Evaluate the probe's argument N (indexed from 0), returning a value
1368 corresponding to it. Assertion is thrown if N does not exist. */
1369
1370 struct value *
1371 stap_probe::evaluate_argument (unsigned n, struct frame_info *frame)
1372 {
1373 struct stap_probe_arg *arg;
1374 int pos = 0;
1375 struct gdbarch *gdbarch = get_frame_arch (frame);
1376
1377 arg = this->get_arg_by_number (n, gdbarch);
1378 return evaluate_subexp_standard (arg->atype, arg->aexpr.get (), &pos,
1379 EVAL_NORMAL);
1380 }
1381
1382 /* Compile the probe's argument N (indexed from 0) to agent expression.
1383 Assertion is thrown if N does not exist. */
1384
1385 void
1386 stap_probe::compile_to_ax (struct agent_expr *expr, struct axs_value *value,
1387 unsigned n)
1388 {
1389 struct stap_probe_arg *arg;
1390 union exp_element *pc;
1391
1392 arg = this->get_arg_by_number (n, expr->gdbarch);
1393
1394 pc = arg->aexpr->elts;
1395 gen_expr (arg->aexpr.get (), &pc, expr, value);
1396
1397 require_rvalue (expr, value);
1398 value->type = arg->atype;
1399 }
1400
1401
1402 /* Set or clear a SystemTap semaphore. ADDRESS is the semaphore's
1403 address. SET is zero if the semaphore should be cleared, or one if
1404 it should be set. This is a helper function for
1405 'stap_probe::set_semaphore' and 'stap_probe::clear_semaphore'. */
1406
1407 static void
1408 stap_modify_semaphore (CORE_ADDR address, int set, struct gdbarch *gdbarch)
1409 {
1410 gdb_byte bytes[sizeof (LONGEST)];
1411 /* The ABI specifies "unsigned short". */
1412 struct type *type = builtin_type (gdbarch)->builtin_unsigned_short;
1413 ULONGEST value;
1414
1415 if (address == 0)
1416 return;
1417
1418 /* Swallow errors. */
1419 if (target_read_memory (address, bytes, TYPE_LENGTH (type)) != 0)
1420 {
1421 warning (_("Could not read the value of a SystemTap semaphore."));
1422 return;
1423 }
1424
1425 value = extract_unsigned_integer (bytes, TYPE_LENGTH (type),
1426 gdbarch_byte_order (gdbarch));
1427 /* Note that we explicitly don't worry about overflow or
1428 underflow. */
1429 if (set)
1430 ++value;
1431 else
1432 --value;
1433
1434 store_unsigned_integer (bytes, TYPE_LENGTH (type),
1435 gdbarch_byte_order (gdbarch), value);
1436
1437 if (target_write_memory (address, bytes, TYPE_LENGTH (type)) != 0)
1438 warning (_("Could not write the value of a SystemTap semaphore."));
1439 }
1440
1441 /* Implementation of the 'set_semaphore' method.
1442
1443 SystemTap semaphores act as reference counters, so calls to this
1444 function must be paired with calls to 'clear_semaphore'.
1445
1446 This function and 'clear_semaphore' race with another tool
1447 changing the probes, but that is too rare to care. */
1448
1449 void
1450 stap_probe::set_semaphore (struct objfile *objfile, struct gdbarch *gdbarch)
1451 {
1452 stap_modify_semaphore (relocate_address (m_sem_addr, objfile), 1, gdbarch);
1453 }
1454
1455 /* Implementation of the 'clear_semaphore' method. */
1456
1457 void
1458 stap_probe::clear_semaphore (struct objfile *objfile, struct gdbarch *gdbarch)
1459 {
1460 stap_modify_semaphore (relocate_address (m_sem_addr, objfile), 0, gdbarch);
1461 }
1462
1463 /* Implementation of the 'get_static_ops' method. */
1464
1465 const static_probe_ops *
1466 stap_probe::get_static_ops () const
1467 {
1468 return &stap_static_probe_ops;
1469 }
1470
1471 /* Implementation of the 'gen_info_probes_table_values' method. */
1472
1473 std::vector<const char *>
1474 stap_probe::gen_info_probes_table_values () const
1475 {
1476 const char *val = NULL;
1477
1478 if (m_sem_addr != 0)
1479 val = print_core_address (this->get_gdbarch (), m_sem_addr);
1480
1481 return std::vector<const char *> { val };
1482 }
1483
1484 /* Helper function that parses the information contained in a
1485 SystemTap's probe. Basically, the information consists in:
1486
1487 - Probe's PC address;
1488 - Link-time section address of `.stapsdt.base' section;
1489 - Link-time address of the semaphore variable, or ZERO if the
1490 probe doesn't have an associated semaphore;
1491 - Probe's provider name;
1492 - Probe's name;
1493 - Probe's argument format
1494
1495 This function returns 1 if the handling was successful, and zero
1496 otherwise. */
1497
1498 static void
1499 handle_stap_probe (struct objfile *objfile, struct sdt_note *el,
1500 std::vector<probe *> *probesp, CORE_ADDR base)
1501 {
1502 bfd *abfd = objfile->obfd;
1503 int size = bfd_get_arch_size (abfd) / 8;
1504 struct gdbarch *gdbarch = get_objfile_arch (objfile);
1505 struct type *ptr_type = builtin_type (gdbarch)->builtin_data_ptr;
1506
1507 /* Provider and the name of the probe. */
1508 const char *provider = (const char *) &el->data[3 * size];
1509 const char *name = ((const char *)
1510 memchr (provider, '\0',
1511 (char *) el->data + el->size - provider));
1512 /* Making sure there is a name. */
1513 if (name == NULL)
1514 {
1515 complaint (&symfile_complaints, _("corrupt probe name when "
1516 "reading `%s'"),
1517 objfile_name (objfile));
1518
1519 /* There is no way to use a probe without a name or a provider, so
1520 returning zero here makes sense. */
1521 return;
1522 }
1523 else
1524 ++name;
1525
1526 /* Retrieving the probe's address. */
1527 CORE_ADDR address = extract_typed_address (&el->data[0], ptr_type);
1528
1529 /* Link-time sh_addr of `.stapsdt.base' section. */
1530 CORE_ADDR base_ref = extract_typed_address (&el->data[size], ptr_type);
1531
1532 /* Semaphore address. */
1533 CORE_ADDR sem_addr = extract_typed_address (&el->data[2 * size], ptr_type);
1534
1535 address += base - base_ref;
1536 if (sem_addr != 0)
1537 sem_addr += base - base_ref;
1538
1539 /* Arguments. We can only extract the argument format if there is a valid
1540 name for this probe. */
1541 const char *probe_args = ((const char*)
1542 memchr (name, '\0',
1543 (char *) el->data + el->size - name));
1544
1545 if (probe_args != NULL)
1546 ++probe_args;
1547
1548 if (probe_args == NULL
1549 || (memchr (probe_args, '\0', (char *) el->data + el->size - name)
1550 != el->data + el->size - 1))
1551 {
1552 complaint (&symfile_complaints, _("corrupt probe argument when "
1553 "reading `%s'"),
1554 objfile_name (objfile));
1555 /* If the argument string is NULL, it means some problem happened with
1556 it. So we return 0. */
1557 return;
1558 }
1559
1560 stap_probe *ret = new stap_probe (std::string (name), std::string (provider),
1561 address, gdbarch, sem_addr, probe_args);
1562
1563 /* Successfully created probe. */
1564 probesp->push_back (ret);
1565 }
1566
1567 /* Helper function which tries to find the base address of the SystemTap
1568 base section named STAP_BASE_SECTION_NAME. */
1569
1570 static void
1571 get_stap_base_address_1 (bfd *abfd, asection *sect, void *obj)
1572 {
1573 asection **ret = (asection **) obj;
1574
1575 if ((sect->flags & (SEC_DATA | SEC_ALLOC | SEC_HAS_CONTENTS))
1576 && sect->name && !strcmp (sect->name, STAP_BASE_SECTION_NAME))
1577 *ret = sect;
1578 }
1579
1580 /* Helper function which iterates over every section in the BFD file,
1581 trying to find the base address of the SystemTap base section.
1582 Returns 1 if found (setting BASE to the proper value), zero otherwise. */
1583
1584 static int
1585 get_stap_base_address (bfd *obfd, bfd_vma *base)
1586 {
1587 asection *ret = NULL;
1588
1589 bfd_map_over_sections (obfd, get_stap_base_address_1, (void *) &ret);
1590
1591 if (ret == NULL)
1592 {
1593 complaint (&symfile_complaints, _("could not obtain base address for "
1594 "SystemTap section on objfile `%s'."),
1595 obfd->filename);
1596 return 0;
1597 }
1598
1599 if (base != NULL)
1600 *base = ret->vma;
1601
1602 return 1;
1603 }
1604
1605 /* Implementation of the 'is_linespec' method. */
1606
1607 bool
1608 stap_static_probe_ops::is_linespec (const char **linespecp) const
1609 {
1610 static const char *const keywords[] = { "-pstap", "-probe-stap", NULL };
1611
1612 return probe_is_linespec_by_keyword (linespecp, keywords);
1613 }
1614
1615 /* Implementation of the 'get_probes' method. */
1616
1617 void
1618 stap_static_probe_ops::get_probes (std::vector<probe *> *probesp,
1619 struct objfile *objfile) const
1620 {
1621 /* If we are here, then this is the first time we are parsing the
1622 SystemTap probe's information. We basically have to count how many
1623 probes the objfile has, and then fill in the necessary information
1624 for each one. */
1625 bfd *obfd = objfile->obfd;
1626 bfd_vma base;
1627 struct sdt_note *iter;
1628 unsigned save_probesp_len = probesp->size ();
1629
1630 if (objfile->separate_debug_objfile_backlink != NULL)
1631 {
1632 /* This is a .debug file, not the objfile itself. */
1633 return;
1634 }
1635
1636 if (elf_tdata (obfd)->sdt_note_head == NULL)
1637 {
1638 /* There isn't any probe here. */
1639 return;
1640 }
1641
1642 if (!get_stap_base_address (obfd, &base))
1643 {
1644 /* There was an error finding the base address for the section.
1645 Just return NULL. */
1646 return;
1647 }
1648
1649 /* Parsing each probe's information. */
1650 for (iter = elf_tdata (obfd)->sdt_note_head;
1651 iter != NULL;
1652 iter = iter->next)
1653 {
1654 /* We first have to handle all the information about the
1655 probe which is present in the section. */
1656 handle_stap_probe (objfile, iter, probesp, base);
1657 }
1658
1659 if (save_probesp_len == probesp->size ())
1660 {
1661 /* If we are here, it means we have failed to parse every known
1662 probe. */
1663 complaint (&symfile_complaints, _("could not parse SystemTap probe(s) "
1664 "from inferior"));
1665 return;
1666 }
1667 }
1668
1669 /* Implementation of the type_name method. */
1670
1671 const char *
1672 stap_static_probe_ops::type_name () const
1673 {
1674 return "stap";
1675 }
1676
1677 /* Implementation of the 'gen_info_probes_table_header' method. */
1678
1679 std::vector<struct info_probe_column>
1680 stap_static_probe_ops::gen_info_probes_table_header () const
1681 {
1682 struct info_probe_column stap_probe_column;
1683
1684 stap_probe_column.field_name = "semaphore";
1685 stap_probe_column.print_name = _("Semaphore");
1686
1687 return std::vector<struct info_probe_column> { stap_probe_column };
1688 }
1689
1690 /* Implementation of the `info probes stap' command. */
1691
1692 static void
1693 info_probes_stap_command (const char *arg, int from_tty)
1694 {
1695 info_probes_for_spops (arg, from_tty, &stap_static_probe_ops);
1696 }
1697
1698 void
1699 _initialize_stap_probe (void)
1700 {
1701 all_static_probe_ops.push_back (&stap_static_probe_ops);
1702
1703 add_setshow_zuinteger_cmd ("stap-expression", class_maintenance,
1704 &stap_expression_debug,
1705 _("Set SystemTap expression debugging."),
1706 _("Show SystemTap expression debugging."),
1707 _("When non-zero, the internal representation "
1708 "of SystemTap expressions will be printed."),
1709 NULL,
1710 show_stapexpressiondebug,
1711 &setdebuglist, &showdebuglist);
1712
1713 add_cmd ("stap", class_info, info_probes_stap_command,
1714 _("\
1715 Show information about SystemTap static probes.\n\
1716 Usage: info probes stap [PROVIDER [NAME [OBJECT]]]\n\
1717 Each argument is a regular expression, used to select probes.\n\
1718 PROVIDER matches probe provider names.\n\
1719 NAME matches the probe names.\n\
1720 OBJECT matches the executable or shared library name."),
1721 info_probes_cmdlist_get ());
1722
1723 }
gdbarch
Definition: gdbarch.c:127
string
const char * string
Definition: signals.c:50
stap_is_integer_prefix
static int stap_is_integer_prefix(struct gdbarch *gdbarch, const char *s, const char **r)
Definition: stap-probe.c:539
probe
Definition: probe.h:112
stap_modify_semaphore
static void stap_modify_semaphore(CORE_ADDR address, int set, struct gdbarch *gdbarch)
Definition: stap-probe.c:1408
stap_probe::m_have_parsed_args
bool m_have_parsed_args
Definition: stap-probe.c:216
axs_value
Definition: ax-gdb.h:77
stap_probe_arg::atype
struct type * atype
Definition: stap-probe.c:94
extract_typed_address
CORE_ADDR extract_typed_address(const gdb_byte *buf, struct type *type)
Definition: findvar.c:154
stap_probe::m_sem_addr
CORE_ADDR m_sem_addr
Definition: stap-probe.c:213
STAP_ARG_BITNESS_32BIT_UNSIGNED
Definition: stap-probe.c:74
objfile::obfd
bfd * obfd
Definition: objfiles.h:342
stap_parse_argument
static expression_up stap_parse_argument(const char **arg, struct type *atype, struct gdbarch *gdbarch)
Definition: stap-probe.c:1146
stap_is_register_prefix
static int stap_is_register_prefix(struct gdbarch *gdbarch, const char *s, const char **r)
Definition: stap-probe.c:509
stap_get_opcode
static enum exp_opcode stap_get_opcode(const char **s)
Definition: stap-probe.c:323
stap_parse_info::gdbarch
struct gdbarch * gdbarch
Definition: stap-probe.h:63
stap_probe_arg::aexpr
expression_up aexpr
Definition: stap-probe.c:97
stap_check_register_suffix
static int stap_check_register_suffix(struct gdbarch *gdbarch, const char *s, const char **r)
Definition: stap-probe.c:632
stap_static_probe_ops::is_linespec
bool is_linespec(const char **linespecp) const override
Definition: stap-probe.c:1608
stap_probe::get_argument_count
unsigned get_argument_count(struct frame_info *frame) override
Definition: stap-probe.c:1288
stap_parse_info::arg_type
struct type * arg_type
Definition: stap-probe.h:60
CORE_ADDR
bfd_vma CORE_ADDR
Definition: common-types.h:41
value::type
struct type * type
Definition: value.c:266
target_write_memory
int target_write_memory(CORE_ADDR memaddr, const gdb_byte *myaddr, ssize_t len)
Definition: target.c:1451
command.h
expression_up
gdb::unique_xmalloc_ptr< expression > expression_up
Definition: expression.h:87
stap_static_probe_ops::gen_info_probes_table_header
std::vector< struct info_probe_column > gen_info_probes_table_header() const override
Definition: stap-probe.c:1680
stap-probe.h
info_probes_stap_command
static void info_probes_stap_command(const char *arg, int from_tty)
Definition: stap-probe.c:1693
stap_probe::get_relocated_address
CORE_ADDR get_relocated_address(struct objfile *objfile) override
Definition: stap-probe.c:1279
stoken::ptr
const char * ptr
Definition: parser-defs.h:91
objfile::separate_debug_objfile_backlink
struct objfile * separate_debug_objfile_backlink
Definition: objfiles.h:441
STAP_OPERAND_PREC_LOGICAL_AND
Definition: stap-probe.c:245
EVAL_NORMAL
Definition: expression.h:125
get_stap_base_address
static int get_stap_base_address(bfd *obfd, bfd_vma *base)
Definition: stap-probe.c:1585
cmd_list_element
Definition: cli-decode.h:46
warning
void warning(const char *fmt,...)
Definition: errors.c:26
stap_is_generic_prefix
static int stap_is_generic_prefix(struct gdbarch *gdbarch, const char *s, const char **r, const char *const *prefixes)
Definition: stap-probe.c:480
STAP_ARG_BITNESS_32BIT_SIGNED
Definition: stap-probe.c:75
stap_parse_info
Definition: stap-probe.h:29
builtin_type
const struct builtin_type * builtin_type(struct gdbarch *gdbarch)
Definition: gdbtypes.c:5217
internal_error
void internal_error(const char *file, int line, const char *fmt,...)
Definition: errors.c:50
ax-gdb.h
language_def
const struct language_defn * language_def(enum language lang)
Definition: language.c:494
stap_parse_info::arg
const char * arg
Definition: stap-probe.h:46
stap_check_register_indirection_suffix
static int stap_check_register_indirection_suffix(struct gdbarch *gdbarch, const char *s, const char **r)
Definition: stap-probe.c:645
builtin_type::builtin_uint8
struct type * builtin_uint8
Definition: gdbtypes.h:1535
info_probes_cmdlist_get
struct cmd_list_element ** info_probes_cmdlist_get(void)
Definition: probe.c:782
builtin_type::builtin_uint16
struct type * builtin_uint16
Definition: gdbtypes.h:1537
STAP_OPERAND_PREC_LOGICAL_OR
Definition: stap-probe.c:242
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
stap_probe::get_static_ops
const static_probe_ops * get_static_ops() const override
Definition: stap-probe.c:1466
stap_static_probe_ops::type_name
const char * type_name() const override
Definition: stap-probe.c:1672
agent_expr::gdbarch
struct gdbarch * gdbarch
Definition: ax.h:100
info_probe_column
Definition: probe.h:29
skip_spaces
char * skip_spaces(char *chp)
Definition: common-utils.c:337
info_probes_for_spops
void info_probes_for_spops(const char *arg, int from_tty, const static_probe_ops *spops)
Definition: probe.c:489
_
#define _(String)
Definition: gdb_locale.h:35
stap_probe::parse_arguments
void parse_arguments(struct gdbarch *gdbarch)
Definition: stap-probe.c:1173
ui_file
Definition: ui-file.h:26
gdbarch_stap_is_single_operand_p
int gdbarch_stap_is_single_operand_p(struct gdbarch *gdbarch)
Definition: gdbarch.c:4458
stap_probe::gen_info_probes_table_values
std::vector< const char * > gen_info_probes_table_values() const override
Definition: stap-probe.c:1474
defs.h
builtin_type
Definition: gdbtypes.h:1495
show_stapexpressiondebug
static void show_stapexpressiondebug(struct ui_file *file, int from_tty, struct cmd_list_element *c, const char *value)
Definition: stap-probe.c:270
ax.h
class_info
Definition: command.h:42
builtin_type::builtin_int32
struct type * builtin_int32
Definition: gdbtypes.h:1538
objfiles.h
arch-utils.h
stap_parse_argument_conditionally
static void stap_parse_argument_conditionally(struct stap_parse_info *p)
Definition: stap-probe.c:990
stap_static_probe_ops::get_probes
void get_probes(std::vector< probe *> *probesp, struct objfile *objfile) const override
Definition: stap-probe.c:1618
add_setshow_zuinteger_cmd
void add_setshow_zuinteger_cmd(const char *name, enum command_class theclass, unsigned int *var, const char *set_doc, const char *show_doc, const char *help_doc, cmd_const_sfunc_ftype *set_func, show_value_ftype *show_func, struct cmd_list_element **set_list, struct cmd_list_element **show_list)
Definition: cli-decode.c:792
stap_arg_bitness
stap_arg_bitness
Definition: stap-probe.c:67
parser-defs.h
stap_parse_info::pstate
struct parser_state pstate
Definition: stap-probe.h:49
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
gdbarch_stap_register_prefixes
const char *const * gdbarch_stap_register_prefixes(struct gdbarch *gdbarch)
Definition: gdbarch.c:4356
write_exp_elt_longcst
void write_exp_elt_longcst(struct parser_state *ps, LONGEST expelt)
Definition: parse.c:255
dump_raw_expression
void dump_raw_expression(struct expression *exp, struct ui_file *stream, const char *note)
Definition: expprint.c:718
gdbarch_stap_gdb_register_prefix
const char * gdbarch_stap_gdb_register_prefix(struct gdbarch *gdbarch)
Definition: gdbarch.c:4424
STAP_OPERAND_PREC_ADD_CMP
Definition: stap-probe.c:249
STAP_ARG_BITNESS_16BIT_UNSIGNED
Definition: stap-probe.c:72
dump_prefix_expression
void dump_prefix_expression(struct expression *exp, struct ui_file *stream)
Definition: expprint.c:1139
stap_probe_arg::bitness
enum stap_arg_bitness bitness
Definition: stap-probe.c:91
prefixify_expression
int prefixify_expression(struct expression *expr)
Definition: parse.c:789
fprintf_filtered
void fprintf_filtered(struct ui_file *stream, const char *format,...)
Definition: utils.c:2008
extract_unsigned_integer
static ULONGEST extract_unsigned_integer(const gdb_byte *addr, int len, enum bfd_endian byte_order)
Definition: defs.h:577
stap_parse_single_operand
static void stap_parse_single_operand(struct stap_parse_info *p)
Definition: stap-probe.c:836
gdbarch_stap_parse_special_token
int gdbarch_stap_parse_special_token(struct gdbarch *gdbarch, struct stap_parse_info *p)
Definition: gdbarch.c:4489
probe::get_name
const std::string & get_name() const
Definition: probe.h:197
gdbarch_stap_integer_suffixes
const char *const * gdbarch_stap_integer_suffixes(struct gdbarch *gdbarch)
Definition: gdbarch.c:4339
cli-utils.h
builtin_type::builtin_int16
struct type * builtin_int16
Definition: gdbtypes.h:1536
stap_probe::set_semaphore
void set_semaphore(struct objfile *objfile, struct gdbarch *gdbarch) override
Definition: stap-probe.c:1450
gdbarch_stap_register_suffixes
const char *const * gdbarch_stap_register_suffixes(struct gdbarch *gdbarch)
Definition: gdbarch.c:4373
SECT_OFF_DATA
#define SECT_OFF_DATA(objfile)
Definition: objfiles.h:674
STAP_OPERAND_PREC_NONE
Definition: stap-probe.c:239
gdbarch_byte_order
enum bfd_endian gdbarch_byte_order(struct gdbarch *gdbarch)
Definition: gdbarch.c:1509
STAP_OPERAND_PREC_BITWISE
Definition: stap-probe.c:253
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
stap_probe_arg::stap_probe_arg
stap_probe_arg(enum stap_arg_bitness bitness_, struct type *atype_, expression_up &&aexpr_)
Definition: stap-probe.c:85
STAP_ARG_BITNESS_8BIT_SIGNED
Definition: stap-probe.c:71
type
Definition: gdbtypes.h:749
language.h
stap_probe::clear_semaphore
void clear_semaphore(struct objfile *objfile, struct gdbarch *gdbarch) override
Definition: stap-probe.c:1458
stap_probe::m_unparsed_args_text
const char * m_unparsed_args_text
Definition: stap-probe.c:219
builtin_type::builtin_uint32
struct type * builtin_uint32
Definition: gdbtypes.h:1539
info_probe_column::field_name
const char * field_name
Definition: probe.h:33
STAP_OPERAND_PREC_MUL
Definition: stap-probe.c:257
stap_parse_info::saved_arg
const char * saved_arg
Definition: stap-probe.h:54
complaint
#define complaint(COMPLAINTS, FMT,...)
Definition: complaints.h:40
stap_parse_info::inside_paren_p
int inside_paren_p
Definition: stap-probe.h:67
info_probe_column::print_name
const char * print_name
Definition: probe.h:37
linespec.h
gdbarch_stap_is_single_operand
int gdbarch_stap_is_single_operand(struct gdbarch *gdbarch, const char *s)
Definition: gdbarch.c:4465
STAP_ARG_BITNESS_8BIT_UNSIGNED
Definition: stap-probe.c:70
gdbarch_addr_bit
int gdbarch_addr_bit(struct gdbarch *gdbarch)
Definition: gdbarch.c:1848
static_probe_ops
Definition: probe.h:52
relocate_address
static CORE_ADDR relocate_address(CORE_ADDR address, struct objfile *objfile)
Definition: stap-probe.c:1270
setdebuglist
struct cmd_list_element * setdebuglist
Definition: cli-cmds.c:153
stap_probe::m_parsed_args
std::vector< struct stap_probe_arg > m_parsed_args
Definition: stap-probe.c:224
user_reg_map_name_to_regnum
int user_reg_map_name_to_regnum(struct gdbarch *gdbarch, const char *name, int len)
Definition: user-regs.c:130
objfile_name
const char * objfile_name(const struct objfile *objfile)
Definition: objfiles.c:1557
get_stap_base_address_1
static void get_stap_base_address_1(bfd *abfd, asection *sect, void *obj)
Definition: stap-probe.c:1571
complaints.h
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
user-regs.h
gdb_assert
#define gdb_assert(expr)
Definition: gdb_assert.h:32
value
Definition: value.c:169
parser_state::release
expression_up release()
Definition: parse.c:169
builtin_type::builtin_unsigned_short
struct type * builtin_unsigned_short
Definition: gdbtypes.h:1507
handle_stap_probe
static void handle_stap_probe(struct objfile *objfile, struct sdt_note *el, std::vector< probe *> *probesp, CORE_ADDR base)
Definition: stap-probe.c:1499
all_static_probe_ops
std::vector< const static_probe_ops * > all_static_probe_ops
Definition: probe.c:882
STAP_ARG_BITNESS_16BIT_SIGNED
Definition: stap-probe.c:73
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
stap_probe::evaluate_argument
struct value * evaluate_argument(unsigned n, struct frame_info *frame) override
Definition: stap-probe.c:1371
gdb_byte
bfd_byte gdb_byte
Definition: common-types.h:38
STAP_BASE_SECTION_NAME
#define STAP_BASE_SECTION_NAME
Definition: stap-probe.c:46
gdbarch_stap_gdb_register_suffix
const char * gdbarch_stap_gdb_register_suffix(struct gdbarch *gdbarch)
Definition: gdbarch.c:4441
exp_element
Definition: expression.h:62
stap_operand_prec
stap_operand_prec
Definition: stap-probe.c:235
stap_probe
Definition: stap-probe.c:124
STAP_ARG_BITNESS_64BIT_UNSIGNED
Definition: stap-probe.c:76
STAP_ARG_BITNESS_UNDEFINED
Definition: stap-probe.c:69
stap_parse_argument_1
static void stap_parse_argument_1(struct stap_parse_info *p, int has_lhs, enum stap_operand_prec prec)
Definition: stap-probe.c:1026
target_read_memory
int target_read_memory(CORE_ADDR memaddr, gdb_byte *myaddr, ssize_t len)
Definition: target.c:1370
stap_parse_register_operand
static void stap_parse_register_operand(struct stap_parse_info *p)
Definition: stap-probe.c:673
builtin_type::builtin_data_ptr
struct type * builtin_data_ptr
Definition: gdbtypes.h:1554
symfile_complaints
struct complaints * symfile_complaints
Definition: complaints.c:96
stap_is_operator
static int stap_is_operator(const char *op)
Definition: stap-probe.c:1322
stap_get_expected_argument_type
static struct type * stap_get_expected_argument_type(struct gdbarch *gdbarch, enum stap_arg_bitness b, const char *probe_name)
Definition: stap-probe.c:428
STAP_ARG_BITNESS_64BIT_SIGNED
Definition: stap-probe.c:77
stap_probe::stap_probe
stap_probe(std::string &&name_, std::string &&provider_, CORE_ADDR address_, struct gdbarch *arch_, CORE_ADDR sem_addr, const char *args_text)
Definition: stap-probe.c:128
gdbarch_stap_integer_prefixes
const char *const * gdbarch_stap_integer_prefixes(struct gdbarch *gdbarch)
Definition: gdbarch.c:4322
gdbarch_stap_register_indirection_prefixes
const char *const * gdbarch_stap_register_indirection_prefixes(struct gdbarch *gdbarch)
Definition: gdbarch.c:4390
_initialize_stap_probe
void _initialize_stap_probe(void)
Definition: stap-probe.c:1699
stap_static_probe_ops
const stap_static_probe_ops stap_static_probe_ops
Definition: stap-probe.c:122
exp_opcode
exp_opcode
Definition: expression.h:42
probe.h
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
stap_is_register_indirection_prefix
static int stap_is_register_indirection_prefix(struct gdbarch *gdbarch, const char *s, const char **r)
Definition: stap-probe.c:522
stap_static_probe_ops
Definition: stap-probe.c:102
print_core_address
const char * print_core_address(struct gdbarch *gdbarch, CORE_ADDR address)
Definition: utils.c:2766
ULONGEST
unsigned long long ULONGEST
Definition: common-types.h:53
stap_expression_debug
static unsigned int stap_expression_debug
Definition: stap-probe.c:51
gdb_stdlog
#define gdb_stdlog
Definition: utils.h:349
builtin_type::builtin_int64
struct type * builtin_int64
Definition: gdbtypes.h:1540
showdebuglist
struct cmd_list_element * showdebuglist
Definition: cli-cmds.c:155
stap_probe::compile_to_ax
void compile_to_ax(struct agent_expr *aexpr, struct axs_value *axs_value, unsigned n) override
Definition: stap-probe.c:1386
stap_probe_arg
Definition: stap-probe.c:82
TYPE_LENGTH
#define TYPE_LENGTH(thistype)
Definition: gdbtypes.h:1235
gdbarch_stap_register_indirection_suffixes
const char *const * gdbarch_stap_register_indirection_suffixes(struct gdbarch *gdbarch)
Definition: gdbarch.c:4407
class_maintenance
Definition: command.h:43
objfile::section_offsets
struct section_offsets * section_offsets
Definition: objfiles.h:396
builtin_type::builtin_uint64
struct type * builtin_uint64
Definition: gdbtypes.h:1541
builtin_type::builtin_int8
struct type * builtin_int8
Definition: gdbtypes.h:1534
stap_generic_check_suffix
static int stap_generic_check_suffix(struct gdbarch *gdbarch, const char *s, const char **r, const char *const *suffixes)
Definition: stap-probe.c:587
stap_probe::can_evaluate_arguments
bool can_evaluate_arguments() const override
Definition: stap-probe.c:1357
stoken
Definition: parser-defs.h:88
write_exp_string
void write_exp_string(struct parser_state *ps, struct stoken str)
Definition: parse.c:318
gdbcmd.h
stap_get_operator_prec
static enum stap_operand_prec stap_get_operator_prec(enum exp_opcode op)
Definition: stap-probe.c:281
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
size
size_t size
Definition: go32-nat.c:242
language_c
Definition: defs.h:207
lookup_pointer_type
struct type * lookup_pointer_type(struct type *type)
Definition: gdbtypes.c:381
get_frame_arch
struct gdbarch * get_frame_arch(struct frame_info *this_frame)
Definition: frame.c:2691
LONGEST
long long LONGEST
Definition: common-types.h:52
gdbarch_stap_parse_special_token_p
int gdbarch_stap_parse_special_token_p(struct gdbarch *gdbarch)
Definition: gdbarch.c:4482
stap_check_integer_suffix
static int stap_check_integer_suffix(struct gdbarch *gdbarch, const char *s, const char **r)
Definition: stap-probe.c:619
stap_probe::get_arg_by_number
struct stap_probe_arg * get_arg_by_number(unsigned n, struct gdbarch *gdbarch)
Definition: stap-probe.c:172
stoken::length
int length
Definition: parser-defs.h:93
probe::get_gdbarch
struct gdbarch * get_gdbarch() const
Definition: probe.h:215
vec.h
ui-out.h
store_unsigned_integer
static void store_unsigned_integer(gdb_byte *addr, int len, enum bfd_endian byte_order, ULONGEST val)
Definition: defs.h:604