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