1 /*
2 * CDDL HEADER START
3 *
4 * The contents of this file are subject to the terms of the
5 * Common Development and Distribution License, Version 1.0 only
6 * (the "License"). You may not use this file except in compliance
7 * with the License.
8 *
9 * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE
10 * or http://www.opensolaris.org/os/licensing.
11 * See the License for the specific language governing permissions
12 * and limitations under the License.
13 *
14 * When distributing Covered Code, include this CDDL HEADER in each
15 * file and include the License file at usr/src/OPENSOLARIS.LICENSE.
16 * If applicable, add the following below this CDDL HEADER, with the
17 * fields enclosed by brackets "[]" replaced with your own identifying
18 * information: Portions Copyright [yyyy] [name of copyright owner]
19 *
20 * CDDL HEADER END
21 */
22
23 /*
24 * Copyright 2006 Sun Microsystems, Inc. All rights reserved.
25 * Copyright (c) 2013, Joyent Inc. All rights reserved.
26 * Copyright (c) 2012, 2016 by Delphix. All rights reserved.
27 */
28
29 #pragma ident "%Z%%M% %I% %E% SMI"
30
31 /*
32 * DTrace D Language Parser
33 *
34 * The D Parser is a lex/yacc parser consisting of the lexer dt_lex.l, the
35 * parsing grammar dt_grammar.y, and this file, dt_parser.c, which handles
36 * the construction of the parse tree nodes and their syntactic validation.
37 * The parse tree is constructed of dt_node_t structures (see <dt_parser.h>)
38 * that are built in two passes: (1) the "create" pass, where the parse tree
39 * nodes are allocated by calls from the grammar to dt_node_*() subroutines,
40 * and (2) the "cook" pass, where nodes are coalesced, assigned D types, and
41 * validated according to the syntactic rules of the language.
42 *
43 * All node allocations are performed using dt_node_alloc(). All node frees
44 * during the parsing phase are performed by dt_node_free(), which frees node-
45 * internal state but does not actually free the nodes. All final node frees
46 * are done as part of the end of dt_compile() or as part of destroying
47 * persistent identifiers or translators which have embedded nodes.
48 *
49 * The dt_node_* routines that implement pass (1) may allocate new nodes. The
50 * dt_cook_* routines that implement pass (2) may *not* allocate new nodes.
51 * They may free existing nodes using dt_node_free(), but they may not actually
52 * deallocate any dt_node_t's. Currently dt_cook_op2() is an exception to this
53 * rule: see the comments therein for how this issue is resolved.
54 *
55 * The dt_cook_* routines are responsible for (at minimum) setting the final
56 * node type (dn_ctfp/dn_type) and attributes (dn_attr). If dn_ctfp/dn_type
57 * are set manually (i.e. not by one of the type assignment functions), then
58 * the DT_NF_COOKED flag must be set manually on the node.
59 *
60 * The cooking pass can be applied to the same parse tree more than once (used
61 * in the case of a comma-separated list of probe descriptions). As such, the
62 * cook routines must not perform any parse tree transformations which would
63 * be invalid if the tree were subsequently cooked using a different context.
64 *
65 * The dn_ctfp and dn_type fields form the type of the node. This tuple can
66 * take on the following set of values, which form our type invariants:
67 *
68 * 1. dn_ctfp = NULL, dn_type = CTF_ERR
69 *
70 * In this state, the node has unknown type and is not yet cooked. The
71 * DT_NF_COOKED flag is not yet set on the node.
72 *
73 * 2. dn_ctfp = DT_DYN_CTFP(dtp), dn_type = DT_DYN_TYPE(dtp)
74 *
75 * In this state, the node is a dynamic D type. This means that generic
76 * operations are not valid on this node and only code that knows how to
77 * examine the inner details of the node can operate on it. A <DYN> node
78 * must have dn_ident set to point to an identifier describing the object
79 * and its type. The DT_NF_REF flag is set for all nodes of type <DYN>.
80 * At present, the D compiler uses the <DYN> type for:
81 *
82 * - associative arrays that do not yet have a value type defined
83 * - translated data (i.e. the result of the xlate operator)
84 * - aggregations
85 *
86 * 3. dn_ctfp = DT_STR_CTFP(dtp), dn_type = DT_STR_TYPE(dtp)
87 *
88 * In this state, the node is of type D string. The string type is really
89 * a char[0] typedef, but requires special handling throughout the compiler.
90 *
91 * 4. dn_ctfp != NULL, dn_type = any other type ID
92 *
93 * In this state, the node is of some known D/CTF type. The normal libctf
94 * APIs can be used to learn more about the type name or structure. When
95 * the type is assigned, the DT_NF_SIGNED, DT_NF_REF, and DT_NF_BITFIELD
96 * flags cache the corresponding attributes of the underlying CTF type.
97 */
98
99 #include <sys/param.h>
100 #include <sys/sysmacros.h>
101 #include <limits.h>
102 #include <setjmp.h>
103 #include <strings.h>
104 #include <assert.h>
105 #ifdef illumos
106 #include <alloca.h>
107 #endif
108 #include <stdlib.h>
109 #include <stdarg.h>
110 #include <stdio.h>
111 #include <errno.h>
112 #include <ctype.h>
113
114 #include <dt_impl.h>
115 #include <dt_grammar.h>
116 #include <dt_module.h>
117 #include <dt_provider.h>
118 #include <dt_string.h>
119 #include <dt_as.h>
120
121 dt_pcb_t *yypcb; /* current control block for parser */
122 dt_node_t *yypragma; /* lex token list for control lines */
123 char yyintprefix; /* int token macro prefix (+/-) */
124 char yyintsuffix[4]; /* int token suffix string [uU][lL] */
125 int yyintdecimal; /* int token format flag (1=decimal, 0=octal/hex) */
126
127 static const char *
opstr(int op)128 opstr(int op)
129 {
130 switch (op) {
131 case DT_TOK_COMMA: return (",");
132 case DT_TOK_ELLIPSIS: return ("...");
133 case DT_TOK_ASGN: return ("=");
134 case DT_TOK_ADD_EQ: return ("+=");
135 case DT_TOK_SUB_EQ: return ("-=");
136 case DT_TOK_MUL_EQ: return ("*=");
137 case DT_TOK_DIV_EQ: return ("/=");
138 case DT_TOK_MOD_EQ: return ("%=");
139 case DT_TOK_AND_EQ: return ("&=");
140 case DT_TOK_XOR_EQ: return ("^=");
141 case DT_TOK_OR_EQ: return ("|=");
142 case DT_TOK_LSH_EQ: return ("<<=");
143 case DT_TOK_RSH_EQ: return (">>=");
144 case DT_TOK_QUESTION: return ("?");
145 case DT_TOK_COLON: return (":");
146 case DT_TOK_LOR: return ("||");
147 case DT_TOK_LXOR: return ("^^");
148 case DT_TOK_LAND: return ("&&");
149 case DT_TOK_BOR: return ("|");
150 case DT_TOK_XOR: return ("^");
151 case DT_TOK_BAND: return ("&");
152 case DT_TOK_EQU: return ("==");
153 case DT_TOK_NEQ: return ("!=");
154 case DT_TOK_LT: return ("<");
155 case DT_TOK_LE: return ("<=");
156 case DT_TOK_GT: return (">");
157 case DT_TOK_GE: return (">=");
158 case DT_TOK_LSH: return ("<<");
159 case DT_TOK_RSH: return (">>");
160 case DT_TOK_ADD: return ("+");
161 case DT_TOK_SUB: return ("-");
162 case DT_TOK_MUL: return ("*");
163 case DT_TOK_DIV: return ("/");
164 case DT_TOK_MOD: return ("%");
165 case DT_TOK_LNEG: return ("!");
166 case DT_TOK_BNEG: return ("~");
167 case DT_TOK_ADDADD: return ("++");
168 case DT_TOK_PREINC: return ("++");
169 case DT_TOK_POSTINC: return ("++");
170 case DT_TOK_SUBSUB: return ("--");
171 case DT_TOK_PREDEC: return ("--");
172 case DT_TOK_POSTDEC: return ("--");
173 case DT_TOK_IPOS: return ("+");
174 case DT_TOK_INEG: return ("-");
175 case DT_TOK_DEREF: return ("*");
176 case DT_TOK_ADDROF: return ("&");
177 case DT_TOK_OFFSETOF: return ("offsetof");
178 case DT_TOK_SIZEOF: return ("sizeof");
179 case DT_TOK_STRINGOF: return ("stringof");
180 case DT_TOK_XLATE: return ("xlate");
181 case DT_TOK_LPAR: return ("(");
182 case DT_TOK_RPAR: return (")");
183 case DT_TOK_LBRAC: return ("[");
184 case DT_TOK_RBRAC: return ("]");
185 case DT_TOK_PTR: return ("->");
186 case DT_TOK_DOT: return (".");
187 case DT_TOK_STRING: return ("<string>");
188 case DT_TOK_IDENT: return ("<ident>");
189 case DT_TOK_TNAME: return ("<type>");
190 case DT_TOK_INT: return ("<int>");
191 default: return ("<?>");
192 }
193 }
194
195 int
dt_type_lookup(const char * s,dtrace_typeinfo_t * tip)196 dt_type_lookup(const char *s, dtrace_typeinfo_t *tip)
197 {
198 static const char delimiters[] = " \t\n\r\v\f*`";
199 dtrace_hdl_t *dtp = yypcb->pcb_hdl;
200 const char *p, *q, *r, *end, *obj;
201
202 for (p = s, end = s + strlen(s); *p != '\0'; p = q) {
203 while (isspace(*p))
204 p++; /* skip leading whitespace prior to token */
205
206 if (p == end || (q = strpbrk(p + 1, delimiters)) == NULL)
207 break; /* empty string or single token remaining */
208
209 if (*q == '`') {
210 char *object = alloca((size_t)(q - p) + 1);
211 char *type = alloca((size_t)(end - s) + 1);
212
213 /*
214 * Copy from the start of the token (p) to the location
215 * backquote (q) to extract the nul-terminated object.
216 */
217 bcopy(p, object, (size_t)(q - p));
218 object[(size_t)(q - p)] = '\0';
219
220 /*
221 * Copy the original string up to the start of this
222 * token (p) into type, and then concatenate everything
223 * after q. This is the type name without the object.
224 */
225 bcopy(s, type, (size_t)(p - s));
226 bcopy(q + 1, type + (size_t)(p - s), strlen(q + 1) + 1);
227
228 /*
229 * There may be at most three delimeters. The second
230 * delimeter is usually used to distinguish the type
231 * within a given module, however, there could be a link
232 * map id on the scene in which case that delimeter
233 * would be the third. We determine presence of the lmid
234 * if it rouglhly meets the from LM[0-9]
235 */
236 if ((r = strchr(q + 1, '`')) != NULL &&
237 ((r = strchr(r + 1, '`')) != NULL)) {
238 if (strchr(r + 1, '`') != NULL)
239 return (dt_set_errno(dtp,
240 EDT_BADSCOPE));
241 if (q[1] != 'L' || q[2] != 'M')
242 return (dt_set_errno(dtp,
243 EDT_BADSCOPE));
244 }
245
246 return (dtrace_lookup_by_type(dtp, object, type, tip));
247 }
248 }
249
250 if (yypcb->pcb_idepth != 0)
251 obj = DTRACE_OBJ_CDEFS;
252 else
253 obj = DTRACE_OBJ_EVERY;
254
255 return (dtrace_lookup_by_type(dtp, obj, s, tip));
256 }
257
258 /*
259 * When we parse type expressions or parse an expression with unary "&", we
260 * need to find a type that is a pointer to a previously known type.
261 * Unfortunately CTF is limited to a per-container view, so ctf_type_pointer()
262 * alone does not suffice for our needs. We provide a more intelligent wrapper
263 * for the compiler that attempts to compute a pointer to either the given type
264 * or its base (that is, we try both "foo_t *" and "struct foo *"), and also
265 * to potentially construct the required type on-the-fly.
266 */
267 int
dt_type_pointer(dtrace_typeinfo_t * tip)268 dt_type_pointer(dtrace_typeinfo_t *tip)
269 {
270 dtrace_hdl_t *dtp = yypcb->pcb_hdl;
271 ctf_file_t *ctfp = tip->dtt_ctfp;
272 ctf_id_t type = tip->dtt_type;
273 ctf_id_t base = ctf_type_resolve(ctfp, type);
274 uint_t bflags = tip->dtt_flags;
275
276 dt_module_t *dmp;
277 ctf_id_t ptr;
278
279 if ((ptr = ctf_type_pointer(ctfp, type)) != CTF_ERR ||
280 (ptr = ctf_type_pointer(ctfp, base)) != CTF_ERR) {
281 tip->dtt_type = ptr;
282 return (0);
283 }
284
285 if (yypcb->pcb_idepth != 0)
286 dmp = dtp->dt_cdefs;
287 else
288 dmp = dtp->dt_ddefs;
289
290 if (ctfp != dmp->dm_ctfp && ctfp != ctf_parent_file(dmp->dm_ctfp) &&
291 (type = ctf_add_type(dmp->dm_ctfp, ctfp, type)) == CTF_ERR) {
292 dtp->dt_ctferr = ctf_errno(dmp->dm_ctfp);
293 return (dt_set_errno(dtp, EDT_CTF));
294 }
295
296 ptr = ctf_add_pointer(dmp->dm_ctfp, CTF_ADD_ROOT, type);
297
298 if (ptr == CTF_ERR || ctf_update(dmp->dm_ctfp) == CTF_ERR) {
299 dtp->dt_ctferr = ctf_errno(dmp->dm_ctfp);
300 return (dt_set_errno(dtp, EDT_CTF));
301 }
302
303 tip->dtt_object = dmp->dm_name;
304 tip->dtt_ctfp = dmp->dm_ctfp;
305 tip->dtt_type = ptr;
306 tip->dtt_flags = bflags;
307
308 return (0);
309 }
310
311 const char *
dt_type_name(ctf_file_t * ctfp,ctf_id_t type,char * buf,size_t len)312 dt_type_name(ctf_file_t *ctfp, ctf_id_t type, char *buf, size_t len)
313 {
314 dtrace_hdl_t *dtp = yypcb->pcb_hdl;
315
316 if (ctfp == DT_FPTR_CTFP(dtp) && type == DT_FPTR_TYPE(dtp))
317 (void) snprintf(buf, len, "function pointer");
318 else if (ctfp == DT_FUNC_CTFP(dtp) && type == DT_FUNC_TYPE(dtp))
319 (void) snprintf(buf, len, "function");
320 else if (ctfp == DT_DYN_CTFP(dtp) && type == DT_DYN_TYPE(dtp))
321 (void) snprintf(buf, len, "dynamic variable");
322 else if (ctfp == NULL)
323 (void) snprintf(buf, len, "<none>");
324 else if (ctf_type_name(ctfp, type, buf, len) == NULL)
325 (void) snprintf(buf, len, "unknown");
326
327 return (buf);
328 }
329
330 /*
331 * Perform the "usual arithmetic conversions" to determine which of the two
332 * input operand types should be promoted and used as a result type. The
333 * rules for this are described in ISOC[6.3.1.8] and K&R[A6.5].
334 */
335 static void
dt_type_promote(dt_node_t * lp,dt_node_t * rp,ctf_file_t ** ofp,ctf_id_t * otype)336 dt_type_promote(dt_node_t *lp, dt_node_t *rp, ctf_file_t **ofp, ctf_id_t *otype)
337 {
338 ctf_file_t *lfp = lp->dn_ctfp;
339 ctf_id_t ltype = lp->dn_type;
340
341 ctf_file_t *rfp = rp->dn_ctfp;
342 ctf_id_t rtype = rp->dn_type;
343
344 ctf_id_t lbase = ctf_type_resolve(lfp, ltype);
345 uint_t lkind = ctf_type_kind(lfp, lbase);
346
347 ctf_id_t rbase = ctf_type_resolve(rfp, rtype);
348 uint_t rkind = ctf_type_kind(rfp, rbase);
349
350 dtrace_hdl_t *dtp = yypcb->pcb_hdl;
351 ctf_encoding_t le, re;
352 uint_t lrank, rrank;
353
354 assert(lkind == CTF_K_INTEGER || lkind == CTF_K_ENUM);
355 assert(rkind == CTF_K_INTEGER || rkind == CTF_K_ENUM);
356
357 if (lkind == CTF_K_ENUM) {
358 lfp = DT_INT_CTFP(dtp);
359 ltype = lbase = DT_INT_TYPE(dtp);
360 }
361
362 if (rkind == CTF_K_ENUM) {
363 rfp = DT_INT_CTFP(dtp);
364 rtype = rbase = DT_INT_TYPE(dtp);
365 }
366
367 if (ctf_type_encoding(lfp, lbase, &le) == CTF_ERR) {
368 yypcb->pcb_hdl->dt_ctferr = ctf_errno(lfp);
369 longjmp(yypcb->pcb_jmpbuf, EDT_CTF);
370 }
371
372 if (ctf_type_encoding(rfp, rbase, &re) == CTF_ERR) {
373 yypcb->pcb_hdl->dt_ctferr = ctf_errno(rfp);
374 longjmp(yypcb->pcb_jmpbuf, EDT_CTF);
375 }
376
377 /*
378 * Compute an integer rank based on the size and unsigned status.
379 * If rank is identical, pick the "larger" of the equivalent types
380 * which we define as having a larger base ctf_id_t. If rank is
381 * different, pick the type with the greater rank.
382 */
383 lrank = le.cte_bits + ((le.cte_format & CTF_INT_SIGNED) == 0);
384 rrank = re.cte_bits + ((re.cte_format & CTF_INT_SIGNED) == 0);
385
386 if (lrank == rrank) {
387 if (lbase - rbase < 0)
388 goto return_rtype;
389 else
390 goto return_ltype;
391 } else if (lrank > rrank) {
392 goto return_ltype;
393 } else
394 goto return_rtype;
395
396 return_ltype:
397 *ofp = lfp;
398 *otype = ltype;
399 return;
400
401 return_rtype:
402 *ofp = rfp;
403 *otype = rtype;
404 }
405
406 void
dt_node_promote(dt_node_t * lp,dt_node_t * rp,dt_node_t * dnp)407 dt_node_promote(dt_node_t *lp, dt_node_t *rp, dt_node_t *dnp)
408 {
409 dt_type_promote(lp, rp, &dnp->dn_ctfp, &dnp->dn_type);
410 dt_node_type_assign(dnp, dnp->dn_ctfp, dnp->dn_type, B_FALSE);
411 dt_node_attr_assign(dnp, dt_attr_min(lp->dn_attr, rp->dn_attr));
412 }
413
414 const char *
dt_node_name(const dt_node_t * dnp,char * buf,size_t len)415 dt_node_name(const dt_node_t *dnp, char *buf, size_t len)
416 {
417 char n1[DT_TYPE_NAMELEN];
418 char n2[DT_TYPE_NAMELEN];
419
420 const char *prefix = "", *suffix = "";
421 const dtrace_syminfo_t *dts;
422 char *s;
423
424 switch (dnp->dn_kind) {
425 case DT_NODE_INT:
426 (void) snprintf(buf, len, "integer constant 0x%llx",
427 (u_longlong_t)dnp->dn_value);
428 break;
429 case DT_NODE_STRING:
430 s = strchr2esc(dnp->dn_string, strlen(dnp->dn_string));
431 (void) snprintf(buf, len, "string constant \"%s\"",
432 s != NULL ? s : dnp->dn_string);
433 free(s);
434 break;
435 case DT_NODE_IDENT:
436 (void) snprintf(buf, len, "identifier %s", dnp->dn_string);
437 break;
438 case DT_NODE_VAR:
439 case DT_NODE_FUNC:
440 case DT_NODE_AGG:
441 case DT_NODE_INLINE:
442 switch (dnp->dn_ident->di_kind) {
443 case DT_IDENT_FUNC:
444 case DT_IDENT_AGGFUNC:
445 case DT_IDENT_ACTFUNC:
446 suffix = "( )";
447 break;
448 case DT_IDENT_AGG:
449 prefix = "@";
450 break;
451 }
452 (void) snprintf(buf, len, "%s %s%s%s",
453 dt_idkind_name(dnp->dn_ident->di_kind),
454 prefix, dnp->dn_ident->di_name, suffix);
455 break;
456 case DT_NODE_SYM:
457 dts = dnp->dn_ident->di_data;
458 (void) snprintf(buf, len, "symbol %s`%s",
459 dts->dts_object, dts->dts_name);
460 break;
461 case DT_NODE_TYPE:
462 (void) snprintf(buf, len, "type %s",
463 dt_node_type_name(dnp, n1, sizeof (n1)));
464 break;
465 case DT_NODE_OP1:
466 case DT_NODE_OP2:
467 case DT_NODE_OP3:
468 (void) snprintf(buf, len, "operator %s", opstr(dnp->dn_op));
469 break;
470 case DT_NODE_DEXPR:
471 case DT_NODE_DFUNC:
472 if (dnp->dn_expr)
473 return (dt_node_name(dnp->dn_expr, buf, len));
474 (void) snprintf(buf, len, "%s", "statement");
475 break;
476 case DT_NODE_PDESC:
477 if (dnp->dn_desc->dtpd_id == 0) {
478 (void) snprintf(buf, len,
479 "probe description %s:%s:%s:%s",
480 dnp->dn_desc->dtpd_provider, dnp->dn_desc->dtpd_mod,
481 dnp->dn_desc->dtpd_func, dnp->dn_desc->dtpd_name);
482 } else {
483 (void) snprintf(buf, len, "probe description %u",
484 dnp->dn_desc->dtpd_id);
485 }
486 break;
487 case DT_NODE_CLAUSE:
488 (void) snprintf(buf, len, "%s", "clause");
489 break;
490 case DT_NODE_MEMBER:
491 (void) snprintf(buf, len, "member %s", dnp->dn_membname);
492 break;
493 case DT_NODE_XLATOR:
494 (void) snprintf(buf, len, "translator <%s> (%s)",
495 dt_type_name(dnp->dn_xlator->dx_dst_ctfp,
496 dnp->dn_xlator->dx_dst_type, n1, sizeof (n1)),
497 dt_type_name(dnp->dn_xlator->dx_src_ctfp,
498 dnp->dn_xlator->dx_src_type, n2, sizeof (n2)));
499 break;
500 case DT_NODE_PROG:
501 (void) snprintf(buf, len, "%s", "program");
502 break;
503 default:
504 (void) snprintf(buf, len, "node <%u>", dnp->dn_kind);
505 break;
506 }
507
508 return (buf);
509 }
510
511 /*
512 * dt_node_xalloc() can be used to create new parse nodes from any libdtrace
513 * caller. The caller is responsible for assigning dn_link appropriately.
514 */
515 dt_node_t *
dt_node_xalloc(dtrace_hdl_t * dtp,int kind)516 dt_node_xalloc(dtrace_hdl_t *dtp, int kind)
517 {
518 dt_node_t *dnp = dt_alloc(dtp, sizeof (dt_node_t));
519
520 if (dnp == NULL)
521 return (NULL);
522
523 dnp->dn_ctfp = NULL;
524 dnp->dn_type = CTF_ERR;
525 dnp->dn_kind = (uchar_t)kind;
526 dnp->dn_flags = 0;
527 dnp->dn_op = 0;
528 dnp->dn_line = -1;
529 dnp->dn_reg = -1;
530 dnp->dn_attr = _dtrace_defattr;
531 dnp->dn_list = NULL;
532 dnp->dn_link = NULL;
533 bzero(&dnp->dn_u, sizeof (dnp->dn_u));
534
535 return (dnp);
536 }
537
538 /*
539 * dt_node_alloc() is used to create new parse nodes from the parser. It
540 * assigns the node location based on the current lexer line number and places
541 * the new node on the default allocation list. If allocation fails, we
542 * automatically longjmp the caller back to the enclosing compilation call.
543 */
544 static dt_node_t *
dt_node_alloc(int kind)545 dt_node_alloc(int kind)
546 {
547 dt_node_t *dnp = dt_node_xalloc(yypcb->pcb_hdl, kind);
548
549 if (dnp == NULL)
550 longjmp(yypcb->pcb_jmpbuf, EDT_NOMEM);
551
552 dnp->dn_line = yylineno;
553 dnp->dn_link = yypcb->pcb_list;
554 yypcb->pcb_list = dnp;
555
556 return (dnp);
557 }
558
559 void
dt_node_free(dt_node_t * dnp)560 dt_node_free(dt_node_t *dnp)
561 {
562 uchar_t kind = dnp->dn_kind;
563
564 dnp->dn_kind = DT_NODE_FREE;
565
566 switch (kind) {
567 case DT_NODE_STRING:
568 case DT_NODE_IDENT:
569 case DT_NODE_TYPE:
570 free(dnp->dn_string);
571 dnp->dn_string = NULL;
572 break;
573
574 case DT_NODE_VAR:
575 case DT_NODE_FUNC:
576 case DT_NODE_PROBE:
577 if (dnp->dn_ident != NULL) {
578 if (dnp->dn_ident->di_flags & DT_IDFLG_ORPHAN)
579 dt_ident_destroy(dnp->dn_ident);
580 dnp->dn_ident = NULL;
581 }
582 dt_node_list_free(&dnp->dn_args);
583 break;
584
585 case DT_NODE_OP1:
586 if (dnp->dn_child != NULL) {
587 dt_node_free(dnp->dn_child);
588 dnp->dn_child = NULL;
589 }
590 break;
591
592 case DT_NODE_OP3:
593 if (dnp->dn_expr != NULL) {
594 dt_node_free(dnp->dn_expr);
595 dnp->dn_expr = NULL;
596 }
597 /*FALLTHRU*/
598 case DT_NODE_OP2:
599 if (dnp->dn_left != NULL) {
600 dt_node_free(dnp->dn_left);
601 dnp->dn_left = NULL;
602 }
603 if (dnp->dn_right != NULL) {
604 dt_node_free(dnp->dn_right);
605 dnp->dn_right = NULL;
606 }
607 break;
608
609 case DT_NODE_DEXPR:
610 case DT_NODE_DFUNC:
611 if (dnp->dn_expr != NULL) {
612 dt_node_free(dnp->dn_expr);
613 dnp->dn_expr = NULL;
614 }
615 break;
616
617 case DT_NODE_AGG:
618 if (dnp->dn_aggfun != NULL) {
619 dt_node_free(dnp->dn_aggfun);
620 dnp->dn_aggfun = NULL;
621 }
622 dt_node_list_free(&dnp->dn_aggtup);
623 break;
624
625 case DT_NODE_PDESC:
626 free(dnp->dn_spec);
627 dnp->dn_spec = NULL;
628 free(dnp->dn_desc);
629 dnp->dn_desc = NULL;
630 break;
631
632 case DT_NODE_CLAUSE:
633 if (dnp->dn_pred != NULL)
634 dt_node_free(dnp->dn_pred);
635 if (dnp->dn_locals != NULL)
636 dt_idhash_destroy(dnp->dn_locals);
637 dt_node_list_free(&dnp->dn_pdescs);
638 dt_node_list_free(&dnp->dn_acts);
639 break;
640
641 case DT_NODE_MEMBER:
642 free(dnp->dn_membname);
643 dnp->dn_membname = NULL;
644 if (dnp->dn_membexpr != NULL) {
645 dt_node_free(dnp->dn_membexpr);
646 dnp->dn_membexpr = NULL;
647 }
648 break;
649
650 case DT_NODE_PROVIDER:
651 dt_node_list_free(&dnp->dn_probes);
652 free(dnp->dn_provname);
653 dnp->dn_provname = NULL;
654 break;
655
656 case DT_NODE_PROG:
657 dt_node_list_free(&dnp->dn_list);
658 break;
659 }
660 }
661
662 void
dt_node_attr_assign(dt_node_t * dnp,dtrace_attribute_t attr)663 dt_node_attr_assign(dt_node_t *dnp, dtrace_attribute_t attr)
664 {
665 if ((yypcb->pcb_cflags & DTRACE_C_EATTR) &&
666 (dt_attr_cmp(attr, yypcb->pcb_amin) < 0)) {
667 char a[DTRACE_ATTR2STR_MAX];
668 char s[BUFSIZ];
669
670 dnerror(dnp, D_ATTR_MIN, "attributes for %s (%s) are less than "
671 "predefined minimum\n", dt_node_name(dnp, s, sizeof (s)),
672 dtrace_attr2str(attr, a, sizeof (a)));
673 }
674
675 dnp->dn_attr = attr;
676 }
677
678 void
dt_node_type_assign(dt_node_t * dnp,ctf_file_t * fp,ctf_id_t type,boolean_t user)679 dt_node_type_assign(dt_node_t *dnp, ctf_file_t *fp, ctf_id_t type,
680 boolean_t user)
681 {
682 ctf_id_t base = ctf_type_resolve(fp, type);
683 uint_t kind = ctf_type_kind(fp, base);
684 ctf_encoding_t e;
685
686 dnp->dn_flags &=
687 ~(DT_NF_SIGNED | DT_NF_REF | DT_NF_BITFIELD | DT_NF_USERLAND);
688
689 if (kind == CTF_K_INTEGER && ctf_type_encoding(fp, base, &e) == 0) {
690 size_t size = e.cte_bits / NBBY;
691
692 if (size > 8 || (e.cte_bits % NBBY) != 0 || (size & (size - 1)))
693 dnp->dn_flags |= DT_NF_BITFIELD;
694
695 if (e.cte_format & CTF_INT_SIGNED)
696 dnp->dn_flags |= DT_NF_SIGNED;
697 }
698
699 if (kind == CTF_K_FLOAT && ctf_type_encoding(fp, base, &e) == 0) {
700 if (e.cte_bits / NBBY > sizeof (uint64_t))
701 dnp->dn_flags |= DT_NF_REF;
702 }
703
704 if (kind == CTF_K_STRUCT || kind == CTF_K_UNION ||
705 kind == CTF_K_FORWARD ||
706 kind == CTF_K_ARRAY || kind == CTF_K_FUNCTION)
707 dnp->dn_flags |= DT_NF_REF;
708 else if (yypcb != NULL && fp == DT_DYN_CTFP(yypcb->pcb_hdl) &&
709 type == DT_DYN_TYPE(yypcb->pcb_hdl))
710 dnp->dn_flags |= DT_NF_REF;
711
712 if (user)
713 dnp->dn_flags |= DT_NF_USERLAND;
714
715 dnp->dn_flags |= DT_NF_COOKED;
716 dnp->dn_ctfp = fp;
717 dnp->dn_type = type;
718 }
719
720 void
dt_node_type_propagate(const dt_node_t * src,dt_node_t * dst)721 dt_node_type_propagate(const dt_node_t *src, dt_node_t *dst)
722 {
723 assert(src->dn_flags & DT_NF_COOKED);
724 dst->dn_flags = src->dn_flags & ~DT_NF_LVALUE;
725 dst->dn_ctfp = src->dn_ctfp;
726 dst->dn_type = src->dn_type;
727 }
728
729 const char *
dt_node_type_name(const dt_node_t * dnp,char * buf,size_t len)730 dt_node_type_name(const dt_node_t *dnp, char *buf, size_t len)
731 {
732 if (dt_node_is_dynamic(dnp) && dnp->dn_ident != NULL) {
733 (void) snprintf(buf, len, "%s",
734 dt_idkind_name(dt_ident_resolve(dnp->dn_ident)->di_kind));
735 return (buf);
736 }
737
738 if (dnp->dn_flags & DT_NF_USERLAND) {
739 size_t n = snprintf(buf, len, "userland ");
740 len = len > n ? len - n : 0;
741 (void) dt_type_name(dnp->dn_ctfp, dnp->dn_type, buf + n, len);
742 return (buf);
743 }
744
745 return (dt_type_name(dnp->dn_ctfp, dnp->dn_type, buf, len));
746 }
747
748 size_t
dt_node_type_size(const dt_node_t * dnp)749 dt_node_type_size(const dt_node_t *dnp)
750 {
751 ctf_id_t base;
752 dtrace_hdl_t *dtp = yypcb->pcb_hdl;
753
754 if (dnp->dn_kind == DT_NODE_STRING)
755 return (strlen(dnp->dn_string) + 1);
756
757 if (dt_node_is_dynamic(dnp) && dnp->dn_ident != NULL)
758 return (dt_ident_size(dnp->dn_ident));
759
760 base = ctf_type_resolve(dnp->dn_ctfp, dnp->dn_type);
761
762 if (ctf_type_kind(dnp->dn_ctfp, base) == CTF_K_FORWARD)
763 return (0);
764
765 /*
766 * Here we have a 32-bit user pointer that is being used with a 64-bit
767 * kernel. When we're using it and its tagged as a userland reference --
768 * then we need to keep it as a 32-bit pointer. However, if we are
769 * referring to it as a kernel address, eg. being used after a copyin()
770 * then we need to make sure that we actually return the kernel's size
771 * of a pointer, 8 bytes.
772 */
773 if (ctf_type_kind(dnp->dn_ctfp, base) == CTF_K_POINTER &&
774 ctf_getmodel(dnp->dn_ctfp) == CTF_MODEL_ILP32 &&
775 !(dnp->dn_flags & DT_NF_USERLAND) &&
776 dtp->dt_conf.dtc_ctfmodel == CTF_MODEL_LP64)
777 return (8);
778
779 return (ctf_type_size(dnp->dn_ctfp, dnp->dn_type));
780 }
781
782 /*
783 * Determine if the specified parse tree node references an identifier of the
784 * specified kind, and if so return a pointer to it; otherwise return NULL.
785 * This function resolves the identifier itself, following through any inlines.
786 */
787 dt_ident_t *
dt_node_resolve(const dt_node_t * dnp,uint_t idkind)788 dt_node_resolve(const dt_node_t *dnp, uint_t idkind)
789 {
790 dt_ident_t *idp;
791
792 switch (dnp->dn_kind) {
793 case DT_NODE_VAR:
794 case DT_NODE_SYM:
795 case DT_NODE_FUNC:
796 case DT_NODE_AGG:
797 case DT_NODE_INLINE:
798 case DT_NODE_PROBE:
799 idp = dt_ident_resolve(dnp->dn_ident);
800 return (idp->di_kind == idkind ? idp : NULL);
801 }
802
803 if (dt_node_is_dynamic(dnp)) {
804 idp = dt_ident_resolve(dnp->dn_ident);
805 return (idp->di_kind == idkind ? idp : NULL);
806 }
807
808 return (NULL);
809 }
810
811 size_t
dt_node_sizeof(const dt_node_t * dnp)812 dt_node_sizeof(const dt_node_t *dnp)
813 {
814 dtrace_syminfo_t *sip;
815 GElf_Sym sym;
816 dtrace_hdl_t *dtp = yypcb->pcb_hdl;
817
818 /*
819 * The size of the node as used for the sizeof() operator depends on
820 * the kind of the node. If the node is a SYM, the size is obtained
821 * from the symbol table; if it is not a SYM, the size is determined
822 * from the node's type. This is slightly different from C's sizeof()
823 * operator in that (for example) when applied to a function, sizeof()
824 * will evaluate to the length of the function rather than the size of
825 * the function type.
826 */
827 if (dnp->dn_kind != DT_NODE_SYM)
828 return (dt_node_type_size(dnp));
829
830 sip = dnp->dn_ident->di_data;
831
832 if (dtrace_lookup_by_name(dtp, sip->dts_object,
833 sip->dts_name, &sym, NULL) == -1)
834 return (0);
835
836 return (sym.st_size);
837 }
838
839 int
dt_node_is_integer(const dt_node_t * dnp)840 dt_node_is_integer(const dt_node_t *dnp)
841 {
842 ctf_file_t *fp = dnp->dn_ctfp;
843 ctf_encoding_t e;
844 ctf_id_t type;
845 uint_t kind;
846
847 assert(dnp->dn_flags & DT_NF_COOKED);
848
849 type = ctf_type_resolve(fp, dnp->dn_type);
850 kind = ctf_type_kind(fp, type);
851
852 if (kind == CTF_K_INTEGER &&
853 ctf_type_encoding(fp, type, &e) == 0 && IS_VOID(e))
854 return (0); /* void integer */
855
856 return (kind == CTF_K_INTEGER || kind == CTF_K_ENUM);
857 }
858
859 int
dt_node_is_float(const dt_node_t * dnp)860 dt_node_is_float(const dt_node_t *dnp)
861 {
862 ctf_file_t *fp = dnp->dn_ctfp;
863 ctf_encoding_t e;
864 ctf_id_t type;
865 uint_t kind;
866
867 assert(dnp->dn_flags & DT_NF_COOKED);
868
869 type = ctf_type_resolve(fp, dnp->dn_type);
870 kind = ctf_type_kind(fp, type);
871
872 return (kind == CTF_K_FLOAT &&
873 ctf_type_encoding(dnp->dn_ctfp, type, &e) == 0 && (
874 e.cte_format == CTF_FP_SINGLE || e.cte_format == CTF_FP_DOUBLE ||
875 e.cte_format == CTF_FP_LDOUBLE));
876 }
877
878 int
dt_node_is_scalar(const dt_node_t * dnp)879 dt_node_is_scalar(const dt_node_t *dnp)
880 {
881 ctf_file_t *fp = dnp->dn_ctfp;
882 ctf_encoding_t e;
883 ctf_id_t type;
884 uint_t kind;
885
886 assert(dnp->dn_flags & DT_NF_COOKED);
887
888 type = ctf_type_resolve(fp, dnp->dn_type);
889 kind = ctf_type_kind(fp, type);
890
891 if (kind == CTF_K_INTEGER &&
892 ctf_type_encoding(fp, type, &e) == 0 && IS_VOID(e))
893 return (0); /* void cannot be used as a scalar */
894
895 return (kind == CTF_K_INTEGER || kind == CTF_K_ENUM ||
896 kind == CTF_K_POINTER);
897 }
898
899 int
dt_node_is_arith(const dt_node_t * dnp)900 dt_node_is_arith(const dt_node_t *dnp)
901 {
902 ctf_file_t *fp = dnp->dn_ctfp;
903 ctf_encoding_t e;
904 ctf_id_t type;
905 uint_t kind;
906
907 assert(dnp->dn_flags & DT_NF_COOKED);
908
909 type = ctf_type_resolve(fp, dnp->dn_type);
910 kind = ctf_type_kind(fp, type);
911
912 if (kind == CTF_K_INTEGER)
913 return (ctf_type_encoding(fp, type, &e) == 0 && !IS_VOID(e));
914 else
915 return (kind == CTF_K_ENUM);
916 }
917
918 int
dt_node_is_vfptr(const dt_node_t * dnp)919 dt_node_is_vfptr(const dt_node_t *dnp)
920 {
921 ctf_file_t *fp = dnp->dn_ctfp;
922 ctf_encoding_t e;
923 ctf_id_t type;
924 uint_t kind;
925
926 assert(dnp->dn_flags & DT_NF_COOKED);
927
928 type = ctf_type_resolve(fp, dnp->dn_type);
929 if (ctf_type_kind(fp, type) != CTF_K_POINTER)
930 return (0); /* type is not a pointer */
931
932 type = ctf_type_resolve(fp, ctf_type_reference(fp, type));
933 kind = ctf_type_kind(fp, type);
934
935 return (kind == CTF_K_FUNCTION || (kind == CTF_K_INTEGER &&
936 ctf_type_encoding(fp, type, &e) == 0 && IS_VOID(e)));
937 }
938
939 int
dt_node_is_dynamic(const dt_node_t * dnp)940 dt_node_is_dynamic(const dt_node_t *dnp)
941 {
942 if (dnp->dn_kind == DT_NODE_VAR &&
943 (dnp->dn_ident->di_flags & DT_IDFLG_INLINE)) {
944 const dt_idnode_t *inp = dnp->dn_ident->di_iarg;
945 return (inp->din_root ? dt_node_is_dynamic(inp->din_root) : 0);
946 }
947
948 return (dnp->dn_ctfp == DT_DYN_CTFP(yypcb->pcb_hdl) &&
949 dnp->dn_type == DT_DYN_TYPE(yypcb->pcb_hdl));
950 }
951
952 int
dt_node_is_string(const dt_node_t * dnp)953 dt_node_is_string(const dt_node_t *dnp)
954 {
955 return (dnp->dn_ctfp == DT_STR_CTFP(yypcb->pcb_hdl) &&
956 dnp->dn_type == DT_STR_TYPE(yypcb->pcb_hdl));
957 }
958
959 int
dt_node_is_stack(const dt_node_t * dnp)960 dt_node_is_stack(const dt_node_t *dnp)
961 {
962 return (dnp->dn_ctfp == DT_STACK_CTFP(yypcb->pcb_hdl) &&
963 dnp->dn_type == DT_STACK_TYPE(yypcb->pcb_hdl));
964 }
965
966 int
dt_node_is_symaddr(const dt_node_t * dnp)967 dt_node_is_symaddr(const dt_node_t *dnp)
968 {
969 return (dnp->dn_ctfp == DT_SYMADDR_CTFP(yypcb->pcb_hdl) &&
970 dnp->dn_type == DT_SYMADDR_TYPE(yypcb->pcb_hdl));
971 }
972
973 int
dt_node_is_usymaddr(const dt_node_t * dnp)974 dt_node_is_usymaddr(const dt_node_t *dnp)
975 {
976 return (dnp->dn_ctfp == DT_USYMADDR_CTFP(yypcb->pcb_hdl) &&
977 dnp->dn_type == DT_USYMADDR_TYPE(yypcb->pcb_hdl));
978 }
979
980 int
dt_node_is_strcompat(const dt_node_t * dnp)981 dt_node_is_strcompat(const dt_node_t *dnp)
982 {
983 ctf_file_t *fp = dnp->dn_ctfp;
984 ctf_encoding_t e;
985 ctf_arinfo_t r;
986 ctf_id_t base;
987 uint_t kind;
988
989 assert(dnp->dn_flags & DT_NF_COOKED);
990
991 base = ctf_type_resolve(fp, dnp->dn_type);
992 kind = ctf_type_kind(fp, base);
993
994 if (kind == CTF_K_POINTER &&
995 (base = ctf_type_reference(fp, base)) != CTF_ERR &&
996 (base = ctf_type_resolve(fp, base)) != CTF_ERR &&
997 ctf_type_encoding(fp, base, &e) == 0 && IS_CHAR(e))
998 return (1); /* promote char pointer to string */
999
1000 if (kind == CTF_K_ARRAY && ctf_array_info(fp, base, &r) == 0 &&
1001 (base = ctf_type_resolve(fp, r.ctr_contents)) != CTF_ERR &&
1002 ctf_type_encoding(fp, base, &e) == 0 && IS_CHAR(e))
1003 return (1); /* promote char array to string */
1004
1005 return (0);
1006 }
1007
1008 int
dt_node_is_pointer(const dt_node_t * dnp)1009 dt_node_is_pointer(const dt_node_t *dnp)
1010 {
1011 ctf_file_t *fp = dnp->dn_ctfp;
1012 uint_t kind;
1013
1014 assert(dnp->dn_flags & DT_NF_COOKED);
1015
1016 if (dt_node_is_string(dnp))
1017 return (0); /* string are pass-by-ref but act like structs */
1018
1019 kind = ctf_type_kind(fp, ctf_type_resolve(fp, dnp->dn_type));
1020 return (kind == CTF_K_POINTER || kind == CTF_K_ARRAY);
1021 }
1022
1023 int
dt_node_is_void(const dt_node_t * dnp)1024 dt_node_is_void(const dt_node_t *dnp)
1025 {
1026 ctf_file_t *fp = dnp->dn_ctfp;
1027 ctf_encoding_t e;
1028 ctf_id_t type;
1029
1030 if (dt_node_is_dynamic(dnp))
1031 return (0); /* <DYN> is an alias for void but not the same */
1032
1033 if (dt_node_is_stack(dnp))
1034 return (0);
1035
1036 if (dt_node_is_symaddr(dnp) || dt_node_is_usymaddr(dnp))
1037 return (0);
1038
1039 type = ctf_type_resolve(fp, dnp->dn_type);
1040
1041 return (ctf_type_kind(fp, type) == CTF_K_INTEGER &&
1042 ctf_type_encoding(fp, type, &e) == 0 && IS_VOID(e));
1043 }
1044
1045 int
dt_node_is_ptrcompat(const dt_node_t * lp,const dt_node_t * rp,ctf_file_t ** fpp,ctf_id_t * tp)1046 dt_node_is_ptrcompat(const dt_node_t *lp, const dt_node_t *rp,
1047 ctf_file_t **fpp, ctf_id_t *tp)
1048 {
1049 ctf_file_t *lfp = lp->dn_ctfp;
1050 ctf_file_t *rfp = rp->dn_ctfp;
1051
1052 ctf_id_t lbase = CTF_ERR, rbase = CTF_ERR;
1053 ctf_id_t lref = CTF_ERR, rref = CTF_ERR;
1054
1055 int lp_is_void, rp_is_void, lp_is_int, rp_is_int, compat;
1056 uint_t lkind, rkind;
1057 ctf_encoding_t e;
1058 ctf_arinfo_t r;
1059
1060 assert(lp->dn_flags & DT_NF_COOKED);
1061 assert(rp->dn_flags & DT_NF_COOKED);
1062
1063 if (dt_node_is_dynamic(lp) || dt_node_is_dynamic(rp))
1064 return (0); /* fail if either node is a dynamic variable */
1065
1066 lp_is_int = dt_node_is_integer(lp);
1067 rp_is_int = dt_node_is_integer(rp);
1068
1069 if (lp_is_int && rp_is_int)
1070 return (0); /* fail if both nodes are integers */
1071
1072 if (lp_is_int && (lp->dn_kind != DT_NODE_INT || lp->dn_value != 0))
1073 return (0); /* fail if lp is an integer that isn't 0 constant */
1074
1075 if (rp_is_int && (rp->dn_kind != DT_NODE_INT || rp->dn_value != 0))
1076 return (0); /* fail if rp is an integer that isn't 0 constant */
1077
1078 if ((lp_is_int == 0 && rp_is_int == 0) && (
1079 (lp->dn_flags & DT_NF_USERLAND) ^ (rp->dn_flags & DT_NF_USERLAND)))
1080 return (0); /* fail if only one pointer is a userland address */
1081
1082 /*
1083 * Resolve the left-hand and right-hand types to their base type, and
1084 * then resolve the referenced type as well (assuming the base type
1085 * is CTF_K_POINTER or CTF_K_ARRAY). Otherwise [lr]ref = CTF_ERR.
1086 */
1087 if (!lp_is_int) {
1088 lbase = ctf_type_resolve(lfp, lp->dn_type);
1089 lkind = ctf_type_kind(lfp, lbase);
1090
1091 if (lkind == CTF_K_POINTER) {
1092 lref = ctf_type_resolve(lfp,
1093 ctf_type_reference(lfp, lbase));
1094 } else if (lkind == CTF_K_ARRAY &&
1095 ctf_array_info(lfp, lbase, &r) == 0) {
1096 lref = ctf_type_resolve(lfp, r.ctr_contents);
1097 }
1098 }
1099
1100 if (!rp_is_int) {
1101 rbase = ctf_type_resolve(rfp, rp->dn_type);
1102 rkind = ctf_type_kind(rfp, rbase);
1103
1104 if (rkind == CTF_K_POINTER) {
1105 rref = ctf_type_resolve(rfp,
1106 ctf_type_reference(rfp, rbase));
1107 } else if (rkind == CTF_K_ARRAY &&
1108 ctf_array_info(rfp, rbase, &r) == 0) {
1109 rref = ctf_type_resolve(rfp, r.ctr_contents);
1110 }
1111 }
1112
1113 /*
1114 * We know that one or the other type may still be a zero-valued
1115 * integer constant. To simplify the code below, set the integer
1116 * type variables equal to the non-integer types and proceed.
1117 */
1118 if (lp_is_int) {
1119 lbase = rbase;
1120 lkind = rkind;
1121 lref = rref;
1122 lfp = rfp;
1123 } else if (rp_is_int) {
1124 rbase = lbase;
1125 rkind = lkind;
1126 rref = lref;
1127 rfp = lfp;
1128 }
1129
1130 lp_is_void = ctf_type_encoding(lfp, lref, &e) == 0 && IS_VOID(e);
1131 rp_is_void = ctf_type_encoding(rfp, rref, &e) == 0 && IS_VOID(e);
1132
1133 /*
1134 * Let a pointer to a forward declaration be compatible with a pointer
1135 * to a struct or union of the same name.
1136 */
1137 if (lkind == CTF_K_POINTER && rkind == CTF_K_POINTER) {
1138 int lrkind, rrkind;
1139
1140 lrkind = ctf_type_kind(lfp, lref);
1141 rrkind = ctf_type_kind(rfp, rref);
1142 if (lrkind == CTF_K_FORWARD || rrkind == CTF_K_FORWARD) {
1143 const char *lname, *rname;
1144 char ln[DT_TYPE_NAMELEN], rn[DT_TYPE_NAMELEN];
1145
1146 lname = ctf_type_name(lfp, lref, ln, sizeof (ln));
1147 rname = ctf_type_name(rfp, rref, rn, sizeof (rn));
1148 if (lname != NULL && rname != NULL &&
1149 strcmp(lname, rname) == 0) {
1150 lp_is_void = lrkind == CTF_K_FORWARD;
1151 rp_is_void = rrkind == CTF_K_FORWARD;
1152 }
1153 }
1154 }
1155
1156 /*
1157 * The types are compatible if both are pointers to the same type, or
1158 * if either pointer is a void pointer. If they are compatible, set
1159 * tp to point to the more specific pointer type and return it.
1160 */
1161 compat = (lkind == CTF_K_POINTER || lkind == CTF_K_ARRAY) &&
1162 (rkind == CTF_K_POINTER || rkind == CTF_K_ARRAY) &&
1163 (lp_is_void || rp_is_void || ctf_type_compat(lfp, lref, rfp, rref));
1164
1165 if (compat) {
1166 if (fpp != NULL)
1167 *fpp = rp_is_void ? lfp : rfp;
1168 if (tp != NULL)
1169 *tp = rp_is_void ? lbase : rbase;
1170 }
1171
1172 return (compat);
1173 }
1174
1175 /*
1176 * The rules for checking argument types against parameter types are described
1177 * in the ANSI-C spec (see K&R[A7.3.2] and K&R[A7.17]). We use the same rule
1178 * set to determine whether associative array arguments match the prototype.
1179 */
1180 int
dt_node_is_argcompat(const dt_node_t * lp,const dt_node_t * rp)1181 dt_node_is_argcompat(const dt_node_t *lp, const dt_node_t *rp)
1182 {
1183 ctf_file_t *lfp = lp->dn_ctfp;
1184 ctf_file_t *rfp = rp->dn_ctfp;
1185
1186 assert(lp->dn_flags & DT_NF_COOKED);
1187 assert(rp->dn_flags & DT_NF_COOKED);
1188
1189 if (dt_node_is_integer(lp) && dt_node_is_integer(rp))
1190 return (1); /* integer types are compatible */
1191
1192 if (dt_node_is_strcompat(lp) && dt_node_is_strcompat(rp))
1193 return (1); /* string types are compatible */
1194
1195 if (dt_node_is_stack(lp) && dt_node_is_stack(rp))
1196 return (1); /* stack types are compatible */
1197
1198 if (dt_node_is_symaddr(lp) && dt_node_is_symaddr(rp))
1199 return (1); /* symaddr types are compatible */
1200
1201 if (dt_node_is_usymaddr(lp) && dt_node_is_usymaddr(rp))
1202 return (1); /* usymaddr types are compatible */
1203
1204 switch (ctf_type_kind(lfp, ctf_type_resolve(lfp, lp->dn_type))) {
1205 case CTF_K_FUNCTION:
1206 case CTF_K_STRUCT:
1207 case CTF_K_UNION:
1208 return (ctf_type_compat(lfp, lp->dn_type, rfp, rp->dn_type));
1209 default:
1210 return (dt_node_is_ptrcompat(lp, rp, NULL, NULL));
1211 }
1212 }
1213
1214 /*
1215 * We provide dt_node_is_posconst() as a convenience routine for callers who
1216 * wish to verify that an argument is a positive non-zero integer constant.
1217 */
1218 int
dt_node_is_posconst(const dt_node_t * dnp)1219 dt_node_is_posconst(const dt_node_t *dnp)
1220 {
1221 return (dnp->dn_kind == DT_NODE_INT && dnp->dn_value != 0 && (
1222 (dnp->dn_flags & DT_NF_SIGNED) == 0 || (int64_t)dnp->dn_value > 0));
1223 }
1224
1225 int
dt_node_is_actfunc(const dt_node_t * dnp)1226 dt_node_is_actfunc(const dt_node_t *dnp)
1227 {
1228 return (dnp->dn_kind == DT_NODE_FUNC &&
1229 dnp->dn_ident->di_kind == DT_IDENT_ACTFUNC);
1230 }
1231
1232 /*
1233 * The original rules for integer constant typing are described in K&R[A2.5.1].
1234 * However, since we support long long, we instead use the rules from ISO C99
1235 * clause 6.4.4.1 since that is where long longs are formally described. The
1236 * rules require us to know whether the constant was specified in decimal or
1237 * in octal or hex, which we do by looking at our lexer's 'yyintdecimal' flag.
1238 * The type of an integer constant is the first of the corresponding list in
1239 * which its value can be represented:
1240 *
1241 * unsuffixed decimal: int, long, long long
1242 * unsuffixed oct/hex: int, unsigned int, long, unsigned long,
1243 * long long, unsigned long long
1244 * suffix [uU]: unsigned int, unsigned long, unsigned long long
1245 * suffix [lL] decimal: long, long long
1246 * suffix [lL] oct/hex: long, unsigned long, long long, unsigned long long
1247 * suffix [uU][Ll]: unsigned long, unsigned long long
1248 * suffix ll/LL decimal: long long
1249 * suffix ll/LL oct/hex: long long, unsigned long long
1250 * suffix [uU][ll/LL]: unsigned long long
1251 *
1252 * Given that our lexer has already validated the suffixes by regexp matching,
1253 * there is an obvious way to concisely encode these rules: construct an array
1254 * of the types in the order int, unsigned int, long, unsigned long, long long,
1255 * unsigned long long. Compute an integer array starting index based on the
1256 * suffix (e.g. none = 0, u = 1, ull = 5), and compute an increment based on
1257 * the specifier (dec/oct/hex) and suffix (u). Then iterate from the starting
1258 * index to the end, advancing using the increment, and searching until we
1259 * find a limit that matches or we run out of choices (overflow). To make it
1260 * even faster, we precompute the table of type information in dtrace_open().
1261 */
1262 dt_node_t *
dt_node_int(uintmax_t value)1263 dt_node_int(uintmax_t value)
1264 {
1265 dt_node_t *dnp = dt_node_alloc(DT_NODE_INT);
1266 dtrace_hdl_t *dtp = yypcb->pcb_hdl;
1267
1268 int n = (yyintdecimal | (yyintsuffix[0] == 'u')) + 1;
1269 int i = 0;
1270
1271 const char *p;
1272 char c;
1273
1274 dnp->dn_op = DT_TOK_INT;
1275 dnp->dn_value = value;
1276
1277 for (p = yyintsuffix; (c = *p) != '\0'; p++) {
1278 if (c == 'U' || c == 'u')
1279 i += 1;
1280 else if (c == 'L' || c == 'l')
1281 i += 2;
1282 }
1283
1284 for (; i < sizeof (dtp->dt_ints) / sizeof (dtp->dt_ints[0]); i += n) {
1285 if (value <= dtp->dt_ints[i].did_limit) {
1286 dt_node_type_assign(dnp,
1287 dtp->dt_ints[i].did_ctfp,
1288 dtp->dt_ints[i].did_type, B_FALSE);
1289
1290 /*
1291 * If a prefix character is present in macro text, add
1292 * in the corresponding operator node (see dt_lex.l).
1293 */
1294 switch (yyintprefix) {
1295 case '+':
1296 return (dt_node_op1(DT_TOK_IPOS, dnp));
1297 case '-':
1298 return (dt_node_op1(DT_TOK_INEG, dnp));
1299 default:
1300 return (dnp);
1301 }
1302 }
1303 }
1304
1305 xyerror(D_INT_OFLOW, "integer constant 0x%llx cannot be represented "
1306 "in any built-in integral type\n", (u_longlong_t)value);
1307 /*NOTREACHED*/
1308 return (NULL); /* keep gcc happy */
1309 }
1310
1311 dt_node_t *
dt_node_string(char * string)1312 dt_node_string(char *string)
1313 {
1314 dtrace_hdl_t *dtp = yypcb->pcb_hdl;
1315 dt_node_t *dnp;
1316
1317 if (string == NULL)
1318 longjmp(yypcb->pcb_jmpbuf, EDT_NOMEM);
1319
1320 dnp = dt_node_alloc(DT_NODE_STRING);
1321 dnp->dn_op = DT_TOK_STRING;
1322 dnp->dn_string = string;
1323 dt_node_type_assign(dnp, DT_STR_CTFP(dtp), DT_STR_TYPE(dtp), B_FALSE);
1324
1325 return (dnp);
1326 }
1327
1328 dt_node_t *
dt_node_ident(char * name)1329 dt_node_ident(char *name)
1330 {
1331 dt_ident_t *idp;
1332 dt_node_t *dnp;
1333
1334 if (name == NULL)
1335 longjmp(yypcb->pcb_jmpbuf, EDT_NOMEM);
1336
1337 /*
1338 * If the identifier is an inlined integer constant, then create an INT
1339 * node that is a clone of the inline parse tree node and return that
1340 * immediately, allowing this inline to be used in parsing contexts
1341 * that require constant expressions (e.g. scalar array sizes).
1342 */
1343 if ((idp = dt_idstack_lookup(&yypcb->pcb_globals, name)) != NULL &&
1344 (idp->di_flags & DT_IDFLG_INLINE)) {
1345 dt_idnode_t *inp = idp->di_iarg;
1346
1347 if (inp->din_root != NULL &&
1348 inp->din_root->dn_kind == DT_NODE_INT) {
1349 free(name);
1350
1351 dnp = dt_node_alloc(DT_NODE_INT);
1352 dnp->dn_op = DT_TOK_INT;
1353 dnp->dn_value = inp->din_root->dn_value;
1354 dt_node_type_propagate(inp->din_root, dnp);
1355
1356 return (dnp);
1357 }
1358 }
1359
1360 dnp = dt_node_alloc(DT_NODE_IDENT);
1361 dnp->dn_op = name[0] == '@' ? DT_TOK_AGG : DT_TOK_IDENT;
1362 dnp->dn_string = name;
1363
1364 return (dnp);
1365 }
1366
1367 /*
1368 * Create an empty node of type corresponding to the given declaration.
1369 * Explicit references to user types (C or D) are assigned the default
1370 * stability; references to other types are _dtrace_typattr (Private).
1371 */
1372 dt_node_t *
dt_node_type(dt_decl_t * ddp)1373 dt_node_type(dt_decl_t *ddp)
1374 {
1375 dtrace_hdl_t *dtp = yypcb->pcb_hdl;
1376 dtrace_typeinfo_t dtt;
1377 dt_node_t *dnp;
1378 char *name = NULL;
1379 int err;
1380
1381 /*
1382 * If 'ddp' is NULL, we get a decl by popping the decl stack. This
1383 * form of dt_node_type() is used by parameter rules in dt_grammar.y.
1384 */
1385 if (ddp == NULL)
1386 ddp = dt_decl_pop_param(&name);
1387
1388 err = dt_decl_type(ddp, &dtt);
1389 dt_decl_free(ddp);
1390
1391 if (err != 0) {
1392 free(name);
1393 longjmp(yypcb->pcb_jmpbuf, EDT_COMPILER);
1394 }
1395
1396 dnp = dt_node_alloc(DT_NODE_TYPE);
1397 dnp->dn_op = DT_TOK_IDENT;
1398 dnp->dn_string = name;
1399
1400 dt_node_type_assign(dnp, dtt.dtt_ctfp, dtt.dtt_type, dtt.dtt_flags);
1401
1402 if (dtt.dtt_ctfp == dtp->dt_cdefs->dm_ctfp ||
1403 dtt.dtt_ctfp == dtp->dt_ddefs->dm_ctfp)
1404 dt_node_attr_assign(dnp, _dtrace_defattr);
1405 else
1406 dt_node_attr_assign(dnp, _dtrace_typattr);
1407
1408 return (dnp);
1409 }
1410
1411 /*
1412 * Create a type node corresponding to a varargs (...) parameter by just
1413 * assigning it type CTF_ERR. The decl processing code will handle this.
1414 */
1415 dt_node_t *
dt_node_vatype(void)1416 dt_node_vatype(void)
1417 {
1418 dt_node_t *dnp = dt_node_alloc(DT_NODE_TYPE);
1419
1420 dnp->dn_op = DT_TOK_IDENT;
1421 dnp->dn_ctfp = yypcb->pcb_hdl->dt_cdefs->dm_ctfp;
1422 dnp->dn_type = CTF_ERR;
1423 dnp->dn_attr = _dtrace_defattr;
1424
1425 return (dnp);
1426 }
1427
1428 /*
1429 * Instantiate a decl using the contents of the current declaration stack. As
1430 * we do not currently permit decls to be initialized, this function currently
1431 * returns NULL and no parse node is created. When this function is called,
1432 * the topmost scope's ds_ident pointer will be set to NULL (indicating no
1433 * init_declarator rule was matched) or will point to the identifier to use.
1434 */
1435 dt_node_t *
dt_node_decl(void)1436 dt_node_decl(void)
1437 {
1438 dtrace_hdl_t *dtp = yypcb->pcb_hdl;
1439 dt_scope_t *dsp = &yypcb->pcb_dstack;
1440 dt_dclass_t class = dsp->ds_class;
1441 dt_decl_t *ddp = dt_decl_top();
1442
1443 dt_module_t *dmp;
1444 dtrace_typeinfo_t dtt;
1445 ctf_id_t type;
1446
1447 char n1[DT_TYPE_NAMELEN];
1448 char n2[DT_TYPE_NAMELEN];
1449
1450 if (dt_decl_type(ddp, &dtt) != 0)
1451 longjmp(yypcb->pcb_jmpbuf, EDT_COMPILER);
1452
1453 /*
1454 * If we have no declaration identifier, then this is either a spurious
1455 * declaration of an intrinsic type (e.g. "extern int;") or declaration
1456 * or redeclaration of a struct, union, or enum type or tag.
1457 */
1458 if (dsp->ds_ident == NULL) {
1459 if (ddp->dd_kind != CTF_K_STRUCT &&
1460 ddp->dd_kind != CTF_K_UNION && ddp->dd_kind != CTF_K_ENUM)
1461 xyerror(D_DECL_USELESS, "useless declaration\n");
1462
1463 dt_dprintf("type %s added as id %ld\n", dt_type_name(
1464 ddp->dd_ctfp, ddp->dd_type, n1, sizeof (n1)), ddp->dd_type);
1465
1466 return (NULL);
1467 }
1468
1469 if (strchr(dsp->ds_ident, '`') != NULL) {
1470 xyerror(D_DECL_SCOPE, "D scoping operator may not be used in "
1471 "a declaration name (%s)\n", dsp->ds_ident);
1472 }
1473
1474 /*
1475 * If we are nested inside of a C include file, add the declaration to
1476 * the C definition module; otherwise use the D definition module.
1477 */
1478 if (yypcb->pcb_idepth != 0)
1479 dmp = dtp->dt_cdefs;
1480 else
1481 dmp = dtp->dt_ddefs;
1482
1483 /*
1484 * If we see a global or static declaration of a function prototype,
1485 * treat this as equivalent to a D extern declaration.
1486 */
1487 if (ctf_type_kind(dtt.dtt_ctfp, dtt.dtt_type) == CTF_K_FUNCTION &&
1488 (class == DT_DC_DEFAULT || class == DT_DC_STATIC))
1489 class = DT_DC_EXTERN;
1490
1491 switch (class) {
1492 case DT_DC_AUTO:
1493 case DT_DC_REGISTER:
1494 case DT_DC_STATIC:
1495 xyerror(D_DECL_BADCLASS, "specified storage class not "
1496 "appropriate in D\n");
1497 /*NOTREACHED*/
1498
1499 case DT_DC_EXTERN: {
1500 dtrace_typeinfo_t ott;
1501 dtrace_syminfo_t dts;
1502 GElf_Sym sym;
1503
1504 int exists = dtrace_lookup_by_name(dtp,
1505 dmp->dm_name, dsp->ds_ident, &sym, &dts) == 0;
1506
1507 if (exists && (dtrace_symbol_type(dtp, &sym, &dts, &ott) != 0 ||
1508 ctf_type_cmp(dtt.dtt_ctfp, dtt.dtt_type,
1509 ott.dtt_ctfp, ott.dtt_type) != 0)) {
1510 xyerror(D_DECL_IDRED, "identifier redeclared: %s`%s\n"
1511 "\t current: %s\n\tprevious: %s\n",
1512 dmp->dm_name, dsp->ds_ident,
1513 dt_type_name(dtt.dtt_ctfp, dtt.dtt_type,
1514 n1, sizeof (n1)),
1515 dt_type_name(ott.dtt_ctfp, ott.dtt_type,
1516 n2, sizeof (n2)));
1517 } else if (!exists && dt_module_extern(dtp, dmp,
1518 dsp->ds_ident, &dtt) == NULL) {
1519 xyerror(D_UNKNOWN,
1520 "failed to extern %s: %s\n", dsp->ds_ident,
1521 dtrace_errmsg(dtp, dtrace_errno(dtp)));
1522 } else {
1523 dt_dprintf("extern %s`%s type=<%s>\n",
1524 dmp->dm_name, dsp->ds_ident,
1525 dt_type_name(dtt.dtt_ctfp, dtt.dtt_type,
1526 n1, sizeof (n1)));
1527 }
1528 break;
1529 }
1530
1531 case DT_DC_TYPEDEF:
1532 if (dt_idstack_lookup(&yypcb->pcb_globals, dsp->ds_ident)) {
1533 xyerror(D_DECL_IDRED, "global variable identifier "
1534 "redeclared: %s\n", dsp->ds_ident);
1535 }
1536
1537 if (ctf_lookup_by_name(dmp->dm_ctfp,
1538 dsp->ds_ident) != CTF_ERR) {
1539 xyerror(D_DECL_IDRED,
1540 "typedef redeclared: %s\n", dsp->ds_ident);
1541 }
1542
1543 /*
1544 * If the source type for the typedef is not defined in the
1545 * target container or its parent, copy the type to the target
1546 * container and reset dtt_ctfp and dtt_type to the copy.
1547 */
1548 if (dtt.dtt_ctfp != dmp->dm_ctfp &&
1549 dtt.dtt_ctfp != ctf_parent_file(dmp->dm_ctfp)) {
1550
1551 dtt.dtt_type = ctf_add_type(dmp->dm_ctfp,
1552 dtt.dtt_ctfp, dtt.dtt_type);
1553 dtt.dtt_ctfp = dmp->dm_ctfp;
1554
1555 if (dtt.dtt_type == CTF_ERR ||
1556 ctf_update(dtt.dtt_ctfp) == CTF_ERR) {
1557 xyerror(D_UNKNOWN, "failed to copy typedef %s "
1558 "source type: %s\n", dsp->ds_ident,
1559 ctf_errmsg(ctf_errno(dtt.dtt_ctfp)));
1560 }
1561 }
1562
1563 type = ctf_add_typedef(dmp->dm_ctfp,
1564 CTF_ADD_ROOT, dsp->ds_ident, dtt.dtt_type);
1565
1566 if (type == CTF_ERR || ctf_update(dmp->dm_ctfp) == CTF_ERR) {
1567 xyerror(D_UNKNOWN, "failed to typedef %s: %s\n",
1568 dsp->ds_ident, ctf_errmsg(ctf_errno(dmp->dm_ctfp)));
1569 }
1570
1571 dt_dprintf("typedef %s added as id %ld\n", dsp->ds_ident, type);
1572 break;
1573
1574 default: {
1575 ctf_encoding_t cte;
1576 dt_idhash_t *dhp;
1577 dt_ident_t *idp;
1578 dt_node_t idn;
1579 int assc, idkind;
1580 uint_t id, kind;
1581 ushort_t idflags;
1582
1583 switch (class) {
1584 case DT_DC_THIS:
1585 dhp = yypcb->pcb_locals;
1586 idflags = DT_IDFLG_LOCAL;
1587 idp = dt_idhash_lookup(dhp, dsp->ds_ident);
1588 break;
1589 case DT_DC_SELF:
1590 dhp = dtp->dt_tls;
1591 idflags = DT_IDFLG_TLS;
1592 idp = dt_idhash_lookup(dhp, dsp->ds_ident);
1593 break;
1594 default:
1595 dhp = dtp->dt_globals;
1596 idflags = 0;
1597 idp = dt_idstack_lookup(
1598 &yypcb->pcb_globals, dsp->ds_ident);
1599 break;
1600 }
1601
1602 if (ddp->dd_kind == CTF_K_ARRAY && ddp->dd_node == NULL) {
1603 xyerror(D_DECL_ARRNULL,
1604 "array declaration requires array dimension or "
1605 "tuple signature: %s\n", dsp->ds_ident);
1606 }
1607
1608 if (idp != NULL && idp->di_gen == 0) {
1609 xyerror(D_DECL_IDRED, "built-in identifier "
1610 "redeclared: %s\n", idp->di_name);
1611 }
1612
1613 if (dtrace_lookup_by_type(dtp, DTRACE_OBJ_CDEFS,
1614 dsp->ds_ident, NULL) == 0 ||
1615 dtrace_lookup_by_type(dtp, DTRACE_OBJ_DDEFS,
1616 dsp->ds_ident, NULL) == 0) {
1617 xyerror(D_DECL_IDRED, "typedef identifier "
1618 "redeclared: %s\n", dsp->ds_ident);
1619 }
1620
1621 /*
1622 * Cache some attributes of the decl to make the rest of this
1623 * code simpler: if the decl is an array which is subscripted
1624 * by a type rather than an integer, then it's an associative
1625 * array (assc). We then expect to match either DT_IDENT_ARRAY
1626 * for associative arrays or DT_IDENT_SCALAR for anything else.
1627 */
1628 assc = ddp->dd_kind == CTF_K_ARRAY &&
1629 ddp->dd_node->dn_kind == DT_NODE_TYPE;
1630
1631 idkind = assc ? DT_IDENT_ARRAY : DT_IDENT_SCALAR;
1632
1633 /*
1634 * Create a fake dt_node_t on the stack so we can determine the
1635 * type of any matching identifier by assigning to this node.
1636 * If the pre-existing ident has its di_type set, propagate
1637 * the type by hand so as not to trigger a prototype check for
1638 * arrays (yet); otherwise we use dt_ident_cook() on the ident
1639 * to ensure it is fully initialized before looking at it.
1640 */
1641 bzero(&idn, sizeof (dt_node_t));
1642
1643 if (idp != NULL && idp->di_type != CTF_ERR)
1644 dt_node_type_assign(&idn, idp->di_ctfp, idp->di_type,
1645 B_FALSE);
1646 else if (idp != NULL)
1647 (void) dt_ident_cook(&idn, idp, NULL);
1648
1649 if (assc) {
1650 if (class == DT_DC_THIS) {
1651 xyerror(D_DECL_LOCASSC, "associative arrays "
1652 "may not be declared as local variables:"
1653 " %s\n", dsp->ds_ident);
1654 }
1655
1656 if (dt_decl_type(ddp->dd_next, &dtt) != 0)
1657 longjmp(yypcb->pcb_jmpbuf, EDT_COMPILER);
1658 }
1659
1660 if (idp != NULL && (idp->di_kind != idkind ||
1661 ctf_type_cmp(dtt.dtt_ctfp, dtt.dtt_type,
1662 idn.dn_ctfp, idn.dn_type) != 0)) {
1663 xyerror(D_DECL_IDRED, "identifier redeclared: %s\n"
1664 "\t current: %s %s\n\tprevious: %s %s\n",
1665 dsp->ds_ident, dt_idkind_name(idkind),
1666 dt_type_name(dtt.dtt_ctfp,
1667 dtt.dtt_type, n1, sizeof (n1)),
1668 dt_idkind_name(idp->di_kind),
1669 dt_node_type_name(&idn, n2, sizeof (n2)));
1670
1671 } else if (idp != NULL && assc) {
1672 const dt_idsig_t *isp = idp->di_data;
1673 dt_node_t *dnp = ddp->dd_node;
1674 int argc = 0;
1675
1676 for (; dnp != NULL; dnp = dnp->dn_list, argc++) {
1677 const dt_node_t *pnp = &isp->dis_args[argc];
1678
1679 if (argc >= isp->dis_argc)
1680 continue; /* tuple length mismatch */
1681
1682 if (ctf_type_cmp(dnp->dn_ctfp, dnp->dn_type,
1683 pnp->dn_ctfp, pnp->dn_type) == 0)
1684 continue;
1685
1686 xyerror(D_DECL_IDRED,
1687 "identifier redeclared: %s\n"
1688 "\t current: %s, key #%d of type %s\n"
1689 "\tprevious: %s, key #%d of type %s\n",
1690 dsp->ds_ident,
1691 dt_idkind_name(idkind), argc + 1,
1692 dt_node_type_name(dnp, n1, sizeof (n1)),
1693 dt_idkind_name(idp->di_kind), argc + 1,
1694 dt_node_type_name(pnp, n2, sizeof (n2)));
1695 }
1696
1697 if (isp->dis_argc != argc) {
1698 xyerror(D_DECL_IDRED,
1699 "identifier redeclared: %s\n"
1700 "\t current: %s of %s, tuple length %d\n"
1701 "\tprevious: %s of %s, tuple length %d\n",
1702 dsp->ds_ident, dt_idkind_name(idkind),
1703 dt_type_name(dtt.dtt_ctfp, dtt.dtt_type,
1704 n1, sizeof (n1)), argc,
1705 dt_idkind_name(idp->di_kind),
1706 dt_node_type_name(&idn, n2, sizeof (n2)),
1707 isp->dis_argc);
1708 }
1709
1710 } else if (idp == NULL) {
1711 type = ctf_type_resolve(dtt.dtt_ctfp, dtt.dtt_type);
1712 kind = ctf_type_kind(dtt.dtt_ctfp, type);
1713
1714 switch (kind) {
1715 case CTF_K_INTEGER:
1716 if (ctf_type_encoding(dtt.dtt_ctfp, type,
1717 &cte) == 0 && IS_VOID(cte)) {
1718 xyerror(D_DECL_VOIDOBJ, "cannot have "
1719 "void object: %s\n", dsp->ds_ident);
1720 }
1721 break;
1722 case CTF_K_STRUCT:
1723 case CTF_K_UNION:
1724 if (ctf_type_size(dtt.dtt_ctfp, type) != 0)
1725 break; /* proceed to declaring */
1726 /*FALLTHRU*/
1727 case CTF_K_FORWARD:
1728 xyerror(D_DECL_INCOMPLETE,
1729 "incomplete struct/union/enum %s: %s\n",
1730 dt_type_name(dtt.dtt_ctfp, dtt.dtt_type,
1731 n1, sizeof (n1)), dsp->ds_ident);
1732 /*NOTREACHED*/
1733 }
1734
1735 if (dt_idhash_nextid(dhp, &id) == -1) {
1736 xyerror(D_ID_OFLOW, "cannot create %s: limit "
1737 "on number of %s variables exceeded\n",
1738 dsp->ds_ident, dt_idhash_name(dhp));
1739 }
1740
1741 dt_dprintf("declare %s %s variable %s, id=%u\n",
1742 dt_idhash_name(dhp), dt_idkind_name(idkind),
1743 dsp->ds_ident, id);
1744
1745 idp = dt_idhash_insert(dhp, dsp->ds_ident, idkind,
1746 idflags | DT_IDFLG_WRITE | DT_IDFLG_DECL, id,
1747 _dtrace_defattr, 0, assc ? &dt_idops_assc :
1748 &dt_idops_thaw, NULL, dtp->dt_gen);
1749
1750 if (idp == NULL)
1751 longjmp(yypcb->pcb_jmpbuf, EDT_NOMEM);
1752
1753 dt_ident_type_assign(idp, dtt.dtt_ctfp, dtt.dtt_type);
1754
1755 /*
1756 * If we are declaring an associative array, use our
1757 * fake parse node to cook the new assoc identifier.
1758 * This will force the ident code to instantiate the
1759 * array type signature corresponding to the list of
1760 * types pointed to by ddp->dd_node. We also reset
1761 * the identifier's attributes based upon the result.
1762 */
1763 if (assc) {
1764 idp->di_attr =
1765 dt_ident_cook(&idn, idp, &ddp->dd_node);
1766 }
1767 }
1768 }
1769
1770 } /* end of switch */
1771
1772 free(dsp->ds_ident);
1773 dsp->ds_ident = NULL;
1774
1775 return (NULL);
1776 }
1777
1778 dt_node_t *
dt_node_func(dt_node_t * dnp,dt_node_t * args)1779 dt_node_func(dt_node_t *dnp, dt_node_t *args)
1780 {
1781 dt_ident_t *idp;
1782
1783 if (dnp->dn_kind != DT_NODE_IDENT) {
1784 xyerror(D_FUNC_IDENT,
1785 "function designator is not of function type\n");
1786 }
1787
1788 idp = dt_idstack_lookup(&yypcb->pcb_globals, dnp->dn_string);
1789
1790 if (idp == NULL) {
1791 xyerror(D_FUNC_UNDEF,
1792 "undefined function name: %s\n", dnp->dn_string);
1793 }
1794
1795 if (idp->di_kind != DT_IDENT_FUNC &&
1796 idp->di_kind != DT_IDENT_AGGFUNC &&
1797 idp->di_kind != DT_IDENT_ACTFUNC) {
1798 xyerror(D_FUNC_IDKIND, "%s '%s' may not be referenced as a "
1799 "function\n", dt_idkind_name(idp->di_kind), idp->di_name);
1800 }
1801
1802 free(dnp->dn_string);
1803 dnp->dn_string = NULL;
1804
1805 dnp->dn_kind = DT_NODE_FUNC;
1806 dnp->dn_flags &= ~DT_NF_COOKED;
1807 dnp->dn_ident = idp;
1808 dnp->dn_args = args;
1809 dnp->dn_list = NULL;
1810
1811 return (dnp);
1812 }
1813
1814 /*
1815 * The offsetof() function is special because it takes a type name as an
1816 * argument. It does not actually construct its own node; after looking up the
1817 * structure or union offset, we just return an integer node with the offset.
1818 */
1819 dt_node_t *
dt_node_offsetof(dt_decl_t * ddp,char * s)1820 dt_node_offsetof(dt_decl_t *ddp, char *s)
1821 {
1822 dtrace_typeinfo_t dtt;
1823 dt_node_t dn;
1824 char *name;
1825 int err;
1826
1827 ctf_membinfo_t ctm;
1828 ctf_id_t type;
1829 uint_t kind;
1830
1831 name = alloca(strlen(s) + 1);
1832 (void) strcpy(name, s);
1833 free(s);
1834
1835 err = dt_decl_type(ddp, &dtt);
1836 dt_decl_free(ddp);
1837
1838 if (err != 0)
1839 longjmp(yypcb->pcb_jmpbuf, EDT_COMPILER);
1840
1841 type = ctf_type_resolve(dtt.dtt_ctfp, dtt.dtt_type);
1842 kind = ctf_type_kind(dtt.dtt_ctfp, type);
1843
1844 if (kind != CTF_K_STRUCT && kind != CTF_K_UNION) {
1845 xyerror(D_OFFSETOF_TYPE,
1846 "offsetof operand must be a struct or union type\n");
1847 }
1848
1849 if (ctf_member_info(dtt.dtt_ctfp, type, name, &ctm) == CTF_ERR) {
1850 xyerror(D_UNKNOWN, "failed to determine offset of %s: %s\n",
1851 name, ctf_errmsg(ctf_errno(dtt.dtt_ctfp)));
1852 }
1853
1854 bzero(&dn, sizeof (dn));
1855 dt_node_type_assign(&dn, dtt.dtt_ctfp, ctm.ctm_type, B_FALSE);
1856
1857 if (dn.dn_flags & DT_NF_BITFIELD) {
1858 xyerror(D_OFFSETOF_BITFIELD,
1859 "cannot take offset of a bit-field: %s\n", name);
1860 }
1861
1862 return (dt_node_int(ctm.ctm_offset / NBBY));
1863 }
1864
1865 dt_node_t *
dt_node_op1(int op,dt_node_t * cp)1866 dt_node_op1(int op, dt_node_t *cp)
1867 {
1868 dt_node_t *dnp;
1869
1870 if (cp->dn_kind == DT_NODE_INT) {
1871 switch (op) {
1872 case DT_TOK_INEG:
1873 /*
1874 * If we're negating an unsigned integer, zero out any
1875 * extra top bits to truncate the value to the size of
1876 * the effective type determined by dt_node_int().
1877 */
1878 cp->dn_value = -cp->dn_value;
1879 if (!(cp->dn_flags & DT_NF_SIGNED)) {
1880 cp->dn_value &= ~0ULL >>
1881 (64 - dt_node_type_size(cp) * NBBY);
1882 }
1883 /*FALLTHRU*/
1884 case DT_TOK_IPOS:
1885 return (cp);
1886 case DT_TOK_BNEG:
1887 cp->dn_value = ~cp->dn_value;
1888 return (cp);
1889 case DT_TOK_LNEG:
1890 cp->dn_value = !cp->dn_value;
1891 return (cp);
1892 }
1893 }
1894
1895 /*
1896 * If sizeof is applied to a type_name or string constant, we can
1897 * transform 'cp' into an integer constant in the node construction
1898 * pass so that it can then be used for arithmetic in this pass.
1899 */
1900 if (op == DT_TOK_SIZEOF &&
1901 (cp->dn_kind == DT_NODE_STRING || cp->dn_kind == DT_NODE_TYPE)) {
1902 dtrace_hdl_t *dtp = yypcb->pcb_hdl;
1903 size_t size = dt_node_type_size(cp);
1904
1905 if (size == 0) {
1906 xyerror(D_SIZEOF_TYPE, "cannot apply sizeof to an "
1907 "operand of unknown size\n");
1908 }
1909
1910 dt_node_type_assign(cp, dtp->dt_ddefs->dm_ctfp,
1911 ctf_lookup_by_name(dtp->dt_ddefs->dm_ctfp, "size_t"),
1912 B_FALSE);
1913
1914 cp->dn_kind = DT_NODE_INT;
1915 cp->dn_op = DT_TOK_INT;
1916 cp->dn_value = size;
1917
1918 return (cp);
1919 }
1920
1921 /*
1922 * When applying the addressof operator to an identifier, it's okay if
1923 * we can't find type information for the identifier, so flag the node
1924 * to ensure that we don't raise an error.
1925 */
1926 if (op == DT_TOK_ADDROF && cp->dn_kind == DT_NODE_IDENT)
1927 cp->dn_flags |= DT_NF_IDENTADDR;
1928
1929 dnp = dt_node_alloc(DT_NODE_OP1);
1930 assert(op <= USHRT_MAX);
1931 dnp->dn_op = (ushort_t)op;
1932 dnp->dn_child = cp;
1933
1934 return (dnp);
1935 }
1936
1937 /*
1938 * If an integer constant is being cast to another integer type, we can
1939 * perform the cast as part of integer constant folding in this pass. We must
1940 * take action when the integer is being cast to a smaller type or if it is
1941 * changing signed-ness. If so, we first shift rp's bits bits high (losing
1942 * excess bits if narrowing) and then shift them down with either a logical
1943 * shift (unsigned) or arithmetic shift (signed).
1944 */
1945 static void
dt_cast(dt_node_t * lp,dt_node_t * rp)1946 dt_cast(dt_node_t *lp, dt_node_t *rp)
1947 {
1948 size_t srcsize = dt_node_type_size(rp);
1949 size_t dstsize = dt_node_type_size(lp);
1950
1951 if (dstsize < srcsize) {
1952 int n = (sizeof (uint64_t) - dstsize) * NBBY;
1953 rp->dn_value <<= n;
1954 rp->dn_value >>= n;
1955 } else if (dstsize > srcsize) {
1956 int n = (sizeof (uint64_t) - srcsize) * NBBY;
1957 int s = (dstsize - srcsize) * NBBY;
1958
1959 rp->dn_value <<= n;
1960 if (rp->dn_flags & DT_NF_SIGNED) {
1961 rp->dn_value = (intmax_t)rp->dn_value >> s;
1962 rp->dn_value >>= n - s;
1963 } else {
1964 rp->dn_value >>= n;
1965 }
1966 }
1967 }
1968
1969 dt_node_t *
dt_node_op2(int op,dt_node_t * lp,dt_node_t * rp)1970 dt_node_op2(int op, dt_node_t *lp, dt_node_t *rp)
1971 {
1972 dtrace_hdl_t *dtp = yypcb->pcb_hdl;
1973 dt_node_t *dnp;
1974
1975 /*
1976 * First we check for operations that are illegal -- namely those that
1977 * might result in integer division by zero, and abort if one is found.
1978 */
1979 if (rp->dn_kind == DT_NODE_INT && rp->dn_value == 0 &&
1980 (op == DT_TOK_MOD || op == DT_TOK_DIV ||
1981 op == DT_TOK_MOD_EQ || op == DT_TOK_DIV_EQ))
1982 xyerror(D_DIV_ZERO, "expression contains division by zero\n");
1983
1984 /*
1985 * If both children are immediate values, we can just perform inline
1986 * calculation and return a new immediate node with the result.
1987 */
1988 if (lp->dn_kind == DT_NODE_INT && rp->dn_kind == DT_NODE_INT) {
1989 uintmax_t l = lp->dn_value;
1990 uintmax_t r = rp->dn_value;
1991
1992 dnp = dt_node_int(0); /* allocate new integer node for result */
1993
1994 switch (op) {
1995 case DT_TOK_LOR:
1996 dnp->dn_value = l || r;
1997 dt_node_type_assign(dnp,
1998 DT_INT_CTFP(dtp), DT_INT_TYPE(dtp), B_FALSE);
1999 break;
2000 case DT_TOK_LXOR:
2001 dnp->dn_value = (l != 0) ^ (r != 0);
2002 dt_node_type_assign(dnp,
2003 DT_INT_CTFP(dtp), DT_INT_TYPE(dtp), B_FALSE);
2004 break;
2005 case DT_TOK_LAND:
2006 dnp->dn_value = l && r;
2007 dt_node_type_assign(dnp,
2008 DT_INT_CTFP(dtp), DT_INT_TYPE(dtp), B_FALSE);
2009 break;
2010 case DT_TOK_BOR:
2011 dnp->dn_value = l | r;
2012 dt_node_promote(lp, rp, dnp);
2013 break;
2014 case DT_TOK_XOR:
2015 dnp->dn_value = l ^ r;
2016 dt_node_promote(lp, rp, dnp);
2017 break;
2018 case DT_TOK_BAND:
2019 dnp->dn_value = l & r;
2020 dt_node_promote(lp, rp, dnp);
2021 break;
2022 case DT_TOK_EQU:
2023 dnp->dn_value = l == r;
2024 dt_node_type_assign(dnp,
2025 DT_INT_CTFP(dtp), DT_INT_TYPE(dtp), B_FALSE);
2026 break;
2027 case DT_TOK_NEQ:
2028 dnp->dn_value = l != r;
2029 dt_node_type_assign(dnp,
2030 DT_INT_CTFP(dtp), DT_INT_TYPE(dtp), B_FALSE);
2031 break;
2032 case DT_TOK_LT:
2033 dt_node_promote(lp, rp, dnp);
2034 if (dnp->dn_flags & DT_NF_SIGNED)
2035 dnp->dn_value = (intmax_t)l < (intmax_t)r;
2036 else
2037 dnp->dn_value = l < r;
2038 dt_node_type_assign(dnp,
2039 DT_INT_CTFP(dtp), DT_INT_TYPE(dtp), B_FALSE);
2040 break;
2041 case DT_TOK_LE:
2042 dt_node_promote(lp, rp, dnp);
2043 if (dnp->dn_flags & DT_NF_SIGNED)
2044 dnp->dn_value = (intmax_t)l <= (intmax_t)r;
2045 else
2046 dnp->dn_value = l <= r;
2047 dt_node_type_assign(dnp,
2048 DT_INT_CTFP(dtp), DT_INT_TYPE(dtp), B_FALSE);
2049 break;
2050 case DT_TOK_GT:
2051 dt_node_promote(lp, rp, dnp);
2052 if (dnp->dn_flags & DT_NF_SIGNED)
2053 dnp->dn_value = (intmax_t)l > (intmax_t)r;
2054 else
2055 dnp->dn_value = l > r;
2056 dt_node_type_assign(dnp,
2057 DT_INT_CTFP(dtp), DT_INT_TYPE(dtp), B_FALSE);
2058 break;
2059 case DT_TOK_GE:
2060 dt_node_promote(lp, rp, dnp);
2061 if (dnp->dn_flags & DT_NF_SIGNED)
2062 dnp->dn_value = (intmax_t)l >= (intmax_t)r;
2063 else
2064 dnp->dn_value = l >= r;
2065 dt_node_type_assign(dnp,
2066 DT_INT_CTFP(dtp), DT_INT_TYPE(dtp), B_FALSE);
2067 break;
2068 case DT_TOK_LSH:
2069 dnp->dn_value = l << r;
2070 dt_node_type_propagate(lp, dnp);
2071 dt_node_attr_assign(rp,
2072 dt_attr_min(lp->dn_attr, rp->dn_attr));
2073 break;
2074 case DT_TOK_RSH:
2075 dnp->dn_value = l >> r;
2076 dt_node_type_propagate(lp, dnp);
2077 dt_node_attr_assign(rp,
2078 dt_attr_min(lp->dn_attr, rp->dn_attr));
2079 break;
2080 case DT_TOK_ADD:
2081 dnp->dn_value = l + r;
2082 dt_node_promote(lp, rp, dnp);
2083 break;
2084 case DT_TOK_SUB:
2085 dnp->dn_value = l - r;
2086 dt_node_promote(lp, rp, dnp);
2087 break;
2088 case DT_TOK_MUL:
2089 dnp->dn_value = l * r;
2090 dt_node_promote(lp, rp, dnp);
2091 break;
2092 case DT_TOK_DIV:
2093 dt_node_promote(lp, rp, dnp);
2094 if (dnp->dn_flags & DT_NF_SIGNED)
2095 dnp->dn_value = (intmax_t)l / (intmax_t)r;
2096 else
2097 dnp->dn_value = l / r;
2098 break;
2099 case DT_TOK_MOD:
2100 dt_node_promote(lp, rp, dnp);
2101 if (dnp->dn_flags & DT_NF_SIGNED)
2102 dnp->dn_value = (intmax_t)l % (intmax_t)r;
2103 else
2104 dnp->dn_value = l % r;
2105 break;
2106 default:
2107 dt_node_free(dnp);
2108 dnp = NULL;
2109 }
2110
2111 if (dnp != NULL) {
2112 dt_node_free(lp);
2113 dt_node_free(rp);
2114 return (dnp);
2115 }
2116 }
2117
2118 if (op == DT_TOK_LPAR && rp->dn_kind == DT_NODE_INT &&
2119 dt_node_is_integer(lp)) {
2120 dt_cast(lp, rp);
2121 dt_node_type_propagate(lp, rp);
2122 dt_node_attr_assign(rp, dt_attr_min(lp->dn_attr, rp->dn_attr));
2123 dt_node_free(lp);
2124
2125 return (rp);
2126 }
2127
2128 /*
2129 * If no immediate optimizations are available, create an new OP2 node
2130 * and glue the left and right children into place and return.
2131 */
2132 dnp = dt_node_alloc(DT_NODE_OP2);
2133 assert(op <= USHRT_MAX);
2134 dnp->dn_op = (ushort_t)op;
2135 dnp->dn_left = lp;
2136 dnp->dn_right = rp;
2137
2138 return (dnp);
2139 }
2140
2141 dt_node_t *
dt_node_op3(dt_node_t * expr,dt_node_t * lp,dt_node_t * rp)2142 dt_node_op3(dt_node_t *expr, dt_node_t *lp, dt_node_t *rp)
2143 {
2144 dt_node_t *dnp;
2145
2146 if (expr->dn_kind == DT_NODE_INT)
2147 return (expr->dn_value != 0 ? lp : rp);
2148
2149 dnp = dt_node_alloc(DT_NODE_OP3);
2150 dnp->dn_op = DT_TOK_QUESTION;
2151 dnp->dn_expr = expr;
2152 dnp->dn_left = lp;
2153 dnp->dn_right = rp;
2154
2155 return (dnp);
2156 }
2157
2158 dt_node_t *
dt_node_statement(dt_node_t * expr)2159 dt_node_statement(dt_node_t *expr)
2160 {
2161 dt_node_t *dnp;
2162
2163 if (expr->dn_kind == DT_NODE_AGG)
2164 return (expr);
2165
2166 if (expr->dn_kind == DT_NODE_FUNC &&
2167 expr->dn_ident->di_kind == DT_IDENT_ACTFUNC)
2168 dnp = dt_node_alloc(DT_NODE_DFUNC);
2169 else
2170 dnp = dt_node_alloc(DT_NODE_DEXPR);
2171
2172 dnp->dn_expr = expr;
2173 return (dnp);
2174 }
2175
2176 dt_node_t *
dt_node_if(dt_node_t * pred,dt_node_t * acts,dt_node_t * else_acts)2177 dt_node_if(dt_node_t *pred, dt_node_t *acts, dt_node_t *else_acts)
2178 {
2179 dt_node_t *dnp = dt_node_alloc(DT_NODE_IF);
2180 dnp->dn_conditional = pred;
2181 dnp->dn_body = acts;
2182 dnp->dn_alternate_body = else_acts;
2183
2184 return (dnp);
2185 }
2186
2187 dt_node_t *
dt_node_pdesc_by_name(char * spec)2188 dt_node_pdesc_by_name(char *spec)
2189 {
2190 dtrace_hdl_t *dtp = yypcb->pcb_hdl;
2191 dt_node_t *dnp;
2192
2193 if (spec == NULL)
2194 longjmp(yypcb->pcb_jmpbuf, EDT_NOMEM);
2195
2196 dnp = dt_node_alloc(DT_NODE_PDESC);
2197 dnp->dn_spec = spec;
2198 dnp->dn_desc = malloc(sizeof (dtrace_probedesc_t));
2199
2200 if (dnp->dn_desc == NULL)
2201 longjmp(yypcb->pcb_jmpbuf, EDT_NOMEM);
2202
2203 if (dtrace_xstr2desc(dtp, yypcb->pcb_pspec, dnp->dn_spec,
2204 yypcb->pcb_sargc, yypcb->pcb_sargv, dnp->dn_desc) != 0) {
2205 xyerror(D_PDESC_INVAL, "invalid probe description \"%s\": %s\n",
2206 dnp->dn_spec, dtrace_errmsg(dtp, dtrace_errno(dtp)));
2207 }
2208
2209 free(dnp->dn_spec);
2210 dnp->dn_spec = NULL;
2211
2212 return (dnp);
2213 }
2214
2215 dt_node_t *
dt_node_pdesc_by_id(uintmax_t id)2216 dt_node_pdesc_by_id(uintmax_t id)
2217 {
2218 static const char *const names[] = {
2219 "providers", "modules", "functions"
2220 };
2221
2222 dtrace_hdl_t *dtp = yypcb->pcb_hdl;
2223 dt_node_t *dnp = dt_node_alloc(DT_NODE_PDESC);
2224
2225 if ((dnp->dn_desc = malloc(sizeof (dtrace_probedesc_t))) == NULL)
2226 longjmp(yypcb->pcb_jmpbuf, EDT_NOMEM);
2227
2228 if (id > UINT_MAX) {
2229 xyerror(D_PDESC_INVAL, "identifier %llu exceeds maximum "
2230 "probe id\n", (u_longlong_t)id);
2231 }
2232
2233 if (yypcb->pcb_pspec != DTRACE_PROBESPEC_NAME) {
2234 xyerror(D_PDESC_INVAL, "probe identifier %llu not permitted "
2235 "when specifying %s\n", (u_longlong_t)id,
2236 names[yypcb->pcb_pspec]);
2237 }
2238
2239 if (dtrace_id2desc(dtp, (dtrace_id_t)id, dnp->dn_desc) != 0) {
2240 xyerror(D_PDESC_INVAL, "invalid probe identifier %llu: %s\n",
2241 (u_longlong_t)id, dtrace_errmsg(dtp, dtrace_errno(dtp)));
2242 }
2243
2244 return (dnp);
2245 }
2246
2247 dt_node_t *
dt_node_clause(dt_node_t * pdescs,dt_node_t * pred,dt_node_t * acts)2248 dt_node_clause(dt_node_t *pdescs, dt_node_t *pred, dt_node_t *acts)
2249 {
2250 dt_node_t *dnp = dt_node_alloc(DT_NODE_CLAUSE);
2251
2252 dnp->dn_pdescs = pdescs;
2253 dnp->dn_pred = pred;
2254 dnp->dn_acts = acts;
2255
2256 return (dnp);
2257 }
2258
2259 dt_node_t *
dt_node_inline(dt_node_t * expr)2260 dt_node_inline(dt_node_t *expr)
2261 {
2262 dtrace_hdl_t *dtp = yypcb->pcb_hdl;
2263 dt_scope_t *dsp = &yypcb->pcb_dstack;
2264 dt_decl_t *ddp = dt_decl_top();
2265
2266 char n[DT_TYPE_NAMELEN];
2267 dtrace_typeinfo_t dtt;
2268
2269 dt_ident_t *idp, *rdp;
2270 dt_idnode_t *inp;
2271 dt_node_t *dnp;
2272
2273 if (dt_decl_type(ddp, &dtt) != 0)
2274 longjmp(yypcb->pcb_jmpbuf, EDT_COMPILER);
2275
2276 if (dsp->ds_class != DT_DC_DEFAULT) {
2277 xyerror(D_DECL_BADCLASS, "specified storage class not "
2278 "appropriate for inline declaration\n");
2279 }
2280
2281 if (dsp->ds_ident == NULL)
2282 xyerror(D_DECL_USELESS, "inline declaration requires a name\n");
2283
2284 if ((idp = dt_idstack_lookup(
2285 &yypcb->pcb_globals, dsp->ds_ident)) != NULL) {
2286 xyerror(D_DECL_IDRED, "identifier redefined: %s\n\t current: "
2287 "inline definition\n\tprevious: %s %s\n",
2288 idp->di_name, dt_idkind_name(idp->di_kind),
2289 (idp->di_flags & DT_IDFLG_INLINE) ? "inline" : "");
2290 }
2291
2292 /*
2293 * If we are declaring an inlined array, verify that we have a tuple
2294 * signature, and then recompute 'dtt' as the array's value type.
2295 */
2296 if (ddp->dd_kind == CTF_K_ARRAY) {
2297 if (ddp->dd_node == NULL) {
2298 xyerror(D_DECL_ARRNULL, "inline declaration requires "
2299 "array tuple signature: %s\n", dsp->ds_ident);
2300 }
2301
2302 if (ddp->dd_node->dn_kind != DT_NODE_TYPE) {
2303 xyerror(D_DECL_ARRNULL, "inline declaration cannot be "
2304 "of scalar array type: %s\n", dsp->ds_ident);
2305 }
2306
2307 if (dt_decl_type(ddp->dd_next, &dtt) != 0)
2308 longjmp(yypcb->pcb_jmpbuf, EDT_COMPILER);
2309 }
2310
2311 /*
2312 * If the inline identifier is not defined, then create it with the
2313 * orphan flag set. We do not insert the identifier into dt_globals
2314 * until we have successfully cooked the right-hand expression, below.
2315 */
2316 dnp = dt_node_alloc(DT_NODE_INLINE);
2317 dt_node_type_assign(dnp, dtt.dtt_ctfp, dtt.dtt_type, B_FALSE);
2318 dt_node_attr_assign(dnp, _dtrace_defattr);
2319
2320 if (dt_node_is_void(dnp)) {
2321 xyerror(D_DECL_VOIDOBJ,
2322 "cannot declare void inline: %s\n", dsp->ds_ident);
2323 }
2324
2325 if (ctf_type_kind(dnp->dn_ctfp, ctf_type_resolve(
2326 dnp->dn_ctfp, dnp->dn_type)) == CTF_K_FORWARD) {
2327 xyerror(D_DECL_INCOMPLETE,
2328 "incomplete struct/union/enum %s: %s\n",
2329 dt_node_type_name(dnp, n, sizeof (n)), dsp->ds_ident);
2330 }
2331
2332 if ((inp = malloc(sizeof (dt_idnode_t))) == NULL)
2333 longjmp(yypcb->pcb_jmpbuf, EDT_NOMEM);
2334
2335 bzero(inp, sizeof (dt_idnode_t));
2336
2337 idp = dnp->dn_ident = dt_ident_create(dsp->ds_ident,
2338 ddp->dd_kind == CTF_K_ARRAY ? DT_IDENT_ARRAY : DT_IDENT_SCALAR,
2339 DT_IDFLG_INLINE | DT_IDFLG_REF | DT_IDFLG_DECL | DT_IDFLG_ORPHAN, 0,
2340 _dtrace_defattr, 0, &dt_idops_inline, inp, dtp->dt_gen);
2341
2342 if (idp == NULL) {
2343 free(inp);
2344 longjmp(yypcb->pcb_jmpbuf, EDT_NOMEM);
2345 }
2346
2347 /*
2348 * If we're inlining an associative array, create a private identifier
2349 * hash containing the named parameters and store it in inp->din_hash.
2350 * We then push this hash on to the top of the pcb_globals stack.
2351 */
2352 if (ddp->dd_kind == CTF_K_ARRAY) {
2353 dt_idnode_t *pinp;
2354 dt_ident_t *pidp;
2355 dt_node_t *pnp;
2356 uint_t i = 0;
2357
2358 for (pnp = ddp->dd_node; pnp != NULL; pnp = pnp->dn_list)
2359 i++; /* count up parameters for din_argv[] */
2360
2361 inp->din_hash = dt_idhash_create("inline args", NULL, 0, 0);
2362 inp->din_argv = calloc(i, sizeof (dt_ident_t *));
2363
2364 if (inp->din_hash == NULL || inp->din_argv == NULL)
2365 longjmp(yypcb->pcb_jmpbuf, EDT_NOMEM);
2366
2367 /*
2368 * Create an identifier for each parameter as a scalar inline,
2369 * and store it in din_hash and in position in din_argv[]. The
2370 * parameter identifiers also use dt_idops_inline, but we leave
2371 * the dt_idnode_t argument 'pinp' zeroed. This will be filled
2372 * in by the code generation pass with references to the args.
2373 */
2374 for (i = 0, pnp = ddp->dd_node;
2375 pnp != NULL; pnp = pnp->dn_list, i++) {
2376
2377 if (pnp->dn_string == NULL)
2378 continue; /* ignore anonymous parameters */
2379
2380 if ((pinp = malloc(sizeof (dt_idnode_t))) == NULL)
2381 longjmp(yypcb->pcb_jmpbuf, EDT_NOMEM);
2382
2383 pidp = dt_idhash_insert(inp->din_hash, pnp->dn_string,
2384 DT_IDENT_SCALAR, DT_IDFLG_DECL | DT_IDFLG_INLINE, 0,
2385 _dtrace_defattr, 0, &dt_idops_inline,
2386 pinp, dtp->dt_gen);
2387
2388 if (pidp == NULL) {
2389 free(pinp);
2390 longjmp(yypcb->pcb_jmpbuf, EDT_NOMEM);
2391 }
2392
2393 inp->din_argv[i] = pidp;
2394 bzero(pinp, sizeof (dt_idnode_t));
2395 dt_ident_type_assign(pidp, pnp->dn_ctfp, pnp->dn_type);
2396 }
2397
2398 dt_idstack_push(&yypcb->pcb_globals, inp->din_hash);
2399 }
2400
2401 /*
2402 * Unlike most constructors, we need to explicitly cook the right-hand
2403 * side of the inline definition immediately to prevent recursion. If
2404 * the right-hand side uses the inline itself, the cook will fail.
2405 */
2406 expr = dt_node_cook(expr, DT_IDFLG_REF);
2407
2408 if (ddp->dd_kind == CTF_K_ARRAY)
2409 dt_idstack_pop(&yypcb->pcb_globals, inp->din_hash);
2410
2411 /*
2412 * Set the type, attributes, and flags for the inline. If the right-
2413 * hand expression has an identifier, propagate its flags. Then cook
2414 * the identifier to fully initialize it: if we're declaring an inline
2415 * associative array this will construct a type signature from 'ddp'.
2416 */
2417 if (dt_node_is_dynamic(expr))
2418 rdp = dt_ident_resolve(expr->dn_ident);
2419 else if (expr->dn_kind == DT_NODE_VAR || expr->dn_kind == DT_NODE_SYM)
2420 rdp = expr->dn_ident;
2421 else
2422 rdp = NULL;
2423
2424 if (rdp != NULL) {
2425 idp->di_flags |= (rdp->di_flags &
2426 (DT_IDFLG_WRITE | DT_IDFLG_USER | DT_IDFLG_PRIM));
2427 }
2428
2429 idp->di_attr = dt_attr_min(_dtrace_defattr, expr->dn_attr);
2430 dt_ident_type_assign(idp, dtt.dtt_ctfp, dtt.dtt_type);
2431 (void) dt_ident_cook(dnp, idp, &ddp->dd_node);
2432
2433 /*
2434 * Store the parse tree nodes for 'expr' inside of idp->di_data ('inp')
2435 * so that they will be preserved with this identifier. Then pop the
2436 * inline declaration from the declaration stack and restore the lexer.
2437 */
2438 inp->din_list = yypcb->pcb_list;
2439 inp->din_root = expr;
2440
2441 dt_decl_free(dt_decl_pop());
2442 yybegin(YYS_CLAUSE);
2443
2444 /*
2445 * Finally, insert the inline identifier into dt_globals to make it
2446 * visible, and then cook 'dnp' to check its type against 'expr'.
2447 */
2448 dt_idhash_xinsert(dtp->dt_globals, idp);
2449 return (dt_node_cook(dnp, DT_IDFLG_REF));
2450 }
2451
2452 dt_node_t *
dt_node_member(dt_decl_t * ddp,char * name,dt_node_t * expr)2453 dt_node_member(dt_decl_t *ddp, char *name, dt_node_t *expr)
2454 {
2455 dtrace_typeinfo_t dtt;
2456 dt_node_t *dnp;
2457 int err;
2458
2459 if (ddp != NULL) {
2460 err = dt_decl_type(ddp, &dtt);
2461 dt_decl_free(ddp);
2462
2463 if (err != 0)
2464 longjmp(yypcb->pcb_jmpbuf, EDT_COMPILER);
2465 }
2466
2467 dnp = dt_node_alloc(DT_NODE_MEMBER);
2468 dnp->dn_membname = name;
2469 dnp->dn_membexpr = expr;
2470
2471 if (ddp != NULL)
2472 dt_node_type_assign(dnp, dtt.dtt_ctfp, dtt.dtt_type,
2473 dtt.dtt_flags);
2474
2475 return (dnp);
2476 }
2477
2478 dt_node_t *
dt_node_xlator(dt_decl_t * ddp,dt_decl_t * sdp,char * name,dt_node_t * members)2479 dt_node_xlator(dt_decl_t *ddp, dt_decl_t *sdp, char *name, dt_node_t *members)
2480 {
2481 dtrace_hdl_t *dtp = yypcb->pcb_hdl;
2482 dtrace_typeinfo_t src, dst;
2483 dt_node_t sn, dn;
2484 dt_xlator_t *dxp;
2485 dt_node_t *dnp;
2486 int edst, esrc;
2487 uint_t kind;
2488
2489 char n1[DT_TYPE_NAMELEN];
2490 char n2[DT_TYPE_NAMELEN];
2491
2492 edst = dt_decl_type(ddp, &dst);
2493 dt_decl_free(ddp);
2494
2495 esrc = dt_decl_type(sdp, &src);
2496 dt_decl_free(sdp);
2497
2498 if (edst != 0 || esrc != 0) {
2499 free(name);
2500 longjmp(yypcb->pcb_jmpbuf, EDT_COMPILER);
2501 }
2502
2503 bzero(&sn, sizeof (sn));
2504 dt_node_type_assign(&sn, src.dtt_ctfp, src.dtt_type, B_FALSE);
2505
2506 bzero(&dn, sizeof (dn));
2507 dt_node_type_assign(&dn, dst.dtt_ctfp, dst.dtt_type, B_FALSE);
2508
2509 if (dt_xlator_lookup(dtp, &sn, &dn, DT_XLATE_EXACT) != NULL) {
2510 xyerror(D_XLATE_REDECL,
2511 "translator from %s to %s has already been declared\n",
2512 dt_node_type_name(&sn, n1, sizeof (n1)),
2513 dt_node_type_name(&dn, n2, sizeof (n2)));
2514 }
2515
2516 kind = ctf_type_kind(dst.dtt_ctfp,
2517 ctf_type_resolve(dst.dtt_ctfp, dst.dtt_type));
2518
2519 if (kind == CTF_K_FORWARD) {
2520 xyerror(D_XLATE_SOU, "incomplete struct/union/enum %s\n",
2521 dt_type_name(dst.dtt_ctfp, dst.dtt_type, n1, sizeof (n1)));
2522 }
2523
2524 if (kind != CTF_K_STRUCT && kind != CTF_K_UNION) {
2525 xyerror(D_XLATE_SOU,
2526 "translator output type must be a struct or union\n");
2527 }
2528
2529 dxp = dt_xlator_create(dtp, &src, &dst, name, members, yypcb->pcb_list);
2530 yybegin(YYS_CLAUSE);
2531 free(name);
2532
2533 if (dxp == NULL)
2534 longjmp(yypcb->pcb_jmpbuf, EDT_NOMEM);
2535
2536 dnp = dt_node_alloc(DT_NODE_XLATOR);
2537 dnp->dn_xlator = dxp;
2538 dnp->dn_members = members;
2539
2540 return (dt_node_cook(dnp, DT_IDFLG_REF));
2541 }
2542
2543 dt_node_t *
dt_node_probe(char * s,int protoc,dt_node_t * nargs,dt_node_t * xargs)2544 dt_node_probe(char *s, int protoc, dt_node_t *nargs, dt_node_t *xargs)
2545 {
2546 dtrace_hdl_t *dtp = yypcb->pcb_hdl;
2547 int nargc, xargc;
2548 dt_node_t *dnp;
2549
2550 size_t len = strlen(s) + 3; /* +3 for :: and \0 */
2551 char *name = alloca(len);
2552
2553 (void) snprintf(name, len, "::%s", s);
2554 (void) strhyphenate(name);
2555 free(s);
2556
2557 if (strchr(name, '`') != NULL) {
2558 xyerror(D_PROV_BADNAME, "probe name may not "
2559 "contain scoping operator: %s\n", name);
2560 }
2561
2562 if (strlen(name) - 2 >= DTRACE_NAMELEN) {
2563 xyerror(D_PROV_BADNAME, "probe name may not exceed %d "
2564 "characters: %s\n", DTRACE_NAMELEN - 1, name);
2565 }
2566
2567 dnp = dt_node_alloc(DT_NODE_PROBE);
2568
2569 dnp->dn_ident = dt_ident_create(name, DT_IDENT_PROBE,
2570 DT_IDFLG_ORPHAN, DTRACE_IDNONE, _dtrace_defattr, 0,
2571 &dt_idops_probe, NULL, dtp->dt_gen);
2572
2573 nargc = dt_decl_prototype(nargs, nargs,
2574 "probe input", DT_DP_VOID | DT_DP_ANON);
2575
2576 xargc = dt_decl_prototype(xargs, nargs,
2577 "probe output", DT_DP_VOID);
2578
2579 if (nargc > UINT8_MAX) {
2580 xyerror(D_PROV_PRARGLEN, "probe %s input prototype exceeds %u "
2581 "parameters: %d params used\n", name, UINT8_MAX, nargc);
2582 }
2583
2584 if (xargc > UINT8_MAX) {
2585 xyerror(D_PROV_PRARGLEN, "probe %s output prototype exceeds %u "
2586 "parameters: %d params used\n", name, UINT8_MAX, xargc);
2587 }
2588
2589 if (dnp->dn_ident == NULL || dt_probe_create(dtp,
2590 dnp->dn_ident, protoc, nargs, nargc, xargs, xargc) == NULL)
2591 longjmp(yypcb->pcb_jmpbuf, EDT_NOMEM);
2592
2593 return (dnp);
2594 }
2595
2596 dt_node_t *
dt_node_provider(char * name,dt_node_t * probes)2597 dt_node_provider(char *name, dt_node_t *probes)
2598 {
2599 dtrace_hdl_t *dtp = yypcb->pcb_hdl;
2600 dt_node_t *dnp = dt_node_alloc(DT_NODE_PROVIDER);
2601 dt_node_t *lnp;
2602 size_t len;
2603
2604 dnp->dn_provname = name;
2605 dnp->dn_probes = probes;
2606
2607 if (strchr(name, '`') != NULL) {
2608 dnerror(dnp, D_PROV_BADNAME, "provider name may not "
2609 "contain scoping operator: %s\n", name);
2610 }
2611
2612 if ((len = strlen(name)) >= DTRACE_PROVNAMELEN) {
2613 dnerror(dnp, D_PROV_BADNAME, "provider name may not exceed %d "
2614 "characters: %s\n", DTRACE_PROVNAMELEN - 1, name);
2615 }
2616
2617 if (isdigit(name[len - 1])) {
2618 dnerror(dnp, D_PROV_BADNAME, "provider name may not "
2619 "end with a digit: %s\n", name);
2620 }
2621
2622 /*
2623 * Check to see if the provider is already defined or visible through
2624 * dtrace(7D). If so, set dn_provred to treat it as a re-declaration.
2625 * If not, create a new provider and set its interface-only flag. This
2626 * flag may be cleared later by calls made to dt_probe_declare().
2627 */
2628 if ((dnp->dn_provider = dt_provider_lookup(dtp, name)) != NULL)
2629 dnp->dn_provred = B_TRUE;
2630 else if ((dnp->dn_provider = dt_provider_create(dtp, name)) == NULL)
2631 longjmp(yypcb->pcb_jmpbuf, EDT_NOMEM);
2632 else
2633 dnp->dn_provider->pv_flags |= DT_PROVIDER_INTF;
2634
2635 /*
2636 * Store all parse nodes created since we consumed the DT_KEY_PROVIDER
2637 * token with the provider and then restore our lexing state to CLAUSE.
2638 * Note that if dnp->dn_provred is true, we may end up storing dups of
2639 * a provider's interface and implementation: we eat this space because
2640 * the implementation will likely need to redeclare probe members, and
2641 * therefore may result in those member nodes becoming persistent.
2642 */
2643 for (lnp = yypcb->pcb_list; lnp->dn_link != NULL; lnp = lnp->dn_link)
2644 continue; /* skip to end of allocation list */
2645
2646 lnp->dn_link = dnp->dn_provider->pv_nodes;
2647 dnp->dn_provider->pv_nodes = yypcb->pcb_list;
2648
2649 yybegin(YYS_CLAUSE);
2650 return (dnp);
2651 }
2652
2653 dt_node_t *
dt_node_program(dt_node_t * lnp)2654 dt_node_program(dt_node_t *lnp)
2655 {
2656 dt_node_t *dnp = dt_node_alloc(DT_NODE_PROG);
2657 dnp->dn_list = lnp;
2658 return (dnp);
2659 }
2660
2661 /*
2662 * This function provides the underlying implementation of cooking an
2663 * identifier given its node, a hash of dynamic identifiers, an identifier
2664 * kind, and a boolean flag indicating whether we are allowed to instantiate
2665 * a new identifier if the string is not found. This function is either
2666 * called from dt_cook_ident(), below, or directly by the various cooking
2667 * routines that are allowed to instantiate identifiers (e.g. op2 TOK_ASGN).
2668 */
2669 static void
dt_xcook_ident(dt_node_t * dnp,dt_idhash_t * dhp,uint_t idkind,int create)2670 dt_xcook_ident(dt_node_t *dnp, dt_idhash_t *dhp, uint_t idkind, int create)
2671 {
2672 dtrace_hdl_t *dtp = yypcb->pcb_hdl;
2673 const char *sname = dt_idhash_name(dhp);
2674 int uref = 0;
2675
2676 dtrace_attribute_t attr = _dtrace_defattr;
2677 dt_ident_t *idp;
2678 dtrace_syminfo_t dts;
2679 GElf_Sym sym;
2680
2681 const char *scope, *mark;
2682 uchar_t dnkind;
2683 char *name;
2684
2685 /*
2686 * Look for scoping marks in the identifier. If one is found, set our
2687 * scope to either DTRACE_OBJ_KMODS or UMODS or to the first part of
2688 * the string that specifies the scope using an explicit module name.
2689 * If two marks in a row are found, set 'uref' (user symbol reference).
2690 * Otherwise we set scope to DTRACE_OBJ_EXEC, indicating that normal
2691 * scope is desired and we should search the specified idhash.
2692 */
2693 if ((name = strrchr(dnp->dn_string, '`')) != NULL) {
2694 if (name > dnp->dn_string && name[-1] == '`') {
2695 uref++;
2696 name[-1] = '\0';
2697 }
2698
2699 if (name == dnp->dn_string + uref)
2700 scope = uref ? DTRACE_OBJ_UMODS : DTRACE_OBJ_KMODS;
2701 else
2702 scope = dnp->dn_string;
2703
2704 *name++ = '\0'; /* leave name pointing after scoping mark */
2705 dnkind = DT_NODE_VAR;
2706
2707 } else if (idkind == DT_IDENT_AGG) {
2708 scope = DTRACE_OBJ_EXEC;
2709 name = dnp->dn_string + 1;
2710 dnkind = DT_NODE_AGG;
2711 } else {
2712 scope = DTRACE_OBJ_EXEC;
2713 name = dnp->dn_string;
2714 dnkind = DT_NODE_VAR;
2715 }
2716
2717 /*
2718 * If create is set to false, and we fail our idhash lookup, preset
2719 * the errno code to EDT_NOVAR for our final error message below.
2720 * If we end up calling dtrace_lookup_by_name(), it will reset the
2721 * errno appropriately and that error will be reported instead.
2722 */
2723 (void) dt_set_errno(dtp, EDT_NOVAR);
2724 mark = uref ? "``" : "`";
2725
2726 if (scope == DTRACE_OBJ_EXEC && (
2727 (dhp != dtp->dt_globals &&
2728 (idp = dt_idhash_lookup(dhp, name)) != NULL) ||
2729 (dhp == dtp->dt_globals &&
2730 (idp = dt_idstack_lookup(&yypcb->pcb_globals, name)) != NULL))) {
2731 /*
2732 * Check that we are referencing the ident in the manner that
2733 * matches its type if this is a global lookup. In the TLS or
2734 * local case, we don't know how the ident will be used until
2735 * the time operator -> is seen; more parsing is needed.
2736 */
2737 if (idp->di_kind != idkind && dhp == dtp->dt_globals) {
2738 xyerror(D_IDENT_BADREF, "%s '%s' may not be referenced "
2739 "as %s\n", dt_idkind_name(idp->di_kind),
2740 idp->di_name, dt_idkind_name(idkind));
2741 }
2742
2743 /*
2744 * Arrays and aggregations are not cooked individually. They
2745 * have dynamic types and must be referenced using operator [].
2746 * This is handled explicitly by the code for DT_TOK_LBRAC.
2747 */
2748 if (idp->di_kind != DT_IDENT_ARRAY &&
2749 idp->di_kind != DT_IDENT_AGG)
2750 attr = dt_ident_cook(dnp, idp, NULL);
2751 else {
2752 dt_node_type_assign(dnp,
2753 DT_DYN_CTFP(dtp), DT_DYN_TYPE(dtp), B_FALSE);
2754 attr = idp->di_attr;
2755 }
2756
2757 free(dnp->dn_string);
2758 dnp->dn_string = NULL;
2759 dnp->dn_kind = dnkind;
2760 dnp->dn_ident = idp;
2761 dnp->dn_flags |= DT_NF_LVALUE;
2762
2763 if (idp->di_flags & DT_IDFLG_WRITE)
2764 dnp->dn_flags |= DT_NF_WRITABLE;
2765
2766 dt_node_attr_assign(dnp, attr);
2767
2768 } else if (dhp == dtp->dt_globals && scope != DTRACE_OBJ_EXEC &&
2769 dtrace_lookup_by_name(dtp, scope, name, &sym, &dts) == 0) {
2770
2771 dt_module_t *mp = dt_module_lookup_by_name(dtp, dts.dts_object);
2772 int umod = (mp->dm_flags & DT_DM_KERNEL) == 0;
2773 static const char *const kunames[] = { "kernel", "user" };
2774
2775 dtrace_typeinfo_t dtt;
2776 dtrace_syminfo_t *sip;
2777
2778 if (uref ^ umod) {
2779 xyerror(D_SYM_BADREF, "%s module '%s' symbol '%s' may "
2780 "not be referenced as a %s symbol\n", kunames[umod],
2781 dts.dts_object, dts.dts_name, kunames[uref]);
2782 }
2783
2784 if (dtrace_symbol_type(dtp, &sym, &dts, &dtt) != 0) {
2785 /*
2786 * For now, we special-case EDT_DATAMODEL to clarify
2787 * that mixed data models are not currently supported.
2788 */
2789 if (dtp->dt_errno == EDT_DATAMODEL) {
2790 xyerror(D_SYM_MODEL, "cannot use %s symbol "
2791 "%s%s%s in a %s D program\n",
2792 dt_module_modelname(mp),
2793 dts.dts_object, mark, dts.dts_name,
2794 dt_module_modelname(dtp->dt_ddefs));
2795 }
2796
2797 /*
2798 * If we're taking the address of an identifier that
2799 * doesn't have type info, try to make it a void *.
2800 * This lets us use identifiers that are defined in
2801 * assembly and don't have type information.
2802 */
2803 if ((dnp->dn_flags & DT_NF_IDENTADDR) == 0 ||
2804 dtrace_lookup_by_type(dtp, DTRACE_OBJ_CDEFS,
2805 "void", &dtt) != 0) {
2806 xyerror(D_SYM_NOTYPES,
2807 "no symbolic type information is available for "
2808 "%s%s%s: %s\n", dts.dts_object, mark,
2809 dts.dts_name,
2810 dtrace_errmsg(dtp, dtrace_errno(dtp)));
2811 }
2812 }
2813
2814 idp = dt_ident_create(name, DT_IDENT_SYMBOL, 0, 0,
2815 _dtrace_symattr, 0, &dt_idops_thaw, NULL, dtp->dt_gen);
2816
2817 if (idp == NULL)
2818 longjmp(yypcb->pcb_jmpbuf, EDT_NOMEM);
2819
2820 if (mp->dm_flags & DT_DM_PRIMARY)
2821 idp->di_flags |= DT_IDFLG_PRIM;
2822
2823 idp->di_next = dtp->dt_externs;
2824 dtp->dt_externs = idp;
2825
2826 if ((sip = malloc(sizeof (dtrace_syminfo_t))) == NULL)
2827 longjmp(yypcb->pcb_jmpbuf, EDT_NOMEM);
2828
2829 bcopy(&dts, sip, sizeof (dtrace_syminfo_t));
2830 idp->di_data = sip;
2831 idp->di_ctfp = dtt.dtt_ctfp;
2832 idp->di_type = dtt.dtt_type;
2833
2834 free(dnp->dn_string);
2835 dnp->dn_string = NULL;
2836 dnp->dn_kind = DT_NODE_SYM;
2837 dnp->dn_ident = idp;
2838 dnp->dn_flags |= DT_NF_LVALUE;
2839
2840 dt_node_type_assign(dnp, dtt.dtt_ctfp, dtt.dtt_type,
2841 dtt.dtt_flags);
2842 dt_node_attr_assign(dnp, _dtrace_symattr);
2843
2844 if (uref) {
2845 idp->di_flags |= DT_IDFLG_USER;
2846 dnp->dn_flags |= DT_NF_USERLAND;
2847 }
2848
2849 } else if (scope == DTRACE_OBJ_EXEC && create == B_TRUE) {
2850 uint_t flags = DT_IDFLG_WRITE;
2851 uint_t id;
2852
2853 if (dt_idhash_nextid(dhp, &id) == -1) {
2854 xyerror(D_ID_OFLOW, "cannot create %s: limit on number "
2855 "of %s variables exceeded\n", name, sname);
2856 }
2857
2858 if (dhp == yypcb->pcb_locals)
2859 flags |= DT_IDFLG_LOCAL;
2860 else if (dhp == dtp->dt_tls)
2861 flags |= DT_IDFLG_TLS;
2862
2863 dt_dprintf("create %s %s variable %s, id=%u\n",
2864 sname, dt_idkind_name(idkind), name, id);
2865
2866 if (idkind == DT_IDENT_ARRAY || idkind == DT_IDENT_AGG) {
2867 idp = dt_idhash_insert(dhp, name,
2868 idkind, flags, id, _dtrace_defattr, 0,
2869 &dt_idops_assc, NULL, dtp->dt_gen);
2870 } else {
2871 idp = dt_idhash_insert(dhp, name,
2872 idkind, flags, id, _dtrace_defattr, 0,
2873 &dt_idops_thaw, NULL, dtp->dt_gen);
2874 }
2875
2876 if (idp == NULL)
2877 longjmp(yypcb->pcb_jmpbuf, EDT_NOMEM);
2878
2879 /*
2880 * Arrays and aggregations are not cooked individually. They
2881 * have dynamic types and must be referenced using operator [].
2882 * This is handled explicitly by the code for DT_TOK_LBRAC.
2883 */
2884 if (idp->di_kind != DT_IDENT_ARRAY &&
2885 idp->di_kind != DT_IDENT_AGG)
2886 attr = dt_ident_cook(dnp, idp, NULL);
2887 else {
2888 dt_node_type_assign(dnp,
2889 DT_DYN_CTFP(dtp), DT_DYN_TYPE(dtp), B_FALSE);
2890 attr = idp->di_attr;
2891 }
2892
2893 free(dnp->dn_string);
2894 dnp->dn_string = NULL;
2895 dnp->dn_kind = dnkind;
2896 dnp->dn_ident = idp;
2897 dnp->dn_flags |= DT_NF_LVALUE | DT_NF_WRITABLE;
2898
2899 dt_node_attr_assign(dnp, attr);
2900
2901 } else if (scope != DTRACE_OBJ_EXEC) {
2902 xyerror(D_IDENT_UNDEF, "failed to resolve %s%s%s: %s\n",
2903 dnp->dn_string, mark, name,
2904 dtrace_errmsg(dtp, dtrace_errno(dtp)));
2905 } else {
2906 xyerror(D_IDENT_UNDEF, "failed to resolve %s: %s\n",
2907 dnp->dn_string, dtrace_errmsg(dtp, dtrace_errno(dtp)));
2908 }
2909 }
2910
2911 static dt_node_t *
dt_cook_ident(dt_node_t * dnp,uint_t idflags)2912 dt_cook_ident(dt_node_t *dnp, uint_t idflags)
2913 {
2914 dtrace_hdl_t *dtp = yypcb->pcb_hdl;
2915
2916 if (dnp->dn_op == DT_TOK_AGG)
2917 dt_xcook_ident(dnp, dtp->dt_aggs, DT_IDENT_AGG, B_FALSE);
2918 else
2919 dt_xcook_ident(dnp, dtp->dt_globals, DT_IDENT_SCALAR, B_FALSE);
2920
2921 return (dt_node_cook(dnp, idflags));
2922 }
2923
2924 /*
2925 * Since operators [ and -> can instantiate new variables before we know
2926 * whether the reference is for a read or a write, we need to check read
2927 * references to determine if the identifier is currently dt_ident_unref().
2928 * If so, we report that this first access was to an undefined variable.
2929 */
2930 static dt_node_t *
dt_cook_var(dt_node_t * dnp,uint_t idflags)2931 dt_cook_var(dt_node_t *dnp, uint_t idflags)
2932 {
2933 dt_ident_t *idp = dnp->dn_ident;
2934
2935 if ((idflags & DT_IDFLG_REF) && dt_ident_unref(idp)) {
2936 dnerror(dnp, D_VAR_UNDEF,
2937 "%s%s has not yet been declared or assigned\n",
2938 (idp->di_flags & DT_IDFLG_LOCAL) ? "this->" :
2939 (idp->di_flags & DT_IDFLG_TLS) ? "self->" : "",
2940 idp->di_name);
2941 }
2942
2943 dt_node_attr_assign(dnp, dt_ident_cook(dnp, idp, &dnp->dn_args));
2944 return (dnp);
2945 }
2946
2947 /*ARGSUSED*/
2948 static dt_node_t *
dt_cook_func(dt_node_t * dnp,uint_t idflags)2949 dt_cook_func(dt_node_t *dnp, uint_t idflags)
2950 {
2951 dt_node_attr_assign(dnp,
2952 dt_ident_cook(dnp, dnp->dn_ident, &dnp->dn_args));
2953
2954 return (dnp);
2955 }
2956
2957 static dt_node_t *
dt_cook_op1(dt_node_t * dnp,uint_t idflags)2958 dt_cook_op1(dt_node_t *dnp, uint_t idflags)
2959 {
2960 dtrace_hdl_t *dtp = yypcb->pcb_hdl;
2961 dt_node_t *cp = dnp->dn_child;
2962
2963 char n[DT_TYPE_NAMELEN];
2964 dtrace_typeinfo_t dtt;
2965 dt_ident_t *idp;
2966
2967 ctf_encoding_t e;
2968 ctf_arinfo_t r;
2969 ctf_id_t type, base;
2970 uint_t kind;
2971
2972 if (dnp->dn_op == DT_TOK_PREINC || dnp->dn_op == DT_TOK_POSTINC ||
2973 dnp->dn_op == DT_TOK_PREDEC || dnp->dn_op == DT_TOK_POSTDEC)
2974 idflags = DT_IDFLG_REF | DT_IDFLG_MOD;
2975 else
2976 idflags = DT_IDFLG_REF;
2977
2978 /*
2979 * We allow the unary ++ and -- operators to instantiate new scalar
2980 * variables if applied to an identifier; otherwise just cook as usual.
2981 */
2982 if (cp->dn_kind == DT_NODE_IDENT && (idflags & DT_IDFLG_MOD))
2983 dt_xcook_ident(cp, dtp->dt_globals, DT_IDENT_SCALAR, B_TRUE);
2984
2985 cp = dnp->dn_child = dt_node_cook(cp, 0); /* don't set idflags yet */
2986
2987 if (cp->dn_kind == DT_NODE_VAR && dt_ident_unref(cp->dn_ident)) {
2988 if (dt_type_lookup("int64_t", &dtt) != 0)
2989 xyerror(D_TYPE_ERR, "failed to lookup int64_t\n");
2990
2991 dt_ident_type_assign(cp->dn_ident, dtt.dtt_ctfp, dtt.dtt_type);
2992 dt_node_type_assign(cp, dtt.dtt_ctfp, dtt.dtt_type,
2993 dtt.dtt_flags);
2994 }
2995
2996 if (cp->dn_kind == DT_NODE_VAR)
2997 cp->dn_ident->di_flags |= idflags;
2998
2999 switch (dnp->dn_op) {
3000 case DT_TOK_DEREF:
3001 /*
3002 * If the deref operator is applied to a translated pointer,
3003 * we set our output type to the output of the translation.
3004 */
3005 if ((idp = dt_node_resolve(cp, DT_IDENT_XLPTR)) != NULL) {
3006 dt_xlator_t *dxp = idp->di_data;
3007
3008 dnp->dn_ident = &dxp->dx_souid;
3009 dt_node_type_assign(dnp,
3010 dnp->dn_ident->di_ctfp, dnp->dn_ident->di_type,
3011 cp->dn_flags & DT_NF_USERLAND);
3012 break;
3013 }
3014
3015 type = ctf_type_resolve(cp->dn_ctfp, cp->dn_type);
3016 kind = ctf_type_kind(cp->dn_ctfp, type);
3017
3018 if (kind == CTF_K_ARRAY) {
3019 if (ctf_array_info(cp->dn_ctfp, type, &r) != 0) {
3020 dtp->dt_ctferr = ctf_errno(cp->dn_ctfp);
3021 longjmp(yypcb->pcb_jmpbuf, EDT_CTF);
3022 } else
3023 type = r.ctr_contents;
3024 } else if (kind == CTF_K_POINTER) {
3025 type = ctf_type_reference(cp->dn_ctfp, type);
3026 } else {
3027 xyerror(D_DEREF_NONPTR,
3028 "cannot dereference non-pointer type\n");
3029 }
3030
3031 dt_node_type_assign(dnp, cp->dn_ctfp, type,
3032 cp->dn_flags & DT_NF_USERLAND);
3033 base = ctf_type_resolve(cp->dn_ctfp, type);
3034 kind = ctf_type_kind(cp->dn_ctfp, base);
3035
3036 if (kind == CTF_K_INTEGER && ctf_type_encoding(cp->dn_ctfp,
3037 base, &e) == 0 && IS_VOID(e)) {
3038 xyerror(D_DEREF_VOID,
3039 "cannot dereference pointer to void\n");
3040 }
3041
3042 if (kind == CTF_K_FUNCTION) {
3043 xyerror(D_DEREF_FUNC,
3044 "cannot dereference pointer to function\n");
3045 }
3046
3047 if (kind != CTF_K_ARRAY || dt_node_is_string(dnp))
3048 dnp->dn_flags |= DT_NF_LVALUE; /* see K&R[A7.4.3] */
3049
3050 /*
3051 * If we propagated the l-value bit and the child operand was
3052 * a writable D variable or a binary operation of the form
3053 * a + b where a is writable, then propagate the writable bit.
3054 * This is necessary to permit assignments to scalar arrays,
3055 * which are converted to expressions of the form *(a + i).
3056 */
3057 if ((cp->dn_flags & DT_NF_WRITABLE) ||
3058 (cp->dn_kind == DT_NODE_OP2 && cp->dn_op == DT_TOK_ADD &&
3059 (cp->dn_left->dn_flags & DT_NF_WRITABLE)))
3060 dnp->dn_flags |= DT_NF_WRITABLE;
3061
3062 if ((cp->dn_flags & DT_NF_USERLAND) &&
3063 (kind == CTF_K_POINTER || (dnp->dn_flags & DT_NF_REF)))
3064 dnp->dn_flags |= DT_NF_USERLAND;
3065 break;
3066
3067 case DT_TOK_IPOS:
3068 case DT_TOK_INEG:
3069 if (!dt_node_is_arith(cp)) {
3070 xyerror(D_OP_ARITH, "operator %s requires an operand "
3071 "of arithmetic type\n", opstr(dnp->dn_op));
3072 }
3073 dt_node_type_propagate(cp, dnp); /* see K&R[A7.4.4-6] */
3074 break;
3075
3076 case DT_TOK_BNEG:
3077 if (!dt_node_is_integer(cp)) {
3078 xyerror(D_OP_INT, "operator %s requires an operand of "
3079 "integral type\n", opstr(dnp->dn_op));
3080 }
3081 dt_node_type_propagate(cp, dnp); /* see K&R[A7.4.4-6] */
3082 break;
3083
3084 case DT_TOK_LNEG:
3085 if (!dt_node_is_scalar(cp)) {
3086 xyerror(D_OP_SCALAR, "operator %s requires an operand "
3087 "of scalar type\n", opstr(dnp->dn_op));
3088 }
3089 dt_node_type_assign(dnp, DT_INT_CTFP(dtp), DT_INT_TYPE(dtp),
3090 B_FALSE);
3091 break;
3092
3093 case DT_TOK_ADDROF:
3094 if (cp->dn_kind == DT_NODE_VAR || cp->dn_kind == DT_NODE_AGG) {
3095 xyerror(D_ADDROF_VAR,
3096 "cannot take address of dynamic variable\n");
3097 }
3098
3099 if (dt_node_is_dynamic(cp)) {
3100 xyerror(D_ADDROF_VAR,
3101 "cannot take address of dynamic object\n");
3102 }
3103
3104 if (!(cp->dn_flags & DT_NF_LVALUE)) {
3105 xyerror(D_ADDROF_LVAL, /* see K&R[A7.4.2] */
3106 "unacceptable operand for unary & operator\n");
3107 }
3108
3109 if (cp->dn_flags & DT_NF_BITFIELD) {
3110 xyerror(D_ADDROF_BITFIELD,
3111 "cannot take address of bit-field\n");
3112 }
3113
3114 dtt = (dtrace_typeinfo_t){
3115 .dtt_ctfp = cp->dn_ctfp,
3116 .dtt_type = cp->dn_type,
3117 };
3118
3119 if (dt_type_pointer(&dtt) == -1) {
3120 xyerror(D_TYPE_ERR, "cannot find type for \"&\": %s*\n",
3121 dt_node_type_name(cp, n, sizeof (n)));
3122 }
3123
3124 dt_node_type_assign(dnp, dtt.dtt_ctfp, dtt.dtt_type,
3125 cp->dn_flags & DT_NF_USERLAND);
3126 break;
3127
3128 case DT_TOK_SIZEOF:
3129 if (cp->dn_flags & DT_NF_BITFIELD) {
3130 xyerror(D_SIZEOF_BITFIELD,
3131 "cannot apply sizeof to a bit-field\n");
3132 }
3133
3134 if (dt_node_sizeof(cp) == 0) {
3135 xyerror(D_SIZEOF_TYPE, "cannot apply sizeof to an "
3136 "operand of unknown size\n");
3137 }
3138
3139 dt_node_type_assign(dnp, dtp->dt_ddefs->dm_ctfp,
3140 ctf_lookup_by_name(dtp->dt_ddefs->dm_ctfp, "size_t"),
3141 B_FALSE);
3142 break;
3143
3144 case DT_TOK_STRINGOF:
3145 if (!dt_node_is_scalar(cp) && !dt_node_is_pointer(cp) &&
3146 !dt_node_is_strcompat(cp)) {
3147 xyerror(D_STRINGOF_TYPE,
3148 "cannot apply stringof to a value of type %s\n",
3149 dt_node_type_name(cp, n, sizeof (n)));
3150 }
3151 dt_node_type_assign(dnp, DT_STR_CTFP(dtp), DT_STR_TYPE(dtp),
3152 cp->dn_flags & DT_NF_USERLAND);
3153 break;
3154
3155 case DT_TOK_PREINC:
3156 case DT_TOK_POSTINC:
3157 case DT_TOK_PREDEC:
3158 case DT_TOK_POSTDEC:
3159 if (dt_node_is_scalar(cp) == 0) {
3160 xyerror(D_OP_SCALAR, "operator %s requires operand of "
3161 "scalar type\n", opstr(dnp->dn_op));
3162 }
3163
3164 if (dt_node_is_vfptr(cp)) {
3165 xyerror(D_OP_VFPTR, "operator %s requires an operand "
3166 "of known size\n", opstr(dnp->dn_op));
3167 }
3168
3169 if (!(cp->dn_flags & DT_NF_LVALUE)) {
3170 xyerror(D_OP_LVAL, "operator %s requires modifiable "
3171 "lvalue as an operand\n", opstr(dnp->dn_op));
3172 }
3173
3174 if (!(cp->dn_flags & DT_NF_WRITABLE)) {
3175 xyerror(D_OP_WRITE, "operator %s can only be applied "
3176 "to a writable variable\n", opstr(dnp->dn_op));
3177 }
3178
3179 dt_node_type_propagate(cp, dnp); /* see K&R[A7.4.1] */
3180 break;
3181
3182 default:
3183 xyerror(D_UNKNOWN, "invalid unary op %s\n", opstr(dnp->dn_op));
3184 }
3185
3186 dt_node_attr_assign(dnp, cp->dn_attr);
3187 return (dnp);
3188 }
3189
3190 static void
dt_assign_common(dt_node_t * dnp)3191 dt_assign_common(dt_node_t *dnp)
3192 {
3193 dt_node_t *lp = dnp->dn_left;
3194 dt_node_t *rp = dnp->dn_right;
3195 int op = dnp->dn_op;
3196
3197 if (rp->dn_kind == DT_NODE_INT)
3198 dt_cast(lp, rp);
3199
3200 if (!(lp->dn_flags & DT_NF_LVALUE)) {
3201 xyerror(D_OP_LVAL, "operator %s requires modifiable "
3202 "lvalue as an operand\n", opstr(op));
3203 /* see K&R[A7.17] */
3204 }
3205
3206 if (!(lp->dn_flags & DT_NF_WRITABLE)) {
3207 xyerror(D_OP_WRITE, "operator %s can only be applied "
3208 "to a writable variable\n", opstr(op));
3209 }
3210
3211 dt_node_type_propagate(lp, dnp); /* see K&R[A7.17] */
3212 dt_node_attr_assign(dnp, dt_attr_min(lp->dn_attr, rp->dn_attr));
3213 }
3214
3215 static dt_node_t *
dt_cook_op2(dt_node_t * dnp,uint_t idflags)3216 dt_cook_op2(dt_node_t *dnp, uint_t idflags)
3217 {
3218 dtrace_hdl_t *dtp = yypcb->pcb_hdl;
3219 dt_node_t *lp = dnp->dn_left;
3220 dt_node_t *rp = dnp->dn_right;
3221 int op = dnp->dn_op;
3222
3223 ctf_membinfo_t m;
3224 ctf_file_t *ctfp;
3225 ctf_id_t type;
3226 int kind, val, uref;
3227 dt_ident_t *idp;
3228
3229 char n1[DT_TYPE_NAMELEN];
3230 char n2[DT_TYPE_NAMELEN];
3231
3232 /*
3233 * The expression E1[E2] is identical by definition to *((E1)+(E2)) so
3234 * we convert "[" to "+" and glue on "*" at the end (see K&R[A7.3.1])
3235 * unless the left-hand side is an untyped D scalar, associative array,
3236 * or aggregation. In these cases, we proceed to case DT_TOK_LBRAC and
3237 * handle associative array and aggregation references there.
3238 */
3239 if (op == DT_TOK_LBRAC) {
3240 if (lp->dn_kind == DT_NODE_IDENT) {
3241 dt_idhash_t *dhp;
3242 uint_t idkind;
3243
3244 if (lp->dn_op == DT_TOK_AGG) {
3245 dhp = dtp->dt_aggs;
3246 idp = dt_idhash_lookup(dhp, lp->dn_string + 1);
3247 idkind = DT_IDENT_AGG;
3248 } else {
3249 dhp = dtp->dt_globals;
3250 idp = dt_idstack_lookup(
3251 &yypcb->pcb_globals, lp->dn_string);
3252 idkind = DT_IDENT_ARRAY;
3253 }
3254
3255 if (idp == NULL || dt_ident_unref(idp))
3256 dt_xcook_ident(lp, dhp, idkind, B_TRUE);
3257 else
3258 dt_xcook_ident(lp, dhp, idp->di_kind, B_FALSE);
3259 } else {
3260 lp = dnp->dn_left = dt_node_cook(lp, 0);
3261 }
3262
3263 /*
3264 * Switch op to '+' for *(E1 + E2) array mode in these cases:
3265 * (a) lp is a DT_IDENT_ARRAY variable that has already been
3266 * referenced using [] notation (dn_args != NULL).
3267 * (b) lp is a non-ARRAY variable that has already been given
3268 * a type by assignment or declaration (!dt_ident_unref())
3269 * (c) lp is neither a variable nor an aggregation
3270 */
3271 if (lp->dn_kind == DT_NODE_VAR) {
3272 if (lp->dn_ident->di_kind == DT_IDENT_ARRAY) {
3273 if (lp->dn_args != NULL)
3274 op = DT_TOK_ADD;
3275 } else if (!dt_ident_unref(lp->dn_ident)) {
3276 op = DT_TOK_ADD;
3277 }
3278 } else if (lp->dn_kind != DT_NODE_AGG) {
3279 op = DT_TOK_ADD;
3280 }
3281 }
3282
3283 switch (op) {
3284 case DT_TOK_BAND:
3285 case DT_TOK_XOR:
3286 case DT_TOK_BOR:
3287 lp = dnp->dn_left = dt_node_cook(lp, DT_IDFLG_REF);
3288 rp = dnp->dn_right = dt_node_cook(rp, DT_IDFLG_REF);
3289
3290 if (!dt_node_is_integer(lp) || !dt_node_is_integer(rp)) {
3291 xyerror(D_OP_INT, "operator %s requires operands of "
3292 "integral type\n", opstr(op));
3293 }
3294
3295 dt_node_promote(lp, rp, dnp); /* see K&R[A7.11-13] */
3296 break;
3297
3298 case DT_TOK_LSH:
3299 case DT_TOK_RSH:
3300 lp = dnp->dn_left = dt_node_cook(lp, DT_IDFLG_REF);
3301 rp = dnp->dn_right = dt_node_cook(rp, DT_IDFLG_REF);
3302
3303 if (!dt_node_is_integer(lp) || !dt_node_is_integer(rp)) {
3304 xyerror(D_OP_INT, "operator %s requires operands of "
3305 "integral type\n", opstr(op));
3306 }
3307
3308 dt_node_type_propagate(lp, dnp); /* see K&R[A7.8] */
3309 dt_node_attr_assign(dnp, dt_attr_min(lp->dn_attr, rp->dn_attr));
3310 break;
3311
3312 case DT_TOK_MOD:
3313 lp = dnp->dn_left = dt_node_cook(lp, DT_IDFLG_REF);
3314 rp = dnp->dn_right = dt_node_cook(rp, DT_IDFLG_REF);
3315
3316 if (!dt_node_is_integer(lp) || !dt_node_is_integer(rp)) {
3317 xyerror(D_OP_INT, "operator %s requires operands of "
3318 "integral type\n", opstr(op));
3319 }
3320
3321 dt_node_promote(lp, rp, dnp); /* see K&R[A7.6] */
3322 break;
3323
3324 case DT_TOK_MUL:
3325 case DT_TOK_DIV:
3326 lp = dnp->dn_left = dt_node_cook(lp, DT_IDFLG_REF);
3327 rp = dnp->dn_right = dt_node_cook(rp, DT_IDFLG_REF);
3328
3329 if (!dt_node_is_arith(lp) || !dt_node_is_arith(rp)) {
3330 xyerror(D_OP_ARITH, "operator %s requires operands of "
3331 "arithmetic type\n", opstr(op));
3332 }
3333
3334 dt_node_promote(lp, rp, dnp); /* see K&R[A7.6] */
3335 break;
3336
3337 case DT_TOK_LAND:
3338 case DT_TOK_LXOR:
3339 case DT_TOK_LOR:
3340 lp = dnp->dn_left = dt_node_cook(lp, DT_IDFLG_REF);
3341 rp = dnp->dn_right = dt_node_cook(rp, DT_IDFLG_REF);
3342
3343 if (!dt_node_is_scalar(lp) || !dt_node_is_scalar(rp)) {
3344 xyerror(D_OP_SCALAR, "operator %s requires operands "
3345 "of scalar type\n", opstr(op));
3346 }
3347
3348 dt_node_type_assign(dnp, DT_INT_CTFP(dtp), DT_INT_TYPE(dtp),
3349 B_FALSE);
3350 dt_node_attr_assign(dnp, dt_attr_min(lp->dn_attr, rp->dn_attr));
3351 break;
3352
3353 case DT_TOK_LT:
3354 case DT_TOK_LE:
3355 case DT_TOK_GT:
3356 case DT_TOK_GE:
3357 case DT_TOK_EQU:
3358 case DT_TOK_NEQ:
3359 /*
3360 * The D comparison operators provide the ability to transform
3361 * a right-hand identifier into a corresponding enum tag value
3362 * if the left-hand side is an enum type. To do this, we cook
3363 * the left-hand side, and then see if the right-hand side is
3364 * an unscoped identifier defined in the enum. If so, we
3365 * convert into an integer constant node with the tag's value.
3366 */
3367 lp = dnp->dn_left = dt_node_cook(lp, DT_IDFLG_REF);
3368
3369 kind = ctf_type_kind(lp->dn_ctfp,
3370 ctf_type_resolve(lp->dn_ctfp, lp->dn_type));
3371
3372 if (kind == CTF_K_ENUM && rp->dn_kind == DT_NODE_IDENT &&
3373 strchr(rp->dn_string, '`') == NULL && ctf_enum_value(
3374 lp->dn_ctfp, lp->dn_type, rp->dn_string, &val) == 0) {
3375
3376 if ((idp = dt_idstack_lookup(&yypcb->pcb_globals,
3377 rp->dn_string)) != NULL) {
3378 xyerror(D_IDENT_AMBIG,
3379 "ambiguous use of operator %s: %s is "
3380 "both a %s enum tag and a global %s\n",
3381 opstr(op), rp->dn_string,
3382 dt_node_type_name(lp, n1, sizeof (n1)),
3383 dt_idkind_name(idp->di_kind));
3384 }
3385
3386 free(rp->dn_string);
3387 rp->dn_string = NULL;
3388 rp->dn_kind = DT_NODE_INT;
3389 rp->dn_flags |= DT_NF_COOKED;
3390 rp->dn_op = DT_TOK_INT;
3391 rp->dn_value = (intmax_t)val;
3392
3393 dt_node_type_assign(rp, lp->dn_ctfp, lp->dn_type,
3394 B_FALSE);
3395 dt_node_attr_assign(rp, _dtrace_symattr);
3396 }
3397
3398 rp = dnp->dn_right = dt_node_cook(rp, DT_IDFLG_REF);
3399
3400 /*
3401 * The rules for type checking for the relational operators are
3402 * described in the ANSI-C spec (see K&R[A7.9-10]). We perform
3403 * the various tests in order from least to most expensive. We
3404 * also allow derived strings to be compared as a first-class
3405 * type (resulting in a strcmp(3C)-style comparison), and we
3406 * slightly relax the A7.9 rules to permit void pointer
3407 * comparisons as in A7.10. Our users won't be confused by
3408 * this since they understand pointers are just numbers, and
3409 * relaxing this constraint simplifies the implementation.
3410 */
3411 if (ctf_type_compat(lp->dn_ctfp, lp->dn_type,
3412 rp->dn_ctfp, rp->dn_type))
3413 /*EMPTY*/;
3414 else if (dt_node_is_integer(lp) && dt_node_is_integer(rp))
3415 /*EMPTY*/;
3416 else if (dt_node_is_strcompat(lp) && dt_node_is_strcompat(rp) &&
3417 (dt_node_is_string(lp) || dt_node_is_string(rp)))
3418 /*EMPTY*/;
3419 else if (dt_node_is_ptrcompat(lp, rp, NULL, NULL) == 0) {
3420 xyerror(D_OP_INCOMPAT, "operands have "
3421 "incompatible types: \"%s\" %s \"%s\"\n",
3422 dt_node_type_name(lp, n1, sizeof (n1)), opstr(op),
3423 dt_node_type_name(rp, n2, sizeof (n2)));
3424 }
3425
3426 dt_node_type_assign(dnp, DT_INT_CTFP(dtp), DT_INT_TYPE(dtp),
3427 B_FALSE);
3428 dt_node_attr_assign(dnp, dt_attr_min(lp->dn_attr, rp->dn_attr));
3429 break;
3430
3431 case DT_TOK_ADD:
3432 case DT_TOK_SUB: {
3433 /*
3434 * The rules for type checking for the additive operators are
3435 * described in the ANSI-C spec (see K&R[A7.7]). Pointers and
3436 * integers may be manipulated according to specific rules. In
3437 * these cases D permits strings to be treated as pointers.
3438 */
3439 int lp_is_ptr, lp_is_int, rp_is_ptr, rp_is_int;
3440
3441 lp = dnp->dn_left = dt_node_cook(lp, DT_IDFLG_REF);
3442 rp = dnp->dn_right = dt_node_cook(rp, DT_IDFLG_REF);
3443
3444 lp_is_ptr = dt_node_is_string(lp) ||
3445 (dt_node_is_pointer(lp) && !dt_node_is_vfptr(lp));
3446 lp_is_int = dt_node_is_integer(lp);
3447
3448 rp_is_ptr = dt_node_is_string(rp) ||
3449 (dt_node_is_pointer(rp) && !dt_node_is_vfptr(rp));
3450 rp_is_int = dt_node_is_integer(rp);
3451
3452 if (lp_is_int && rp_is_int) {
3453 dt_type_promote(lp, rp, &ctfp, &type);
3454 uref = 0;
3455 } else if (lp_is_ptr && rp_is_int) {
3456 ctfp = lp->dn_ctfp;
3457 type = lp->dn_type;
3458 uref = lp->dn_flags & DT_NF_USERLAND;
3459 } else if (lp_is_int && rp_is_ptr && op == DT_TOK_ADD) {
3460 ctfp = rp->dn_ctfp;
3461 type = rp->dn_type;
3462 uref = rp->dn_flags & DT_NF_USERLAND;
3463 } else if (lp_is_ptr && rp_is_ptr && op == DT_TOK_SUB &&
3464 dt_node_is_ptrcompat(lp, rp, NULL, NULL)) {
3465 ctfp = dtp->dt_ddefs->dm_ctfp;
3466 type = ctf_lookup_by_name(ctfp, "ptrdiff_t");
3467 uref = 0;
3468 } else {
3469 xyerror(D_OP_INCOMPAT, "operands have incompatible "
3470 "types: \"%s\" %s \"%s\"\n",
3471 dt_node_type_name(lp, n1, sizeof (n1)), opstr(op),
3472 dt_node_type_name(rp, n2, sizeof (n2)));
3473 }
3474
3475 dt_node_type_assign(dnp, ctfp, type, B_FALSE);
3476 dt_node_attr_assign(dnp, dt_attr_min(lp->dn_attr, rp->dn_attr));
3477
3478 if (uref)
3479 dnp->dn_flags |= DT_NF_USERLAND;
3480 break;
3481 }
3482
3483 case DT_TOK_OR_EQ:
3484 case DT_TOK_XOR_EQ:
3485 case DT_TOK_AND_EQ:
3486 case DT_TOK_LSH_EQ:
3487 case DT_TOK_RSH_EQ:
3488 case DT_TOK_MOD_EQ:
3489 if (lp->dn_kind == DT_NODE_IDENT) {
3490 dt_xcook_ident(lp, dtp->dt_globals,
3491 DT_IDENT_SCALAR, B_TRUE);
3492 }
3493
3494 lp = dnp->dn_left =
3495 dt_node_cook(lp, DT_IDFLG_REF | DT_IDFLG_MOD);
3496
3497 rp = dnp->dn_right =
3498 dt_node_cook(rp, DT_IDFLG_REF | DT_IDFLG_MOD);
3499
3500 if (!dt_node_is_integer(lp) || !dt_node_is_integer(rp)) {
3501 xyerror(D_OP_INT, "operator %s requires operands of "
3502 "integral type\n", opstr(op));
3503 }
3504 goto asgn_common;
3505
3506 case DT_TOK_MUL_EQ:
3507 case DT_TOK_DIV_EQ:
3508 if (lp->dn_kind == DT_NODE_IDENT) {
3509 dt_xcook_ident(lp, dtp->dt_globals,
3510 DT_IDENT_SCALAR, B_TRUE);
3511 }
3512
3513 lp = dnp->dn_left =
3514 dt_node_cook(lp, DT_IDFLG_REF | DT_IDFLG_MOD);
3515
3516 rp = dnp->dn_right =
3517 dt_node_cook(rp, DT_IDFLG_REF | DT_IDFLG_MOD);
3518
3519 if (!dt_node_is_arith(lp) || !dt_node_is_arith(rp)) {
3520 xyerror(D_OP_ARITH, "operator %s requires operands of "
3521 "arithmetic type\n", opstr(op));
3522 }
3523 goto asgn_common;
3524
3525 case DT_TOK_ASGN:
3526 /*
3527 * If the left-hand side is an identifier, attempt to resolve
3528 * it as either an aggregation or scalar variable. We pass
3529 * B_TRUE to dt_xcook_ident to indicate that a new variable can
3530 * be created if no matching variable exists in the namespace.
3531 */
3532 if (lp->dn_kind == DT_NODE_IDENT) {
3533 if (lp->dn_op == DT_TOK_AGG) {
3534 dt_xcook_ident(lp, dtp->dt_aggs,
3535 DT_IDENT_AGG, B_TRUE);
3536 } else {
3537 dt_xcook_ident(lp, dtp->dt_globals,
3538 DT_IDENT_SCALAR, B_TRUE);
3539 }
3540 }
3541
3542 lp = dnp->dn_left = dt_node_cook(lp, 0); /* don't set mod yet */
3543 rp = dnp->dn_right = dt_node_cook(rp, DT_IDFLG_REF);
3544
3545 /*
3546 * If the left-hand side is an aggregation, verify that we are
3547 * assigning it the result of an aggregating function. Once
3548 * we've done so, hide the func node in the aggregation and
3549 * return the aggregation itself up to the parse tree parent.
3550 * This transformation is legal since the assigned function
3551 * cannot change identity across disjoint cooking passes and
3552 * the argument list subtree is retained for later cooking.
3553 */
3554 if (lp->dn_kind == DT_NODE_AGG) {
3555 const char *aname = lp->dn_ident->di_name;
3556 dt_ident_t *oid = lp->dn_ident->di_iarg;
3557
3558 if (rp->dn_kind != DT_NODE_FUNC ||
3559 rp->dn_ident->di_kind != DT_IDENT_AGGFUNC) {
3560 xyerror(D_AGG_FUNC,
3561 "@%s must be assigned the result of "
3562 "an aggregating function\n", aname);
3563 }
3564
3565 if (oid != NULL && oid != rp->dn_ident) {
3566 xyerror(D_AGG_REDEF,
3567 "aggregation redefined: @%s\n\t "
3568 "current: @%s = %s( )\n\tprevious: @%s = "
3569 "%s( ) : line %d\n", aname, aname,
3570 rp->dn_ident->di_name, aname, oid->di_name,
3571 lp->dn_ident->di_lineno);
3572 } else if (oid == NULL)
3573 lp->dn_ident->di_iarg = rp->dn_ident;
3574
3575 /*
3576 * Do not allow multiple aggregation assignments in a
3577 * single statement, e.g. (@a = count()) = count();
3578 * We produce a message as if the result of aggregating
3579 * function does not propagate DT_NF_LVALUE.
3580 */
3581 if (lp->dn_aggfun != NULL) {
3582 xyerror(D_OP_LVAL, "operator = requires "
3583 "modifiable lvalue as an operand\n");
3584 }
3585
3586 lp->dn_aggfun = rp;
3587 lp = dt_node_cook(lp, DT_IDFLG_MOD);
3588
3589 dnp->dn_left = dnp->dn_right = NULL;
3590 dt_node_free(dnp);
3591
3592 return (lp);
3593 }
3594
3595 /*
3596 * If the right-hand side is a dynamic variable that is the
3597 * output of a translator, our result is the translated type.
3598 */
3599 if ((idp = dt_node_resolve(rp, DT_IDENT_XLSOU)) != NULL) {
3600 ctfp = idp->di_ctfp;
3601 type = idp->di_type;
3602 uref = idp->di_flags & DT_IDFLG_USER;
3603 } else {
3604 ctfp = rp->dn_ctfp;
3605 type = rp->dn_type;
3606 uref = rp->dn_flags & DT_NF_USERLAND;
3607 }
3608
3609 /*
3610 * If the left-hand side of an assignment statement is a virgin
3611 * variable created by this compilation pass, reset the type of
3612 * this variable to the type of the right-hand side.
3613 */
3614 if (lp->dn_kind == DT_NODE_VAR &&
3615 dt_ident_unref(lp->dn_ident)) {
3616 dt_node_type_assign(lp, ctfp, type, B_FALSE);
3617 dt_ident_type_assign(lp->dn_ident, ctfp, type);
3618
3619 if (uref) {
3620 lp->dn_flags |= DT_NF_USERLAND;
3621 lp->dn_ident->di_flags |= DT_IDFLG_USER;
3622 }
3623 }
3624
3625 if (lp->dn_kind == DT_NODE_VAR)
3626 lp->dn_ident->di_flags |= DT_IDFLG_MOD;
3627
3628 /*
3629 * The rules for type checking for the assignment operators are
3630 * described in the ANSI-C spec (see K&R[A7.17]). We share
3631 * most of this code with the argument list checking code.
3632 */
3633 if (!dt_node_is_string(lp)) {
3634 kind = ctf_type_kind(lp->dn_ctfp,
3635 ctf_type_resolve(lp->dn_ctfp, lp->dn_type));
3636
3637 if (kind == CTF_K_ARRAY || kind == CTF_K_FUNCTION) {
3638 xyerror(D_OP_ARRFUN, "operator %s may not be "
3639 "applied to operand of type \"%s\"\n",
3640 opstr(op),
3641 dt_node_type_name(lp, n1, sizeof (n1)));
3642 }
3643 }
3644
3645 if (idp != NULL && idp->di_kind == DT_IDENT_XLSOU &&
3646 ctf_type_compat(lp->dn_ctfp, lp->dn_type, ctfp, type))
3647 goto asgn_common;
3648
3649 if (dt_node_is_argcompat(lp, rp))
3650 goto asgn_common;
3651
3652 xyerror(D_OP_INCOMPAT,
3653 "operands have incompatible types: \"%s\" %s \"%s\"\n",
3654 dt_node_type_name(lp, n1, sizeof (n1)), opstr(op),
3655 dt_node_type_name(rp, n2, sizeof (n2)));
3656 /*NOTREACHED*/
3657
3658 case DT_TOK_ADD_EQ:
3659 case DT_TOK_SUB_EQ:
3660 if (lp->dn_kind == DT_NODE_IDENT) {
3661 dt_xcook_ident(lp, dtp->dt_globals,
3662 DT_IDENT_SCALAR, B_TRUE);
3663 }
3664
3665 lp = dnp->dn_left =
3666 dt_node_cook(lp, DT_IDFLG_REF | DT_IDFLG_MOD);
3667
3668 rp = dnp->dn_right =
3669 dt_node_cook(rp, DT_IDFLG_REF | DT_IDFLG_MOD);
3670
3671 if (dt_node_is_string(lp) || dt_node_is_string(rp)) {
3672 xyerror(D_OP_INCOMPAT, "operands have "
3673 "incompatible types: \"%s\" %s \"%s\"\n",
3674 dt_node_type_name(lp, n1, sizeof (n1)), opstr(op),
3675 dt_node_type_name(rp, n2, sizeof (n2)));
3676 }
3677
3678 /*
3679 * The rules for type checking for the assignment operators are
3680 * described in the ANSI-C spec (see K&R[A7.17]). To these
3681 * rules we add that only writable D nodes can be modified.
3682 */
3683 if (dt_node_is_integer(lp) == 0 ||
3684 dt_node_is_integer(rp) == 0) {
3685 if (!dt_node_is_pointer(lp) || dt_node_is_vfptr(lp)) {
3686 xyerror(D_OP_VFPTR,
3687 "operator %s requires left-hand scalar "
3688 "operand of known size\n", opstr(op));
3689 } else if (dt_node_is_integer(rp) == 0 &&
3690 dt_node_is_ptrcompat(lp, rp, NULL, NULL) == 0) {
3691 xyerror(D_OP_INCOMPAT, "operands have "
3692 "incompatible types: \"%s\" %s \"%s\"\n",
3693 dt_node_type_name(lp, n1, sizeof (n1)),
3694 opstr(op),
3695 dt_node_type_name(rp, n2, sizeof (n2)));
3696 }
3697 }
3698 asgn_common:
3699 dt_assign_common(dnp);
3700 break;
3701
3702 case DT_TOK_PTR:
3703 /*
3704 * If the left-hand side of operator -> is one of the scoping
3705 * keywords, permit a local or thread variable to be created or
3706 * referenced.
3707 */
3708 if (lp->dn_kind == DT_NODE_IDENT) {
3709 dt_idhash_t *dhp = NULL;
3710
3711 if (strcmp(lp->dn_string, "self") == 0) {
3712 dhp = dtp->dt_tls;
3713 } else if (strcmp(lp->dn_string, "this") == 0) {
3714 dhp = yypcb->pcb_locals;
3715 }
3716 if (dhp != NULL) {
3717 if (rp->dn_kind != DT_NODE_VAR) {
3718 dt_xcook_ident(rp, dhp,
3719 DT_IDENT_SCALAR, B_TRUE);
3720 }
3721
3722 if (idflags != 0)
3723 rp = dt_node_cook(rp, idflags);
3724
3725 /* avoid freeing rp */
3726 dnp->dn_right = dnp->dn_left;
3727 dt_node_free(dnp);
3728 return (rp);
3729 }
3730 }
3731 /*FALLTHRU*/
3732 case DT_TOK_DOT:
3733 lp = dnp->dn_left = dt_node_cook(lp, DT_IDFLG_REF);
3734
3735 if (rp->dn_kind != DT_NODE_IDENT) {
3736 xyerror(D_OP_IDENT, "operator %s must be followed by "
3737 "an identifier\n", opstr(op));
3738 }
3739
3740 if ((idp = dt_node_resolve(lp, DT_IDENT_XLSOU)) != NULL ||
3741 (idp = dt_node_resolve(lp, DT_IDENT_XLPTR)) != NULL) {
3742 /*
3743 * If the left-hand side is a translated struct or ptr,
3744 * the type of the left is the translation output type.
3745 */
3746 dt_xlator_t *dxp = idp->di_data;
3747
3748 if (dt_xlator_member(dxp, rp->dn_string) == NULL) {
3749 xyerror(D_XLATE_NOCONV,
3750 "translator does not define conversion "
3751 "for member: %s\n", rp->dn_string);
3752 }
3753
3754 ctfp = idp->di_ctfp;
3755 type = ctf_type_resolve(ctfp, idp->di_type);
3756 uref = idp->di_flags & DT_IDFLG_USER;
3757 } else {
3758 ctfp = lp->dn_ctfp;
3759 type = ctf_type_resolve(ctfp, lp->dn_type);
3760 uref = lp->dn_flags & DT_NF_USERLAND;
3761 }
3762
3763 kind = ctf_type_kind(ctfp, type);
3764
3765 if (op == DT_TOK_PTR) {
3766 if (kind != CTF_K_POINTER) {
3767 xyerror(D_OP_PTR, "operator %s must be "
3768 "applied to a pointer\n", opstr(op));
3769 }
3770 type = ctf_type_reference(ctfp, type);
3771 type = ctf_type_resolve(ctfp, type);
3772 kind = ctf_type_kind(ctfp, type);
3773 }
3774
3775 /*
3776 * If we follow a reference to a forward declaration tag,
3777 * search the entire type space for the actual definition.
3778 */
3779 while (kind == CTF_K_FORWARD) {
3780 char *tag = ctf_type_name(ctfp, type, n1, sizeof (n1));
3781 dtrace_typeinfo_t dtt;
3782
3783 if (tag != NULL && dt_type_lookup(tag, &dtt) == 0 &&
3784 (dtt.dtt_ctfp != ctfp || dtt.dtt_type != type)) {
3785 ctfp = dtt.dtt_ctfp;
3786 type = ctf_type_resolve(ctfp, dtt.dtt_type);
3787 kind = ctf_type_kind(ctfp, type);
3788 } else {
3789 xyerror(D_OP_INCOMPLETE,
3790 "operator %s cannot be applied to a "
3791 "forward declaration: no %s definition "
3792 "is available\n", opstr(op), tag);
3793 }
3794 }
3795
3796 if (kind != CTF_K_STRUCT && kind != CTF_K_UNION) {
3797 if (op == DT_TOK_PTR) {
3798 xyerror(D_OP_SOU, "operator -> cannot be "
3799 "applied to pointer to type \"%s\"; must "
3800 "be applied to a struct or union pointer\n",
3801 ctf_type_name(ctfp, type, n1, sizeof (n1)));
3802 } else {
3803 xyerror(D_OP_SOU, "operator %s cannot be "
3804 "applied to type \"%s\"; must be applied "
3805 "to a struct or union\n", opstr(op),
3806 ctf_type_name(ctfp, type, n1, sizeof (n1)));
3807 }
3808 }
3809
3810 if (ctf_member_info(ctfp, type, rp->dn_string, &m) == CTF_ERR) {
3811 xyerror(D_TYPE_MEMBER,
3812 "%s is not a member of %s\n", rp->dn_string,
3813 ctf_type_name(ctfp, type, n1, sizeof (n1)));
3814 }
3815
3816 type = ctf_type_resolve(ctfp, m.ctm_type);
3817 kind = ctf_type_kind(ctfp, type);
3818
3819 dt_node_type_assign(dnp, ctfp, m.ctm_type, B_FALSE);
3820 dt_node_attr_assign(dnp, lp->dn_attr);
3821
3822 if (op == DT_TOK_PTR && (kind != CTF_K_ARRAY ||
3823 dt_node_is_string(dnp)))
3824 dnp->dn_flags |= DT_NF_LVALUE; /* see K&R[A7.3.3] */
3825
3826 if (op == DT_TOK_DOT && (lp->dn_flags & DT_NF_LVALUE) &&
3827 (kind != CTF_K_ARRAY || dt_node_is_string(dnp)))
3828 dnp->dn_flags |= DT_NF_LVALUE; /* see K&R[A7.3.3] */
3829
3830 if (lp->dn_flags & DT_NF_WRITABLE)
3831 dnp->dn_flags |= DT_NF_WRITABLE;
3832
3833 if (uref && (kind == CTF_K_POINTER ||
3834 (dnp->dn_flags & DT_NF_REF)))
3835 dnp->dn_flags |= DT_NF_USERLAND;
3836 break;
3837
3838 case DT_TOK_LBRAC: {
3839 /*
3840 * If op is DT_TOK_LBRAC, we know from the special-case code at
3841 * the top that lp is either a D variable or an aggregation.
3842 */
3843 dt_node_t *lnp;
3844
3845 /*
3846 * If the left-hand side is an aggregation, just set dn_aggtup
3847 * to the right-hand side and return the cooked aggregation.
3848 * This transformation is legal since we are just collapsing
3849 * nodes to simplify later processing, and the entire aggtup
3850 * parse subtree is retained for subsequent cooking passes.
3851 */
3852 if (lp->dn_kind == DT_NODE_AGG) {
3853 if (lp->dn_aggtup != NULL) {
3854 xyerror(D_AGG_MDIM, "improper attempt to "
3855 "reference @%s as a multi-dimensional "
3856 "array\n", lp->dn_ident->di_name);
3857 }
3858
3859 lp->dn_aggtup = rp;
3860 lp = dt_node_cook(lp, 0);
3861
3862 dnp->dn_left = dnp->dn_right = NULL;
3863 dt_node_free(dnp);
3864
3865 return (lp);
3866 }
3867
3868 assert(lp->dn_kind == DT_NODE_VAR);
3869 idp = lp->dn_ident;
3870
3871 /*
3872 * If the left-hand side is a non-global scalar that hasn't yet
3873 * been referenced or modified, it was just created by self->
3874 * or this-> and we can convert it from scalar to assoc array.
3875 */
3876 if (idp->di_kind == DT_IDENT_SCALAR && dt_ident_unref(idp) &&
3877 (idp->di_flags & (DT_IDFLG_LOCAL | DT_IDFLG_TLS)) != 0) {
3878
3879 if (idp->di_flags & DT_IDFLG_LOCAL) {
3880 xyerror(D_ARR_LOCAL,
3881 "local variables may not be used as "
3882 "associative arrays: %s\n", idp->di_name);
3883 }
3884
3885 dt_dprintf("morph variable %s (id %u) from scalar to "
3886 "array\n", idp->di_name, idp->di_id);
3887
3888 dt_ident_morph(idp, DT_IDENT_ARRAY,
3889 &dt_idops_assc, NULL);
3890 }
3891
3892 if (idp->di_kind != DT_IDENT_ARRAY) {
3893 xyerror(D_IDENT_BADREF, "%s '%s' may not be referenced "
3894 "as %s\n", dt_idkind_name(idp->di_kind),
3895 idp->di_name, dt_idkind_name(DT_IDENT_ARRAY));
3896 }
3897
3898 /*
3899 * Now that we've confirmed our left-hand side is a DT_NODE_VAR
3900 * of idkind DT_IDENT_ARRAY, we need to splice the [ node from
3901 * the parse tree and leave a cooked DT_NODE_VAR in its place
3902 * where dn_args for the VAR node is the right-hand 'rp' tree,
3903 * as shown in the parse tree diagram below:
3904 *
3905 * / /
3906 * [ OP2 "[" ]=dnp [ VAR ]=dnp
3907 * / \ => |
3908 * / \ +- dn_args -> [ ??? ]=rp
3909 * [ VAR ]=lp [ ??? ]=rp
3910 *
3911 * Since the final dt_node_cook(dnp) can fail using longjmp we
3912 * must perform the transformations as a group first by over-
3913 * writing 'dnp' to become the VAR node, so that the parse tree
3914 * is guaranteed to be in a consistent state if the cook fails.
3915 */
3916 assert(lp->dn_kind == DT_NODE_VAR);
3917 assert(lp->dn_args == NULL);
3918
3919 lnp = dnp->dn_link;
3920 bcopy(lp, dnp, sizeof (dt_node_t));
3921 dnp->dn_link = lnp;
3922
3923 dnp->dn_args = rp;
3924 dnp->dn_list = NULL;
3925
3926 dt_node_free(lp);
3927 return (dt_node_cook(dnp, idflags));
3928 }
3929
3930 case DT_TOK_XLATE: {
3931 dt_xlator_t *dxp;
3932
3933 assert(lp->dn_kind == DT_NODE_TYPE);
3934 rp = dnp->dn_right = dt_node_cook(rp, DT_IDFLG_REF);
3935 dxp = dt_xlator_lookup(dtp, rp, lp, DT_XLATE_FUZZY);
3936
3937 if (dxp == NULL) {
3938 xyerror(D_XLATE_NONE,
3939 "cannot translate from \"%s\" to \"%s\"\n",
3940 dt_node_type_name(rp, n1, sizeof (n1)),
3941 dt_node_type_name(lp, n2, sizeof (n2)));
3942 }
3943
3944 dnp->dn_ident = dt_xlator_ident(dxp, lp->dn_ctfp, lp->dn_type);
3945 dt_node_type_assign(dnp, DT_DYN_CTFP(dtp), DT_DYN_TYPE(dtp),
3946 B_FALSE);
3947 dt_node_attr_assign(dnp,
3948 dt_attr_min(rp->dn_attr, dnp->dn_ident->di_attr));
3949 break;
3950 }
3951
3952 case DT_TOK_LPAR: {
3953 ctf_id_t ltype, rtype;
3954 uint_t lkind, rkind;
3955
3956 assert(lp->dn_kind == DT_NODE_TYPE);
3957 rp = dnp->dn_right = dt_node_cook(rp, DT_IDFLG_REF);
3958
3959 ltype = ctf_type_resolve(lp->dn_ctfp, lp->dn_type);
3960 lkind = ctf_type_kind(lp->dn_ctfp, ltype);
3961
3962 rtype = ctf_type_resolve(rp->dn_ctfp, rp->dn_type);
3963 rkind = ctf_type_kind(rp->dn_ctfp, rtype);
3964
3965 /*
3966 * The rules for casting are loosely explained in K&R[A7.5]
3967 * and K&R[A6]. Basically, we can cast to the same type or
3968 * same base type, between any kind of scalar values, from
3969 * arrays to pointers, and we can cast anything to void.
3970 * To these rules D adds casts from scalars to strings.
3971 */
3972 if (ctf_type_compat(lp->dn_ctfp, lp->dn_type,
3973 rp->dn_ctfp, rp->dn_type))
3974 /*EMPTY*/;
3975 else if (dt_node_is_scalar(lp) &&
3976 (dt_node_is_scalar(rp) || rkind == CTF_K_FUNCTION))
3977 /*EMPTY*/;
3978 else if (dt_node_is_void(lp))
3979 /*EMPTY*/;
3980 else if (lkind == CTF_K_POINTER && dt_node_is_pointer(rp))
3981 /*EMPTY*/;
3982 else if (dt_node_is_string(lp) && (dt_node_is_scalar(rp) ||
3983 dt_node_is_pointer(rp) || dt_node_is_strcompat(rp)))
3984 /*EMPTY*/;
3985 else {
3986 xyerror(D_CAST_INVAL,
3987 "invalid cast expression: \"%s\" to \"%s\"\n",
3988 dt_node_type_name(rp, n1, sizeof (n1)),
3989 dt_node_type_name(lp, n2, sizeof (n2)));
3990 }
3991
3992 dt_node_type_propagate(lp, dnp); /* see K&R[A7.5] */
3993 dt_node_attr_assign(dnp, dt_attr_min(lp->dn_attr, rp->dn_attr));
3994
3995 /*
3996 * If it's a pointer then should be able to (attempt to)
3997 * assign to it.
3998 */
3999 if (lkind == CTF_K_POINTER)
4000 dnp->dn_flags |= DT_NF_WRITABLE;
4001
4002 break;
4003 }
4004
4005 case DT_TOK_COMMA:
4006 lp = dnp->dn_left = dt_node_cook(lp, DT_IDFLG_REF);
4007 rp = dnp->dn_right = dt_node_cook(rp, DT_IDFLG_REF);
4008
4009 if (dt_node_is_dynamic(lp) || dt_node_is_dynamic(rp)) {
4010 xyerror(D_OP_DYN, "operator %s operands "
4011 "cannot be of dynamic type\n", opstr(op));
4012 }
4013
4014 if (dt_node_is_actfunc(lp) || dt_node_is_actfunc(rp)) {
4015 xyerror(D_OP_ACT, "operator %s operands "
4016 "cannot be actions\n", opstr(op));
4017 }
4018
4019 dt_node_type_propagate(rp, dnp); /* see K&R[A7.18] */
4020 dt_node_attr_assign(dnp, dt_attr_min(lp->dn_attr, rp->dn_attr));
4021 break;
4022
4023 default:
4024 xyerror(D_UNKNOWN, "invalid binary op %s\n", opstr(op));
4025 }
4026
4027 /*
4028 * Complete the conversion of E1[E2] to *((E1)+(E2)) that we started
4029 * at the top of our switch() above (see K&R[A7.3.1]). Since E2 is
4030 * parsed as an argument_expression_list by dt_grammar.y, we can
4031 * end up with a comma-separated list inside of a non-associative
4032 * array reference. We check for this and report an appropriate error.
4033 */
4034 if (dnp->dn_op == DT_TOK_LBRAC && op == DT_TOK_ADD) {
4035 dt_node_t *pnp;
4036
4037 if (rp->dn_list != NULL) {
4038 xyerror(D_ARR_BADREF,
4039 "cannot access %s as an associative array\n",
4040 dt_node_name(lp, n1, sizeof (n1)));
4041 }
4042
4043 dnp->dn_op = DT_TOK_ADD;
4044 pnp = dt_node_op1(DT_TOK_DEREF, dnp);
4045
4046 /*
4047 * Cook callbacks are not typically permitted to allocate nodes.
4048 * When we do, we must insert them in the middle of an existing
4049 * allocation list rather than having them appended to the pcb
4050 * list because the sub-expression may be part of a definition.
4051 */
4052 assert(yypcb->pcb_list == pnp);
4053 yypcb->pcb_list = pnp->dn_link;
4054
4055 pnp->dn_link = dnp->dn_link;
4056 dnp->dn_link = pnp;
4057
4058 return (dt_node_cook(pnp, DT_IDFLG_REF));
4059 }
4060
4061 return (dnp);
4062 }
4063
4064 /*ARGSUSED*/
4065 static dt_node_t *
dt_cook_op3(dt_node_t * dnp,uint_t idflags)4066 dt_cook_op3(dt_node_t *dnp, uint_t idflags)
4067 {
4068 dt_node_t *lp, *rp;
4069 ctf_file_t *ctfp;
4070 ctf_id_t type;
4071
4072 dnp->dn_expr = dt_node_cook(dnp->dn_expr, DT_IDFLG_REF);
4073 lp = dnp->dn_left = dt_node_cook(dnp->dn_left, DT_IDFLG_REF);
4074 rp = dnp->dn_right = dt_node_cook(dnp->dn_right, DT_IDFLG_REF);
4075
4076 if (!dt_node_is_scalar(dnp->dn_expr)) {
4077 xyerror(D_OP_SCALAR,
4078 "operator ?: expression must be of scalar type\n");
4079 }
4080
4081 if (dt_node_is_dynamic(lp) || dt_node_is_dynamic(rp)) {
4082 xyerror(D_OP_DYN,
4083 "operator ?: operands cannot be of dynamic type\n");
4084 }
4085
4086 /*
4087 * The rules for type checking for the ternary operator are complex and
4088 * are described in the ANSI-C spec (see K&R[A7.16]). We implement
4089 * the various tests in order from least to most expensive.
4090 */
4091 if (ctf_type_compat(lp->dn_ctfp, lp->dn_type,
4092 rp->dn_ctfp, rp->dn_type)) {
4093 ctfp = lp->dn_ctfp;
4094 type = lp->dn_type;
4095 } else if (dt_node_is_integer(lp) && dt_node_is_integer(rp)) {
4096 dt_type_promote(lp, rp, &ctfp, &type);
4097 } else if (dt_node_is_strcompat(lp) && dt_node_is_strcompat(rp) &&
4098 (dt_node_is_string(lp) || dt_node_is_string(rp))) {
4099 ctfp = DT_STR_CTFP(yypcb->pcb_hdl);
4100 type = DT_STR_TYPE(yypcb->pcb_hdl);
4101 } else if (dt_node_is_ptrcompat(lp, rp, &ctfp, &type) == 0) {
4102 xyerror(D_OP_INCOMPAT,
4103 "operator ?: operands must have compatible types\n");
4104 }
4105
4106 if (dt_node_is_actfunc(lp) || dt_node_is_actfunc(rp)) {
4107 xyerror(D_OP_ACT, "action cannot be "
4108 "used in a conditional context\n");
4109 }
4110
4111 dt_node_type_assign(dnp, ctfp, type, B_FALSE);
4112 dt_node_attr_assign(dnp, dt_attr_min(dnp->dn_expr->dn_attr,
4113 dt_attr_min(lp->dn_attr, rp->dn_attr)));
4114
4115 return (dnp);
4116 }
4117
4118 static dt_node_t *
dt_cook_statement(dt_node_t * dnp,uint_t idflags)4119 dt_cook_statement(dt_node_t *dnp, uint_t idflags)
4120 {
4121 dnp->dn_expr = dt_node_cook(dnp->dn_expr, idflags);
4122 dt_node_attr_assign(dnp, dnp->dn_expr->dn_attr);
4123
4124 return (dnp);
4125 }
4126
4127 /*
4128 * If dn_aggfun is set, this node is a collapsed aggregation assignment (see
4129 * the special case code for DT_TOK_ASGN in dt_cook_op2() above), in which
4130 * case we cook both the tuple and the function call. If dn_aggfun is NULL,
4131 * this node is just a reference to the aggregation's type and attributes.
4132 */
4133 /*ARGSUSED*/
4134 static dt_node_t *
dt_cook_aggregation(dt_node_t * dnp,uint_t idflags)4135 dt_cook_aggregation(dt_node_t *dnp, uint_t idflags)
4136 {
4137 dtrace_hdl_t *dtp = yypcb->pcb_hdl;
4138
4139 if (dnp->dn_aggfun != NULL) {
4140 dnp->dn_aggfun = dt_node_cook(dnp->dn_aggfun, DT_IDFLG_REF);
4141 dt_node_attr_assign(dnp, dt_ident_cook(dnp,
4142 dnp->dn_ident, &dnp->dn_aggtup));
4143 } else {
4144 dt_node_type_assign(dnp, DT_DYN_CTFP(dtp), DT_DYN_TYPE(dtp),
4145 B_FALSE);
4146 dt_node_attr_assign(dnp, dnp->dn_ident->di_attr);
4147 }
4148
4149 return (dnp);
4150 }
4151
4152 /*
4153 * Since D permits new variable identifiers to be instantiated in any program
4154 * expression, we may need to cook a clause's predicate either before or after
4155 * the action list depending on the program code in question. Consider:
4156 *
4157 * probe-description-list probe-description-list
4158 * /x++/ /x == 0/
4159 * { {
4160 * trace(x); trace(x++);
4161 * } }
4162 *
4163 * In the left-hand example, the predicate uses operator ++ to instantiate 'x'
4164 * as a variable of type int64_t. The predicate must be cooked first because
4165 * otherwise the statement trace(x) refers to an unknown identifier. In the
4166 * right-hand example, the action list uses ++ to instantiate 'x'; the action
4167 * list must be cooked first because otherwise the predicate x == 0 refers to
4168 * an unknown identifier. In order to simplify programming, we support both.
4169 *
4170 * When cooking a clause, we cook the action statements before the predicate by
4171 * default, since it seems more common to create or modify identifiers in the
4172 * action list. If cooking fails due to an unknown identifier, we attempt to
4173 * cook the predicate (i.e. do it first) and then go back and cook the actions.
4174 * If this, too, fails (or if we get an error other than D_IDENT_UNDEF) we give
4175 * up and report failure back to the user. There are five possible paths:
4176 *
4177 * cook actions = OK, cook predicate = OK -> OK
4178 * cook actions = OK, cook predicate = ERR -> ERR
4179 * cook actions = ERR, cook predicate = ERR -> ERR
4180 * cook actions = ERR, cook predicate = OK, cook actions = OK -> OK
4181 * cook actions = ERR, cook predicate = OK, cook actions = ERR -> ERR
4182 *
4183 * The programmer can still defeat our scheme by creating circular definition
4184 * dependencies between predicates and actions, as in this example clause:
4185 *
4186 * probe-description-list
4187 * /x++ && y == 0/
4188 * {
4189 * trace(x + y++);
4190 * }
4191 *
4192 * but it doesn't seem worth the complexity to handle such rare cases. The
4193 * user can simply use the D variable declaration syntax to work around them.
4194 */
4195 static dt_node_t *
dt_cook_clause(dt_node_t * dnp,uint_t idflags)4196 dt_cook_clause(dt_node_t *dnp, uint_t idflags)
4197 {
4198 volatile int err, tries;
4199 jmp_buf ojb;
4200
4201 /*
4202 * Before assigning dn_ctxattr, temporarily assign the probe attribute
4203 * to 'dnp' itself to force an attribute check and minimum violation.
4204 */
4205 dt_node_attr_assign(dnp, yypcb->pcb_pinfo.dtp_attr);
4206 dnp->dn_ctxattr = yypcb->pcb_pinfo.dtp_attr;
4207
4208 bcopy(yypcb->pcb_jmpbuf, ojb, sizeof (jmp_buf));
4209 tries = 0;
4210
4211 if (dnp->dn_pred != NULL && (err = setjmp(yypcb->pcb_jmpbuf)) != 0) {
4212 bcopy(ojb, yypcb->pcb_jmpbuf, sizeof (jmp_buf));
4213 if (tries++ != 0 || err != EDT_COMPILER || (
4214 yypcb->pcb_hdl->dt_errtag != dt_errtag(D_IDENT_UNDEF) &&
4215 yypcb->pcb_hdl->dt_errtag != dt_errtag(D_VAR_UNDEF)))
4216 longjmp(yypcb->pcb_jmpbuf, err);
4217 }
4218
4219 if (tries == 0) {
4220 yylabel("action list");
4221
4222 dt_node_attr_assign(dnp,
4223 dt_node_list_cook(&dnp->dn_acts, idflags));
4224
4225 bcopy(ojb, yypcb->pcb_jmpbuf, sizeof (jmp_buf));
4226 yylabel(NULL);
4227 }
4228
4229 if (dnp->dn_pred != NULL) {
4230 yylabel("predicate");
4231
4232 dnp->dn_pred = dt_node_cook(dnp->dn_pred, idflags);
4233 dt_node_attr_assign(dnp,
4234 dt_attr_min(dnp->dn_attr, dnp->dn_pred->dn_attr));
4235
4236 if (!dt_node_is_scalar(dnp->dn_pred)) {
4237 xyerror(D_PRED_SCALAR,
4238 "predicate result must be of scalar type\n");
4239 }
4240
4241 yylabel(NULL);
4242 }
4243
4244 if (tries != 0) {
4245 yylabel("action list");
4246
4247 dt_node_attr_assign(dnp,
4248 dt_node_list_cook(&dnp->dn_acts, idflags));
4249
4250 yylabel(NULL);
4251 }
4252
4253 return (dnp);
4254 }
4255
4256 /*ARGSUSED*/
4257 static dt_node_t *
dt_cook_inline(dt_node_t * dnp,uint_t idflags)4258 dt_cook_inline(dt_node_t *dnp, uint_t idflags)
4259 {
4260 dt_idnode_t *inp = dnp->dn_ident->di_iarg;
4261 dt_ident_t *rdp;
4262
4263 char n1[DT_TYPE_NAMELEN];
4264 char n2[DT_TYPE_NAMELEN];
4265
4266 assert(dnp->dn_ident->di_flags & DT_IDFLG_INLINE);
4267 assert(inp->din_root->dn_flags & DT_NF_COOKED);
4268
4269 /*
4270 * If we are inlining a translation, verify that the inline declaration
4271 * type exactly matches the type that is returned by the translation.
4272 * Otherwise just use dt_node_is_argcompat() to check the types.
4273 */
4274 if ((rdp = dt_node_resolve(inp->din_root, DT_IDENT_XLSOU)) != NULL ||
4275 (rdp = dt_node_resolve(inp->din_root, DT_IDENT_XLPTR)) != NULL) {
4276
4277 ctf_file_t *lctfp = dnp->dn_ctfp;
4278 ctf_id_t ltype = ctf_type_resolve(lctfp, dnp->dn_type);
4279
4280 dt_xlator_t *dxp = rdp->di_data;
4281 ctf_file_t *rctfp = dxp->dx_dst_ctfp;
4282 ctf_id_t rtype = dxp->dx_dst_base;
4283
4284 if (ctf_type_kind(lctfp, ltype) == CTF_K_POINTER) {
4285 ltype = ctf_type_reference(lctfp, ltype);
4286 ltype = ctf_type_resolve(lctfp, ltype);
4287 }
4288
4289 if (ctf_type_compat(lctfp, ltype, rctfp, rtype) == 0) {
4290 dnerror(dnp, D_OP_INCOMPAT,
4291 "inline %s definition uses incompatible types: "
4292 "\"%s\" = \"%s\"\n", dnp->dn_ident->di_name,
4293 dt_type_name(lctfp, ltype, n1, sizeof (n1)),
4294 dt_type_name(rctfp, rtype, n2, sizeof (n2)));
4295 }
4296
4297 } else if (dt_node_is_argcompat(dnp, inp->din_root) == 0) {
4298 dnerror(dnp, D_OP_INCOMPAT,
4299 "inline %s definition uses incompatible types: "
4300 "\"%s\" = \"%s\"\n", dnp->dn_ident->di_name,
4301 dt_node_type_name(dnp, n1, sizeof (n1)),
4302 dt_node_type_name(inp->din_root, n2, sizeof (n2)));
4303 }
4304
4305 return (dnp);
4306 }
4307
4308 static dt_node_t *
dt_cook_member(dt_node_t * dnp,uint_t idflags)4309 dt_cook_member(dt_node_t *dnp, uint_t idflags)
4310 {
4311 dnp->dn_membexpr = dt_node_cook(dnp->dn_membexpr, idflags);
4312 dt_node_attr_assign(dnp, dnp->dn_membexpr->dn_attr);
4313 return (dnp);
4314 }
4315
4316 /*ARGSUSED*/
4317 static dt_node_t *
dt_cook_xlator(dt_node_t * dnp,uint_t idflags)4318 dt_cook_xlator(dt_node_t *dnp, uint_t idflags)
4319 {
4320 dtrace_hdl_t *dtp = yypcb->pcb_hdl;
4321 dt_xlator_t *dxp = dnp->dn_xlator;
4322 dt_node_t *mnp;
4323
4324 char n1[DT_TYPE_NAMELEN];
4325 char n2[DT_TYPE_NAMELEN];
4326
4327 dtrace_attribute_t attr = _dtrace_maxattr;
4328 ctf_membinfo_t ctm;
4329
4330 /*
4331 * Before cooking each translator member, we push a reference to the
4332 * hash containing translator-local identifiers on to pcb_globals to
4333 * temporarily interpose these identifiers in front of other globals.
4334 */
4335 dt_idstack_push(&yypcb->pcb_globals, dxp->dx_locals);
4336
4337 for (mnp = dnp->dn_members; mnp != NULL; mnp = mnp->dn_list) {
4338 if (ctf_member_info(dxp->dx_dst_ctfp, dxp->dx_dst_type,
4339 mnp->dn_membname, &ctm) == CTF_ERR) {
4340 xyerror(D_XLATE_MEMB,
4341 "translator member %s is not a member of %s\n",
4342 mnp->dn_membname, ctf_type_name(dxp->dx_dst_ctfp,
4343 dxp->dx_dst_type, n1, sizeof (n1)));
4344 }
4345
4346 (void) dt_node_cook(mnp, DT_IDFLG_REF);
4347 dt_node_type_assign(mnp, dxp->dx_dst_ctfp, ctm.ctm_type,
4348 B_FALSE);
4349 attr = dt_attr_min(attr, mnp->dn_attr);
4350
4351 if (dt_node_is_argcompat(mnp, mnp->dn_membexpr) == 0) {
4352 xyerror(D_XLATE_INCOMPAT,
4353 "translator member %s definition uses "
4354 "incompatible types: \"%s\" = \"%s\"\n",
4355 mnp->dn_membname,
4356 dt_node_type_name(mnp, n1, sizeof (n1)),
4357 dt_node_type_name(mnp->dn_membexpr,
4358 n2, sizeof (n2)));
4359 }
4360 }
4361
4362 dt_idstack_pop(&yypcb->pcb_globals, dxp->dx_locals);
4363
4364 dxp->dx_souid.di_attr = attr;
4365 dxp->dx_ptrid.di_attr = attr;
4366
4367 dt_node_type_assign(dnp, DT_DYN_CTFP(dtp), DT_DYN_TYPE(dtp), B_FALSE);
4368 dt_node_attr_assign(dnp, _dtrace_defattr);
4369
4370 return (dnp);
4371 }
4372
4373 static void
dt_node_provider_cmp_argv(dt_provider_t * pvp,dt_node_t * pnp,const char * kind,uint_t old_argc,dt_node_t * old_argv,uint_t new_argc,dt_node_t * new_argv)4374 dt_node_provider_cmp_argv(dt_provider_t *pvp, dt_node_t *pnp, const char *kind,
4375 uint_t old_argc, dt_node_t *old_argv, uint_t new_argc, dt_node_t *new_argv)
4376 {
4377 dt_probe_t *prp = pnp->dn_ident->di_data;
4378 uint_t i;
4379
4380 char n1[DT_TYPE_NAMELEN];
4381 char n2[DT_TYPE_NAMELEN];
4382
4383 if (old_argc != new_argc) {
4384 dnerror(pnp, D_PROV_INCOMPAT,
4385 "probe %s:%s %s prototype mismatch:\n"
4386 "\t current: %u arg%s\n\tprevious: %u arg%s\n",
4387 pvp->pv_desc.dtvd_name, prp->pr_ident->di_name, kind,
4388 new_argc, new_argc != 1 ? "s" : "",
4389 old_argc, old_argc != 1 ? "s" : "");
4390 }
4391
4392 for (i = 0; i < old_argc; i++,
4393 old_argv = old_argv->dn_list, new_argv = new_argv->dn_list) {
4394 if (ctf_type_cmp(old_argv->dn_ctfp, old_argv->dn_type,
4395 new_argv->dn_ctfp, new_argv->dn_type) == 0)
4396 continue;
4397
4398 dnerror(pnp, D_PROV_INCOMPAT,
4399 "probe %s:%s %s prototype argument #%u mismatch:\n"
4400 "\t current: %s\n\tprevious: %s\n",
4401 pvp->pv_desc.dtvd_name, prp->pr_ident->di_name, kind, i + 1,
4402 dt_node_type_name(new_argv, n1, sizeof (n1)),
4403 dt_node_type_name(old_argv, n2, sizeof (n2)));
4404 }
4405 }
4406
4407 /*
4408 * Compare a new probe declaration with an existing probe definition (either
4409 * from a previous declaration or cached from the kernel). If the existing
4410 * definition and declaration both have an input and output parameter list,
4411 * compare both lists. Otherwise compare only the output parameter lists.
4412 */
4413 static void
dt_node_provider_cmp(dt_provider_t * pvp,dt_node_t * pnp,dt_probe_t * old,dt_probe_t * new)4414 dt_node_provider_cmp(dt_provider_t *pvp, dt_node_t *pnp,
4415 dt_probe_t *old, dt_probe_t *new)
4416 {
4417 dt_node_provider_cmp_argv(pvp, pnp, "output",
4418 old->pr_xargc, old->pr_xargs, new->pr_xargc, new->pr_xargs);
4419
4420 if (old->pr_nargs != old->pr_xargs && new->pr_nargs != new->pr_xargs) {
4421 dt_node_provider_cmp_argv(pvp, pnp, "input",
4422 old->pr_nargc, old->pr_nargs, new->pr_nargc, new->pr_nargs);
4423 }
4424
4425 if (old->pr_nargs == old->pr_xargs && new->pr_nargs != new->pr_xargs) {
4426 if (pvp->pv_flags & DT_PROVIDER_IMPL) {
4427 dnerror(pnp, D_PROV_INCOMPAT,
4428 "provider interface mismatch: %s\n"
4429 "\t current: probe %s:%s has an output prototype\n"
4430 "\tprevious: probe %s:%s has no output prototype\n",
4431 pvp->pv_desc.dtvd_name, pvp->pv_desc.dtvd_name,
4432 new->pr_ident->di_name, pvp->pv_desc.dtvd_name,
4433 old->pr_ident->di_name);
4434 }
4435
4436 if (old->pr_ident->di_gen == yypcb->pcb_hdl->dt_gen)
4437 old->pr_ident->di_flags |= DT_IDFLG_ORPHAN;
4438
4439 dt_idhash_delete(pvp->pv_probes, old->pr_ident);
4440 dt_probe_declare(pvp, new);
4441 }
4442 }
4443
4444 static void
dt_cook_probe(dt_node_t * dnp,dt_provider_t * pvp)4445 dt_cook_probe(dt_node_t *dnp, dt_provider_t *pvp)
4446 {
4447 dtrace_hdl_t *dtp = yypcb->pcb_hdl;
4448 dt_probe_t *prp = dnp->dn_ident->di_data;
4449
4450 dt_xlator_t *dxp;
4451 uint_t i;
4452
4453 char n1[DT_TYPE_NAMELEN];
4454 char n2[DT_TYPE_NAMELEN];
4455
4456 if (prp->pr_nargs == prp->pr_xargs)
4457 return;
4458
4459 for (i = 0; i < prp->pr_xargc; i++) {
4460 dt_node_t *xnp = prp->pr_xargv[i];
4461 dt_node_t *nnp = prp->pr_nargv[prp->pr_mapping[i]];
4462
4463 if ((dxp = dt_xlator_lookup(dtp,
4464 nnp, xnp, DT_XLATE_FUZZY)) != NULL) {
4465 if (dt_provider_xref(dtp, pvp, dxp->dx_id) != 0)
4466 longjmp(yypcb->pcb_jmpbuf, EDT_NOMEM);
4467 continue;
4468 }
4469
4470 if (dt_node_is_argcompat(nnp, xnp))
4471 continue; /* no translator defined and none required */
4472
4473 dnerror(dnp, D_PROV_PRXLATOR, "translator for %s:%s output "
4474 "argument #%u from %s to %s is not defined\n",
4475 pvp->pv_desc.dtvd_name, dnp->dn_ident->di_name, i + 1,
4476 dt_node_type_name(nnp, n1, sizeof (n1)),
4477 dt_node_type_name(xnp, n2, sizeof (n2)));
4478 }
4479 }
4480
4481 /*ARGSUSED*/
4482 static dt_node_t *
dt_cook_provider(dt_node_t * dnp,uint_t idflags)4483 dt_cook_provider(dt_node_t *dnp, uint_t idflags)
4484 {
4485 dt_provider_t *pvp = dnp->dn_provider;
4486 dt_node_t *pnp;
4487
4488 /*
4489 * If we're declaring a provider for the first time and it is unknown
4490 * to dtrace(7D), insert the probe definitions into the provider's hash.
4491 * If we're redeclaring a known provider, verify the interface matches.
4492 */
4493 for (pnp = dnp->dn_probes; pnp != NULL; pnp = pnp->dn_list) {
4494 const char *probename = pnp->dn_ident->di_name;
4495 dt_probe_t *prp = dt_probe_lookup(pvp, probename);
4496
4497 assert(pnp->dn_kind == DT_NODE_PROBE);
4498
4499 if (prp != NULL && dnp->dn_provred) {
4500 dt_node_provider_cmp(pvp, pnp,
4501 prp, pnp->dn_ident->di_data);
4502 } else if (prp == NULL && dnp->dn_provred) {
4503 dnerror(pnp, D_PROV_INCOMPAT,
4504 "provider interface mismatch: %s\n"
4505 "\t current: probe %s:%s defined\n"
4506 "\tprevious: probe %s:%s not defined\n",
4507 dnp->dn_provname, dnp->dn_provname,
4508 probename, dnp->dn_provname, probename);
4509 } else if (prp != NULL) {
4510 dnerror(pnp, D_PROV_PRDUP, "probe redeclared: %s:%s\n",
4511 dnp->dn_provname, probename);
4512 } else
4513 dt_probe_declare(pvp, pnp->dn_ident->di_data);
4514
4515 dt_cook_probe(pnp, pvp);
4516 }
4517
4518 return (dnp);
4519 }
4520
4521 /*ARGSUSED*/
4522 static dt_node_t *
dt_cook_none(dt_node_t * dnp,uint_t idflags)4523 dt_cook_none(dt_node_t *dnp, uint_t idflags)
4524 {
4525 return (dnp);
4526 }
4527
4528 static dt_node_t *(* const dt_cook_funcs[])(dt_node_t *, uint_t) = {
4529 [DT_NODE_FREE] = dt_cook_none,
4530 [DT_NODE_INT] = dt_cook_none,
4531 [DT_NODE_STRING] = dt_cook_none,
4532 [DT_NODE_IDENT] = dt_cook_ident,
4533 [DT_NODE_VAR] = dt_cook_var,
4534 [DT_NODE_SYM] = dt_cook_none,
4535 [DT_NODE_TYPE] = dt_cook_none,
4536 [DT_NODE_FUNC] = dt_cook_func,
4537 [DT_NODE_OP1] = dt_cook_op1,
4538 [DT_NODE_OP2] = dt_cook_op2,
4539 [DT_NODE_OP3] = dt_cook_op3,
4540 [DT_NODE_DEXPR] = dt_cook_statement,
4541 [DT_NODE_DFUNC] = dt_cook_statement,
4542 [DT_NODE_AGG] = dt_cook_aggregation,
4543 [DT_NODE_PDESC] = dt_cook_none,
4544 [DT_NODE_CLAUSE] = dt_cook_clause,
4545 [DT_NODE_INLINE] = dt_cook_inline,
4546 [DT_NODE_MEMBER] = dt_cook_member,
4547 [DT_NODE_XLATOR] = dt_cook_xlator,
4548 [DT_NODE_PROBE] = dt_cook_none,
4549 [DT_NODE_PROVIDER] = dt_cook_provider,
4550 [DT_NODE_PROG] = dt_cook_none,
4551 [DT_NODE_IF] = dt_cook_none,
4552 };
4553
4554 /*
4555 * Recursively cook the parse tree starting at the specified node. The idflags
4556 * parameter is used to indicate the type of reference (r/w) and is applied to
4557 * the resulting identifier if it is a D variable or D aggregation.
4558 */
4559 dt_node_t *
dt_node_cook(dt_node_t * dnp,uint_t idflags)4560 dt_node_cook(dt_node_t *dnp, uint_t idflags)
4561 {
4562 int oldlineno = yylineno;
4563
4564 yylineno = dnp->dn_line;
4565
4566 assert(dnp->dn_kind <
4567 sizeof (dt_cook_funcs) / sizeof (dt_cook_funcs[0]));
4568 dnp = dt_cook_funcs[dnp->dn_kind](dnp, idflags);
4569 dnp->dn_flags |= DT_NF_COOKED;
4570
4571 if (dnp->dn_kind == DT_NODE_VAR || dnp->dn_kind == DT_NODE_AGG)
4572 dnp->dn_ident->di_flags |= idflags;
4573
4574 yylineno = oldlineno;
4575 return (dnp);
4576 }
4577
4578 dtrace_attribute_t
dt_node_list_cook(dt_node_t ** pnp,uint_t idflags)4579 dt_node_list_cook(dt_node_t **pnp, uint_t idflags)
4580 {
4581 dtrace_attribute_t attr = _dtrace_defattr;
4582 dt_node_t *dnp, *nnp;
4583
4584 for (dnp = (pnp != NULL ? *pnp : NULL); dnp != NULL; dnp = nnp) {
4585 nnp = dnp->dn_list;
4586 dnp = *pnp = dt_node_cook(dnp, idflags);
4587 attr = dt_attr_min(attr, dnp->dn_attr);
4588 dnp->dn_list = nnp;
4589 pnp = &dnp->dn_list;
4590 }
4591
4592 return (attr);
4593 }
4594
4595 void
dt_node_list_free(dt_node_t ** pnp)4596 dt_node_list_free(dt_node_t **pnp)
4597 {
4598 dt_node_t *dnp, *nnp;
4599
4600 for (dnp = (pnp != NULL ? *pnp : NULL); dnp != NULL; dnp = nnp) {
4601 nnp = dnp->dn_list;
4602 dt_node_free(dnp);
4603 }
4604
4605 if (pnp != NULL)
4606 *pnp = NULL;
4607 }
4608
4609 void
dt_node_link_free(dt_node_t ** pnp)4610 dt_node_link_free(dt_node_t **pnp)
4611 {
4612 dt_node_t *dnp, *nnp;
4613
4614 for (dnp = (pnp != NULL ? *pnp : NULL); dnp != NULL; dnp = nnp) {
4615 nnp = dnp->dn_link;
4616 dt_node_free(dnp);
4617 }
4618
4619 for (dnp = (pnp != NULL ? *pnp : NULL); dnp != NULL; dnp = nnp) {
4620 nnp = dnp->dn_link;
4621 free(dnp);
4622 }
4623
4624 if (pnp != NULL)
4625 *pnp = NULL;
4626 }
4627
4628 dt_node_t *
dt_node_link(dt_node_t * lp,dt_node_t * rp)4629 dt_node_link(dt_node_t *lp, dt_node_t *rp)
4630 {
4631 dt_node_t *dnp;
4632
4633 if (lp == NULL)
4634 return (rp);
4635 else if (rp == NULL)
4636 return (lp);
4637
4638 for (dnp = lp; dnp->dn_list != NULL; dnp = dnp->dn_list)
4639 continue;
4640
4641 dnp->dn_list = rp;
4642 return (lp);
4643 }
4644
4645 /*
4646 * Compute the DOF dtrace_diftype_t representation of a node's type. This is
4647 * called from a variety of places in the library so it cannot assume yypcb
4648 * is valid: any references to handle-specific data must be made through 'dtp'.
4649 */
4650 void
dt_node_diftype(dtrace_hdl_t * dtp,const dt_node_t * dnp,dtrace_diftype_t * tp)4651 dt_node_diftype(dtrace_hdl_t *dtp, const dt_node_t *dnp, dtrace_diftype_t *tp)
4652 {
4653 if (dnp->dn_ctfp == DT_STR_CTFP(dtp) &&
4654 dnp->dn_type == DT_STR_TYPE(dtp)) {
4655 tp->dtdt_kind = DIF_TYPE_STRING;
4656 tp->dtdt_ckind = CTF_K_UNKNOWN;
4657 } else {
4658 tp->dtdt_kind = DIF_TYPE_CTF;
4659 tp->dtdt_ckind = ctf_type_kind(dnp->dn_ctfp,
4660 ctf_type_resolve(dnp->dn_ctfp, dnp->dn_type));
4661 }
4662
4663 tp->dtdt_flags = (dnp->dn_flags & DT_NF_REF) ?
4664 (dnp->dn_flags & DT_NF_USERLAND) ? DIF_TF_BYUREF :
4665 DIF_TF_BYREF : 0;
4666 tp->dtdt_pad = 0;
4667 tp->dtdt_size = ctf_type_size(dnp->dn_ctfp, dnp->dn_type);
4668 }
4669
4670 /*
4671 * Output the parse tree as D. The "-xtree=8" argument will call this
4672 * function to print out the program after any syntactic sugar
4673 * transformations have been applied (e.g. to implement "if"). The
4674 * resulting output can be used to understand the transformations
4675 * applied by these features, or to run such a script on a system that
4676 * does not support these features
4677 *
4678 * Note that the output does not express precisely the same program as
4679 * the input. In particular:
4680 * - Only the clauses are output. #pragma options, variable
4681 * declarations, etc. are excluded.
4682 * - Command argument substitution has already been done, so the output
4683 * will not contain e.g. $$1, but rather the substituted string.
4684 */
4685 void
dt_printd(dt_node_t * dnp,FILE * fp,int depth)4686 dt_printd(dt_node_t *dnp, FILE *fp, int depth)
4687 {
4688 dt_node_t *arg;
4689
4690 switch (dnp->dn_kind) {
4691 case DT_NODE_INT:
4692 (void) fprintf(fp, "0x%llx", (u_longlong_t)dnp->dn_value);
4693 if (!(dnp->dn_flags & DT_NF_SIGNED))
4694 (void) fprintf(fp, "u");
4695 break;
4696
4697 case DT_NODE_STRING: {
4698 char *escd = strchr2esc(dnp->dn_string, strlen(dnp->dn_string));
4699 (void) fprintf(fp, "\"%s\"", escd);
4700 free(escd);
4701 break;
4702 }
4703
4704 case DT_NODE_IDENT:
4705 (void) fprintf(fp, "%s", dnp->dn_string);
4706 break;
4707
4708 case DT_NODE_VAR:
4709 (void) fprintf(fp, "%s%s",
4710 (dnp->dn_ident->di_flags & DT_IDFLG_LOCAL) ? "this->" :
4711 (dnp->dn_ident->di_flags & DT_IDFLG_TLS) ? "self->" : "",
4712 dnp->dn_ident->di_name);
4713
4714 if (dnp->dn_args != NULL) {
4715 (void) fprintf(fp, "[");
4716
4717 for (arg = dnp->dn_args; arg != NULL;
4718 arg = arg->dn_list) {
4719 dt_printd(arg, fp, 0);
4720 if (arg->dn_list != NULL)
4721 (void) fprintf(fp, ", ");
4722 }
4723
4724 (void) fprintf(fp, "]");
4725 }
4726 break;
4727
4728 case DT_NODE_SYM: {
4729 const dtrace_syminfo_t *dts = dnp->dn_ident->di_data;
4730 (void) fprintf(fp, "%s`%s", dts->dts_object, dts->dts_name);
4731 break;
4732 }
4733 case DT_NODE_FUNC:
4734 (void) fprintf(fp, "%s(", dnp->dn_ident->di_name);
4735
4736 for (arg = dnp->dn_args; arg != NULL; arg = arg->dn_list) {
4737 dt_printd(arg, fp, 0);
4738 if (arg->dn_list != NULL)
4739 (void) fprintf(fp, ", ");
4740 }
4741 (void) fprintf(fp, ")");
4742 break;
4743
4744 case DT_NODE_OP1:
4745 (void) fprintf(fp, "%s(", opstr(dnp->dn_op));
4746 dt_printd(dnp->dn_child, fp, 0);
4747 (void) fprintf(fp, ")");
4748 break;
4749
4750 case DT_NODE_OP2:
4751 (void) fprintf(fp, "(");
4752 dt_printd(dnp->dn_left, fp, 0);
4753 if (dnp->dn_op == DT_TOK_LPAR) {
4754 (void) fprintf(fp, ")");
4755 dt_printd(dnp->dn_right, fp, 0);
4756 break;
4757 }
4758 if (dnp->dn_op == DT_TOK_PTR || dnp->dn_op == DT_TOK_DOT ||
4759 dnp->dn_op == DT_TOK_LBRAC)
4760 (void) fprintf(fp, "%s", opstr(dnp->dn_op));
4761 else
4762 (void) fprintf(fp, " %s ", opstr(dnp->dn_op));
4763 dt_printd(dnp->dn_right, fp, 0);
4764 if (dnp->dn_op == DT_TOK_LBRAC) {
4765 dt_node_t *ln = dnp->dn_right;
4766 while (ln->dn_list != NULL) {
4767 (void) fprintf(fp, ", ");
4768 dt_printd(ln->dn_list, fp, depth);
4769 ln = ln->dn_list;
4770 }
4771 (void) fprintf(fp, "]");
4772 }
4773 (void) fprintf(fp, ")");
4774 break;
4775
4776 case DT_NODE_OP3:
4777 (void) fprintf(fp, "(");
4778 dt_printd(dnp->dn_expr, fp, 0);
4779 (void) fprintf(fp, " ? ");
4780 dt_printd(dnp->dn_left, fp, 0);
4781 (void) fprintf(fp, " : ");
4782 dt_printd(dnp->dn_right, fp, 0);
4783 (void) fprintf(fp, ")");
4784 break;
4785
4786 case DT_NODE_DEXPR:
4787 case DT_NODE_DFUNC:
4788 (void) fprintf(fp, "%*s", depth * 8, "");
4789 dt_printd(dnp->dn_expr, fp, depth + 1);
4790 (void) fprintf(fp, ";\n");
4791 break;
4792
4793 case DT_NODE_PDESC:
4794 (void) fprintf(fp, "%s:%s:%s:%s",
4795 dnp->dn_desc->dtpd_provider, dnp->dn_desc->dtpd_mod,
4796 dnp->dn_desc->dtpd_func, dnp->dn_desc->dtpd_name);
4797 break;
4798
4799 case DT_NODE_CLAUSE:
4800 for (arg = dnp->dn_pdescs; arg != NULL; arg = arg->dn_list) {
4801 dt_printd(arg, fp, 0);
4802 if (arg->dn_list != NULL)
4803 (void) fprintf(fp, ",");
4804 (void) fprintf(fp, "\n");
4805 }
4806
4807 if (dnp->dn_pred != NULL) {
4808 (void) fprintf(fp, "/");
4809 dt_printd(dnp->dn_pred, fp, 0);
4810 (void) fprintf(fp, "/\n");
4811 }
4812
4813 (void) fprintf(fp, "{\n");
4814 for (arg = dnp->dn_acts; arg != NULL; arg = arg->dn_list)
4815 dt_printd(arg, fp, depth + 1);
4816 (void) fprintf(fp, "}\n");
4817 (void) fprintf(fp, "\n");
4818 break;
4819
4820 case DT_NODE_IF:
4821 (void) fprintf(fp, "%*sif (", depth * 8, "");
4822 dt_printd(dnp->dn_conditional, fp, 0);
4823 (void) fprintf(fp, ") {\n");
4824
4825 for (arg = dnp->dn_body; arg != NULL; arg = arg->dn_list)
4826 dt_printd(arg, fp, depth + 1);
4827 if (dnp->dn_alternate_body == NULL) {
4828 (void) fprintf(fp, "%*s}\n", depth * 8, "");
4829 } else {
4830 (void) fprintf(fp, "%*s} else {\n", depth * 8, "");
4831 for (arg = dnp->dn_alternate_body; arg != NULL;
4832 arg = arg->dn_list)
4833 dt_printd(arg, fp, depth + 1);
4834 (void) fprintf(fp, "%*s}\n", depth * 8, "");
4835 }
4836
4837 break;
4838
4839 default:
4840 (void) fprintf(fp, "/* bad node %p, kind %d */\n",
4841 (void *)dnp, dnp->dn_kind);
4842 }
4843 }
4844
4845 void
dt_node_printr(dt_node_t * dnp,FILE * fp,int depth)4846 dt_node_printr(dt_node_t *dnp, FILE *fp, int depth)
4847 {
4848 char n[DT_TYPE_NAMELEN], buf[BUFSIZ], a[8];
4849 const dtrace_syminfo_t *dts;
4850 const dt_idnode_t *inp;
4851 dt_node_t *arg;
4852
4853 (void) fprintf(fp, "%*s", depth * 2, "");
4854 (void) dt_attr_str(dnp->dn_attr, a, sizeof (a));
4855
4856 if (dnp->dn_ctfp != NULL && dnp->dn_type != CTF_ERR &&
4857 ctf_type_name(dnp->dn_ctfp, dnp->dn_type, n, sizeof (n)) != NULL) {
4858 (void) snprintf(buf, BUFSIZ, "type=<%s> attr=%s flags=", n, a);
4859 } else {
4860 (void) snprintf(buf, BUFSIZ, "type=<%ld> attr=%s flags=",
4861 dnp->dn_type, a);
4862 }
4863
4864 if (dnp->dn_flags != 0) {
4865 n[0] = '\0';
4866 if (dnp->dn_flags & DT_NF_SIGNED)
4867 (void) strcat(n, ",SIGN");
4868 if (dnp->dn_flags & DT_NF_COOKED)
4869 (void) strcat(n, ",COOK");
4870 if (dnp->dn_flags & DT_NF_REF)
4871 (void) strcat(n, ",REF");
4872 if (dnp->dn_flags & DT_NF_LVALUE)
4873 (void) strcat(n, ",LVAL");
4874 if (dnp->dn_flags & DT_NF_WRITABLE)
4875 (void) strcat(n, ",WRITE");
4876 if (dnp->dn_flags & DT_NF_BITFIELD)
4877 (void) strcat(n, ",BITF");
4878 if (dnp->dn_flags & DT_NF_USERLAND)
4879 (void) strcat(n, ",USER");
4880 (void) strcat(buf, n + 1);
4881 } else
4882 (void) strcat(buf, "0");
4883
4884 switch (dnp->dn_kind) {
4885 case DT_NODE_FREE:
4886 (void) fprintf(fp, "FREE <node %p>\n", (void *)dnp);
4887 break;
4888
4889 case DT_NODE_INT:
4890 (void) fprintf(fp, "INT 0x%llx (%s)\n",
4891 (u_longlong_t)dnp->dn_value, buf);
4892 break;
4893
4894 case DT_NODE_STRING:
4895 (void) fprintf(fp, "STRING \"%s\" (%s)\n", dnp->dn_string, buf);
4896 break;
4897
4898 case DT_NODE_IDENT:
4899 (void) fprintf(fp, "IDENT %s (%s)\n", dnp->dn_string, buf);
4900 break;
4901
4902 case DT_NODE_VAR:
4903 (void) fprintf(fp, "VARIABLE %s%s (%s)\n",
4904 (dnp->dn_ident->di_flags & DT_IDFLG_LOCAL) ? "this->" :
4905 (dnp->dn_ident->di_flags & DT_IDFLG_TLS) ? "self->" : "",
4906 dnp->dn_ident->di_name, buf);
4907
4908 if (dnp->dn_args != NULL)
4909 (void) fprintf(fp, "%*s[\n", depth * 2, "");
4910
4911 for (arg = dnp->dn_args; arg != NULL; arg = arg->dn_list) {
4912 dt_node_printr(arg, fp, depth + 1);
4913 if (arg->dn_list != NULL)
4914 (void) fprintf(fp, "%*s,\n", depth * 2, "");
4915 }
4916
4917 if (dnp->dn_args != NULL)
4918 (void) fprintf(fp, "%*s]\n", depth * 2, "");
4919 break;
4920
4921 case DT_NODE_SYM:
4922 dts = dnp->dn_ident->di_data;
4923 (void) fprintf(fp, "SYMBOL %s`%s (%s)\n",
4924 dts->dts_object, dts->dts_name, buf);
4925 break;
4926
4927 case DT_NODE_TYPE:
4928 if (dnp->dn_string != NULL) {
4929 (void) fprintf(fp, "TYPE (%s) %s\n",
4930 buf, dnp->dn_string);
4931 } else
4932 (void) fprintf(fp, "TYPE (%s)\n", buf);
4933 break;
4934
4935 case DT_NODE_FUNC:
4936 (void) fprintf(fp, "FUNC %s (%s)\n",
4937 dnp->dn_ident->di_name, buf);
4938
4939 for (arg = dnp->dn_args; arg != NULL; arg = arg->dn_list) {
4940 dt_node_printr(arg, fp, depth + 1);
4941 if (arg->dn_list != NULL)
4942 (void) fprintf(fp, "%*s,\n", depth * 2, "");
4943 }
4944 break;
4945
4946 case DT_NODE_OP1:
4947 (void) fprintf(fp, "OP1 %s (%s)\n", opstr(dnp->dn_op), buf);
4948 dt_node_printr(dnp->dn_child, fp, depth + 1);
4949 break;
4950
4951 case DT_NODE_OP2:
4952 (void) fprintf(fp, "OP2 %s (%s)\n", opstr(dnp->dn_op), buf);
4953 dt_node_printr(dnp->dn_left, fp, depth + 1);
4954 dt_node_printr(dnp->dn_right, fp, depth + 1);
4955 if (dnp->dn_op == DT_TOK_LBRAC) {
4956 dt_node_t *ln = dnp->dn_right;
4957 while (ln->dn_list != NULL) {
4958 dt_node_printr(ln->dn_list, fp, depth + 1);
4959 ln = ln->dn_list;
4960 }
4961 }
4962 break;
4963
4964 case DT_NODE_OP3:
4965 (void) fprintf(fp, "OP3 (%s)\n", buf);
4966 dt_node_printr(dnp->dn_expr, fp, depth + 1);
4967 (void) fprintf(fp, "%*s?\n", depth * 2, "");
4968 dt_node_printr(dnp->dn_left, fp, depth + 1);
4969 (void) fprintf(fp, "%*s:\n", depth * 2, "");
4970 dt_node_printr(dnp->dn_right, fp, depth + 1);
4971 break;
4972
4973 case DT_NODE_DEXPR:
4974 case DT_NODE_DFUNC:
4975 (void) fprintf(fp, "D EXPRESSION attr=%s\n", a);
4976 dt_node_printr(dnp->dn_expr, fp, depth + 1);
4977 break;
4978
4979 case DT_NODE_AGG:
4980 (void) fprintf(fp, "AGGREGATE @%s attr=%s [\n",
4981 dnp->dn_ident->di_name, a);
4982
4983 for (arg = dnp->dn_aggtup; arg != NULL; arg = arg->dn_list) {
4984 dt_node_printr(arg, fp, depth + 1);
4985 if (arg->dn_list != NULL)
4986 (void) fprintf(fp, "%*s,\n", depth * 2, "");
4987 }
4988
4989 if (dnp->dn_aggfun) {
4990 (void) fprintf(fp, "%*s] = ", depth * 2, "");
4991 dt_node_printr(dnp->dn_aggfun, fp, depth + 1);
4992 } else
4993 (void) fprintf(fp, "%*s]\n", depth * 2, "");
4994
4995 if (dnp->dn_aggfun)
4996 (void) fprintf(fp, "%*s)\n", depth * 2, "");
4997 break;
4998
4999 case DT_NODE_PDESC:
5000 (void) fprintf(fp, "PDESC %s:%s:%s:%s [%u]\n",
5001 dnp->dn_desc->dtpd_provider, dnp->dn_desc->dtpd_mod,
5002 dnp->dn_desc->dtpd_func, dnp->dn_desc->dtpd_name,
5003 dnp->dn_desc->dtpd_id);
5004 break;
5005
5006 case DT_NODE_CLAUSE:
5007 (void) fprintf(fp, "CLAUSE attr=%s\n", a);
5008
5009 for (arg = dnp->dn_pdescs; arg != NULL; arg = arg->dn_list)
5010 dt_node_printr(arg, fp, depth + 1);
5011
5012 (void) fprintf(fp, "%*sCTXATTR %s\n", depth * 2, "",
5013 dt_attr_str(dnp->dn_ctxattr, a, sizeof (a)));
5014
5015 if (dnp->dn_pred != NULL) {
5016 (void) fprintf(fp, "%*sPREDICATE /\n", depth * 2, "");
5017 dt_node_printr(dnp->dn_pred, fp, depth + 1);
5018 (void) fprintf(fp, "%*s/\n", depth * 2, "");
5019 }
5020
5021 for (arg = dnp->dn_acts; arg != NULL; arg = arg->dn_list)
5022 dt_node_printr(arg, fp, depth + 1);
5023 (void) fprintf(fp, "\n");
5024 break;
5025
5026 case DT_NODE_INLINE:
5027 inp = dnp->dn_ident->di_iarg;
5028
5029 (void) fprintf(fp, "INLINE %s (%s)\n",
5030 dnp->dn_ident->di_name, buf);
5031 dt_node_printr(inp->din_root, fp, depth + 1);
5032 break;
5033
5034 case DT_NODE_MEMBER:
5035 (void) fprintf(fp, "MEMBER %s (%s)\n", dnp->dn_membname, buf);
5036 if (dnp->dn_membexpr)
5037 dt_node_printr(dnp->dn_membexpr, fp, depth + 1);
5038 break;
5039
5040 case DT_NODE_XLATOR:
5041 (void) fprintf(fp, "XLATOR (%s)", buf);
5042
5043 if (ctf_type_name(dnp->dn_xlator->dx_src_ctfp,
5044 dnp->dn_xlator->dx_src_type, n, sizeof (n)) != NULL)
5045 (void) fprintf(fp, " from <%s>", n);
5046
5047 if (ctf_type_name(dnp->dn_xlator->dx_dst_ctfp,
5048 dnp->dn_xlator->dx_dst_type, n, sizeof (n)) != NULL)
5049 (void) fprintf(fp, " to <%s>", n);
5050
5051 (void) fprintf(fp, "\n");
5052
5053 for (arg = dnp->dn_members; arg != NULL; arg = arg->dn_list)
5054 dt_node_printr(arg, fp, depth + 1);
5055 break;
5056
5057 case DT_NODE_PROBE:
5058 (void) fprintf(fp, "PROBE %s\n", dnp->dn_ident->di_name);
5059 break;
5060
5061 case DT_NODE_PROVIDER:
5062 (void) fprintf(fp, "PROVIDER %s (%s)\n",
5063 dnp->dn_provname, dnp->dn_provred ? "redecl" : "decl");
5064 for (arg = dnp->dn_probes; arg != NULL; arg = arg->dn_list)
5065 dt_node_printr(arg, fp, depth + 1);
5066 break;
5067
5068 case DT_NODE_PROG:
5069 (void) fprintf(fp, "PROGRAM attr=%s\n", a);
5070 for (arg = dnp->dn_list; arg != NULL; arg = arg->dn_list)
5071 dt_node_printr(arg, fp, depth + 1);
5072 break;
5073
5074 case DT_NODE_IF:
5075 (void) fprintf(fp, "IF attr=%s CONDITION:\n", a);
5076
5077 dt_node_printr(dnp->dn_conditional, fp, depth + 1);
5078
5079 (void) fprintf(fp, "%*sIF BODY: \n", depth * 2, "");
5080 for (arg = dnp->dn_body; arg != NULL; arg = arg->dn_list)
5081 dt_node_printr(arg, fp, depth + 1);
5082
5083 if (dnp->dn_alternate_body != NULL) {
5084 (void) fprintf(fp, "%*sIF ELSE: \n", depth * 2, "");
5085 for (arg = dnp->dn_alternate_body; arg != NULL;
5086 arg = arg->dn_list)
5087 dt_node_printr(arg, fp, depth + 1);
5088 }
5089
5090 break;
5091
5092 default:
5093 (void) fprintf(fp, "<bad node %p, kind %d>\n",
5094 (void *)dnp, dnp->dn_kind);
5095 }
5096 }
5097
5098 int
dt_node_root(dt_node_t * dnp)5099 dt_node_root(dt_node_t *dnp)
5100 {
5101 yypcb->pcb_root = dnp;
5102 return (0);
5103 }
5104
5105 /*PRINTFLIKE3*/
5106 void
dnerror(const dt_node_t * dnp,dt_errtag_t tag,const char * format,...)5107 dnerror(const dt_node_t *dnp, dt_errtag_t tag, const char *format, ...)
5108 {
5109 int oldlineno = yylineno;
5110 va_list ap;
5111
5112 yylineno = dnp->dn_line;
5113
5114 va_start(ap, format);
5115 xyvwarn(tag, format, ap);
5116 va_end(ap);
5117
5118 yylineno = oldlineno;
5119 longjmp(yypcb->pcb_jmpbuf, EDT_COMPILER);
5120 }
5121
5122 /*PRINTFLIKE3*/
5123 void
dnwarn(const dt_node_t * dnp,dt_errtag_t tag,const char * format,...)5124 dnwarn(const dt_node_t *dnp, dt_errtag_t tag, const char *format, ...)
5125 {
5126 int oldlineno = yylineno;
5127 va_list ap;
5128
5129 yylineno = dnp->dn_line;
5130
5131 va_start(ap, format);
5132 xyvwarn(tag, format, ap);
5133 va_end(ap);
5134
5135 yylineno = oldlineno;
5136 }
5137
5138 /*PRINTFLIKE2*/
5139 void
xyerror(dt_errtag_t tag,const char * format,...)5140 xyerror(dt_errtag_t tag, const char *format, ...)
5141 {
5142 va_list ap;
5143
5144 va_start(ap, format);
5145 xyvwarn(tag, format, ap);
5146 va_end(ap);
5147
5148 longjmp(yypcb->pcb_jmpbuf, EDT_COMPILER);
5149 }
5150
5151 /*PRINTFLIKE2*/
5152 void
xywarn(dt_errtag_t tag,const char * format,...)5153 xywarn(dt_errtag_t tag, const char *format, ...)
5154 {
5155 va_list ap;
5156
5157 va_start(ap, format);
5158 xyvwarn(tag, format, ap);
5159 va_end(ap);
5160 }
5161
5162 void
xyvwarn(dt_errtag_t tag,const char * format,va_list ap)5163 xyvwarn(dt_errtag_t tag, const char *format, va_list ap)
5164 {
5165 if (yypcb == NULL)
5166 return; /* compiler is not currently active: act as a no-op */
5167
5168 dt_set_errmsg(yypcb->pcb_hdl, dt_errtag(tag), yypcb->pcb_region,
5169 yypcb->pcb_filetag, yypcb->pcb_fileptr ? yylineno : 0, format, ap);
5170 }
5171
5172 /*PRINTFLIKE1*/
5173 void
yyerror(const char * format,...)5174 yyerror(const char *format, ...)
5175 {
5176 va_list ap;
5177
5178 va_start(ap, format);
5179 yyvwarn(format, ap);
5180 va_end(ap);
5181
5182 longjmp(yypcb->pcb_jmpbuf, EDT_COMPILER);
5183 }
5184
5185 /*PRINTFLIKE1*/
5186 void
yywarn(const char * format,...)5187 yywarn(const char *format, ...)
5188 {
5189 va_list ap;
5190
5191 va_start(ap, format);
5192 yyvwarn(format, ap);
5193 va_end(ap);
5194 }
5195
5196 void
yyvwarn(const char * format,va_list ap)5197 yyvwarn(const char *format, va_list ap)
5198 {
5199 if (yypcb == NULL)
5200 return; /* compiler is not currently active: act as a no-op */
5201
5202 dt_set_errmsg(yypcb->pcb_hdl, dt_errtag(D_SYNTAX), yypcb->pcb_region,
5203 yypcb->pcb_filetag, yypcb->pcb_fileptr ? yylineno : 0, format, ap);
5204
5205 if (strchr(format, '\n') == NULL) {
5206 dtrace_hdl_t *dtp = yypcb->pcb_hdl;
5207 size_t len = strlen(dtp->dt_errmsg);
5208 char *p, *s = dtp->dt_errmsg + len;
5209 size_t n = sizeof (dtp->dt_errmsg) - len;
5210
5211 if (yytext[0] == '\0')
5212 (void) snprintf(s, n, " near end of input");
5213 else if (yytext[0] == '\n')
5214 (void) snprintf(s, n, " near end of line");
5215 else {
5216 if ((p = strchr(yytext, '\n')) != NULL)
5217 *p = '\0'; /* crop at newline */
5218 (void) snprintf(s, n, " near \"%s\"", yytext);
5219 }
5220 }
5221 }
5222
5223 void
yylabel(const char * label)5224 yylabel(const char *label)
5225 {
5226 dt_dprintf("set label to <%s>\n", label ? label : "NULL");
5227 yypcb->pcb_region = label;
5228 }
5229
5230 int
yywrap(void)5231 yywrap(void)
5232 {
5233 return (1); /* indicate that lex should return a zero token for EOF */
5234 }
5235