Print this page
7085 add support for "if" and "else" statements in dtrace
| Split |
Close |
| Expand all |
| Collapse all |
--- old/usr/src/lib/libdtrace/common/dt_parser.h
+++ new/usr/src/lib/libdtrace/common/dt_parser.h
1 1 /*
2 2 * CDDL HEADER START
3 3 *
4 4 * The contents of this file are subject to the terms of the
5 5 * Common Development and Distribution License (the "License").
6 6 * You may not use this file except in compliance with the License.
7 7 *
8 8 * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE
9 9 * or http://www.opensolaris.org/os/licensing.
10 10 * See the License for the specific language governing permissions
11 11 * and limitations under the License.
12 12 *
13 13 * When distributing Covered Code, include this CDDL HEADER in each
14 14 * file and include the License file at usr/src/OPENSOLARIS.LICENSE.
15 15 * If applicable, add the following below this CDDL HEADER, with the
16 16 * fields enclosed by brackets "[]" replaced with your own identifying
17 17 * information: Portions Copyright [yyyy] [name of copyright owner]
18 18 *
19 19 * CDDL HEADER END
|
↓ open down ↓ |
19 lines elided |
↑ open up ↑ |
20 20 */
21 21 /*
22 22 * Copyright 2007 Sun Microsystems, Inc. All rights reserved.
23 23 * Use is subject to license terms.
24 24 */
25 25 /*
26 26 * Copyright (c) 2013 by Delphix. All rights reserved.
27 27 * Copyright (c) 2013 Joyent, Inc. All rights reserved.
28 28 */
29 29
30 +/*
31 + * Copyright (c) 2014 by Delphix. All rights reserved.
32 + */
33 +
30 34 #ifndef _DT_PARSER_H
31 35 #define _DT_PARSER_H
32 36
33 37 #include <sys/types.h>
34 38 #include <sys/dtrace.h>
35 39
36 40 #include <libctf.h>
37 41 #include <stdarg.h>
38 42 #include <stdio.h>
39 43
40 44 #ifdef __cplusplus
41 45 extern "C" {
42 46 #endif
43 47
44 48 #include <dt_errtags.h>
45 49 #include <dt_ident.h>
46 50 #include <dt_decl.h>
47 51 #include <dt_xlator.h>
48 52 #include <dt_list.h>
49 53
50 54 typedef struct dt_node {
51 55 ctf_file_t *dn_ctfp; /* CTF type container for node's type */
52 56 ctf_id_t dn_type; /* CTF type reference for node's type */
53 57 uchar_t dn_kind; /* node kind (DT_NODE_*, defined below) */
54 58 uchar_t dn_flags; /* node flags (DT_NF_*, defined below) */
55 59 ushort_t dn_op; /* operator (DT_TOK_*, defined by lex) */
56 60 int dn_line; /* line number for error messages */
57 61 int dn_reg; /* register allocated by cg */
58 62 dtrace_attribute_t dn_attr; /* node stability attributes */
59 63
60 64 /*
61 65 * D compiler nodes, as is the usual style, contain a union of the
62 66 * different sub-elements required by the various kinds of nodes.
63 67 * These sub-elements are accessed using the macros defined below.
64 68 */
65 69 union {
66 70 struct {
67 71 uintmax_t _value; /* integer value */
68 72 char *_string; /* string value */
69 73 } _const;
70 74
71 75 struct {
72 76 dt_ident_t *_ident; /* identifier reference */
73 77 struct dt_node *_links[3]; /* child node pointers */
74 78 } _nodes;
75 79
76 80 struct {
77 81 struct dt_node *_descs; /* list of descriptions */
78 82 struct dt_node *_pred; /* predicate expression */
79 83 struct dt_node *_acts; /* action statement list */
80 84 dt_idhash_t *_locals; /* local variable hash */
81 85 dtrace_attribute_t _attr; /* context attributes */
82 86 } _clause;
83 87
84 88 struct {
85 89 char *_spec; /* specifier string (if any) */
86 90 dtrace_probedesc_t *_desc; /* final probe description */
87 91 } _pdesc;
88 92
89 93 struct {
90 94 char *_name; /* string name of member */
91 95 struct dt_node *_expr; /* expression node pointer */
92 96 dt_xlator_t *_xlator; /* translator reference */
93 97 uint_t _id; /* member identifier */
94 98 } _member;
95 99
96 100 struct {
97 101 dt_xlator_t *_xlator; /* translator reference */
|
↓ open down ↓ |
58 lines elided |
↑ open up ↑ |
98 102 struct dt_node *_xmemb; /* individual xlator member */
99 103 struct dt_node *_membs; /* list of member nodes */
100 104 } _xlator;
101 105
102 106 struct {
103 107 char *_name; /* string name of provider */
104 108 struct dt_provider *_pvp; /* provider references */
105 109 struct dt_node *_probes; /* list of probe nodes */
106 110 int _redecl; /* provider redeclared */
107 111 } _provider;
112 +
113 + struct {
114 + struct dt_node *_conditional;
115 + struct dt_node *_body;
116 + struct dt_node *_alternate_body;
117 + } _conditional;
108 118 } dn_u;
109 119
110 120 struct dt_node *dn_list; /* parse tree list link */
111 121 struct dt_node *dn_link; /* allocation list link */
112 122 } dt_node_t;
113 123
114 124 #define dn_value dn_u._const._value /* DT_NODE_INT */
115 125 #define dn_string dn_u._const._string /* STRING, IDENT, TYPE */
116 126 #define dn_ident dn_u._nodes._ident /* VAR,SYM,FUN,AGG,INL,PROBE */
117 127 #define dn_args dn_u._nodes._links[0] /* DT_NODE_VAR, FUNC */
118 128 #define dn_child dn_u._nodes._links[0] /* DT_NODE_OP1 */
119 129 #define dn_left dn_u._nodes._links[0] /* DT_NODE_OP2, OP3 */
120 130 #define dn_right dn_u._nodes._links[1] /* DT_NODE_OP2, OP3 */
121 131 #define dn_expr dn_u._nodes._links[2] /* DT_NODE_OP3, DEXPR */
122 132 #define dn_aggfun dn_u._nodes._links[0] /* DT_NODE_AGG */
123 133 #define dn_aggtup dn_u._nodes._links[1] /* DT_NODE_AGG */
124 134 #define dn_pdescs dn_u._clause._descs /* DT_NODE_CLAUSE */
125 135 #define dn_pred dn_u._clause._pred /* DT_NODE_CLAUSE */
126 136 #define dn_acts dn_u._clause._acts /* DT_NODE_CLAUSE */
127 137 #define dn_locals dn_u._clause._locals /* DT_NODE_CLAUSE */
128 138 #define dn_ctxattr dn_u._clause._attr /* DT_NODE_CLAUSE */
129 139 #define dn_spec dn_u._pdesc._spec /* DT_NODE_PDESC */
130 140 #define dn_desc dn_u._pdesc._desc /* DT_NODE_PDESC */
131 141 #define dn_membname dn_u._member._name /* DT_NODE_MEMBER */
132 142 #define dn_membexpr dn_u._member._expr /* DT_NODE_MEMBER */
|
↓ open down ↓ |
15 lines elided |
↑ open up ↑ |
133 143 #define dn_membxlator dn_u._member._xlator /* DT_NODE_MEMBER */
134 144 #define dn_membid dn_u._member._id /* DT_NODE_MEMBER */
135 145 #define dn_xlator dn_u._xlator._xlator /* DT_NODE_XLATOR */
136 146 #define dn_xmember dn_u._xlator._xmemb /* DT_NODE_XLATOR */
137 147 #define dn_members dn_u._xlator._membs /* DT_NODE_XLATOR */
138 148 #define dn_provname dn_u._provider._name /* DT_NODE_PROVIDER */
139 149 #define dn_provider dn_u._provider._pvp /* DT_NODE_PROVIDER */
140 150 #define dn_provred dn_u._provider._redecl /* DT_NODE_PROVIDER */
141 151 #define dn_probes dn_u._provider._probes /* DT_NODE_PROVIDER */
142 152
153 +/* DT_NODE_IF: */
154 +#define dn_conditional dn_u._conditional._conditional
155 +#define dn_body dn_u._conditional._body
156 +#define dn_alternate_body dn_u._conditional._alternate_body
157 +
143 158 #define DT_NODE_FREE 0 /* unused node (waiting to be freed) */
144 159 #define DT_NODE_INT 1 /* integer value */
145 160 #define DT_NODE_STRING 2 /* string value */
146 161 #define DT_NODE_IDENT 3 /* identifier */
147 162 #define DT_NODE_VAR 4 /* variable reference */
148 163 #define DT_NODE_SYM 5 /* symbol reference */
149 164 #define DT_NODE_TYPE 6 /* type reference or formal parameter */
150 165 #define DT_NODE_FUNC 7 /* function call */
151 166 #define DT_NODE_OP1 8 /* unary operator */
152 167 #define DT_NODE_OP2 9 /* binary operator */
153 168 #define DT_NODE_OP3 10 /* ternary operator */
154 169 #define DT_NODE_DEXPR 11 /* D expression action */
|
↓ open down ↓ |
2 lines elided |
↑ open up ↑ |
155 170 #define DT_NODE_DFUNC 12 /* D function action */
156 171 #define DT_NODE_AGG 13 /* aggregation */
157 172 #define DT_NODE_PDESC 14 /* probe description */
158 173 #define DT_NODE_CLAUSE 15 /* clause definition */
159 174 #define DT_NODE_INLINE 16 /* inline definition */
160 175 #define DT_NODE_MEMBER 17 /* member definition */
161 176 #define DT_NODE_XLATOR 18 /* translator definition */
162 177 #define DT_NODE_PROBE 19 /* probe definition */
163 178 #define DT_NODE_PROVIDER 20 /* provider definition */
164 179 #define DT_NODE_PROG 21 /* program translation unit */
180 +#define DT_NODE_IF 22 /* if statement */
165 181
166 182 #define DT_NF_SIGNED 0x01 /* data is a signed quantity (else unsigned) */
167 183 #define DT_NF_COOKED 0x02 /* data is a known type (else still cooking) */
168 184 #define DT_NF_REF 0x04 /* pass by reference (array, struct, union) */
169 185 #define DT_NF_LVALUE 0x08 /* node is an l-value according to ANSI-C */
170 186 #define DT_NF_WRITABLE 0x10 /* node is writable (can be modified) */
171 187 #define DT_NF_BITFIELD 0x20 /* node is an integer bitfield */
172 188 #define DT_NF_USERLAND 0x40 /* data is a userland address */
173 189
174 190 #define DT_TYPE_NAMELEN 128 /* reasonable size for ctf_type_name() */
175 191
176 192 extern int dt_node_is_integer(const dt_node_t *);
177 193 extern int dt_node_is_float(const dt_node_t *);
178 194 extern int dt_node_is_scalar(const dt_node_t *);
179 195 extern int dt_node_is_arith(const dt_node_t *);
180 196 extern int dt_node_is_vfptr(const dt_node_t *);
181 197 extern int dt_node_is_dynamic(const dt_node_t *);
182 198 extern int dt_node_is_stack(const dt_node_t *);
183 199 extern int dt_node_is_symaddr(const dt_node_t *);
184 200 extern int dt_node_is_usymaddr(const dt_node_t *);
185 201 extern int dt_node_is_string(const dt_node_t *);
186 202 extern int dt_node_is_strcompat(const dt_node_t *);
187 203 extern int dt_node_is_pointer(const dt_node_t *);
188 204 extern int dt_node_is_void(const dt_node_t *);
189 205 extern int dt_node_is_ptrcompat(const dt_node_t *, const dt_node_t *,
190 206 ctf_file_t **, ctf_id_t *);
191 207 extern int dt_node_is_argcompat(const dt_node_t *, const dt_node_t *);
192 208 extern int dt_node_is_posconst(const dt_node_t *);
193 209 extern int dt_node_is_actfunc(const dt_node_t *);
194 210
195 211 extern dt_node_t *dt_node_int(uintmax_t);
196 212 extern dt_node_t *dt_node_string(char *);
197 213 extern dt_node_t *dt_node_ident(char *);
198 214 extern dt_node_t *dt_node_type(dt_decl_t *);
199 215 extern dt_node_t *dt_node_vatype(void);
200 216 extern dt_node_t *dt_node_decl(void);
201 217 extern dt_node_t *dt_node_func(dt_node_t *, dt_node_t *);
202 218 extern dt_node_t *dt_node_offsetof(dt_decl_t *, char *);
203 219 extern dt_node_t *dt_node_op1(int, dt_node_t *);
204 220 extern dt_node_t *dt_node_op2(int, dt_node_t *, dt_node_t *);
205 221 extern dt_node_t *dt_node_op3(dt_node_t *, dt_node_t *, dt_node_t *);
|
↓ open down ↓ |
31 lines elided |
↑ open up ↑ |
206 222 extern dt_node_t *dt_node_statement(dt_node_t *);
207 223 extern dt_node_t *dt_node_pdesc_by_name(char *);
208 224 extern dt_node_t *dt_node_pdesc_by_id(uintmax_t);
209 225 extern dt_node_t *dt_node_clause(dt_node_t *, dt_node_t *, dt_node_t *);
210 226 extern dt_node_t *dt_node_inline(dt_node_t *);
211 227 extern dt_node_t *dt_node_member(dt_decl_t *, char *, dt_node_t *);
212 228 extern dt_node_t *dt_node_xlator(dt_decl_t *, dt_decl_t *, char *, dt_node_t *);
213 229 extern dt_node_t *dt_node_probe(char *, int, dt_node_t *, dt_node_t *);
214 230 extern dt_node_t *dt_node_provider(char *, dt_node_t *);
215 231 extern dt_node_t *dt_node_program(dt_node_t *);
232 +extern dt_node_t *dt_node_if(dt_node_t *, dt_node_t *, dt_node_t *);
216 233
217 234 extern dt_node_t *dt_node_link(dt_node_t *, dt_node_t *);
218 235 extern dt_node_t *dt_node_cook(dt_node_t *, uint_t);
219 236
220 237 extern dt_node_t *dt_node_xalloc(dtrace_hdl_t *, int);
221 238 extern void dt_node_free(dt_node_t *);
222 239
223 240 extern dtrace_attribute_t dt_node_list_cook(dt_node_t **, uint_t);
224 241 extern void dt_node_list_free(dt_node_t **);
225 242 extern void dt_node_link_free(dt_node_t **);
226 243
227 244 extern void dt_node_attr_assign(dt_node_t *, dtrace_attribute_t);
228 245 extern void dt_node_type_assign(dt_node_t *, ctf_file_t *, ctf_id_t, boolean_t);
229 246 extern void dt_node_type_propagate(const dt_node_t *, dt_node_t *);
|
↓ open down ↓ |
4 lines elided |
↑ open up ↑ |
230 247 extern const char *dt_node_type_name(const dt_node_t *, char *, size_t);
231 248 extern size_t dt_node_type_size(const dt_node_t *);
232 249
233 250 extern dt_ident_t *dt_node_resolve(const dt_node_t *, uint_t);
234 251 extern size_t dt_node_sizeof(const dt_node_t *);
235 252 extern void dt_node_promote(dt_node_t *, dt_node_t *, dt_node_t *);
236 253
237 254 extern void dt_node_diftype(dtrace_hdl_t *,
238 255 const dt_node_t *, dtrace_diftype_t *);
239 256 extern void dt_node_printr(dt_node_t *, FILE *, int);
257 +extern void dt_printd(dt_node_t *, FILE *, int);
240 258 extern const char *dt_node_name(const dt_node_t *, char *, size_t);
241 259 extern int dt_node_root(dt_node_t *);
242 260
243 261 struct dtrace_typeinfo; /* see <dtrace.h> */
244 262 struct dt_pcb; /* see <dt_impl.h> */
245 263
246 264 #define IS_CHAR(e) \
247 265 (((e).cte_format & (CTF_INT_CHAR | CTF_INT_SIGNED)) == \
248 266 (CTF_INT_CHAR | CTF_INT_SIGNED) && (e).cte_bits == NBBY)
249 267
250 268 #define IS_VOID(e) \
251 269 ((e).cte_offset == 0 && (e).cte_bits == 0)
252 270
253 271 extern int dt_type_lookup(const char *, struct dtrace_typeinfo *);
254 272 extern int dt_type_pointer(struct dtrace_typeinfo *);
255 273 extern const char *dt_type_name(ctf_file_t *, ctf_id_t, char *, size_t);
256 274
257 275 typedef enum {
258 276 YYS_CLAUSE, /* lex/yacc state for finding program clauses */
259 277 YYS_DEFINE, /* lex/yacc state for parsing persistent definitions */
260 278 YYS_EXPR, /* lex/yacc state for parsing D expressions */
261 279 YYS_DONE, /* lex/yacc state for indicating parse tree is done */
262 280 YYS_CONTROL /* lex/yacc state for parsing control lines */
263 281 } yystate_t;
264 282
265 283 extern void dnerror(const dt_node_t *, dt_errtag_t, const char *, ...);
266 284 extern void dnwarn(const dt_node_t *, dt_errtag_t, const char *, ...);
267 285
268 286 extern void xyerror(dt_errtag_t, const char *, ...);
269 287 extern void xywarn(dt_errtag_t, const char *, ...);
270 288 extern void xyvwarn(dt_errtag_t, const char *, va_list);
271 289
272 290 extern void yyerror(const char *, ...);
273 291 extern void yywarn(const char *, ...);
274 292 extern void yyvwarn(const char *, va_list);
275 293
276 294 extern void yylabel(const char *);
277 295 extern void yybegin(yystate_t);
278 296 extern void yyinit(struct dt_pcb *);
279 297
280 298 extern int yyparse(void);
281 299 extern int yyinput(void);
282 300
283 301 #ifdef __cplusplus
284 302 }
285 303 #endif
286 304
287 305 #endif /* _DT_PARSER_H */
|
↓ open down ↓ |
38 lines elided |
↑ open up ↑ |
XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX