17c478bd9Sstevel@tonic-gate /*
27c478bd9Sstevel@tonic-gate  * CDDL HEADER START
37c478bd9Sstevel@tonic-gate  *
47c478bd9Sstevel@tonic-gate  * The contents of this file are subject to the terms of the
523a1cceaSRoger A. Faulkner  * Common Development and Distribution License (the "License").
623a1cceaSRoger A. Faulkner  * You may not use this file except in compliance with the License.
77c478bd9Sstevel@tonic-gate  *
87c478bd9Sstevel@tonic-gate  * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE
97c478bd9Sstevel@tonic-gate  * or http://www.opensolaris.org/os/licensing.
107c478bd9Sstevel@tonic-gate  * See the License for the specific language governing permissions
117c478bd9Sstevel@tonic-gate  * and limitations under the License.
127c478bd9Sstevel@tonic-gate  *
137c478bd9Sstevel@tonic-gate  * When distributing Covered Code, include this CDDL HEADER in each
147c478bd9Sstevel@tonic-gate  * file and include the License file at usr/src/OPENSOLARIS.LICENSE.
157c478bd9Sstevel@tonic-gate  * If applicable, add the following below this CDDL HEADER, with the
167c478bd9Sstevel@tonic-gate  * fields enclosed by brackets "[]" replaced with your own identifying
177c478bd9Sstevel@tonic-gate  * information: Portions Copyright [yyyy] [name of copyright owner]
187c478bd9Sstevel@tonic-gate  *
197c478bd9Sstevel@tonic-gate  * CDDL HEADER END
207c478bd9Sstevel@tonic-gate  */
21e4586ebfSmws 
227c478bd9Sstevel@tonic-gate /*
2323a1cceaSRoger A. Faulkner  * Copyright (c) 2003, 2010, Oracle and/or its affiliates. All rights reserved.
24ec57c73dSBryan Cantrill  * Copyright (c) 2011, Joyent Inc. All rights reserved.
25*e5803b76SAdam H. Leventhal  * Copyright (c) 2012 by Delphix. All rights reserved.
267c478bd9Sstevel@tonic-gate  */
277c478bd9Sstevel@tonic-gate 
287c478bd9Sstevel@tonic-gate /*
297c478bd9Sstevel@tonic-gate  * DTrace D Language Parser
307c478bd9Sstevel@tonic-gate  *
317c478bd9Sstevel@tonic-gate  * The D Parser is a lex/yacc parser consisting of the lexer dt_lex.l, the
327c478bd9Sstevel@tonic-gate  * parsing grammar dt_grammar.y, and this file, dt_parser.c, which handles
337c478bd9Sstevel@tonic-gate  * the construction of the parse tree nodes and their syntactic validation.
347c478bd9Sstevel@tonic-gate  * The parse tree is constructed of dt_node_t structures (see <dt_parser.h>)
357c478bd9Sstevel@tonic-gate  * that are built in two passes: (1) the "create" pass, where the parse tree
367c478bd9Sstevel@tonic-gate  * nodes are allocated by calls from the grammar to dt_node_*() subroutines,
377c478bd9Sstevel@tonic-gate  * and (2) the "cook" pass, where nodes are coalesced, assigned D types, and
387c478bd9Sstevel@tonic-gate  * validated according to the syntactic rules of the language.
397c478bd9Sstevel@tonic-gate  *
407c478bd9Sstevel@tonic-gate  * All node allocations are performed using dt_node_alloc().  All node frees
417c478bd9Sstevel@tonic-gate  * during the parsing phase are performed by dt_node_free(), which frees node-
427c478bd9Sstevel@tonic-gate  * internal state but does not actually free the nodes.  All final node frees
437c478bd9Sstevel@tonic-gate  * are done as part of the end of dt_compile() or as part of destroying
447c478bd9Sstevel@tonic-gate  * persistent identifiers or translators which have embedded nodes.
457c478bd9Sstevel@tonic-gate  *
467c478bd9Sstevel@tonic-gate  * The dt_node_* routines that implement pass (1) may allocate new nodes.  The
477c478bd9Sstevel@tonic-gate  * dt_cook_* routines that implement pass (2) may *not* allocate new nodes.
487c478bd9Sstevel@tonic-gate  * They may free existing nodes using dt_node_free(), but they may not actually
497c478bd9Sstevel@tonic-gate  * deallocate any dt_node_t's.  Currently dt_cook_op2() is an exception to this
507c478bd9Sstevel@tonic-gate  * rule: see the comments therein for how this issue is resolved.
517c478bd9Sstevel@tonic-gate  *
527c478bd9Sstevel@tonic-gate  * The dt_cook_* routines are responsible for (at minimum) setting the final
537c478bd9Sstevel@tonic-gate  * node type (dn_ctfp/dn_type) and attributes (dn_attr).  If dn_ctfp/dn_type
547c478bd9Sstevel@tonic-gate  * are set manually (i.e. not by one of the type assignment functions), then
557c478bd9Sstevel@tonic-gate  * the DT_NF_COOKED flag must be set manually on the node.
567c478bd9Sstevel@tonic-gate  *
577c478bd9Sstevel@tonic-gate  * The cooking pass can be applied to the same parse tree more than once (used
587c478bd9Sstevel@tonic-gate  * in the case of a comma-separated list of probe descriptions).  As such, the
597c478bd9Sstevel@tonic-gate  * cook routines must not perform any parse tree transformations which would
607c478bd9Sstevel@tonic-gate  * be invalid if the tree were subsequently cooked using a different context.
617c478bd9Sstevel@tonic-gate  *
627c478bd9Sstevel@tonic-gate  * The dn_ctfp and dn_type fields form the type of the node.  This tuple can
637c478bd9Sstevel@tonic-gate  * take on the following set of values, which form our type invariants:
647c478bd9Sstevel@tonic-gate  *
657c478bd9Sstevel@tonic-gate  * 1. dn_ctfp = NULL, dn_type = CTF_ERR
667c478bd9Sstevel@tonic-gate  *
677c478bd9Sstevel@tonic-gate  *    In this state, the node has unknown type and is not yet cooked.  The
687c478bd9Sstevel@tonic-gate  *    DT_NF_COOKED flag is not yet set on the node.
697c478bd9Sstevel@tonic-gate  *
707c478bd9Sstevel@tonic-gate  * 2. dn_ctfp = DT_DYN_CTFP(dtp), dn_type = DT_DYN_TYPE(dtp)
717c478bd9Sstevel@tonic-gate  *
727c478bd9Sstevel@tonic-gate  *    In this state, the node is a dynamic D type.  This means that generic
737c478bd9Sstevel@tonic-gate  *    operations are not valid on this node and only code that knows how to
747c478bd9Sstevel@tonic-gate  *    examine the inner details of the node can operate on it.  A <DYN> node
757c478bd9Sstevel@tonic-gate  *    must have dn_ident set to point to an identifier describing the object
767c478bd9Sstevel@tonic-gate  *    and its type.  The DT_NF_REF flag is set for all nodes of type <DYN>.
777c478bd9Sstevel@tonic-gate  *    At present, the D compiler uses the <DYN> type for:
787c478bd9Sstevel@tonic-gate  *
797c478bd9Sstevel@tonic-gate  *    - associative arrays that do not yet have a value type defined
807c478bd9Sstevel@tonic-gate  *    - translated data (i.e. the result of the xlate operator)
817c478bd9Sstevel@tonic-gate  *    - aggregations
827c478bd9Sstevel@tonic-gate  *
837c478bd9Sstevel@tonic-gate  * 3. dn_ctfp = DT_STR_CTFP(dtp), dn_type = DT_STR_TYPE(dtp)
847c478bd9Sstevel@tonic-gate  *
857c478bd9Sstevel@tonic-gate  *    In this state, the node is of type D string.  The string type is really
867c478bd9Sstevel@tonic-gate  *    a char[0] typedef, but requires special handling throughout the compiler.
877c478bd9Sstevel@tonic-gate  *
887c478bd9Sstevel@tonic-gate  * 4. dn_ctfp != NULL, dn_type = any other type ID
897c478bd9Sstevel@tonic-gate  *
907c478bd9Sstevel@tonic-gate  *    In this state, the node is of some known D/CTF type.  The normal libctf
917c478bd9Sstevel@tonic-gate  *    APIs can be used to learn more about the type name or structure.  When
927c478bd9Sstevel@tonic-gate  *    the type is assigned, the DT_NF_SIGNED, DT_NF_REF, and DT_NF_BITFIELD
937c478bd9Sstevel@tonic-gate  *    flags cache the corresponding attributes of the underlying CTF type.
947c478bd9Sstevel@tonic-gate  */
957c478bd9Sstevel@tonic-gate 
967c478bd9Sstevel@tonic-gate #include <sys/param.h>
97*e5803b76SAdam H. Leventhal #include <sys/sysmacros.h>
987c478bd9Sstevel@tonic-gate #include <limits.h>
997c478bd9Sstevel@tonic-gate #include <setjmp.h>
1007c478bd9Sstevel@tonic-gate #include <strings.h>
1017c478bd9Sstevel@tonic-gate #include <assert.h>
1027c478bd9Sstevel@tonic-gate #include <alloca.h>
1037c478bd9Sstevel@tonic-gate #include <stdlib.h>
1047c478bd9Sstevel@tonic-gate #include <stdarg.h>
1057c478bd9Sstevel@tonic-gate #include <stdio.h>
1067c478bd9Sstevel@tonic-gate #include <errno.h>
1077c478bd9Sstevel@tonic-gate #include <ctype.h>
1087c478bd9Sstevel@tonic-gate 
1097c478bd9Sstevel@tonic-gate #include <dt_impl.h>
1107c478bd9Sstevel@tonic-gate #include <dt_grammar.h>
1117c478bd9Sstevel@tonic-gate #include <dt_module.h>
1127c478bd9Sstevel@tonic-gate #include <dt_provider.h>
1137c478bd9Sstevel@tonic-gate #include <dt_string.h>
1147c478bd9Sstevel@tonic-gate #include <dt_as.h>
1157c478bd9Sstevel@tonic-gate 
1167c478bd9Sstevel@tonic-gate dt_pcb_t *yypcb;	/* current control block for parser */
1177c478bd9Sstevel@tonic-gate dt_node_t *yypragma;	/* lex token list for control lines */
1187c478bd9Sstevel@tonic-gate char yyintprefix;	/* int token macro prefix (+/-) */
1197c478bd9Sstevel@tonic-gate char yyintsuffix[4];	/* int token suffix string [uU][lL] */
1207c478bd9Sstevel@tonic-gate int yyintdecimal;	/* int token format flag (1=decimal, 0=octal/hex) */
1217c478bd9Sstevel@tonic-gate 
1227c478bd9Sstevel@tonic-gate static const char *
1237c478bd9Sstevel@tonic-gate opstr(int op)
1247c478bd9Sstevel@tonic-gate {
1257c478bd9Sstevel@tonic-gate 	switch (op) {
1267c478bd9Sstevel@tonic-gate 	case DT_TOK_COMMA:	return (",");
1277c478bd9Sstevel@tonic-gate 	case DT_TOK_ELLIPSIS:	return ("...");
1287c478bd9Sstevel@tonic-gate 	case DT_TOK_ASGN:	return ("=");
1297c478bd9Sstevel@tonic-gate 	case DT_TOK_ADD_EQ:	return ("+=");
1307c478bd9Sstevel@tonic-gate 	case DT_TOK_SUB_EQ:	return ("-=");
1317c478bd9Sstevel@tonic-gate 	case DT_TOK_MUL_EQ:	return ("*=");
1327c478bd9Sstevel@tonic-gate 	case DT_TOK_DIV_EQ:	return ("/=");
1337c478bd9Sstevel@tonic-gate 	case DT_TOK_MOD_EQ:	return ("%=");
1347c478bd9Sstevel@tonic-gate 	case DT_TOK_AND_EQ:	return ("&=");
1357c478bd9Sstevel@tonic-gate 	case DT_TOK_XOR_EQ:	return ("^=");
1367c478bd9Sstevel@tonic-gate 	case DT_TOK_OR_EQ:	return ("|=");
1377c478bd9Sstevel@tonic-gate 	case DT_TOK_LSH_EQ:	return ("<<=");
1387c478bd9Sstevel@tonic-gate 	case DT_TOK_RSH_EQ:	return (">>=");
1397c478bd9Sstevel@tonic-gate 	case DT_TOK_QUESTION:	return ("?");
1407c478bd9Sstevel@tonic-gate 	case DT_TOK_COLON:	return (":");
1417c478bd9Sstevel@tonic-gate 	case DT_TOK_LOR:	return ("||");
1427c478bd9Sstevel@tonic-gate 	case DT_TOK_LXOR:	return ("^^");
1437c478bd9Sstevel@tonic-gate 	case DT_TOK_LAND:	return ("&&");
1447c478bd9Sstevel@tonic-gate 	case DT_TOK_BOR:	return ("|");
1457c478bd9Sstevel@tonic-gate 	case DT_TOK_XOR:	return ("^");
1467c478bd9Sstevel@tonic-gate 	case DT_TOK_BAND:	return ("&");
1477c478bd9Sstevel@tonic-gate 	case DT_TOK_EQU:	return ("==");
1487c478bd9Sstevel@tonic-gate 	case DT_TOK_NEQ:	return ("!=");
1497c478bd9Sstevel@tonic-gate 	case DT_TOK_LT:		return ("<");
1507c478bd9Sstevel@tonic-gate 	case DT_TOK_LE:		return ("<=");
1517c478bd9Sstevel@tonic-gate 	case DT_TOK_GT:		return (">");
1527c478bd9Sstevel@tonic-gate 	case DT_TOK_GE:		return (">=");
1537c478bd9Sstevel@tonic-gate 	case DT_TOK_LSH:	return ("<<");
1547c478bd9Sstevel@tonic-gate 	case DT_TOK_RSH:	return (">>");
1557c478bd9Sstevel@tonic-gate 	case DT_TOK_ADD:	return ("+");
1567c478bd9Sstevel@tonic-gate 	case DT_TOK_SUB:	return ("-");
1577c478bd9Sstevel@tonic-gate 	case DT_TOK_MUL:	return ("*");
1587c478bd9Sstevel@tonic-gate 	case DT_TOK_DIV:	return ("/");
1597c478bd9Sstevel@tonic-gate 	case DT_TOK_MOD:	return ("%");
1607c478bd9Sstevel@tonic-gate 	case DT_TOK_LNEG:	return ("!");
1617c478bd9Sstevel@tonic-gate 	case DT_TOK_BNEG:	return ("~");
1627c478bd9Sstevel@tonic-gate 	case DT_TOK_ADDADD:	return ("++");
1637c478bd9Sstevel@tonic-gate 	case DT_TOK_PREINC:	return ("++");
1647c478bd9Sstevel@tonic-gate 	case DT_TOK_POSTINC:	return ("++");
1657c478bd9Sstevel@tonic-gate 	case DT_TOK_SUBSUB:	return ("--");
1667c478bd9Sstevel@tonic-gate 	case DT_TOK_PREDEC:	return ("--");
1677c478bd9Sstevel@tonic-gate 	case DT_TOK_POSTDEC:	return ("--");
1687c478bd9Sstevel@tonic-gate 	case DT_TOK_IPOS:	return ("+");
1697c478bd9Sstevel@tonic-gate 	case DT_TOK_INEG:	return ("-");
1707c478bd9Sstevel@tonic-gate 	case DT_TOK_DEREF:	return ("*");
1717c478bd9Sstevel@tonic-gate 	case DT_TOK_ADDROF:	return ("&");
1727c478bd9Sstevel@tonic-gate 	case DT_TOK_OFFSETOF:	return ("offsetof");
1737c478bd9Sstevel@tonic-gate 	case DT_TOK_SIZEOF:	return ("sizeof");
1747c478bd9Sstevel@tonic-gate 	case DT_TOK_STRINGOF:	return ("stringof");
1757c478bd9Sstevel@tonic-gate 	case DT_TOK_XLATE:	return ("xlate");
1767c478bd9Sstevel@tonic-gate 	case DT_TOK_LPAR:	return ("(");
1777c478bd9Sstevel@tonic-gate 	case DT_TOK_RPAR:	return (")");
1787c478bd9Sstevel@tonic-gate 	case DT_TOK_LBRAC:	return ("[");
1797c478bd9Sstevel@tonic-gate 	case DT_TOK_RBRAC:	return ("]");
1807c478bd9Sstevel@tonic-gate 	case DT_TOK_PTR:	return ("->");
1817c478bd9Sstevel@tonic-gate 	case DT_TOK_DOT:	return (".");
1827c478bd9Sstevel@tonic-gate 	case DT_TOK_STRING:	return ("<string>");
1837c478bd9Sstevel@tonic-gate 	case DT_TOK_IDENT:	return ("<ident>");
1847c478bd9Sstevel@tonic-gate 	case DT_TOK_TNAME:	return ("<type>");
1857c478bd9Sstevel@tonic-gate 	case DT_TOK_INT:	return ("<int>");
1867c478bd9Sstevel@tonic-gate 	default:		return ("<?>");
1877c478bd9Sstevel@tonic-gate 	}
1887c478bd9Sstevel@tonic-gate }
1897c478bd9Sstevel@tonic-gate 
1907c478bd9Sstevel@tonic-gate int
1917c478bd9Sstevel@tonic-gate dt_type_lookup(const char *s, dtrace_typeinfo_t *tip)
1927c478bd9Sstevel@tonic-gate {
1937c478bd9Sstevel@tonic-gate 	static const char delimiters[] = " \t\n\r\v\f*`";
1947c478bd9Sstevel@tonic-gate 	dtrace_hdl_t *dtp = yypcb->pcb_hdl;
1957c478bd9Sstevel@tonic-gate 	const char *p, *q, *end, *obj;
1967c478bd9Sstevel@tonic-gate 
1977c478bd9Sstevel@tonic-gate 	for (p = s, end = s + strlen(s); *p != '\0'; p = q) {
1987c478bd9Sstevel@tonic-gate 		while (isspace(*p))
1997c478bd9Sstevel@tonic-gate 			p++;	/* skip leading whitespace prior to token */
2007c478bd9Sstevel@tonic-gate 
2017c478bd9Sstevel@tonic-gate 		if (p == end || (q = strpbrk(p + 1, delimiters)) == NULL)
2027c478bd9Sstevel@tonic-gate 			break;	/* empty string or single token remaining */
2037c478bd9Sstevel@tonic-gate 
2047c478bd9Sstevel@tonic-gate 		if (*q == '`') {
2057c478bd9Sstevel@tonic-gate 			char *object = alloca((size_t)(q - p) + 1);
2067c478bd9Sstevel@tonic-gate 			char *type = alloca((size_t)(end - s) + 1);
2077c478bd9Sstevel@tonic-gate 
2087c478bd9Sstevel@tonic-gate 			/*
2097c478bd9Sstevel@tonic-gate 			 * Copy from the start of the token (p) to the location
2107c478bd9Sstevel@tonic-gate 			 * backquote (q) to extract the nul-terminated object.
2117c478bd9Sstevel@tonic-gate 			 */
2127c478bd9Sstevel@tonic-gate 			bcopy(p, object, (size_t)(q - p));
2137c478bd9Sstevel@tonic-gate 			object[(size_t)(q - p)] = '\0';
2147c478bd9Sstevel@tonic-gate 
2157c478bd9Sstevel@tonic-gate 			/*
2167c478bd9Sstevel@tonic-gate 			 * Copy the original string up to the start of this
2177c478bd9Sstevel@tonic-gate 			 * token (p) into type, and then concatenate everything
2187c478bd9Sstevel@tonic-gate 			 * after q.  This is the type name without the object.
2197c478bd9Sstevel@tonic-gate 			 */
2207c478bd9Sstevel@tonic-gate 			bcopy(s, type, (size_t)(p - s));
2217c478bd9Sstevel@tonic-gate 			bcopy(q + 1, type + (size_t)(p - s), strlen(q + 1) + 1);
2227c478bd9Sstevel@tonic-gate 
2237c478bd9Sstevel@tonic-gate 			if (strchr(q + 1, '`') != NULL)
2247c478bd9Sstevel@tonic-gate 				return (dt_set_errno(dtp, EDT_BADSCOPE));
2257c478bd9Sstevel@tonic-gate 
2267c478bd9Sstevel@tonic-gate 			return (dtrace_lookup_by_type(dtp, object, type, tip));
2277c478bd9Sstevel@tonic-gate 		}
2287c478bd9Sstevel@tonic-gate 	}
2297c478bd9Sstevel@tonic-gate 
2307c478bd9Sstevel@tonic-gate 	if (yypcb->pcb_idepth != 0)
2317c478bd9Sstevel@tonic-gate 		obj = DTRACE_OBJ_CDEFS;
2327c478bd9Sstevel@tonic-gate 	else
2337c478bd9Sstevel@tonic-gate 		obj = DTRACE_OBJ_EVERY;
2347c478bd9Sstevel@tonic-gate 
2357c478bd9Sstevel@tonic-gate 	return (dtrace_lookup_by_type(dtp, obj, s, tip));
2367c478bd9Sstevel@tonic-gate }
2377c478bd9Sstevel@tonic-gate 
2387c478bd9Sstevel@tonic-gate /*
2397c478bd9Sstevel@tonic-gate  * When we parse type expressions or parse an expression with unary "&", we
2407c478bd9Sstevel@tonic-gate  * need to find a type that is a pointer to a previously known type.
2417c478bd9Sstevel@tonic-gate  * Unfortunately CTF is limited to a per-container view, so ctf_type_pointer()
2427c478bd9Sstevel@tonic-gate  * alone does not suffice for our needs.  We provide a more intelligent wrapper
2437c478bd9Sstevel@tonic-gate  * for the compiler that attempts to compute a pointer to either the given type
2447c478bd9Sstevel@tonic-gate  * or its base (that is, we try both "foo_t *" and "struct foo *"), and also
2457c478bd9Sstevel@tonic-gate  * to potentially construct the required type on-the-fly.
2467c478bd9Sstevel@tonic-gate  */
2477c478bd9Sstevel@tonic-gate int
2487c478bd9Sstevel@tonic-gate dt_type_pointer(dtrace_typeinfo_t *tip)
2497c478bd9Sstevel@tonic-gate {
2507c478bd9Sstevel@tonic-gate 	dtrace_hdl_t *dtp = yypcb->pcb_hdl;
2517c478bd9Sstevel@tonic-gate 	ctf_file_t *ctfp = tip->dtt_ctfp;
2527c478bd9Sstevel@tonic-gate 	ctf_id_t type = tip->dtt_type;
2537c478bd9Sstevel@tonic-gate 	ctf_id_t base = ctf_type_resolve(ctfp, type);
2547c478bd9Sstevel@tonic-gate 
2557c478bd9Sstevel@tonic-gate 	dt_module_t *dmp;
2567c478bd9Sstevel@tonic-gate 	ctf_id_t ptr;
2577c478bd9Sstevel@tonic-gate 
2587c478bd9Sstevel@tonic-gate 	if ((ptr = ctf_type_pointer(ctfp, type)) != CTF_ERR ||
2597c478bd9Sstevel@tonic-gate 	    (ptr = ctf_type_pointer(ctfp, base)) != CTF_ERR) {
2607c478bd9Sstevel@tonic-gate 		tip->dtt_type = ptr;
2617c478bd9Sstevel@tonic-gate 		return (0);
2627c478bd9Sstevel@tonic-gate 	}
2637c478bd9Sstevel@tonic-gate 
2647c478bd9Sstevel@tonic-gate 	if (yypcb->pcb_idepth != 0)
2657c478bd9Sstevel@tonic-gate 		dmp = dtp->dt_cdefs;
2667c478bd9Sstevel@tonic-gate 	else
2677c478bd9Sstevel@tonic-gate 		dmp = dtp->dt_ddefs;
2687c478bd9Sstevel@tonic-gate 
2697c478bd9Sstevel@tonic-gate 	if (ctfp != dmp->dm_ctfp && ctfp != ctf_parent_file(dmp->dm_ctfp) &&
2707c478bd9Sstevel@tonic-gate 	    (type = ctf_add_type(dmp->dm_ctfp, ctfp, type)) == CTF_ERR) {
2717c478bd9Sstevel@tonic-gate 		dtp->dt_ctferr = ctf_errno(dmp->dm_ctfp);
2727c478bd9Sstevel@tonic-gate 		return (dt_set_errno(dtp, EDT_CTF));
2737c478bd9Sstevel@tonic-gate 	}
2747c478bd9Sstevel@tonic-gate 
2757c478bd9Sstevel@tonic-gate 	ptr = ctf_add_pointer(dmp->dm_ctfp, CTF_ADD_ROOT, type);
2767c478bd9Sstevel@tonic-gate 
2777c478bd9Sstevel@tonic-gate 	if (ptr == CTF_ERR || ctf_update(dmp->dm_ctfp) == CTF_ERR) {
2787c478bd9Sstevel@tonic-gate 		dtp->dt_ctferr = ctf_errno(dmp->dm_ctfp);
2797c478bd9Sstevel@tonic-gate 		return (dt_set_errno(dtp, EDT_CTF));
2807c478bd9Sstevel@tonic-gate 	}
2817c478bd9Sstevel@tonic-gate 
2827c478bd9Sstevel@tonic-gate 	tip->dtt_object = dmp->dm_name;
2837c478bd9Sstevel@tonic-gate 	tip->dtt_ctfp = dmp->dm_ctfp;
2847c478bd9Sstevel@tonic-gate 	tip->dtt_type = ptr;
2857c478bd9Sstevel@tonic-gate 
2867c478bd9Sstevel@tonic-gate 	return (0);
2877c478bd9Sstevel@tonic-gate }
2887c478bd9Sstevel@tonic-gate 
2897c478bd9Sstevel@tonic-gate const char *
2907c478bd9Sstevel@tonic-gate dt_type_name(ctf_file_t *ctfp, ctf_id_t type, char *buf, size_t len)
2917c478bd9Sstevel@tonic-gate {
2927c478bd9Sstevel@tonic-gate 	dtrace_hdl_t *dtp = yypcb->pcb_hdl;
2937c478bd9Sstevel@tonic-gate 
2947c478bd9Sstevel@tonic-gate 	if (ctfp == DT_FPTR_CTFP(dtp) && type == DT_FPTR_TYPE(dtp))
2957c478bd9Sstevel@tonic-gate 		(void) snprintf(buf, len, "function pointer");
2967c478bd9Sstevel@tonic-gate 	else if (ctfp == DT_FUNC_CTFP(dtp) && type == DT_FUNC_TYPE(dtp))
2977c478bd9Sstevel@tonic-gate 		(void) snprintf(buf, len, "function");
2987c478bd9Sstevel@tonic-gate 	else if (ctfp == DT_DYN_CTFP(dtp) && type == DT_DYN_TYPE(dtp))
2997c478bd9Sstevel@tonic-gate 		(void) snprintf(buf, len, "dynamic variable");
3007c478bd9Sstevel@tonic-gate 	else if (ctfp == NULL)
3017c478bd9Sstevel@tonic-gate 		(void) snprintf(buf, len, "<none>");
3027c478bd9Sstevel@tonic-gate 	else if (ctf_type_name(ctfp, type, buf, len) == NULL)
3037c478bd9Sstevel@tonic-gate 		(void) snprintf(buf, len, "unknown");
3047c478bd9Sstevel@tonic-gate 
3057c478bd9Sstevel@tonic-gate 	return (buf);
3067c478bd9Sstevel@tonic-gate }
3077c478bd9Sstevel@tonic-gate 
3087c478bd9Sstevel@tonic-gate /*
3097c478bd9Sstevel@tonic-gate  * Perform the "usual arithmetic conversions" to determine which of the two
3107c478bd9Sstevel@tonic-gate  * input operand types should be promoted and used as a result type.  The
3117c478bd9Sstevel@tonic-gate  * rules for this are described in ISOC[6.3.1.8] and K&R[A6.5].
3127c478bd9Sstevel@tonic-gate  */
3137c478bd9Sstevel@tonic-gate static void
3147c478bd9Sstevel@tonic-gate dt_type_promote(dt_node_t *lp, dt_node_t *rp, ctf_file_t **ofp, ctf_id_t *otype)
3157c478bd9Sstevel@tonic-gate {
3167c478bd9Sstevel@tonic-gate 	ctf_file_t *lfp = lp->dn_ctfp;
3177c478bd9Sstevel@tonic-gate 	ctf_id_t ltype = lp->dn_type;
3187c478bd9Sstevel@tonic-gate 
3197c478bd9Sstevel@tonic-gate 	ctf_file_t *rfp = rp->dn_ctfp;
3207c478bd9Sstevel@tonic-gate 	ctf_id_t rtype = rp->dn_type;
3217c478bd9Sstevel@tonic-gate 
3227c478bd9Sstevel@tonic-gate 	ctf_id_t lbase = ctf_type_resolve(lfp, ltype);
3237c478bd9Sstevel@tonic-gate 	uint_t lkind = ctf_type_kind(lfp, lbase);
3247c478bd9Sstevel@tonic-gate 
3257c478bd9Sstevel@tonic-gate 	ctf_id_t rbase = ctf_type_resolve(rfp, rtype);
3267c478bd9Sstevel@tonic-gate 	uint_t rkind = ctf_type_kind(rfp, rbase);
3277c478bd9Sstevel@tonic-gate 
3287c478bd9Sstevel@tonic-gate 	dtrace_hdl_t *dtp = yypcb->pcb_hdl;
3297c478bd9Sstevel@tonic-gate 	ctf_encoding_t le, re;
3307c478bd9Sstevel@tonic-gate 	uint_t lrank, rrank;
3317c478bd9Sstevel@tonic-gate 
3327c478bd9Sstevel@tonic-gate 	assert(lkind == CTF_K_INTEGER || lkind == CTF_K_ENUM);
3337c478bd9Sstevel@tonic-gate 	assert(rkind == CTF_K_INTEGER || rkind == CTF_K_ENUM);
3347c478bd9Sstevel@tonic-gate 
3357c478bd9Sstevel@tonic-gate 	if (lkind == CTF_K_ENUM) {
3367c478bd9Sstevel@tonic-gate 		lfp = DT_INT_CTFP(dtp);
3377c478bd9Sstevel@tonic-gate 		ltype = lbase = DT_INT_TYPE(dtp);
3387c478bd9Sstevel@tonic-gate 	}
3397c478bd9Sstevel@tonic-gate 
3407c478bd9Sstevel@tonic-gate 	if (rkind == CTF_K_ENUM) {
3417c478bd9Sstevel@tonic-gate 		rfp = DT_INT_CTFP(dtp);
3427c478bd9Sstevel@tonic-gate 		rtype = rbase = DT_INT_TYPE(dtp);
3437c478bd9Sstevel@tonic-gate 	}
3447c478bd9Sstevel@tonic-gate 
3457c478bd9Sstevel@tonic-gate 	if (ctf_type_encoding(lfp, lbase, &le) == CTF_ERR) {
3467c478bd9Sstevel@tonic-gate 		yypcb->pcb_hdl->dt_ctferr = ctf_errno(lfp);
3477c478bd9Sstevel@tonic-gate 		longjmp(yypcb->pcb_jmpbuf, EDT_CTF);
3487c478bd9Sstevel@tonic-gate 	}
3497c478bd9Sstevel@tonic-gate 
3507c478bd9Sstevel@tonic-gate 	if (ctf_type_encoding(rfp, rbase, &re) == CTF_ERR) {
3517c478bd9Sstevel@tonic-gate 		yypcb->pcb_hdl->dt_ctferr = ctf_errno(rfp);
3527c478bd9Sstevel@tonic-gate 		longjmp(yypcb->pcb_jmpbuf, EDT_CTF);
3537c478bd9Sstevel@tonic-gate 	}
3547c478bd9Sstevel@tonic-gate 
3557c478bd9Sstevel@tonic-gate 	/*
3567c478bd9Sstevel@tonic-gate 	 * Compute an integer rank based on the size and unsigned status.
3577c478bd9Sstevel@tonic-gate 	 * If rank is identical, pick the "larger" of the equivalent types
3587c478bd9Sstevel@tonic-gate 	 * which we define as having a larger base ctf_id_t.  If rank is
3597c478bd9Sstevel@tonic-gate 	 * different, pick the type with the greater rank.
3607c478bd9Sstevel@tonic-gate 	 */
3617c478bd9Sstevel@tonic-gate 	lrank = le.cte_bits + ((le.cte_format & CTF_INT_SIGNED) == 0);
3627c478bd9Sstevel@tonic-gate 	rrank = re.cte_bits + ((re.cte_format & CTF_INT_SIGNED) == 0);
3637c478bd9Sstevel@tonic-gate 
3647c478bd9Sstevel@tonic-gate 	if (lrank == rrank) {
3657c478bd9Sstevel@tonic-gate 		if (lbase - rbase < 0)
3667c478bd9Sstevel@tonic-gate 			goto return_rtype;
3677c478bd9Sstevel@tonic-gate 		else
3687c478bd9Sstevel@tonic-gate 			goto return_ltype;
3697c478bd9Sstevel@tonic-gate 	} else if (lrank > rrank) {
3707c478bd9Sstevel@tonic-gate 		goto return_ltype;
3717c478bd9Sstevel@tonic-gate 	} else
3727c478bd9Sstevel@tonic-gate 		goto return_rtype;
3737c478bd9Sstevel@tonic-gate 
3747c478bd9Sstevel@tonic-gate return_ltype:
3757c478bd9Sstevel@tonic-gate 	*ofp = lfp;
3767c478bd9Sstevel@tonic-gate 	*otype = ltype;
3777c478bd9Sstevel@tonic-gate 	return;
3787c478bd9Sstevel@tonic-gate 
3797c478bd9Sstevel@tonic-gate return_rtype:
3807c478bd9Sstevel@tonic-gate 	*ofp = rfp;
3817c478bd9Sstevel@tonic-gate 	*otype = rtype;
3827c478bd9Sstevel@tonic-gate }
3837c478bd9Sstevel@tonic-gate 
3847c478bd9Sstevel@tonic-gate void
3857c478bd9Sstevel@tonic-gate dt_node_promote(dt_node_t *lp, dt_node_t *rp, dt_node_t *dnp)
3867c478bd9Sstevel@tonic-gate {
3877c478bd9Sstevel@tonic-gate 	dt_type_promote(lp, rp, &dnp->dn_ctfp, &dnp->dn_type);
3887c478bd9Sstevel@tonic-gate 	dt_node_type_assign(dnp, dnp->dn_ctfp, dnp->dn_type);
3897c478bd9Sstevel@tonic-gate 	dt_node_attr_assign(dnp, dt_attr_min(lp->dn_attr, rp->dn_attr));
3907c478bd9Sstevel@tonic-gate }
3917c478bd9Sstevel@tonic-gate 
3927c478bd9Sstevel@tonic-gate const char *
3937c478bd9Sstevel@tonic-gate dt_node_name(const dt_node_t *dnp, char *buf, size_t len)
3947c478bd9Sstevel@tonic-gate {
3957c478bd9Sstevel@tonic-gate 	char n1[DT_TYPE_NAMELEN];
3967c478bd9Sstevel@tonic-gate 	char n2[DT_TYPE_NAMELEN];
3977c478bd9Sstevel@tonic-gate 
3987c478bd9Sstevel@tonic-gate 	const char *prefix = "", *suffix = "";
3997c478bd9Sstevel@tonic-gate 	const dtrace_syminfo_t *dts;
4007c478bd9Sstevel@tonic-gate 	char *s;
4017c478bd9Sstevel@tonic-gate 
4027c478bd9Sstevel@tonic-gate 	switch (dnp->dn_kind) {
4037c478bd9Sstevel@tonic-gate 	case DT_NODE_INT:
4047c478bd9Sstevel@tonic-gate 		(void) snprintf(buf, len, "integer constant 0x%llx",
4057c478bd9Sstevel@tonic-gate 		    (u_longlong_t)dnp->dn_value);
4067c478bd9Sstevel@tonic-gate 		break;
4077c478bd9Sstevel@tonic-gate 	case DT_NODE_STRING:
4087c478bd9Sstevel@tonic-gate 		s = strchr2esc(dnp->dn_string, strlen(dnp->dn_string));
4097c478bd9Sstevel@tonic-gate 		(void) snprintf(buf, len, "string constant \"%s\"",
4107c478bd9Sstevel@tonic-gate 		    s != NULL ? s : dnp->dn_string);
4117c478bd9Sstevel@tonic-gate 		free(s);
4127c478bd9Sstevel@tonic-gate 		break;
4137c478bd9Sstevel@tonic-gate 	case DT_NODE_IDENT:
4147c478bd9Sstevel@tonic-gate 		(void) snprintf(buf, len, "identifier %s", dnp->dn_string);
4157c478bd9Sstevel@tonic-gate 		break;
4167c478bd9Sstevel@tonic-gate 	case DT_NODE_VAR:
4177c478bd9Sstevel@tonic-gate 	case DT_NODE_FUNC:
4187c478bd9Sstevel@tonic-gate 	case DT_NODE_AGG:
4197c478bd9Sstevel@tonic-gate 	case DT_NODE_INLINE:
4207c478bd9Sstevel@tonic-gate 		switch (dnp->dn_ident->di_kind) {
4217c478bd9Sstevel@tonic-gate 		case DT_IDENT_FUNC:
4227c478bd9Sstevel@tonic-gate 		case DT_IDENT_AGGFUNC:
4237c478bd9Sstevel@tonic-gate 		case DT_IDENT_ACTFUNC:
4247c478bd9Sstevel@tonic-gate 			suffix = "( )";
4257c478bd9Sstevel@tonic-gate 			break;
4267c478bd9Sstevel@tonic-gate 		case DT_IDENT_AGG:
4277c478bd9Sstevel@tonic-gate 			prefix = "@";
4287c478bd9Sstevel@tonic-gate 			break;
4297c478bd9Sstevel@tonic-gate 		}
4307c478bd9Sstevel@tonic-gate 		(void) snprintf(buf, len, "%s %s%s%s",
4317c478bd9Sstevel@tonic-gate 		    dt_idkind_name(dnp->dn_ident->di_kind),
4327c478bd9Sstevel@tonic-gate 		    prefix, dnp->dn_ident->di_name, suffix);
4337c478bd9Sstevel@tonic-gate 		break;
4347c478bd9Sstevel@tonic-gate 	case DT_NODE_SYM:
4357c478bd9Sstevel@tonic-gate 		dts = dnp->dn_ident->di_data;
4367c478bd9Sstevel@tonic-gate 		(void) snprintf(buf, len, "symbol %s`%s",
4377c478bd9Sstevel@tonic-gate 		    dts->dts_object, dts->dts_name);
4387c478bd9Sstevel@tonic-gate 		break;
4397c478bd9Sstevel@tonic-gate 	case DT_NODE_TYPE:
4407c478bd9Sstevel@tonic-gate 		(void) snprintf(buf, len, "type %s",
4417c478bd9Sstevel@tonic-gate 		    dt_node_type_name(dnp, n1, sizeof (n1)));
4427c478bd9Sstevel@tonic-gate 		break;
4437c478bd9Sstevel@tonic-gate 	case DT_NODE_OP1:
4447c478bd9Sstevel@tonic-gate 	case DT_NODE_OP2:
4457c478bd9Sstevel@tonic-gate 	case DT_NODE_OP3:
4467c478bd9Sstevel@tonic-gate 		(void) snprintf(buf, len, "operator %s", opstr(dnp->dn_op));
4477c478bd9Sstevel@tonic-gate 		break;
4487c478bd9Sstevel@tonic-gate 	case DT_NODE_DEXPR:
4497c478bd9Sstevel@tonic-gate 	case DT_NODE_DFUNC:
4507c478bd9Sstevel@tonic-gate 		if (dnp->dn_expr)
4517c478bd9Sstevel@tonic-gate 			return (dt_node_name(dnp->dn_expr, buf, len));
4527c478bd9Sstevel@tonic-gate 		(void) snprintf(buf, len, "%s", "statement");
4537c478bd9Sstevel@tonic-gate 		break;
4547c478bd9Sstevel@tonic-gate 	case DT_NODE_PDESC:
4557c478bd9Sstevel@tonic-gate 		if (dnp->dn_desc->dtpd_id == 0) {
4567c478bd9Sstevel@tonic-gate 			(void) snprintf(buf, len,
4577c478bd9Sstevel@tonic-gate 			    "probe description %s:%s:%s:%s",
4587c478bd9Sstevel@tonic-gate 			    dnp->dn_desc->dtpd_provider, dnp->dn_desc->dtpd_mod,
4597c478bd9Sstevel@tonic-gate 			    dnp->dn_desc->dtpd_func, dnp->dn_desc->dtpd_name);
4607c478bd9Sstevel@tonic-gate 		} else {
4617c478bd9Sstevel@tonic-gate 			(void) snprintf(buf, len, "probe description %u",
4627c478bd9Sstevel@tonic-gate 			    dnp->dn_desc->dtpd_id);
4637c478bd9Sstevel@tonic-gate 		}
4647c478bd9Sstevel@tonic-gate 		break;
4657c478bd9Sstevel@tonic-gate 	case DT_NODE_CLAUSE:
4667c478bd9Sstevel@tonic-gate 		(void) snprintf(buf, len, "%s", "clause");
4677c478bd9Sstevel@tonic-gate 		break;
4687c478bd9Sstevel@tonic-gate 	case DT_NODE_MEMBER:
4697c478bd9Sstevel@tonic-gate 		(void) snprintf(buf, len, "member %s", dnp->dn_membname);
4707c478bd9Sstevel@tonic-gate 		break;
4717c478bd9Sstevel@tonic-gate 	case DT_NODE_XLATOR:
4727c478bd9Sstevel@tonic-gate 		(void) snprintf(buf, len, "translator <%s> (%s)",
4737c478bd9Sstevel@tonic-gate 		    dt_type_name(dnp->dn_xlator->dx_dst_ctfp,
47423a1cceaSRoger A. Faulkner 		    dnp->dn_xlator->dx_dst_type, n1, sizeof (n1)),
4757c478bd9Sstevel@tonic-gate 		    dt_type_name(dnp->dn_xlator->dx_src_ctfp,
47623a1cceaSRoger A. Faulkner 		    dnp->dn_xlator->dx_src_type, n2, sizeof (n2)));
4777c478bd9Sstevel@tonic-gate 		break;
4787c478bd9Sstevel@tonic-gate 	case DT_NODE_PROG:
4797c478bd9Sstevel@tonic-gate 		(void) snprintf(buf, len, "%s", "program");
4807c478bd9Sstevel@tonic-gate 		break;
4817c478bd9Sstevel@tonic-gate 	default:
4827c478bd9Sstevel@tonic-gate 		(void) snprintf(buf, len, "node <%u>", dnp->dn_kind);
4837c478bd9Sstevel@tonic-gate 		break;
4847c478bd9Sstevel@tonic-gate 	}
4857c478bd9Sstevel@tonic-gate 
4867c478bd9Sstevel@tonic-gate 	return (buf);
4877c478bd9Sstevel@tonic-gate }
4887c478bd9Sstevel@tonic-gate 
4897c478bd9Sstevel@tonic-gate /*
4907c478bd9Sstevel@tonic-gate  * dt_node_xalloc() can be used to create new parse nodes from any libdtrace
4917c478bd9Sstevel@tonic-gate  * caller.  The caller is responsible for assigning dn_link appropriately.
4927c478bd9Sstevel@tonic-gate  */
4937c478bd9Sstevel@tonic-gate dt_node_t *
4947c478bd9Sstevel@tonic-gate dt_node_xalloc(dtrace_hdl_t *dtp, int kind)
4957c478bd9Sstevel@tonic-gate {
4967c478bd9Sstevel@tonic-gate 	dt_node_t *dnp = dt_alloc(dtp, sizeof (dt_node_t));
4977c478bd9Sstevel@tonic-gate 
4987c478bd9Sstevel@tonic-gate 	if (dnp == NULL)
4997c478bd9Sstevel@tonic-gate 		return (NULL);
5007c478bd9Sstevel@tonic-gate 
5017c478bd9Sstevel@tonic-gate 	dnp->dn_ctfp = NULL;
5027c478bd9Sstevel@tonic-gate 	dnp->dn_type = CTF_ERR;
5037c478bd9Sstevel@tonic-gate 	dnp->dn_kind = (uchar_t)kind;
5047c478bd9Sstevel@tonic-gate 	dnp->dn_flags = 0;
5057c478bd9Sstevel@tonic-gate 	dnp->dn_op = 0;
5067c478bd9Sstevel@tonic-gate 	dnp->dn_line = -1;
5077c478bd9Sstevel@tonic-gate 	dnp->dn_reg = -1;
5087c478bd9Sstevel@tonic-gate 	dnp->dn_attr = _dtrace_defattr;
5097c478bd9Sstevel@tonic-gate 	dnp->dn_list = NULL;
5107c478bd9Sstevel@tonic-gate 	dnp->dn_link = NULL;
5117c478bd9Sstevel@tonic-gate 	bzero(&dnp->dn_u, sizeof (dnp->dn_u));
5127c478bd9Sstevel@tonic-gate 
5137c478bd9Sstevel@tonic-gate 	return (dnp);
5147c478bd9Sstevel@tonic-gate }
5157c478bd9Sstevel@tonic-gate 
5167c478bd9Sstevel@tonic-gate /*
5177c478bd9Sstevel@tonic-gate  * dt_node_alloc() is used to create new parse nodes from the parser.  It
5187c478bd9Sstevel@tonic-gate  * assigns the node location based on the current lexer line number and places
5197c478bd9Sstevel@tonic-gate  * the new node on the default allocation list.  If allocation fails, we
5207c478bd9Sstevel@tonic-gate  * automatically longjmp the caller back to the enclosing compilation call.
5217c478bd9Sstevel@tonic-gate  */
5227c478bd9Sstevel@tonic-gate static dt_node_t *
5237c478bd9Sstevel@tonic-gate dt_node_alloc(int kind)
5247c478bd9Sstevel@tonic-gate {
5257c478bd9Sstevel@tonic-gate 	dt_node_t *dnp = dt_node_xalloc(yypcb->pcb_hdl, kind);
5267c478bd9Sstevel@tonic-gate 
5277c478bd9Sstevel@tonic-gate 	if (dnp == NULL)
5287c478bd9Sstevel@tonic-gate 		longjmp(yypcb->pcb_jmpbuf, EDT_NOMEM);
5297c478bd9Sstevel@tonic-gate 
5307c478bd9Sstevel@tonic-gate 	dnp->dn_line = yylineno;
5317c478bd9Sstevel@tonic-gate 	dnp->dn_link = yypcb->pcb_list;
5327c478bd9Sstevel@tonic-gate 	yypcb->pcb_list = dnp;
5337c478bd9Sstevel@tonic-gate 
5347c478bd9Sstevel@tonic-gate 	return (dnp);
5357c478bd9Sstevel@tonic-gate }
5367c478bd9Sstevel@tonic-gate 
5377c478bd9Sstevel@tonic-gate void
5387c478bd9Sstevel@tonic-gate dt_node_free(dt_node_t *dnp)
5397c478bd9Sstevel@tonic-gate {
5407c478bd9Sstevel@tonic-gate 	uchar_t kind = dnp->dn_kind;
5417c478bd9Sstevel@tonic-gate 
5427c478bd9Sstevel@tonic-gate 	dnp->dn_kind = DT_NODE_FREE;
5437c478bd9Sstevel@tonic-gate 
5447c478bd9Sstevel@tonic-gate 	switch (kind) {
5457c478bd9Sstevel@tonic-gate 	case DT_NODE_STRING:
5467c478bd9Sstevel@tonic-gate 	case DT_NODE_IDENT:
5477c478bd9Sstevel@tonic-gate 	case DT_NODE_TYPE:
5487c478bd9Sstevel@tonic-gate 		free(dnp->dn_string);
5497c478bd9Sstevel@tonic-gate 		dnp->dn_string = NULL;
5507c478bd9Sstevel@tonic-gate 		break;
5517c478bd9Sstevel@tonic-gate 
5527c478bd9Sstevel@tonic-gate 	case DT_NODE_VAR:
5537c478bd9Sstevel@tonic-gate 	case DT_NODE_FUNC:
5547c478bd9Sstevel@tonic-gate 	case DT_NODE_PROBE:
5557c478bd9Sstevel@tonic-gate 		if (dnp->dn_ident != NULL) {
5567c478bd9Sstevel@tonic-gate 			if (dnp->dn_ident->di_flags & DT_IDFLG_ORPHAN)
5577c478bd9Sstevel@tonic-gate 				dt_ident_destroy(dnp->dn_ident);
5587c478bd9Sstevel@tonic-gate 			dnp->dn_ident = NULL;
5597c478bd9Sstevel@tonic-gate 		}
5607c478bd9Sstevel@tonic-gate 		dt_node_list_free(&dnp->dn_args);
5617c478bd9Sstevel@tonic-gate 		break;
5627c478bd9Sstevel@tonic-gate 
5637c478bd9Sstevel@tonic-gate 	case DT_NODE_OP1:
5647c478bd9Sstevel@tonic-gate 		if (dnp->dn_child != NULL) {
5657c478bd9Sstevel@tonic-gate 			dt_node_free(dnp->dn_child);
5667c478bd9Sstevel@tonic-gate 			dnp->dn_child = NULL;
5677c478bd9Sstevel@tonic-gate 		}
5687c478bd9Sstevel@tonic-gate 		break;
5697c478bd9Sstevel@tonic-gate 
5707c478bd9Sstevel@tonic-gate 	case DT_NODE_OP3:
5717c478bd9Sstevel@tonic-gate 		if (dnp->dn_expr != NULL) {
5727c478bd9Sstevel@tonic-gate 			dt_node_free(dnp->dn_expr);
5737c478bd9Sstevel@tonic-gate 			dnp->dn_expr = NULL;
5747c478bd9Sstevel@tonic-gate 		}
5757c478bd9Sstevel@tonic-gate 		/*FALLTHRU*/
5767c478bd9Sstevel@tonic-gate 	case DT_NODE_OP2:
5777c478bd9Sstevel@tonic-gate 		if (dnp->dn_left != NULL) {
5787c478bd9Sstevel@tonic-gate 			dt_node_free(dnp->dn_left);
5797c478bd9Sstevel@tonic-gate 			dnp->dn_left = NULL;
5807c478bd9Sstevel@tonic-gate 		}
5817c478bd9Sstevel@tonic-gate 		if (dnp->dn_right != NULL) {
5827c478bd9Sstevel@tonic-gate 			dt_node_free(dnp->dn_right);
5837c478bd9Sstevel@tonic-gate 			dnp->dn_right = NULL;
5847c478bd9Sstevel@tonic-gate 		}
5857c478bd9Sstevel@tonic-gate 		break;
5867c478bd9Sstevel@tonic-gate 
5877c478bd9Sstevel@tonic-gate 	case DT_NODE_DEXPR:
5887c478bd9Sstevel@tonic-gate 	case DT_NODE_DFUNC:
5897c478bd9Sstevel@tonic-gate 		if (dnp->dn_expr != NULL) {
5907c478bd9Sstevel@tonic-gate 			dt_node_free(dnp->dn_expr);
5917c478bd9Sstevel@tonic-gate 			dnp->dn_expr = NULL;
5927c478bd9Sstevel@tonic-gate 		}
5937c478bd9Sstevel@tonic-gate 		break;
5947c478bd9Sstevel@tonic-gate 
5957c478bd9Sstevel@tonic-gate 	case DT_NODE_AGG:
5967c478bd9Sstevel@tonic-gate 		if (dnp->dn_aggfun != NULL) {
5977c478bd9Sstevel@tonic-gate 			dt_node_free(dnp->dn_aggfun);
5987c478bd9Sstevel@tonic-gate 			dnp->dn_aggfun = NULL;
5997c478bd9Sstevel@tonic-gate 		}
6007c478bd9Sstevel@tonic-gate 		dt_node_list_free(&dnp->dn_aggtup);
6017c478bd9Sstevel@tonic-gate 		break;
6027c478bd9Sstevel@tonic-gate 
6037c478bd9Sstevel@tonic-gate 	case DT_NODE_PDESC:
6047c478bd9Sstevel@tonic-gate 		free(dnp->dn_spec);
6057c478bd9Sstevel@tonic-gate 		dnp->dn_spec = NULL;
6067c478bd9Sstevel@tonic-gate 		free(dnp->dn_desc);
6077c478bd9Sstevel@tonic-gate 		dnp->dn_desc = NULL;
6087c478bd9Sstevel@tonic-gate 		break;
6097c478bd9Sstevel@tonic-gate 
6107c478bd9Sstevel@tonic-gate 	case DT_NODE_CLAUSE:
6117c478bd9Sstevel@tonic-gate 		if (dnp->dn_pred != NULL)
6127c478bd9Sstevel@tonic-gate 			dt_node_free(dnp->dn_pred);
6137c478bd9Sstevel@tonic-gate 		if (dnp->dn_locals != NULL)
6147c478bd9Sstevel@tonic-gate 			dt_idhash_destroy(dnp->dn_locals);
6157c478bd9Sstevel@tonic-gate 		dt_node_list_free(&dnp->dn_pdescs);
6167c478bd9Sstevel@tonic-gate 		dt_node_list_free(&dnp->dn_acts);
6177c478bd9Sstevel@tonic-gate 		break;
6187c478bd9Sstevel@tonic-gate 
6197c478bd9Sstevel@tonic-gate 	case DT_NODE_MEMBER:
6207c478bd9Sstevel@tonic-gate 		free(dnp->dn_membname);
6217c478bd9Sstevel@tonic-gate 		dnp->dn_membname = NULL;
6227c478bd9Sstevel@tonic-gate 		if (dnp->dn_membexpr != NULL) {
6237c478bd9Sstevel@tonic-gate 			dt_node_free(dnp->dn_membexpr);
6247c478bd9Sstevel@tonic-gate 			dnp->dn_membexpr = NULL;
6257c478bd9Sstevel@tonic-gate 		}
6267c478bd9Sstevel@tonic-gate 		break;
6277c478bd9Sstevel@tonic-gate 
6287c478bd9Sstevel@tonic-gate 	case DT_NODE_PROVIDER:
6297c478bd9Sstevel@tonic-gate 		dt_node_list_free(&dnp->dn_probes);
6307c478bd9Sstevel@tonic-gate 		free(dnp->dn_provname);
6317c478bd9Sstevel@tonic-gate 		dnp->dn_provname = NULL;
6327c478bd9Sstevel@tonic-gate 		break;
6337c478bd9Sstevel@tonic-gate 
6347c478bd9Sstevel@tonic-gate 	case DT_NODE_PROG:
6357c478bd9Sstevel@tonic-gate 		dt_node_list_free(&dnp->dn_list);
6367c478bd9Sstevel@tonic-gate 		break;
6377c478bd9Sstevel@tonic-gate 	}
6387c478bd9Sstevel@tonic-gate }
6397c478bd9Sstevel@tonic-gate 
6407c478bd9Sstevel@tonic-gate void
6417c478bd9Sstevel@tonic-gate dt_node_attr_assign(dt_node_t *dnp, dtrace_attribute_t attr)
6427c478bd9Sstevel@tonic-gate {
6437c478bd9Sstevel@tonic-gate 	if ((yypcb->pcb_cflags & DTRACE_C_EATTR) &&
6447c478bd9Sstevel@tonic-gate 	    (dt_attr_cmp(attr, yypcb->pcb_amin) < 0)) {
6457c478bd9Sstevel@tonic-gate 		char a[DTRACE_ATTR2STR_MAX];
6467c478bd9Sstevel@tonic-gate 		char s[BUFSIZ];
6477c478bd9Sstevel@tonic-gate 
6487c478bd9Sstevel@tonic-gate 		dnerror(dnp, D_ATTR_MIN, "attributes for %s (%s) are less than "
6497c478bd9Sstevel@tonic-gate 		    "predefined minimum\n", dt_node_name(dnp, s, sizeof (s)),
6507c478bd9Sstevel@tonic-gate 		    dtrace_attr2str(attr, a, sizeof (a)));
6517c478bd9Sstevel@tonic-gate 	}
6527c478bd9Sstevel@tonic-gate 
6537c478bd9Sstevel@tonic-gate 	dnp->dn_attr = attr;
6547c478bd9Sstevel@tonic-gate }
6557c478bd9Sstevel@tonic-gate 
6567c478bd9Sstevel@tonic-gate void
6577c478bd9Sstevel@tonic-gate dt_node_type_assign(dt_node_t *dnp, ctf_file_t *fp, ctf_id_t type)
6587c478bd9Sstevel@tonic-gate {
6597c478bd9Sstevel@tonic-gate 	ctf_id_t base = ctf_type_resolve(fp, type);
6607c478bd9Sstevel@tonic-gate 	uint_t kind = ctf_type_kind(fp, base);
6617c478bd9Sstevel@tonic-gate 	ctf_encoding_t e;
6627c478bd9Sstevel@tonic-gate 
6637c478bd9Sstevel@tonic-gate 	dnp->dn_flags &=
6647c478bd9Sstevel@tonic-gate 	    ~(DT_NF_SIGNED | DT_NF_REF | DT_NF_BITFIELD | DT_NF_USERLAND);
6657c478bd9Sstevel@tonic-gate 
6667c478bd9Sstevel@tonic-gate 	if (kind == CTF_K_INTEGER && ctf_type_encoding(fp, base, &e) == 0) {
6677c478bd9Sstevel@tonic-gate 		size_t size = e.cte_bits / NBBY;
6687c478bd9Sstevel@tonic-gate 
6697c478bd9Sstevel@tonic-gate 		if (size > 8 || (e.cte_bits % NBBY) != 0 || (size & (size - 1)))
6707c478bd9Sstevel@tonic-gate 			dnp->dn_flags |= DT_NF_BITFIELD;
6717c478bd9Sstevel@tonic-gate 
6727c478bd9Sstevel@tonic-gate 		if (e.cte_format & CTF_INT_SIGNED)
6737c478bd9Sstevel@tonic-gate 			dnp->dn_flags |= DT_NF_SIGNED;
6747c478bd9Sstevel@tonic-gate 	}
6757c478bd9Sstevel@tonic-gate 
6767c478bd9Sstevel@tonic-gate 	if (kind == CTF_K_FLOAT && ctf_type_encoding(fp, base, &e) == 0) {
6777c478bd9Sstevel@tonic-gate 		if (e.cte_bits / NBBY > sizeof (uint64_t))
6787c478bd9Sstevel@tonic-gate 			dnp->dn_flags |= DT_NF_REF;
6797c478bd9Sstevel@tonic-gate 	}
6807c478bd9Sstevel@tonic-gate 
6817c478bd9Sstevel@tonic-gate 	if (kind == CTF_K_STRUCT || kind == CTF_K_UNION ||
6827c478bd9Sstevel@tonic-gate 	    kind == CTF_K_FORWARD ||
6837c478bd9Sstevel@tonic-gate 	    kind == CTF_K_ARRAY || kind == CTF_K_FUNCTION)
6847c478bd9Sstevel@tonic-gate 		dnp->dn_flags |= DT_NF_REF;
6857c478bd9Sstevel@tonic-gate 	else if (yypcb != NULL && fp == DT_DYN_CTFP(yypcb->pcb_hdl) &&
6867c478bd9Sstevel@tonic-gate 	    type == DT_DYN_TYPE(yypcb->pcb_hdl))
6877c478bd9Sstevel@tonic-gate 		dnp->dn_flags |= DT_NF_REF;
6887c478bd9Sstevel@tonic-gate 
6897c478bd9Sstevel@tonic-gate 	dnp->dn_flags |= DT_NF_COOKED;
6907c478bd9Sstevel@tonic-gate 	dnp->dn_ctfp = fp;
6917c478bd9Sstevel@tonic-gate 	dnp->dn_type = type;
6927c478bd9Sstevel@tonic-gate }
6937c478bd9Sstevel@tonic-gate 
6947c478bd9Sstevel@tonic-gate void
6957c478bd9Sstevel@tonic-gate dt_node_type_propagate(const dt_node_t *src, dt_node_t *dst)
6967c478bd9Sstevel@tonic-gate {
6977c478bd9Sstevel@tonic-gate 	assert(src->dn_flags & DT_NF_COOKED);
6987c478bd9Sstevel@tonic-gate 	dst->dn_flags = src->dn_flags & ~DT_NF_LVALUE;
6997c478bd9Sstevel@tonic-gate 	dst->dn_ctfp = src->dn_ctfp;
7007c478bd9Sstevel@tonic-gate 	dst->dn_type = src->dn_type;
7017c478bd9Sstevel@tonic-gate }
7027c478bd9Sstevel@tonic-gate 
7037c478bd9Sstevel@tonic-gate const char *
7047c478bd9Sstevel@tonic-gate dt_node_type_name(const dt_node_t *dnp, char *buf, size_t len)
7057c478bd9Sstevel@tonic-gate {
7067c478bd9Sstevel@tonic-gate 	if (dt_node_is_dynamic(dnp) && dnp->dn_ident != NULL) {
7077c478bd9Sstevel@tonic-gate 		(void) snprintf(buf, len, "%s",
7087c478bd9Sstevel@tonic-gate 		    dt_idkind_name(dt_ident_resolve(dnp->dn_ident)->di_kind));
7097c478bd9Sstevel@tonic-gate 		return (buf);
7107c478bd9Sstevel@tonic-gate 	}
7117c478bd9Sstevel@tonic-gate 
7127c478bd9Sstevel@tonic-gate 	if (dnp->dn_flags & DT_NF_USERLAND) {
7137c478bd9Sstevel@tonic-gate 		size_t n = snprintf(buf, len, "userland ");
7147c478bd9Sstevel@tonic-gate 		len = len > n ? len - n : 0;
7157c478bd9Sstevel@tonic-gate 		(void) dt_type_name(dnp->dn_ctfp, dnp->dn_type, buf + n, len);
7167c478bd9Sstevel@tonic-gate 		return (buf);
7177c478bd9Sstevel@tonic-gate 	}
7187c478bd9Sstevel@tonic-gate 
7197c478bd9Sstevel@tonic-gate 	return (dt_type_name(dnp->dn_ctfp, dnp->dn_type, buf, len));
7207c478bd9Sstevel@tonic-gate }
7217c478bd9Sstevel@tonic-gate 
7227c478bd9Sstevel@tonic-gate size_t
7237c478bd9Sstevel@tonic-gate dt_node_type_size(const dt_node_t *dnp)
7247c478bd9Sstevel@tonic-gate {
725ec57c73dSBryan Cantrill 	ctf_id_t base;
726ec57c73dSBryan Cantrill 
7277c478bd9Sstevel@tonic-gate 	if (dnp->dn_kind == DT_NODE_STRING)
7287c478bd9Sstevel@tonic-gate 		return (strlen(dnp->dn_string) + 1);
7297c478bd9Sstevel@tonic-gate 
7307c478bd9Sstevel@tonic-gate 	if (dt_node_is_dynamic(dnp) && dnp->dn_ident != NULL)
7317c478bd9Sstevel@tonic-gate 		return (dt_ident_size(dnp->dn_ident));
7327c478bd9Sstevel@tonic-gate 
733ec57c73dSBryan Cantrill 	base = ctf_type_resolve(dnp->dn_ctfp, dnp->dn_type);
734ec57c73dSBryan Cantrill 
735ec57c73dSBryan Cantrill 	if (ctf_type_kind(dnp->dn_ctfp, base) == CTF_K_FORWARD)
736ec57c73dSBryan Cantrill 		return (0);
737ec57c73dSBryan Cantrill 
7387c478bd9Sstevel@tonic-gate 	return (ctf_type_size(dnp->dn_ctfp, dnp->dn_type));
7397c478bd9Sstevel@tonic-gate }
7407c478bd9Sstevel@tonic-gate 
7417c478bd9Sstevel@tonic-gate /*
7427c478bd9Sstevel@tonic-gate  * Determine if the specified parse tree node references an identifier of the
7437c478bd9Sstevel@tonic-gate  * specified kind, and if so return a pointer to it; otherwise return NULL.
7447c478bd9Sstevel@tonic-gate  * This function resolves the identifier itself, following through any inlines.
7457c478bd9Sstevel@tonic-gate  */
7467c478bd9Sstevel@tonic-gate dt_ident_t *
7477c478bd9Sstevel@tonic-gate dt_node_resolve(const dt_node_t *dnp, uint_t idkind)
7487c478bd9Sstevel@tonic-gate {
7497c478bd9Sstevel@tonic-gate 	dt_ident_t *idp;
7507c478bd9Sstevel@tonic-gate 
7517c478bd9Sstevel@tonic-gate 	switch (dnp->dn_kind) {
7527c478bd9Sstevel@tonic-gate 	case DT_NODE_VAR:
7537c478bd9Sstevel@tonic-gate 	case DT_NODE_SYM:
7547c478bd9Sstevel@tonic-gate 	case DT_NODE_FUNC:
7557c478bd9Sstevel@tonic-gate 	case DT_NODE_AGG:
7567c478bd9Sstevel@tonic-gate 	case DT_NODE_INLINE:
7577c478bd9Sstevel@tonic-gate 	case DT_NODE_PROBE:
7587c478bd9Sstevel@tonic-gate 		idp = dt_ident_resolve(dnp->dn_ident);
7597c478bd9Sstevel@tonic-gate 		return (idp->di_kind == idkind ? idp : NULL);
7607c478bd9Sstevel@tonic-gate 	}
7617c478bd9Sstevel@tonic-gate 
7627c478bd9Sstevel@tonic-gate 	if (dt_node_is_dynamic(dnp)) {
7637c478bd9Sstevel@tonic-gate 		idp = dt_ident_resolve(dnp->dn_ident);
7647c478bd9Sstevel@tonic-gate 		return (idp->di_kind == idkind ? idp : NULL);
7657c478bd9Sstevel@tonic-gate 	}
7667c478bd9Sstevel@tonic-gate 
7677c478bd9Sstevel@tonic-gate 	return (NULL);
7687c478bd9Sstevel@tonic-gate }
7697c478bd9Sstevel@tonic-gate 
7707c478bd9Sstevel@tonic-gate size_t
7717c478bd9Sstevel@tonic-gate dt_node_sizeof(const dt_node_t *dnp)
7727c478bd9Sstevel@tonic-gate {
7737c478bd9Sstevel@tonic-gate 	dtrace_syminfo_t *sip;
7747c478bd9Sstevel@tonic-gate 	GElf_Sym sym;
7757c478bd9Sstevel@tonic-gate 	dtrace_hdl_t *dtp = yypcb->pcb_hdl;
7767c478bd9Sstevel@tonic-gate 
7777c478bd9Sstevel@tonic-gate 	/*
7787c478bd9Sstevel@tonic-gate 	 * The size of the node as used for the sizeof() operator depends on
7797c478bd9Sstevel@tonic-gate 	 * the kind of the node.  If the node is a SYM, the size is obtained
7807c478bd9Sstevel@tonic-gate 	 * from the symbol table; if it is not a SYM, the size is determined
7817c478bd9Sstevel@tonic-gate 	 * from the node's type.  This is slightly different from C's sizeof()
7827c478bd9Sstevel@tonic-gate 	 * operator in that (for example) when applied to a function, sizeof()
7837c478bd9Sstevel@tonic-gate 	 * will evaluate to the length of the function rather than the size of
7847c478bd9Sstevel@tonic-gate 	 * the function type.
7857c478bd9Sstevel@tonic-gate 	 */
7867c478bd9Sstevel@tonic-gate 	if (dnp->dn_kind != DT_NODE_SYM)
7877c478bd9Sstevel@tonic-gate 		return (dt_node_type_size(dnp));
7887c478bd9Sstevel@tonic-gate 
7897c478bd9Sstevel@tonic-gate 	sip = dnp->dn_ident->di_data;
7907c478bd9Sstevel@tonic-gate 
7917c478bd9Sstevel@tonic-gate 	if (dtrace_lookup_by_name(dtp, sip->dts_object,
7927c478bd9Sstevel@tonic-gate 	    sip->dts_name, &sym, NULL) == -1)
7937c478bd9Sstevel@tonic-gate 		return (0);
7947c478bd9Sstevel@tonic-gate 
7957c478bd9Sstevel@tonic-gate 	return (sym.st_size);
7967c478bd9Sstevel@tonic-gate }
7977c478bd9Sstevel@tonic-gate 
7987c478bd9Sstevel@tonic-gate int
7997c478bd9Sstevel@tonic-gate dt_node_is_integer(const dt_node_t *dnp)
8007c478bd9Sstevel@tonic-gate {
8017c478bd9Sstevel@tonic-gate 	ctf_file_t *fp = dnp->dn_ctfp;
8027c478bd9Sstevel@tonic-gate 	ctf_encoding_t e;
8037c478bd9Sstevel@tonic-gate 	ctf_id_t type;
8047c478bd9Sstevel@tonic-gate 	uint_t kind;
8057c478bd9Sstevel@tonic-gate 
8067c478bd9Sstevel@tonic-gate 	assert(dnp->dn_flags & DT_NF_COOKED);
8077c478bd9Sstevel@tonic-gate 
8087c478bd9Sstevel@tonic-gate 	type = ctf_type_resolve(fp, dnp->dn_type);
8097c478bd9Sstevel@tonic-gate 	kind = ctf_type_kind(fp, type);
8107c478bd9Sstevel@tonic-gate 
8117c478bd9Sstevel@tonic-gate 	if (kind == CTF_K_INTEGER &&
8127c478bd9Sstevel@tonic-gate 	    ctf_type_encoding(fp, type, &e) == 0 && IS_VOID(e))
8137c478bd9Sstevel@tonic-gate 		return (0); /* void integer */
8147c478bd9Sstevel@tonic-gate 
8157c478bd9Sstevel@tonic-gate 	return (kind == CTF_K_INTEGER || kind == CTF_K_ENUM);
8167c478bd9Sstevel@tonic-gate }
8177c478bd9Sstevel@tonic-gate 
8187c478bd9Sstevel@tonic-gate int
8197c478bd9Sstevel@tonic-gate dt_node_is_float(const dt_node_t *dnp)
8207c478bd9Sstevel@tonic-gate {
8217c478bd9Sstevel@tonic-gate 	ctf_file_t *fp = dnp->dn_ctfp;
8227c478bd9Sstevel@tonic-gate 	ctf_encoding_t e;
8237c478bd9Sstevel@tonic-gate 	ctf_id_t type;
8247c478bd9Sstevel@tonic-gate 	uint_t kind;
8257c478bd9Sstevel@tonic-gate 
8267c478bd9Sstevel@tonic-gate 	assert(dnp->dn_flags & DT_NF_COOKED);
8277c478bd9Sstevel@tonic-gate 
8287c478bd9Sstevel@tonic-gate 	type = ctf_type_resolve(fp, dnp->dn_type);
8297c478bd9Sstevel@tonic-gate 	kind = ctf_type_kind(fp, type);
8307c478bd9Sstevel@tonic-gate 
8317c478bd9Sstevel@tonic-gate 	return (kind == CTF_K_FLOAT &&
8327c478bd9Sstevel@tonic-gate 	    ctf_type_encoding(dnp->dn_ctfp, type, &e) == 0 && (
8337c478bd9Sstevel@tonic-gate 	    e.cte_format == CTF_FP_SINGLE || e.cte_format == CTF_FP_DOUBLE ||
8347c478bd9Sstevel@tonic-gate 	    e.cte_format == CTF_FP_LDOUBLE));
8357c478bd9Sstevel@tonic-gate }
8367c478bd9Sstevel@tonic-gate 
8377c478bd9Sstevel@tonic-gate int
8387c478bd9Sstevel@tonic-gate dt_node_is_scalar(const dt_node_t *dnp)
8397c478bd9Sstevel@tonic-gate {
8407c478bd9Sstevel@tonic-gate 	ctf_file_t *fp = dnp->dn_ctfp;
8417c478bd9Sstevel@tonic-gate 	ctf_encoding_t e;
8427c478bd9Sstevel@tonic-gate 	ctf_id_t type;
8437c478bd9Sstevel@tonic-gate 	uint_t kind;
8447c478bd9Sstevel@tonic-gate 
8457c478bd9Sstevel@tonic-gate 	assert(dnp->dn_flags & DT_NF_COOKED);
8467c478bd9Sstevel@tonic-gate 
8477c478bd9Sstevel@tonic-gate 	type = ctf_type_resolve(fp, dnp->dn_type);
8487c478bd9Sstevel@tonic-gate 	kind = ctf_type_kind(fp, type);
8497c478bd9Sstevel@tonic-gate 
8507c478bd9Sstevel@tonic-gate 	if (kind == CTF_K_INTEGER &&
8517c478bd9Sstevel@tonic-gate 	    ctf_type_encoding(fp, type, &e) == 0 && IS_VOID(e))
8527c478bd9Sstevel@tonic-gate 		return (0); /* void cannot be used as a scalar */
8537c478bd9Sstevel@tonic-gate 
8547c478bd9Sstevel@tonic-gate 	return (kind == CTF_K_INTEGER || kind == CTF_K_ENUM ||
8557c478bd9Sstevel@tonic-gate 	    kind == CTF_K_POINTER);
8567c478bd9Sstevel@tonic-gate }
8577c478bd9Sstevel@tonic-gate 
8587c478bd9Sstevel@tonic-gate int
8597c478bd9Sstevel@tonic-gate dt_node_is_arith(const dt_node_t *dnp)
8607c478bd9Sstevel@tonic-gate {
8617c478bd9Sstevel@tonic-gate 	ctf_file_t *fp = dnp->dn_ctfp;
8627c478bd9Sstevel@tonic-gate 	ctf_encoding_t e;
8637c478bd9Sstevel@tonic-gate 	ctf_id_t type;
8647c478bd9Sstevel@tonic-gate 	uint_t kind;
8657c478bd9Sstevel@tonic-gate 
8667c478bd9Sstevel@tonic-gate 	assert(dnp->dn_flags & DT_NF_COOKED);
8677c478bd9Sstevel@tonic-gate 
8687c478bd9Sstevel@tonic-gate 	type = ctf_type_resolve(fp, dnp->dn_type);
8697c478bd9Sstevel@tonic-gate 	kind = ctf_type_kind(fp, type);
8707c478bd9Sstevel@tonic-gate 
8717c478bd9Sstevel@tonic-gate 	if (kind == CTF_K_INTEGER)
8727c478bd9Sstevel@tonic-gate 		return (ctf_type_encoding(fp, type, &e) == 0 && !IS_VOID(e));
8737c478bd9Sstevel@tonic-gate 	else
8747c478bd9Sstevel@tonic-gate 		return (kind == CTF_K_ENUM);
8757c478bd9Sstevel@tonic-gate }
8767c478bd9Sstevel@tonic-gate 
8777c478bd9Sstevel@tonic-gate int
8787c478bd9Sstevel@tonic-gate dt_node_is_vfptr(const dt_node_t *dnp)
8797c478bd9Sstevel@tonic-gate {
8807c478bd9Sstevel@tonic-gate 	ctf_file_t *fp = dnp->dn_ctfp;
8817c478bd9Sstevel@tonic-gate 	ctf_encoding_t e;
8827c478bd9Sstevel@tonic-gate 	ctf_id_t type;
8837c478bd9Sstevel@tonic-gate 	uint_t kind;
8847c478bd9Sstevel@tonic-gate 
8857c478bd9Sstevel@tonic-gate 	assert(dnp->dn_flags & DT_NF_COOKED);
8867c478bd9Sstevel@tonic-gate 
8877c478bd9Sstevel@tonic-gate 	type = ctf_type_resolve(fp, dnp->dn_type);
8887c478bd9Sstevel@tonic-gate 	if (ctf_type_kind(fp, type) != CTF_K_POINTER)
8897c478bd9Sstevel@tonic-gate 		return (0); /* type is not a pointer */
8907c478bd9Sstevel@tonic-gate 
8917c478bd9Sstevel@tonic-gate 	type = ctf_type_resolve(fp, ctf_type_reference(fp, type));
8927c478bd9Sstevel@tonic-gate 	kind = ctf_type_kind(fp, type);
8937c478bd9Sstevel@tonic-gate 
8947c478bd9Sstevel@tonic-gate 	return (kind == CTF_K_FUNCTION || (kind == CTF_K_INTEGER &&
8957c478bd9Sstevel@tonic-gate 	    ctf_type_encoding(fp, type, &e) == 0 && IS_VOID(e)));
8967c478bd9Sstevel@tonic-gate }
8977c478bd9Sstevel@tonic-gate 
8987c478bd9Sstevel@tonic-gate int
8997c478bd9Sstevel@tonic-gate dt_node_is_dynamic(const dt_node_t *dnp)
9007c478bd9Sstevel@tonic-gate {
9017c478bd9Sstevel@tonic-gate 	if (dnp->dn_kind == DT_NODE_VAR &&
9027c478bd9Sstevel@tonic-gate 	    (dnp->dn_ident->di_flags & DT_IDFLG_INLINE)) {
9037c478bd9Sstevel@tonic-gate 		const dt_idnode_t *inp = dnp->dn_ident->di_iarg;
9041a7c1b72Smws 		return (inp->din_root ? dt_node_is_dynamic(inp->din_root) : 0);
9057c478bd9Sstevel@tonic-gate 	}
9067c478bd9Sstevel@tonic-gate 
9077c478bd9Sstevel@tonic-gate 	return (dnp->dn_ctfp == DT_DYN_CTFP(yypcb->pcb_hdl) &&
9087c478bd9Sstevel@tonic-gate 	    dnp->dn_type == DT_DYN_TYPE(yypcb->pcb_hdl));
9097c478bd9Sstevel@tonic-gate }
9107c478bd9Sstevel@tonic-gate 
9117c478bd9Sstevel@tonic-gate int
9127c478bd9Sstevel@tonic-gate dt_node_is_string(const dt_node_t *dnp)
9137c478bd9Sstevel@tonic-gate {
9147c478bd9Sstevel@tonic-gate 	return (dnp->dn_ctfp == DT_STR_CTFP(yypcb->pcb_hdl) &&
9157c478bd9Sstevel@tonic-gate 	    dnp->dn_type == DT_STR_TYPE(yypcb->pcb_hdl));
9167c478bd9Sstevel@tonic-gate }
9177c478bd9Sstevel@tonic-gate 
9187c478bd9Sstevel@tonic-gate int
9197c478bd9Sstevel@tonic-gate dt_node_is_stack(const dt_node_t *dnp)
9207c478bd9Sstevel@tonic-gate {
9217c478bd9Sstevel@tonic-gate 	return (dnp->dn_ctfp == DT_STACK_CTFP(yypcb->pcb_hdl) &&
9227c478bd9Sstevel@tonic-gate 	    dnp->dn_type == DT_STACK_TYPE(yypcb->pcb_hdl));
9237c478bd9Sstevel@tonic-gate }
9247c478bd9Sstevel@tonic-gate 
925a1b5e537Sbmc int
926a1b5e537Sbmc dt_node_is_symaddr(const dt_node_t *dnp)
927a1b5e537Sbmc {
928a1b5e537Sbmc 	return (dnp->dn_ctfp == DT_SYMADDR_CTFP(yypcb->pcb_hdl) &&
929a1b5e537Sbmc 	    dnp->dn_type == DT_SYMADDR_TYPE(yypcb->pcb_hdl));
930a1b5e537Sbmc }
931a1b5e537Sbmc 
932a1b5e537Sbmc int
933a1b5e537Sbmc dt_node_is_usymaddr(const dt_node_t *dnp)
934a1b5e537Sbmc {
935a1b5e537Sbmc 	return (dnp->dn_ctfp == DT_USYMADDR_CTFP(yypcb->pcb_hdl) &&
936a1b5e537Sbmc 	    dnp->dn_type == DT_USYMADDR_TYPE(yypcb->pcb_hdl));
937a1b5e537Sbmc }
938a1b5e537Sbmc 
9397c478bd9Sstevel@tonic-gate int
9407c478bd9Sstevel@tonic-gate dt_node_is_strcompat(const dt_node_t *dnp)
9417c478bd9Sstevel@tonic-gate {
9427c478bd9Sstevel@tonic-gate 	ctf_file_t *fp = dnp->dn_ctfp;
9437c478bd9Sstevel@tonic-gate 	ctf_encoding_t e;
9447c478bd9Sstevel@tonic-gate 	ctf_arinfo_t r;
9457c478bd9Sstevel@tonic-gate 	ctf_id_t base;
9467c478bd9Sstevel@tonic-gate 	uint_t kind;
9477c478bd9Sstevel@tonic-gate 
9487c478bd9Sstevel@tonic-gate 	assert(dnp->dn_flags & DT_NF_COOKED);
9497c478bd9Sstevel@tonic-gate 
9507c478bd9Sstevel@tonic-gate 	base = ctf_type_resolve(fp, dnp->dn_type);
9517c478bd9Sstevel@tonic-gate 	kind = ctf_type_kind(fp, base);
9527c478bd9Sstevel@tonic-gate 
9537c478bd9Sstevel@tonic-gate 	if (kind == CTF_K_POINTER &&
9547c478bd9Sstevel@tonic-gate 	    (base = ctf_type_reference(fp, base)) != CTF_ERR &&
9557c478bd9Sstevel@tonic-gate 	    (base = ctf_type_resolve(fp, base)) != CTF_ERR &&
9567c478bd9Sstevel@tonic-gate 	    ctf_type_encoding(fp, base, &e) == 0 && IS_CHAR(e))
9577c478bd9Sstevel@tonic-gate 		return (1); /* promote char pointer to string */
9587c478bd9Sstevel@tonic-gate 
9597c478bd9Sstevel@tonic-gate 	if (kind == CTF_K_ARRAY && ctf_array_info(fp, base, &r) == 0 &&
9607c478bd9Sstevel@tonic-gate 	    (base = ctf_type_resolve(fp, r.ctr_contents)) != CTF_ERR &&
9617c478bd9Sstevel@tonic-gate 	    ctf_type_encoding(fp, base, &e) == 0 && IS_CHAR(e))
9627c478bd9Sstevel@tonic-gate 		return (1); /* promote char array to string */
9637c478bd9Sstevel@tonic-gate 
9647c478bd9Sstevel@tonic-gate 	return (0);
9657c478bd9Sstevel@tonic-gate }
9667c478bd9Sstevel@tonic-gate 
9677c478bd9Sstevel@tonic-gate int
9687c478bd9Sstevel@tonic-gate dt_node_is_pointer(const dt_node_t *dnp)
9697c478bd9Sstevel@tonic-gate {
9707c478bd9Sstevel@tonic-gate 	ctf_file_t *fp = dnp->dn_ctfp;
9717c478bd9Sstevel@tonic-gate 	uint_t kind;
9727c478bd9Sstevel@tonic-gate 
9737c478bd9Sstevel@tonic-gate 	assert(dnp->dn_flags & DT_NF_COOKED);
9747c478bd9Sstevel@tonic-gate 
9757c478bd9Sstevel@tonic-gate 	if (dt_node_is_string(dnp))
9767c478bd9Sstevel@tonic-gate 		return (0); /* string are pass-by-ref but act like structs */
9777c478bd9Sstevel@tonic-gate 
9787c478bd9Sstevel@tonic-gate 	kind = ctf_type_kind(fp, ctf_type_resolve(fp, dnp->dn_type));
9797c478bd9Sstevel@tonic-gate 	return (kind == CTF_K_POINTER || kind == CTF_K_ARRAY);
9807c478bd9Sstevel@tonic-gate }
9817c478bd9Sstevel@tonic-gate 
9827c478bd9Sstevel@tonic-gate int
9837c478bd9Sstevel@tonic-gate dt_node_is_void(const dt_node_t *dnp)
9847c478bd9Sstevel@tonic-gate {
9857c478bd9Sstevel@tonic-gate 	ctf_file_t *fp = dnp->dn_ctfp;
9867c478bd9Sstevel@tonic-gate 	ctf_encoding_t e;
9877c478bd9Sstevel@tonic-gate 	ctf_id_t type;
9887c478bd9Sstevel@tonic-gate 
9897c478bd9Sstevel@tonic-gate 	if (dt_node_is_dynamic(dnp))
9907c478bd9Sstevel@tonic-gate 		return (0); /* <DYN> is an alias for void but not the same */
9917c478bd9Sstevel@tonic-gate 
9927c478bd9Sstevel@tonic-gate 	if (dt_node_is_stack(dnp))
9937c478bd9Sstevel@tonic-gate 		return (0);
9947c478bd9Sstevel@tonic-gate 
995a1b5e537Sbmc 	if (dt_node_is_symaddr(dnp) || dt_node_is_usymaddr(dnp))
996a1b5e537Sbmc 		return (0);
997a1b5e537Sbmc 
9987c478bd9Sstevel@tonic-gate 	type = ctf_type_resolve(fp, dnp->dn_type);
9997c478bd9Sstevel@tonic-gate 
10007c478bd9Sstevel@tonic-gate 	return (ctf_type_kind(fp, type) == CTF_K_INTEGER &&
10017c478bd9Sstevel@tonic-gate 	    ctf_type_encoding(fp, type, &e) == 0 && IS_VOID(e));
10027c478bd9Sstevel@tonic-gate }
10037c478bd9Sstevel@tonic-gate 
10047c478bd9Sstevel@tonic-gate int
10057c478bd9Sstevel@tonic-gate dt_node_is_ptrcompat(const dt_node_t *lp, const dt_node_t *rp,
10067c478bd9Sstevel@tonic-gate     ctf_file_t **fpp, ctf_id_t *tp)
10077c478bd9Sstevel@tonic-gate {
10087c478bd9Sstevel@tonic-gate 	ctf_file_t *lfp = lp->dn_ctfp;
10097c478bd9Sstevel@tonic-gate 	ctf_file_t *rfp = rp->dn_ctfp;
10107c478bd9Sstevel@tonic-gate 
10117c478bd9Sstevel@tonic-gate 	ctf_id_t lbase = CTF_ERR, rbase = CTF_ERR;
10127c478bd9Sstevel@tonic-gate 	ctf_id_t lref = CTF_ERR, rref = CTF_ERR;
10137c478bd9Sstevel@tonic-gate 
10147c478bd9Sstevel@tonic-gate 	int lp_is_void, rp_is_void, lp_is_int, rp_is_int, compat;
10157c478bd9Sstevel@tonic-gate 	uint_t lkind, rkind;
10167c478bd9Sstevel@tonic-gate 	ctf_encoding_t e;
10177c478bd9Sstevel@tonic-gate 	ctf_arinfo_t r;
10187c478bd9Sstevel@tonic-gate 
10197c478bd9Sstevel@tonic-gate 	assert(lp->dn_flags & DT_NF_COOKED);
10207c478bd9Sstevel@tonic-gate 	assert(rp->dn_flags & DT_NF_COOKED);
10217c478bd9Sstevel@tonic-gate 
10227c478bd9Sstevel@tonic-gate 	if (dt_node_is_dynamic(lp) || dt_node_is_dynamic(rp))
10237c478bd9Sstevel@tonic-gate 		return (0); /* fail if either node is a dynamic variable */
10247c478bd9Sstevel@tonic-gate 
10257c478bd9Sstevel@tonic-gate 	lp_is_int = dt_node_is_integer(lp);
10267c478bd9Sstevel@tonic-gate 	rp_is_int = dt_node_is_integer(rp);
10277c478bd9Sstevel@tonic-gate 
10287c478bd9Sstevel@tonic-gate 	if (lp_is_int && rp_is_int)
10297c478bd9Sstevel@tonic-gate 		return (0); /* fail if both nodes are integers */
10307c478bd9Sstevel@tonic-gate 
10317c478bd9Sstevel@tonic-gate 	if (lp_is_int && (lp->dn_kind != DT_NODE_INT || lp->dn_value != 0))
10327c478bd9Sstevel@tonic-gate 		return (0); /* fail if lp is an integer that isn't 0 constant */
10337c478bd9Sstevel@tonic-gate 
10347c478bd9Sstevel@tonic-gate 	if (rp_is_int && (rp->dn_kind != DT_NODE_INT || rp->dn_value != 0))
10357c478bd9Sstevel@tonic-gate 		return (0); /* fail if rp is an integer that isn't 0 constant */
10367c478bd9Sstevel@tonic-gate 
10377c478bd9Sstevel@tonic-gate 	if ((lp_is_int == 0 && rp_is_int == 0) && (
10387c478bd9Sstevel@tonic-gate 	    (lp->dn_flags & DT_NF_USERLAND) ^ (rp->dn_flags & DT_NF_USERLAND)))
10397c478bd9Sstevel@tonic-gate 		return (0); /* fail if only one pointer is a userland address */
10407c478bd9Sstevel@tonic-gate 
10417c478bd9Sstevel@tonic-gate 	/*
10427c478bd9Sstevel@tonic-gate 	 * Resolve the left-hand and right-hand types to their base type, and
10437c478bd9Sstevel@tonic-gate 	 * then resolve the referenced type as well (assuming the base type
10447c478bd9Sstevel@tonic-gate 	 * is CTF_K_POINTER or CTF_K_ARRAY).  Otherwise [lr]ref = CTF_ERR.
10457c478bd9Sstevel@tonic-gate 	 */
10467c478bd9Sstevel@tonic-gate 	if (!lp_is_int) {
10477c478bd9Sstevel@tonic-gate 		lbase = ctf_type_resolve(lfp, lp->dn_type);
10487c478bd9Sstevel@tonic-gate 		lkind = ctf_type_kind(lfp, lbase);
10497c478bd9Sstevel@tonic-gate 
10507c478bd9Sstevel@tonic-gate 		if (lkind == CTF_K_POINTER) {
10517c478bd9Sstevel@tonic-gate 			lref = ctf_type_resolve(lfp,
10527c478bd9Sstevel@tonic-gate 			    ctf_type_reference(lfp, lbase));
10537c478bd9Sstevel@tonic-gate 		} else if (lkind == CTF_K_ARRAY &&
10547c478bd9Sstevel@tonic-gate 		    ctf_array_info(lfp, lbase, &r) == 0) {
10557c478bd9Sstevel@tonic-gate 			lref = ctf_type_resolve(lfp, r.ctr_contents);
10567c478bd9Sstevel@tonic-gate 		}
10577c478bd9Sstevel@tonic-gate 	}
10587c478bd9Sstevel@tonic-gate 
10597c478bd9Sstevel@tonic-gate 	if (!rp_is_int) {
10607c478bd9Sstevel@tonic-gate 		rbase = ctf_type_resolve(rfp, rp->dn_type);
10617c478bd9Sstevel@tonic-gate 		rkind = ctf_type_kind(rfp, rbase);
10627c478bd9Sstevel@tonic-gate 
10637c478bd9Sstevel@tonic-gate 		if (rkind == CTF_K_POINTER) {
10647c478bd9Sstevel@tonic-gate 			rref = ctf_type_resolve(rfp,
10657c478bd9Sstevel@tonic-gate 			    ctf_type_reference(rfp, rbase));
10667c478bd9Sstevel@tonic-gate 		} else if (rkind == CTF_K_ARRAY &&
10677c478bd9Sstevel@tonic-gate 		    ctf_array_info(rfp, rbase, &r) == 0) {
10687c478bd9Sstevel@tonic-gate 			rref = ctf_type_resolve(rfp, r.ctr_contents);
10697c478bd9Sstevel@tonic-gate 		}
10707c478bd9Sstevel@tonic-gate 	}
10717c478bd9Sstevel@tonic-gate 
10727c478bd9Sstevel@tonic-gate 	/*
10737c478bd9Sstevel@tonic-gate 	 * We know that one or the other type may still be a zero-valued
10747c478bd9Sstevel@tonic-gate 	 * integer constant.  To simplify the code below, set the integer
10757c478bd9Sstevel@tonic-gate 	 * type variables equal to the non-integer types and proceed.
10767c478bd9Sstevel@tonic-gate 	 */
10777c478bd9Sstevel@tonic-gate 	if (lp_is_int) {
10787c478bd9Sstevel@tonic-gate 		lbase = rbase;
10797c478bd9Sstevel@tonic-gate 		lkind = rkind;
10807c478bd9Sstevel@tonic-gate 		lref = rref;
10817c478bd9Sstevel@tonic-gate 		lfp = rfp;
10827c478bd9Sstevel@tonic-gate 	} else if (rp_is_int) {
10837c478bd9Sstevel@tonic-gate 		rbase = lbase;
10847c478bd9Sstevel@tonic-gate 		rkind = lkind;
10857c478bd9Sstevel@tonic-gate 		rref = lref;
10867c478bd9Sstevel@tonic-gate 		rfp = lfp;
10877c478bd9Sstevel@tonic-gate 	}
10887c478bd9Sstevel@tonic-gate 
10897c478bd9Sstevel@tonic-gate 	lp_is_void = ctf_type_encoding(lfp, lref, &e) == 0 && IS_VOID(e);
10907c478bd9Sstevel@tonic-gate 	rp_is_void = ctf_type_encoding(rfp, rref, &e) == 0 && IS_VOID(e);
10917c478bd9Sstevel@tonic-gate 
10927c478bd9Sstevel@tonic-gate 	/*
10937c478bd9Sstevel@tonic-gate 	 * The types are compatible if both are pointers to the same type, or
10947c478bd9Sstevel@tonic-gate 	 * if either pointer is a void pointer.  If they are compatible, set
10957c478bd9Sstevel@tonic-gate 	 * tp to point to the more specific pointer type and return it.
10967c478bd9Sstevel@tonic-gate 	 */
10977c478bd9Sstevel@tonic-gate 	compat = (lkind == CTF_K_POINTER || lkind == CTF_K_ARRAY) &&
10987c478bd9Sstevel@tonic-gate 	    (rkind == CTF_K_POINTER || rkind == CTF_K_ARRAY) &&
10997c478bd9Sstevel@tonic-gate 	    (lp_is_void || rp_is_void || ctf_type_compat(lfp, lref, rfp, rref));
11007c478bd9Sstevel@tonic-gate 
11017c478bd9Sstevel@tonic-gate 	if (compat) {
11027c478bd9Sstevel@tonic-gate 		if (fpp != NULL)
11037c478bd9Sstevel@tonic-gate 			*fpp = rp_is_void ? lfp : rfp;
11047c478bd9Sstevel@tonic-gate 		if (tp != NULL)
11057c478bd9Sstevel@tonic-gate 			*tp = rp_is_void ? lbase : rbase;
11067c478bd9Sstevel@tonic-gate 	}
11077c478bd9Sstevel@tonic-gate 
11087c478bd9Sstevel@tonic-gate 	return (compat);
11097c478bd9Sstevel@tonic-gate }
11107c478bd9Sstevel@tonic-gate 
11117c478bd9Sstevel@tonic-gate /*
11127c478bd9Sstevel@tonic-gate  * The rules for checking argument types against parameter types are described
11137c478bd9Sstevel@tonic-gate  * in the ANSI-C spec (see K&R[A7.3.2] and K&R[A7.17]).  We use the same rule
11147c478bd9Sstevel@tonic-gate  * set to determine whether associative array arguments match the prototype.
11157c478bd9Sstevel@tonic-gate  */
11167c478bd9Sstevel@tonic-gate int
11177c478bd9Sstevel@tonic-gate dt_node_is_argcompat(const dt_node_t *lp, const dt_node_t *rp)
11187c478bd9Sstevel@tonic-gate {
11197c478bd9Sstevel@tonic-gate 	ctf_file_t *lfp = lp->dn_ctfp;
11207c478bd9Sstevel@tonic-gate 	ctf_file_t *rfp = rp->dn_ctfp;
11217c478bd9Sstevel@tonic-gate 
11227c478bd9Sstevel@tonic-gate 	assert(lp->dn_flags & DT_NF_COOKED);
11237c478bd9Sstevel@tonic-gate 	assert(rp->dn_flags & DT_NF_COOKED);
11247c478bd9Sstevel@tonic-gate 
11257c478bd9Sstevel@tonic-gate 	if (dt_node_is_integer(lp) && dt_node_is_integer(rp))
11267c478bd9Sstevel@tonic-gate 		return (1); /* integer types are compatible */
11277c478bd9Sstevel@tonic-gate 
11287c478bd9Sstevel@tonic-gate 	if (dt_node_is_strcompat(lp) && dt_node_is_strcompat(rp))
11297c478bd9Sstevel@tonic-gate 		return (1); /* string types are compatible */
11307c478bd9Sstevel@tonic-gate 
11317c478bd9Sstevel@tonic-gate 	if (dt_node_is_stack(lp) && dt_node_is_stack(rp))
11327c478bd9Sstevel@tonic-gate 		return (1); /* stack types are compatible */
11337c478bd9Sstevel@tonic-gate 
1134a1b5e537Sbmc 	if (dt_node_is_symaddr(lp) && dt_node_is_symaddr(rp))
1135a1b5e537Sbmc 		return (1); /* symaddr types are compatible */
1136a1b5e537Sbmc 
1137a1b5e537Sbmc 	if (dt_node_is_usymaddr(lp) && dt_node_is_usymaddr(rp))
1138a1b5e537Sbmc 		return (1); /* usymaddr types are compatible */
1139a1b5e537Sbmc 
11407c478bd9Sstevel@tonic-gate 	switch (ctf_type_kind(lfp, ctf_type_resolve(lfp, lp->dn_type))) {
11417c478bd9Sstevel@tonic-gate 	case CTF_K_FUNCTION:
11427c478bd9Sstevel@tonic-gate 	case CTF_K_STRUCT:
11437c478bd9Sstevel@tonic-gate 	case CTF_K_UNION:
11447c478bd9Sstevel@tonic-gate 		return (ctf_type_compat(lfp, lp->dn_type, rfp, rp->dn_type));
11457c478bd9Sstevel@tonic-gate 	default:
11467c478bd9Sstevel@tonic-gate 		return (dt_node_is_ptrcompat(lp, rp, NULL, NULL));
11477c478bd9Sstevel@tonic-gate 	}
11487c478bd9Sstevel@tonic-gate }
11497c478bd9Sstevel@tonic-gate 
11507c478bd9Sstevel@tonic-gate /*
11517c478bd9Sstevel@tonic-gate  * We provide dt_node_is_posconst() as a convenience routine for callers who
11527c478bd9Sstevel@tonic-gate  * wish to verify that an argument is a positive non-zero integer constant.
11537c478bd9Sstevel@tonic-gate  */
11547c478bd9Sstevel@tonic-gate int
11557c478bd9Sstevel@tonic-gate dt_node_is_posconst(const dt_node_t *dnp)
11567c478bd9Sstevel@tonic-gate {
11577c478bd9Sstevel@tonic-gate 	return (dnp->dn_kind == DT_NODE_INT && dnp->dn_value != 0 && (
11587c478bd9Sstevel@tonic-gate 	    (dnp->dn_flags & DT_NF_SIGNED) == 0 || (int64_t)dnp->dn_value > 0));
11597c478bd9Sstevel@tonic-gate }
11607c478bd9Sstevel@tonic-gate 
11617c478bd9Sstevel@tonic-gate int
11627c478bd9Sstevel@tonic-gate dt_node_is_actfunc(const dt_node_t *dnp)
11637c478bd9Sstevel@tonic-gate {
11647c478bd9Sstevel@tonic-gate 	return (dnp->dn_kind == DT_NODE_FUNC &&
11657c478bd9Sstevel@tonic-gate 	    dnp->dn_ident->di_kind == DT_IDENT_ACTFUNC);
11667c478bd9Sstevel@tonic-gate }
11677c478bd9Sstevel@tonic-gate 
11687c478bd9Sstevel@tonic-gate /*
11697c478bd9Sstevel@tonic-gate  * The original rules for integer constant typing are described in K&R[A2.5.1].
11707c478bd9Sstevel@tonic-gate  * However, since we support long long, we instead use the rules from ISO C99
11717c478bd9Sstevel@tonic-gate  * clause 6.4.4.1 since that is where long longs are formally described.  The
11727c478bd9Sstevel@tonic-gate  * rules require us to know whether the constant was specified in decimal or
11737c478bd9Sstevel@tonic-gate  * in octal or hex, which we do by looking at our lexer's 'yyintdecimal' flag.
11747c478bd9Sstevel@tonic-gate  * The type of an integer constant is the first of the corresponding list in
11757c478bd9Sstevel@tonic-gate  * which its value can be represented:
11767c478bd9Sstevel@tonic-gate  *
11777c478bd9Sstevel@tonic-gate  * unsuffixed decimal:   int, long, long long
11787c478bd9Sstevel@tonic-gate  * unsuffixed oct/hex:   int, unsigned int, long, unsigned long,
11797c478bd9Sstevel@tonic-gate  *                       long long, unsigned long long
11807c478bd9Sstevel@tonic-gate  * suffix [uU]:          unsigned int, unsigned long, unsigned long long
11817c478bd9Sstevel@tonic-gate  * suffix [lL] decimal:  long, long long
11827c478bd9Sstevel@tonic-gate  * suffix [lL] oct/hex:  long, unsigned long, long long, unsigned long long
11837c478bd9Sstevel@tonic-gate  * suffix [uU][Ll]:      unsigned long, unsigned long long
11847c478bd9Sstevel@tonic-gate  * suffix ll/LL decimal: long long
11857c478bd9Sstevel@tonic-gate  * suffix ll/LL oct/hex: long long, unsigned long long
11867c478bd9Sstevel@tonic-gate  * suffix [uU][ll/LL]:   unsigned long long
11877c478bd9Sstevel@tonic-gate  *
11887c478bd9Sstevel@tonic-gate  * Given that our lexer has already validated the suffixes by regexp matching,
11897c478bd9Sstevel@tonic-gate  * there is an obvious way to concisely encode these rules: construct an array
11907c478bd9Sstevel@tonic-gate  * of the types in the order int, unsigned int, long, unsigned long, long long,
11917c478bd9Sstevel@tonic-gate  * unsigned long long.  Compute an integer array starting index based on the
11927c478bd9Sstevel@tonic-gate  * suffix (e.g. none = 0, u = 1, ull = 5), and compute an increment based on
11937c478bd9Sstevel@tonic-gate  * the specifier (dec/oct/hex) and suffix (u).  Then iterate from the starting
11947c478bd9Sstevel@tonic-gate  * index to the end, advancing using the increment, and searching until we
11957c478bd9Sstevel@tonic-gate  * find a limit that matches or we run out of choices (overflow).  To make it
11967c478bd9Sstevel@tonic-gate  * even faster, we precompute the table of type information in dtrace_open().
11977c478bd9Sstevel@tonic-gate  */
11987c478bd9Sstevel@tonic-gate dt_node_t *
11997c478bd9Sstevel@tonic-gate dt_node_int(uintmax_t value)
12007c478bd9Sstevel@tonic-gate {
12017c478bd9Sstevel@tonic-gate 	dt_node_t *dnp = dt_node_alloc(DT_NODE_INT);
12027c478bd9Sstevel@tonic-gate 	dtrace_hdl_t *dtp = yypcb->pcb_hdl;
12037c478bd9Sstevel@tonic-gate 
12047c478bd9Sstevel@tonic-gate 	int n = (yyintdecimal | (yyintsuffix[0] == 'u')) + 1;
12057c478bd9Sstevel@tonic-gate 	int i = 0;
12067c478bd9Sstevel@tonic-gate 
12077c478bd9Sstevel@tonic-gate 	const char *p;
12087c478bd9Sstevel@tonic-gate 	char c;
12097c478bd9Sstevel@tonic-gate 
12107c478bd9Sstevel@tonic-gate 	dnp->dn_op = DT_TOK_INT;
12117c478bd9Sstevel@tonic-gate 	dnp->dn_value = value;
12127c478bd9Sstevel@tonic-gate 
12137c478bd9Sstevel@tonic-gate 	for (p = yyintsuffix; (c = *p) != '\0'; p++) {
12147c478bd9Sstevel@tonic-gate 		if (c == 'U' || c == 'u')
12157c478bd9Sstevel@tonic-gate 			i += 1;
12167c478bd9Sstevel@tonic-gate 		else if (c == 'L' || c == 'l')
12177c478bd9Sstevel@tonic-gate 			i += 2;
12187c478bd9Sstevel@tonic-gate 	}
12197c478bd9Sstevel@tonic-gate 
12207c478bd9Sstevel@tonic-gate 	for (; i < sizeof (dtp->dt_ints) / sizeof (dtp->dt_ints[0]); i += n) {
12217c478bd9Sstevel@tonic-gate 		if (value <= dtp->dt_ints[i].did_limit) {
12227c478bd9Sstevel@tonic-gate 			dt_node_type_assign(dnp,
12237c478bd9Sstevel@tonic-gate 			    dtp->dt_ints[i].did_ctfp,
12247c478bd9Sstevel@tonic-gate 			    dtp->dt_ints[i].did_type);
12257c478bd9Sstevel@tonic-gate 
12267c478bd9Sstevel@tonic-gate 			/*
12277c478bd9Sstevel@tonic-gate 			 * If a prefix character is present in macro text, add
12287c478bd9Sstevel@tonic-gate 			 * in the corresponding operator node (see dt_lex.l).
12297c478bd9Sstevel@tonic-gate 			 */
12307c478bd9Sstevel@tonic-gate 			switch (yyintprefix) {
12317c478bd9Sstevel@tonic-gate 			case '+':
12327c478bd9Sstevel@tonic-gate 				return (dt_node_op1(DT_TOK_IPOS, dnp));
12337c478bd9Sstevel@tonic-gate 			case '-':
12347c478bd9Sstevel@tonic-gate 				return (dt_node_op1(DT_TOK_INEG, dnp));
12357c478bd9Sstevel@tonic-gate 			default:
12367c478bd9Sstevel@tonic-gate 				return (dnp);
12377c478bd9Sstevel@tonic-gate 			}
12387c478bd9Sstevel@tonic-gate 		}
12397c478bd9Sstevel@tonic-gate 	}
12407c478bd9Sstevel@tonic-gate 
12417c478bd9Sstevel@tonic-gate 	xyerror(D_INT_OFLOW, "integer constant 0x%llx cannot be represented "
12427c478bd9Sstevel@tonic-gate 	    "in any built-in integral type\n", (u_longlong_t)value);
12437c478bd9Sstevel@tonic-gate 	/*NOTREACHED*/
12447c478bd9Sstevel@tonic-gate 	return (NULL);		/* keep gcc happy */
12457c478bd9Sstevel@tonic-gate }
12467c478bd9Sstevel@tonic-gate 
12477c478bd9Sstevel@tonic-gate dt_node_t *
12487c478bd9Sstevel@tonic-gate dt_node_string(char *string)
12497c478bd9Sstevel@tonic-gate {
12507c478bd9Sstevel@tonic-gate 	dtrace_hdl_t *dtp = yypcb->pcb_hdl;
12517c478bd9Sstevel@tonic-gate 	dt_node_t *dnp;
12527c478bd9Sstevel@tonic-gate 
12537c478bd9Sstevel@tonic-gate 	if (string == NULL)
12547c478bd9Sstevel@tonic-gate 		longjmp(yypcb->pcb_jmpbuf, EDT_NOMEM);
12557c478bd9Sstevel@tonic-gate 
12567c478bd9Sstevel@tonic-gate 	dnp = dt_node_alloc(DT_NODE_STRING);
12577c478bd9Sstevel@tonic-gate 	dnp->dn_op = DT_TOK_STRING;
12587c478bd9Sstevel@tonic-gate 	dnp->dn_string = string;
12597c478bd9Sstevel@tonic-gate 	dt_node_type_assign(dnp, DT_STR_CTFP(dtp), DT_STR_TYPE(dtp));
12607c478bd9Sstevel@tonic-gate 
12617c478bd9Sstevel@tonic-gate 	return (dnp);
12627c478bd9Sstevel@tonic-gate }
12637c478bd9Sstevel@tonic-gate 
12647c478bd9Sstevel@tonic-gate dt_node_t *
12657c478bd9Sstevel@tonic-gate dt_node_ident(char *name)
12667c478bd9Sstevel@tonic-gate {
12677c478bd9Sstevel@tonic-gate 	dt_ident_t *idp;
12687c478bd9Sstevel@tonic-gate 	dt_node_t *dnp;
12697c478bd9Sstevel@tonic-gate 
12707c478bd9Sstevel@tonic-gate 	if (name == NULL)
12717c478bd9Sstevel@tonic-gate 		longjmp(yypcb->pcb_jmpbuf, EDT_NOMEM);
12727c478bd9Sstevel@tonic-gate 
12737c478bd9Sstevel@tonic-gate 	/*
12747c478bd9Sstevel@tonic-gate 	 * If the identifier is an inlined integer constant, then create an INT
12757c478bd9Sstevel@tonic-gate 	 * node that is a clone of the inline parse tree node and return that
12767c478bd9Sstevel@tonic-gate 	 * immediately, allowing this inline to be used in parsing contexts
12777c478bd9Sstevel@tonic-gate 	 * that require constant expressions (e.g. scalar array sizes).
12787c478bd9Sstevel@tonic-gate 	 */
12797c478bd9Sstevel@tonic-gate 	if ((idp = dt_idstack_lookup(&yypcb->pcb_globals, name)) != NULL &&
12807c478bd9Sstevel@tonic-gate 	    (idp->di_flags & DT_IDFLG_INLINE)) {
12817c478bd9Sstevel@tonic-gate 		dt_idnode_t *inp = idp->di_iarg;
12827c478bd9Sstevel@tonic-gate 
12831a7c1b72Smws 		if (inp->din_root != NULL &&
12841a7c1b72Smws 		    inp->din_root->dn_kind == DT_NODE_INT) {
12857c478bd9Sstevel@tonic-gate 			free(name);
12867c478bd9Sstevel@tonic-gate 
12877c478bd9Sstevel@tonic-gate 			dnp = dt_node_alloc(DT_NODE_INT);
12887c478bd9Sstevel@tonic-gate 			dnp->dn_op = DT_TOK_INT;
12897c478bd9Sstevel@tonic-gate 			dnp->dn_value = inp->din_root->dn_value;
12907c478bd9Sstevel@tonic-gate 			dt_node_type_propagate(inp->din_root, dnp);
12917c478bd9Sstevel@tonic-gate 
12927c478bd9Sstevel@tonic-gate 			return (dnp);
12937c478bd9Sstevel@tonic-gate 		}
12947c478bd9Sstevel@tonic-gate 	}
12957c478bd9Sstevel@tonic-gate 
12967c478bd9Sstevel@tonic-gate 	dnp = dt_node_alloc(DT_NODE_IDENT);
12977c478bd9Sstevel@tonic-gate 	dnp->dn_op = name[0] == '@' ? DT_TOK_AGG : DT_TOK_IDENT;
12987c478bd9Sstevel@tonic-gate 	dnp->dn_string = name;
12997c478bd9Sstevel@tonic-gate 
13007c478bd9Sstevel@tonic-gate 	return (dnp);
13017c478bd9Sstevel@tonic-gate }
13027c478bd9Sstevel@tonic-gate 
13037c478bd9Sstevel@tonic-gate /*
13047c478bd9Sstevel@tonic-gate  * Create an empty node of type corresponding to the given declaration.
13057c478bd9Sstevel@tonic-gate  * Explicit references to user types (C or D) are assigned the default
13067c478bd9Sstevel@tonic-gate  * stability; references to other types are _dtrace_typattr (Private).
13077c478bd9Sstevel@tonic-gate  */
13087c478bd9Sstevel@tonic-gate dt_node_t *
13097c478bd9Sstevel@tonic-gate dt_node_type(dt_decl_t *ddp)
13107c478bd9Sstevel@tonic-gate {
13117c478bd9Sstevel@tonic-gate 	dtrace_hdl_t *dtp = yypcb->pcb_hdl;
13127c478bd9Sstevel@tonic-gate 	dtrace_typeinfo_t dtt;
13137c478bd9Sstevel@tonic-gate 	dt_node_t *dnp;
13147c478bd9Sstevel@tonic-gate 	char *name = NULL;
13157c478bd9Sstevel@tonic-gate 	int err;
13167c478bd9Sstevel@tonic-gate 
13177c478bd9Sstevel@tonic-gate 	/*
13187c478bd9Sstevel@tonic-gate 	 * If 'ddp' is NULL, we get a decl by popping the decl stack.  This
13197c478bd9Sstevel@tonic-gate 	 * form of dt_node_type() is used by parameter rules in dt_grammar.y.
13207c478bd9Sstevel@tonic-gate 	 */
13217c478bd9Sstevel@tonic-gate 	if (ddp == NULL)
13227c478bd9Sstevel@tonic-gate 		ddp = dt_decl_pop_param(&name);
13237c478bd9Sstevel@tonic-gate 
13247c478bd9Sstevel@tonic-gate 	err = dt_decl_type(ddp, &dtt);
13257c478bd9Sstevel@tonic-gate 	dt_decl_free(ddp);
13267c478bd9Sstevel@tonic-gate 
13277c478bd9Sstevel@tonic-gate 	if (err != 0) {
13287c478bd9Sstevel@tonic-gate 		free(name);
13297c478bd9Sstevel@tonic-gate 		longjmp(yypcb->pcb_jmpbuf, EDT_COMPILER);
13307c478bd9Sstevel@tonic-gate 	}
13317c478bd9Sstevel@tonic-gate 
13327c478bd9Sstevel@tonic-gate 	dnp = dt_node_alloc(DT_NODE_TYPE);
13337c478bd9Sstevel@tonic-gate 	dnp->dn_op = DT_TOK_IDENT;
13347c478bd9Sstevel@tonic-gate 	dnp->dn_string = name;
13357c478bd9Sstevel@tonic-gate 	dt_node_type_assign(dnp, dtt.dtt_ctfp, dtt.dtt_type);
13367c478bd9Sstevel@tonic-gate 
13377c478bd9Sstevel@tonic-gate 	if (dtt.dtt_ctfp == dtp->dt_cdefs->dm_ctfp ||
13387c478bd9Sstevel@tonic-gate 	    dtt.dtt_ctfp == dtp->dt_ddefs->dm_ctfp)
13397c478bd9Sstevel@tonic-gate 		dt_node_attr_assign(dnp, _dtrace_defattr);
13407c478bd9Sstevel@tonic-gate 	else
13417c478bd9Sstevel@tonic-gate 		dt_node_attr_assign(dnp, _dtrace_typattr);
13427c478bd9Sstevel@tonic-gate 
13437c478bd9Sstevel@tonic-gate 	return (dnp);
13447c478bd9Sstevel@tonic-gate }
13457c478bd9Sstevel@tonic-gate 
13467c478bd9Sstevel@tonic-gate /*
13477c478bd9Sstevel@tonic-gate  * Create a type node corresponding to a varargs (...) parameter by just
13487c478bd9Sstevel@tonic-gate  * assigning it type CTF_ERR.  The decl processing code will handle this.
13497c478bd9Sstevel@tonic-gate  */
13507c478bd9Sstevel@tonic-gate dt_node_t *
13517c478bd9Sstevel@tonic-gate dt_node_vatype(void)
13527c478bd9Sstevel@tonic-gate {
13537c478bd9Sstevel@tonic-gate 	dt_node_t *dnp = dt_node_alloc(DT_NODE_TYPE);
13547c478bd9Sstevel@tonic-gate 
13557c478bd9Sstevel@tonic-gate 	dnp->dn_op = DT_TOK_IDENT;
13567c478bd9Sstevel@tonic-gate 	dnp->dn_ctfp = yypcb->pcb_hdl->dt_cdefs->dm_ctfp;
13577c478bd9Sstevel@tonic-gate 	dnp->dn_type = CTF_ERR;
13587c478bd9Sstevel@tonic-gate 	dnp->dn_attr = _dtrace_defattr;
13597c478bd9Sstevel@tonic-gate 
13607c478bd9Sstevel@tonic-gate 	return (dnp);
13617c478bd9Sstevel@tonic-gate }
13627c478bd9Sstevel@tonic-gate 
13637c478bd9Sstevel@tonic-gate /*
13647c478bd9Sstevel@tonic-gate  * Instantiate a decl using the contents of the current declaration stack.  As
13657c478bd9Sstevel@tonic-gate  * we do not currently permit decls to be initialized, this function currently
13667c478bd9Sstevel@tonic-gate  * returns NULL and no parse node is created.  When this function is called,
13677c478bd9Sstevel@tonic-gate  * the topmost scope's ds_ident pointer will be set to NULL (indicating no
13687c478bd9Sstevel@tonic-gate  * init_declarator rule was matched) or will point to the identifier to use.
13697c478bd9Sstevel@tonic-gate  */
13707c478bd9Sstevel@tonic-gate dt_node_t *
13717c478bd9Sstevel@tonic-gate dt_node_decl(void)
13727c478bd9Sstevel@tonic-gate {
13737c478bd9Sstevel@tonic-gate 	dtrace_hdl_t *dtp = yypcb->pcb_hdl;
13747c478bd9Sstevel@tonic-gate 	dt_scope_t *dsp = &yypcb->pcb_dstack;
13757c478bd9Sstevel@tonic-gate 	dt_dclass_t class = dsp->ds_class;
13767c478bd9Sstevel@tonic-gate 	dt_decl_t *ddp = dt_decl_top();
13777c478bd9Sstevel@tonic-gate 
13787c478bd9Sstevel@tonic-gate 	dt_module_t *dmp;
13797c478bd9Sstevel@tonic-gate 	dtrace_typeinfo_t dtt;
13807c478bd9Sstevel@tonic-gate 	ctf_id_t type;
13817c478bd9Sstevel@tonic-gate 
13827c478bd9Sstevel@tonic-gate 	char n1[DT_TYPE_NAMELEN];
13837c478bd9Sstevel@tonic-gate 	char n2[DT_TYPE_NAMELEN];
13847c478bd9Sstevel@tonic-gate 
13857c478bd9Sstevel@tonic-gate 	if (dt_decl_type(ddp, &dtt) != 0)
13867c478bd9Sstevel@tonic-gate 		longjmp(yypcb->pcb_jmpbuf, EDT_COMPILER);
13877c478bd9Sstevel@tonic-gate 
13887c478bd9Sstevel@tonic-gate 	/*
13897c478bd9Sstevel@tonic-gate 	 * If we have no declaration identifier, then this is either a spurious
13907c478bd9Sstevel@tonic-gate 	 * declaration of an intrinsic type (e.g. "extern int;") or declaration
13917c478bd9Sstevel@tonic-gate 	 * or redeclaration of a struct, union, or enum type or tag.
13927c478bd9Sstevel@tonic-gate 	 */
13937c478bd9Sstevel@tonic-gate 	if (dsp->ds_ident == NULL) {
13947c478bd9Sstevel@tonic-gate 		if (ddp->dd_kind != CTF_K_STRUCT &&
13957c478bd9Sstevel@tonic-gate 		    ddp->dd_kind != CTF_K_UNION && ddp->dd_kind != CTF_K_ENUM)
13967c478bd9Sstevel@tonic-gate 			xyerror(D_DECL_USELESS, "useless declaration\n");
13977c478bd9Sstevel@tonic-gate 
13987c478bd9Sstevel@tonic-gate 		dt_dprintf("type %s added as id %ld\n", dt_type_name(
13997c478bd9Sstevel@tonic-gate 		    ddp->dd_ctfp, ddp->dd_type, n1, sizeof (n1)), ddp->dd_type);
14007c478bd9Sstevel@tonic-gate 
14017c478bd9Sstevel@tonic-gate 		return (NULL);
14027c478bd9Sstevel@tonic-gate 	}
14037c478bd9Sstevel@tonic-gate 
14047c478bd9Sstevel@tonic-gate 	if (strchr(dsp->ds_ident, '`') != NULL) {
14057c478bd9Sstevel@tonic-gate 		xyerror(D_DECL_SCOPE, "D scoping operator may not be used in "
14067c478bd9Sstevel@tonic-gate 		    "a declaration name (%s)\n", dsp->ds_ident);
14077c478bd9Sstevel@tonic-gate 	}
14087c478bd9Sstevel@tonic-gate 
14097c478bd9Sstevel@tonic-gate 	/*
14107c478bd9Sstevel@tonic-gate 	 * If we are nested inside of a C include file, add the declaration to
14117c478bd9Sstevel@tonic-gate 	 * the C definition module; otherwise use the D definition module.
14127c478bd9Sstevel@tonic-gate 	 */
14137c478bd9Sstevel@tonic-gate 	if (yypcb->pcb_idepth != 0)
14147c478bd9Sstevel@tonic-gate 		dmp = dtp->dt_cdefs;
14157c478bd9Sstevel@tonic-gate 	else
14167c478bd9Sstevel@tonic-gate 		dmp = dtp->dt_ddefs;
14177c478bd9Sstevel@tonic-gate 
14187c478bd9Sstevel@tonic-gate 	/*
14197c478bd9Sstevel@tonic-gate 	 * If we see a global or static declaration of a function prototype,
14207c478bd9Sstevel@tonic-gate 	 * treat this as equivalent to a D extern declaration.
14217c478bd9Sstevel@tonic-gate 	 */
14227c478bd9Sstevel@tonic-gate 	if (ctf_type_kind(dtt.dtt_ctfp, dtt.dtt_type) == CTF_K_FUNCTION &&
14237c478bd9Sstevel@tonic-gate 	    (class == DT_DC_DEFAULT || class == DT_DC_STATIC))
14247c478bd9Sstevel@tonic-gate 		class = DT_DC_EXTERN;
14257c478bd9Sstevel@tonic-gate 
14267c478bd9Sstevel@tonic-gate 	switch (class) {
14277c478bd9Sstevel@tonic-gate 	case DT_DC_AUTO:
14287c478bd9Sstevel@tonic-gate 	case DT_DC_REGISTER:
14297c478bd9Sstevel@tonic-gate 	case DT_DC_STATIC:
14307c478bd9Sstevel@tonic-gate 		xyerror(D_DECL_BADCLASS, "specified storage class not "
14317c478bd9Sstevel@tonic-gate 		    "appropriate in D\n");
14327c478bd9Sstevel@tonic-gate 		/*NOTREACHED*/
14337c478bd9Sstevel@tonic-gate 
14347c478bd9Sstevel@tonic-gate 	case DT_DC_EXTERN: {
14357c478bd9Sstevel@tonic-gate 		dtrace_typeinfo_t ott;
14367c478bd9Sstevel@tonic-gate 		dtrace_syminfo_t dts;
14377c478bd9Sstevel@tonic-gate 		GElf_Sym sym;
14387c478bd9Sstevel@tonic-gate 
14397c478bd9Sstevel@tonic-gate 		int exists = dtrace_lookup_by_name(dtp,
14407c478bd9Sstevel@tonic-gate 		    dmp->dm_name, dsp->ds_ident, &sym, &dts) == 0;
14417c478bd9Sstevel@tonic-gate 
14427c478bd9Sstevel@tonic-gate 		if (exists && (dtrace_symbol_type(dtp, &sym, &dts, &ott) != 0 ||
14437c478bd9Sstevel@tonic-gate 		    ctf_type_cmp(dtt.dtt_ctfp, dtt.dtt_type,
14447c478bd9Sstevel@tonic-gate 		    ott.dtt_ctfp, ott.dtt_type) != 0)) {
14457c478bd9Sstevel@tonic-gate 			xyerror(D_DECL_IDRED, "identifier redeclared: %s`%s\n"
14467c478bd9Sstevel@tonic-gate 			    "\t current: %s\n\tprevious: %s\n",
14477c478bd9Sstevel@tonic-gate 			    dmp->dm_name, dsp->ds_ident,
14487c478bd9Sstevel@tonic-gate 			    dt_type_name(dtt.dtt_ctfp, dtt.dtt_type,
144923a1cceaSRoger A. Faulkner 			    n1, sizeof (n1)),
14507c478bd9Sstevel@tonic-gate 			    dt_type_name(ott.dtt_ctfp, ott.dtt_type,
145123a1cceaSRoger A. Faulkner 			    n2, sizeof (n2)));
14527c478bd9Sstevel@tonic-gate 		} else if (!exists && dt_module_extern(dtp, dmp,
14537c478bd9Sstevel@tonic-gate 		    dsp->ds_ident, &dtt) == NULL) {
14547c478bd9Sstevel@tonic-gate 			xyerror(D_UNKNOWN,
14557c478bd9Sstevel@tonic-gate 			    "failed to extern %s: %s\n", dsp->ds_ident,
14567c478bd9Sstevel@tonic-gate 			    dtrace_errmsg(dtp, dtrace_errno(dtp)));
14577c478bd9Sstevel@tonic-gate 		} else {
14587c478bd9Sstevel@tonic-gate 			dt_dprintf("extern %s`%s type=<%s>\n",
14597c478bd9Sstevel@tonic-gate 			    dmp->dm_name, dsp->ds_ident,
14607c478bd9Sstevel@tonic-gate 			    dt_type_name(dtt.dtt_ctfp, dtt.dtt_type,
146123a1cceaSRoger A. Faulkner 			    n1, sizeof (n1)));
14627c478bd9Sstevel@tonic-gate 		}
14637c478bd9Sstevel@tonic-gate 		break;
14647c478bd9Sstevel@tonic-gate 	}
14657c478bd9Sstevel@tonic-gate 
14667c478bd9Sstevel@tonic-gate 	case DT_DC_TYPEDEF:
1467e4586ebfSmws 		if (dt_idstack_lookup(&yypcb->pcb_globals, dsp->ds_ident)) {
1468e4586ebfSmws 			xyerror(D_DECL_IDRED, "global variable identifier "
1469e4586ebfSmws 			    "redeclared: %s\n", dsp->ds_ident);
1470e4586ebfSmws 		}
1471e4586ebfSmws 
1472e4586ebfSmws 		if (ctf_lookup_by_name(dmp->dm_ctfp,
1473e4586ebfSmws 		    dsp->ds_ident) != CTF_ERR) {
1474e4586ebfSmws 			xyerror(D_DECL_IDRED,
1475e4586ebfSmws 			    "typedef redeclared: %s\n", dsp->ds_ident);
1476e4586ebfSmws 		}
1477e4586ebfSmws 
14787c478bd9Sstevel@tonic-gate 		/*
14797c478bd9Sstevel@tonic-gate 		 * If the source type for the typedef is not defined in the
14807c478bd9Sstevel@tonic-gate 		 * target container or its parent, copy the type to the target
14817c478bd9Sstevel@tonic-gate 		 * container and reset dtt_ctfp and dtt_type to the copy.
14827c478bd9Sstevel@tonic-gate 		 */
14837c478bd9Sstevel@tonic-gate 		if (dtt.dtt_ctfp != dmp->dm_ctfp &&
14847c478bd9Sstevel@tonic-gate 		    dtt.dtt_ctfp != ctf_parent_file(dmp->dm_ctfp)) {
14857c478bd9Sstevel@tonic-gate 
14867c478bd9Sstevel@tonic-gate 			dtt.dtt_type = ctf_add_type(dmp->dm_ctfp,
14877c478bd9Sstevel@tonic-gate 			    dtt.dtt_ctfp, dtt.dtt_type);
14887c478bd9Sstevel@tonic-gate 			dtt.dtt_ctfp = dmp->dm_ctfp;
14897c478bd9Sstevel@tonic-gate 
14907c478bd9Sstevel@tonic-gate 			if (dtt.dtt_type == CTF_ERR ||
14917c478bd9Sstevel@tonic-gate 			    ctf_update(dtt.dtt_ctfp) == CTF_ERR) {
14927c478bd9Sstevel@tonic-gate 				xyerror(D_UNKNOWN, "failed to copy typedef %s "
14937c478bd9Sstevel@tonic-gate 				    "source type: %s\n", dsp->ds_ident,
14947c478bd9Sstevel@tonic-gate 				    ctf_errmsg(ctf_errno(dtt.dtt_ctfp)));
14957c478bd9Sstevel@tonic-gate 			}
14967c478bd9Sstevel@tonic-gate 		}
14977c478bd9Sstevel@tonic-gate 
14987c478bd9Sstevel@tonic-gate 		type = ctf_add_typedef(dmp->dm_ctfp,
14997c478bd9Sstevel@tonic-gate 		    CTF_ADD_ROOT, dsp->ds_ident, dtt.dtt_type);
15007c478bd9Sstevel@tonic-gate 
15017c478bd9Sstevel@tonic-gate 		if (type == CTF_ERR || ctf_update(dmp->dm_ctfp) == CTF_ERR) {
15027c478bd9Sstevel@tonic-gate 			xyerror(D_UNKNOWN, "failed to typedef %s: %s\n",
15037c478bd9Sstevel@tonic-gate 			    dsp->ds_ident, ctf_errmsg(ctf_errno(dmp->dm_ctfp)));
15047c478bd9Sstevel@tonic-gate 		}
15057c478bd9Sstevel@tonic-gate 
15067c478bd9Sstevel@tonic-gate 		dt_dprintf("typedef %s added as id %ld\n", dsp->ds_ident, type);
15077c478bd9Sstevel@tonic-gate 		break;
15087c478bd9Sstevel@tonic-gate 
15097c478bd9Sstevel@tonic-gate 	default: {
15107c478bd9Sstevel@tonic-gate 		ctf_encoding_t cte;
15117c478bd9Sstevel@tonic-gate 		dt_idhash_t *dhp;
15127c478bd9Sstevel@tonic-gate 		dt_ident_t *idp;
15137c478bd9Sstevel@tonic-gate 		dt_node_t idn;
15147c478bd9Sstevel@tonic-gate 		int assc, idkind;
15157c478bd9Sstevel@tonic-gate 		uint_t id, kind;
15167c478bd9Sstevel@tonic-gate 		ushort_t idflags;
15177c478bd9Sstevel@tonic-gate 
15187c478bd9Sstevel@tonic-gate 		switch (class) {
15197c478bd9Sstevel@tonic-gate 		case DT_DC_THIS:
15207c478bd9Sstevel@tonic-gate 			dhp = yypcb->pcb_locals;
15217c478bd9Sstevel@tonic-gate 			idflags = DT_IDFLG_LOCAL;
15227c478bd9Sstevel@tonic-gate 			idp = dt_idhash_lookup(dhp, dsp->ds_ident);
15237c478bd9Sstevel@tonic-gate 			break;
15247c478bd9Sstevel@tonic-gate 		case DT_DC_SELF:
15257c478bd9Sstevel@tonic-gate 			dhp = dtp->dt_tls;
15267c478bd9Sstevel@tonic-gate 			idflags = DT_IDFLG_TLS;
15277c478bd9Sstevel@tonic-gate 			idp = dt_idhash_lookup(dhp, dsp->ds_ident);
15287c478bd9Sstevel@tonic-gate 			break;
15297c478bd9Sstevel@tonic-gate 		default:
15307c478bd9Sstevel@tonic-gate 			dhp = dtp->dt_globals;
15317c478bd9Sstevel@tonic-gate 			idflags = 0;
15327c478bd9Sstevel@tonic-gate 			idp = dt_idstack_lookup(
15337c478bd9Sstevel@tonic-gate 			    &yypcb->pcb_globals, dsp->ds_ident);
15347c478bd9Sstevel@tonic-gate 			break;
15357c478bd9Sstevel@tonic-gate 		}
15367c478bd9Sstevel@tonic-gate 
15377c478bd9Sstevel@tonic-gate 		if (ddp->dd_kind == CTF_K_ARRAY && ddp->dd_node == NULL) {
15387c478bd9Sstevel@tonic-gate 			xyerror(D_DECL_ARRNULL,
15397c478bd9Sstevel@tonic-gate 			    "array declaration requires array dimension or "
15407c478bd9Sstevel@tonic-gate 			    "tuple signature: %s\n", dsp->ds_ident);
15417c478bd9Sstevel@tonic-gate 		}
15427c478bd9Sstevel@tonic-gate 
15437c478bd9Sstevel@tonic-gate 		if (idp != NULL && idp->di_gen == 0) {
15447c478bd9Sstevel@tonic-gate 			xyerror(D_DECL_IDRED, "built-in identifier "
15457c478bd9Sstevel@tonic-gate 			    "redeclared: %s\n", idp->di_name);
15467c478bd9Sstevel@tonic-gate 		}
15477c478bd9Sstevel@tonic-gate 
1548e4586ebfSmws 		if (dtrace_lookup_by_type(dtp, DTRACE_OBJ_CDEFS,
1549e4586ebfSmws 		    dsp->ds_ident, NULL) == 0 ||
1550e4586ebfSmws 		    dtrace_lookup_by_type(dtp, DTRACE_OBJ_DDEFS,
1551e4586ebfSmws 		    dsp->ds_ident, NULL) == 0) {
1552e4586ebfSmws 			xyerror(D_DECL_IDRED, "typedef identifier "
1553e4586ebfSmws 			    "redeclared: %s\n", dsp->ds_ident);
1554e4586ebfSmws 		}
1555e4586ebfSmws 
15567c478bd9Sstevel@tonic-gate 		/*
15577c478bd9Sstevel@tonic-gate 		 * Cache some attributes of the decl to make the rest of this
15587c478bd9Sstevel@tonic-gate 		 * code simpler: if the decl is an array which is subscripted
15597c478bd9Sstevel@tonic-gate 		 * by a type rather than an integer, then it's an associative
15607c478bd9Sstevel@tonic-gate 		 * array (assc).  We then expect to match either DT_IDENT_ARRAY
15617c478bd9Sstevel@tonic-gate 		 * for associative arrays or DT_IDENT_SCALAR for anything else.
15627c478bd9Sstevel@tonic-gate 		 */
15637c478bd9Sstevel@tonic-gate 		assc = ddp->dd_kind == CTF_K_ARRAY &&
15647c478bd9Sstevel@tonic-gate 		    ddp->dd_node->dn_kind == DT_NODE_TYPE;
15657c478bd9Sstevel@tonic-gate 
15667c478bd9Sstevel@tonic-gate 		idkind = assc ? DT_IDENT_ARRAY : DT_IDENT_SCALAR;
15677c478bd9Sstevel@tonic-gate 
15687c478bd9Sstevel@tonic-gate 		/*
15697c478bd9Sstevel@tonic-gate 		 * Create a fake dt_node_t on the stack so we can determine the
15707c478bd9Sstevel@tonic-gate 		 * type of any matching identifier by assigning to this node.
15717c478bd9Sstevel@tonic-gate 		 * If the pre-existing ident has its di_type set, propagate
15727c478bd9Sstevel@tonic-gate 		 * the type by hand so as not to trigger a prototype check for
15737c478bd9Sstevel@tonic-gate 		 * arrays (yet); otherwise we use dt_ident_cook() on the ident
15747c478bd9Sstevel@tonic-gate 		 * to ensure it is fully initialized before looking at it.
15757c478bd9Sstevel@tonic-gate 		 */
15767c478bd9Sstevel@tonic-gate 		bzero(&idn, sizeof (dt_node_t));
15777c478bd9Sstevel@tonic-gate 
15787c478bd9Sstevel@tonic-gate 		if (idp != NULL && idp->di_type != CTF_ERR)
15797c478bd9Sstevel@tonic-gate 			dt_node_type_assign(&idn, idp->di_ctfp, idp->di_type);
15807c478bd9Sstevel@tonic-gate 		else if (idp != NULL)
15817c478bd9Sstevel@tonic-gate 			(void) dt_ident_cook(&idn, idp, NULL);
15827c478bd9Sstevel@tonic-gate 
15837c478bd9Sstevel@tonic-gate 		if (assc) {
15847c478bd9Sstevel@tonic-gate 			if (class == DT_DC_THIS) {
15857c478bd9Sstevel@tonic-gate 				xyerror(D_DECL_LOCASSC, "associative arrays "
15867c478bd9Sstevel@tonic-gate 				    "may not be declared as local variables:"
15877c478bd9Sstevel@tonic-gate 				    " %s\n", dsp->ds_ident);
15887c478bd9Sstevel@tonic-gate 			}
15897c478bd9Sstevel@tonic-gate 
15907c478bd9Sstevel@tonic-gate 			if (dt_decl_type(ddp->dd_next, &dtt) != 0)
15917c478bd9Sstevel@tonic-gate 				longjmp(yypcb->pcb_jmpbuf, EDT_COMPILER);
15927c478bd9Sstevel@tonic-gate 		}
15937c478bd9Sstevel@tonic-gate 
15947c478bd9Sstevel@tonic-gate 		if (idp != NULL && (idp->di_kind != idkind ||
15957c478bd9Sstevel@tonic-gate 		    ctf_type_cmp(dtt.dtt_ctfp, dtt.dtt_type,
15967c478bd9Sstevel@tonic-gate 		    idn.dn_ctfp, idn.dn_type) != 0)) {
15977c478bd9Sstevel@tonic-gate 			xyerror(D_DECL_IDRED, "identifier redeclared: %s\n"
15987c478bd9Sstevel@tonic-gate 			    "\t current: %s %s\n\tprevious: %s %s\n",
15997c478bd9Sstevel@tonic-gate 			    dsp->ds_ident, dt_idkind_name(idkind),
16007c478bd9Sstevel@tonic-gate 			    dt_type_name(dtt.dtt_ctfp,
16017c478bd9Sstevel@tonic-gate 			    dtt.dtt_type, n1, sizeof (n1)),
16027c478bd9Sstevel@tonic-gate 			    dt_idkind_name(idp->di_kind),
16037c478bd9Sstevel@tonic-gate 			    dt_node_type_name(&idn, n2, sizeof (n2)));
16047c478bd9Sstevel@tonic-gate 
16057c478bd9Sstevel@tonic-gate 		} else if (idp != NULL && assc) {
16067c478bd9Sstevel@tonic-gate 			const dt_idsig_t *isp = idp->di_data;
16077c478bd9Sstevel@tonic-gate 			dt_node_t *dnp = ddp->dd_node;
16087c478bd9Sstevel@tonic-gate 			int argc = 0;
16097c478bd9Sstevel@tonic-gate 
16107c478bd9Sstevel@tonic-gate 			for (; dnp != NULL; dnp = dnp->dn_list, argc++) {
16117c478bd9Sstevel@tonic-gate 				const dt_node_t *pnp = &isp->dis_args[argc];
16127c478bd9Sstevel@tonic-gate 
16137c478bd9Sstevel@tonic-gate 				if (argc >= isp->dis_argc)
16147c478bd9Sstevel@tonic-gate 					continue; /* tuple length mismatch */
16157c478bd9Sstevel@tonic-gate 
16167c478bd9Sstevel@tonic-gate 				if (ctf_type_cmp(dnp->dn_ctfp, dnp->dn_type,
16177c478bd9Sstevel@tonic-gate 				    pnp->dn_ctfp, pnp->dn_type) == 0)
16187c478bd9Sstevel@tonic-gate 					continue;
16197c478bd9Sstevel@tonic-gate 
16207c478bd9Sstevel@tonic-gate 				xyerror(D_DECL_IDRED,
16217c478bd9Sstevel@tonic-gate 				    "identifier redeclared: %s\n"
16227c478bd9Sstevel@tonic-gate 				    "\t current: %s, key #%d of type %s\n"
16237c478bd9Sstevel@tonic-gate 				    "\tprevious: %s, key #%d of type %s\n",
16247c478bd9Sstevel@tonic-gate 				    dsp->ds_ident,
16257c478bd9Sstevel@tonic-gate 				    dt_idkind_name(idkind), argc + 1,
16267c478bd9Sstevel@tonic-gate 				    dt_node_type_name(dnp, n1, sizeof (n1)),
16277c478bd9Sstevel@tonic-gate 				    dt_idkind_name(idp->di_kind), argc + 1,
16287c478bd9Sstevel@tonic-gate 				    dt_node_type_name(pnp, n2, sizeof (n2)));
16297c478bd9Sstevel@tonic-gate 			}
16307c478bd9Sstevel@tonic-gate 
16317c478bd9Sstevel@tonic-gate 			if (isp->dis_argc != argc) {
16327c478bd9Sstevel@tonic-gate 				xyerror(D_DECL_IDRED,
16337c478bd9Sstevel@tonic-gate 				    "identifier redeclared: %s\n"
16347c478bd9Sstevel@tonic-gate 				    "\t current: %s of %s, tuple length %d\n"
16357c478bd9Sstevel@tonic-gate 				    "\tprevious: %s of %s, tuple length %d\n",
16367c478bd9Sstevel@tonic-gate 				    dsp->ds_ident, dt_idkind_name(idkind),
16377c478bd9Sstevel@tonic-gate 				    dt_type_name(dtt.dtt_ctfp, dtt.dtt_type,
16387c478bd9Sstevel@tonic-gate 				    n1, sizeof (n1)), argc,
16397c478bd9Sstevel@tonic-gate 				    dt_idkind_name(idp->di_kind),
16407c478bd9Sstevel@tonic-gate 				    dt_node_type_name(&idn, n2, sizeof (n2)),
16417c478bd9Sstevel@tonic-gate 				    isp->dis_argc);
16427c478bd9Sstevel@tonic-gate 			}
16437c478bd9Sstevel@tonic-gate 
16447c478bd9Sstevel@tonic-gate 		} else if (idp == NULL) {
16457c478bd9Sstevel@tonic-gate 			type = ctf_type_resolve(dtt.dtt_ctfp, dtt.dtt_type);
16467c478bd9Sstevel@tonic-gate 			kind = ctf_type_kind(dtt.dtt_ctfp, type);
16477c478bd9Sstevel@tonic-gate 
16487c478bd9Sstevel@tonic-gate 			switch (kind) {
16497c478bd9Sstevel@tonic-gate 			case CTF_K_INTEGER:
16507c478bd9Sstevel@tonic-gate 				if (ctf_type_encoding(dtt.dtt_ctfp, type,
16517c478bd9Sstevel@tonic-gate 				    &cte) == 0 && IS_VOID(cte)) {
16527c478bd9Sstevel@tonic-gate 					xyerror(D_DECL_VOIDOBJ, "cannot have "
16537c478bd9Sstevel@tonic-gate 					    "void object: %s\n", dsp->ds_ident);
16547c478bd9Sstevel@tonic-gate 				}
16557c478bd9Sstevel@tonic-gate 				break;
16567c478bd9Sstevel@tonic-gate 			case CTF_K_STRUCT:
16577c478bd9Sstevel@tonic-gate 			case CTF_K_UNION:
16587c478bd9Sstevel@tonic-gate 				if (ctf_type_size(dtt.dtt_ctfp, type) != 0)
16597c478bd9Sstevel@tonic-gate 					break; /* proceed to declaring */
16607c478bd9Sstevel@tonic-gate 				/*FALLTHRU*/
16617c478bd9Sstevel@tonic-gate 			case CTF_K_FORWARD:
16627c478bd9Sstevel@tonic-gate 				xyerror(D_DECL_INCOMPLETE,
16637c478bd9Sstevel@tonic-gate 				    "incomplete struct/union/enum %s: %s\n",
16647c478bd9Sstevel@tonic-gate 				    dt_type_name(dtt.dtt_ctfp, dtt.dtt_type,
16657c478bd9Sstevel@tonic-gate 				    n1, sizeof (n1)), dsp->ds_ident);
16667c478bd9Sstevel@tonic-gate 				/*NOTREACHED*/
16677c478bd9Sstevel@tonic-gate 			}
16687c478bd9Sstevel@tonic-gate 
16697c478bd9Sstevel@tonic-gate 			if (dt_idhash_nextid(dhp, &id) == -1) {
16707c478bd9Sstevel@tonic-gate 				xyerror(D_ID_OFLOW, "cannot create %s: limit "
16717c478bd9Sstevel@tonic-gate 				    "on number of %s variables exceeded\n",
16727c478bd9Sstevel@tonic-gate 				    dsp->ds_ident, dt_idhash_name(dhp));
16737c478bd9Sstevel@tonic-gate 			}
16747c478bd9Sstevel@tonic-gate 
16757c478bd9Sstevel@tonic-gate 			dt_dprintf("declare %s %s variable %s, id=%u\n",
16767c478bd9Sstevel@tonic-gate 			    dt_idhash_name(dhp), dt_idkind_name(idkind),
16777c478bd9Sstevel@tonic-gate 			    dsp->ds_ident, id);
16787c478bd9Sstevel@tonic-gate 
16797c478bd9Sstevel@tonic-gate 			idp = dt_idhash_insert(dhp, dsp->ds_ident, idkind,
16807c478bd9Sstevel@tonic-gate 			    idflags | DT_IDFLG_WRITE | DT_IDFLG_DECL, id,
16817c478bd9Sstevel@tonic-gate 			    _dtrace_defattr, 0, assc ? &dt_idops_assc :
16827c478bd9Sstevel@tonic-gate 			    &dt_idops_thaw, NULL, dtp->dt_gen);
16837c478bd9Sstevel@tonic-gate 
16847c478bd9Sstevel@tonic-gate 			if (idp == NULL)
16857c478bd9Sstevel@tonic-gate 				longjmp(yypcb->pcb_jmpbuf, EDT_NOMEM);
16867c478bd9Sstevel@tonic-gate 
16877c478bd9Sstevel@tonic-gate 			dt_ident_type_assign(idp, dtt.dtt_ctfp, dtt.dtt_type);
16887c478bd9Sstevel@tonic-gate 
16897c478bd9Sstevel@tonic-gate 			/*
16907c478bd9Sstevel@tonic-gate 			 * If we are declaring an associative array, use our
16917c478bd9Sstevel@tonic-gate 			 * fake parse node to cook the new assoc identifier.
16927c478bd9Sstevel@tonic-gate 			 * This will force the ident code to instantiate the
16937c478bd9Sstevel@tonic-gate 			 * array type signature corresponding to the list of
16947c478bd9Sstevel@tonic-gate 			 * types pointed to by ddp->dd_node.  We also reset
16957c478bd9Sstevel@tonic-gate 			 * the identifier's attributes based upon the result.
16967c478bd9Sstevel@tonic-gate 			 */
16977c478bd9Sstevel@tonic-gate 			if (assc) {
16987c478bd9Sstevel@tonic-gate 				idp->di_attr =
16997c478bd9Sstevel@tonic-gate 				    dt_ident_cook(&idn, idp, &ddp->dd_node);
17007c478bd9Sstevel@tonic-gate 			}
17017c478bd9Sstevel@tonic-gate 		}
17027c478bd9Sstevel@tonic-gate 	}
17037c478bd9Sstevel@tonic-gate 
17047c478bd9Sstevel@tonic-gate 	} /* end of switch */
17057c478bd9Sstevel@tonic-gate 
17067c478bd9Sstevel@tonic-gate 	free(dsp->ds_ident);
17077c478bd9Sstevel@tonic-gate 	dsp->ds_ident = NULL;
17087c478bd9Sstevel@tonic-gate 
17097c478bd9Sstevel@tonic-gate 	return (NULL);
17107c478bd9Sstevel@tonic-gate }
17117c478bd9Sstevel@tonic-gate 
17127c478bd9Sstevel@tonic-gate dt_node_t *
17137c478bd9Sstevel@tonic-gate dt_node_func(dt_node_t *dnp, dt_node_t *args)
17147c478bd9Sstevel@tonic-gate {
17157c478bd9Sstevel@tonic-gate 	dt_ident_t *idp;
17167c478bd9Sstevel@tonic-gate 
17177c478bd9Sstevel@tonic-gate 	if (dnp->dn_kind != DT_NODE_IDENT) {
17187c478bd9Sstevel@tonic-gate 		xyerror(D_FUNC_IDENT,
17197c478bd9Sstevel@tonic-gate 		    "function designator is not of function type\n");
17207c478bd9Sstevel@tonic-gate 	}
17217c478bd9Sstevel@tonic-gate 
17227c478bd9Sstevel@tonic-gate 	idp = dt_idstack_lookup(&yypcb->pcb_globals, dnp->dn_string);
17237c478bd9Sstevel@tonic-gate 
17247c478bd9Sstevel@tonic-gate 	if (idp == NULL) {
17257c478bd9Sstevel@tonic-gate 		xyerror(D_FUNC_UNDEF,
17267c478bd9Sstevel@tonic-gate 		    "undefined function name: %s\n", dnp->dn_string);
17277c478bd9Sstevel@tonic-gate 	}
17287c478bd9Sstevel@tonic-gate 
17297c478bd9Sstevel@tonic-gate 	if (idp->di_kind != DT_IDENT_FUNC &&
17307c478bd9Sstevel@tonic-gate 	    idp->di_kind != DT_IDENT_AGGFUNC &&
17317c478bd9Sstevel@tonic-gate 	    idp->di_kind != DT_IDENT_ACTFUNC) {
17327c478bd9Sstevel@tonic-gate 		xyerror(D_FUNC_IDKIND, "%s '%s' may not be referenced as a "
17337c478bd9Sstevel@tonic-gate 		    "function\n", dt_idkind_name(idp->di_kind), idp->di_name);
17347c478bd9Sstevel@tonic-gate 	}
17357c478bd9Sstevel@tonic-gate 
17367c478bd9Sstevel@tonic-gate 	free(dnp->dn_string);
17377c478bd9Sstevel@tonic-gate 	dnp->dn_string = NULL;
17387c478bd9Sstevel@tonic-gate 
17397c478bd9Sstevel@tonic-gate 	dnp->dn_kind = DT_NODE_FUNC;
17407c478bd9Sstevel@tonic-gate 	dnp->dn_flags &= ~DT_NF_COOKED;
17417c478bd9Sstevel@tonic-gate 	dnp->dn_ident = idp;
17427c478bd9Sstevel@tonic-gate 	dnp->dn_args = args;
17437c478bd9Sstevel@tonic-gate 	dnp->dn_list = NULL;
17447c478bd9Sstevel@tonic-gate 
17457c478bd9Sstevel@tonic-gate 	return (dnp);
17467c478bd9Sstevel@tonic-gate }
17477c478bd9Sstevel@tonic-gate 
17487c478bd9Sstevel@tonic-gate /*
17497c478bd9Sstevel@tonic-gate  * The offsetof() function is special because it takes a type name as an
17507c478bd9Sstevel@tonic-gate  * argument.  It does not actually construct its own node; after looking up the
17517c478bd9Sstevel@tonic-gate  * structure or union offset, we just return an integer node with the offset.
17527c478bd9Sstevel@tonic-gate  */
17537c478bd9Sstevel@tonic-gate dt_node_t *
17547c478bd9Sstevel@tonic-gate dt_node_offsetof(dt_decl_t *ddp, char *s)
17557c478bd9Sstevel@tonic-gate {
17567c478bd9Sstevel@tonic-gate 	dtrace_typeinfo_t dtt;
17577c478bd9Sstevel@tonic-gate 	dt_node_t dn;
17587c478bd9Sstevel@tonic-gate 	char *name;
17597c478bd9Sstevel@tonic-gate 	int err;
17607c478bd9Sstevel@tonic-gate 
17617c478bd9Sstevel@tonic-gate 	ctf_membinfo_t ctm;
17627c478bd9Sstevel@tonic-gate 	ctf_id_t type;
17637c478bd9Sstevel@tonic-gate 	uint_t kind;
17647c478bd9Sstevel@tonic-gate 
176523a1cceaSRoger A. Faulkner 	name = strdupa(s);
17667c478bd9Sstevel@tonic-gate 	free(s);
17677c478bd9Sstevel@tonic-gate 
17687c478bd9Sstevel@tonic-gate 	err = dt_decl_type(ddp, &dtt);
17697c478bd9Sstevel@tonic-gate 	dt_decl_free(ddp);
17707c478bd9Sstevel@tonic-gate 
17717c478bd9Sstevel@tonic-gate 	if (err != 0)
17727c478bd9Sstevel@tonic-gate 		longjmp(yypcb->pcb_jmpbuf, EDT_COMPILER);
17737c478bd9Sstevel@tonic-gate 
17747c478bd9Sstevel@tonic-gate 	type = ctf_type_resolve(dtt.dtt_ctfp, dtt.dtt_type);
17757c478bd9Sstevel@tonic-gate 	kind = ctf_type_kind(dtt.dtt_ctfp, type);
17767c478bd9Sstevel@tonic-gate 
17777c478bd9Sstevel@tonic-gate 	if (kind != CTF_K_STRUCT && kind != CTF_K_UNION) {
17787c478bd9Sstevel@tonic-gate 		xyerror(D_OFFSETOF_TYPE,
17797c478bd9Sstevel@tonic-gate 		    "offsetof operand must be a struct or union type\n");
17807c478bd9Sstevel@tonic-gate 	}
17817c478bd9Sstevel@tonic-gate 
17827c478bd9Sstevel@tonic-gate 	if (ctf_member_info(dtt.dtt_ctfp, type, name, &ctm) == CTF_ERR) {
17837c478bd9Sstevel@tonic-gate 		xyerror(D_UNKNOWN, "failed to determine offset of %s: %s\n",
17847c478bd9Sstevel@tonic-gate 		    name, ctf_errmsg(ctf_errno(dtt.dtt_ctfp)));
17857c478bd9Sstevel@tonic-gate 	}
17867c478bd9Sstevel@tonic-gate 
17877c478bd9Sstevel@tonic-gate 	bzero(&dn, sizeof (dn));
17887c478bd9Sstevel@tonic-gate 	dt_node_type_assign(&dn, dtt.dtt_ctfp, ctm.ctm_type);
17897c478bd9Sstevel@tonic-gate 
17907c478bd9Sstevel@tonic-gate 	if (dn.dn_flags & DT_NF_BITFIELD) {
17917c478bd9Sstevel@tonic-gate 		xyerror(D_OFFSETOF_BITFIELD,
17927c478bd9Sstevel@tonic-gate 		    "cannot take offset of a bit-field: %s\n", name);
17937c478bd9Sstevel@tonic-gate 	}
17947c478bd9Sstevel@tonic-gate 
17957c478bd9Sstevel@tonic-gate 	return (dt_node_int(ctm.ctm_offset / NBBY));
17967c478bd9Sstevel@tonic-gate }
17977c478bd9Sstevel@tonic-gate 
17987c478bd9Sstevel@tonic-gate dt_node_t *
17997c478bd9Sstevel@tonic-gate dt_node_op1(int op, dt_node_t *cp)
18007c478bd9Sstevel@tonic-gate {
18017c478bd9Sstevel@tonic-gate 	dt_node_t *dnp;
18027c478bd9Sstevel@tonic-gate 
18037c478bd9Sstevel@tonic-gate 	if (cp->dn_kind == DT_NODE_INT) {
18047c478bd9Sstevel@tonic-gate 		switch (op) {
18057c478bd9Sstevel@tonic-gate 		case DT_TOK_INEG:
18067c478bd9Sstevel@tonic-gate 			/*
18077c478bd9Sstevel@tonic-gate 			 * If we're negating an unsigned integer, zero out any
18087c478bd9Sstevel@tonic-gate 			 * extra top bits to truncate the value to the size of
18097c478bd9Sstevel@tonic-gate 			 * the effective type determined by dt_node_int().
18107c478bd9Sstevel@tonic-gate 			 */
18117c478bd9Sstevel@tonic-gate 			cp->dn_value = -cp->dn_value;
18127c478bd9Sstevel@tonic-gate 			if (!(cp->dn_flags & DT_NF_SIGNED)) {
18137c478bd9Sstevel@tonic-gate 				cp->dn_value &= ~0ULL >>
18147c478bd9Sstevel@tonic-gate 				    (64 - dt_node_type_size(cp) * NBBY);
18157c478bd9Sstevel@tonic-gate 			}
18167c478bd9Sstevel@tonic-gate 			/*FALLTHRU*/
18177c478bd9Sstevel@tonic-gate 		case DT_TOK_IPOS:
18187c478bd9Sstevel@tonic-gate 			return (cp);
18197c478bd9Sstevel@tonic-gate 		case DT_TOK_BNEG:
18207c478bd9Sstevel@tonic-gate 			cp->dn_value = ~cp->dn_value;
18217c478bd9Sstevel@tonic-gate 			return (cp);
18227c478bd9Sstevel@tonic-gate 		case DT_TOK_LNEG:
18237c478bd9Sstevel@tonic-gate 			cp->dn_value = !cp->dn_value;
18247c478bd9Sstevel@tonic-gate 			return (cp);
18257c478bd9Sstevel@tonic-gate 		}
18267c478bd9Sstevel@tonic-gate 	}
18277c478bd9Sstevel@tonic-gate 
18287c478bd9Sstevel@tonic-gate 	/*
18297c478bd9Sstevel@tonic-gate 	 * If sizeof is applied to a type_name or string constant, we can
18307c478bd9Sstevel@tonic-gate 	 * transform 'cp' into an integer constant in the node construction
18317c478bd9Sstevel@tonic-gate 	 * pass so that it can then be used for arithmetic in this pass.
18327c478bd9Sstevel@tonic-gate 	 */
18337c478bd9Sstevel@tonic-gate 	if (op == DT_TOK_SIZEOF &&
18347c478bd9Sstevel@tonic-gate 	    (cp->dn_kind == DT_NODE_STRING || cp->dn_kind == DT_NODE_TYPE)) {
18357c478bd9Sstevel@tonic-gate 		dtrace_hdl_t *dtp = yypcb->pcb_hdl;
18367c478bd9Sstevel@tonic-gate 		size_t size = dt_node_type_size(cp);
18377c478bd9Sstevel@tonic-gate 
18387c478bd9Sstevel@tonic-gate 		if (size == 0) {
18397c478bd9Sstevel@tonic-gate 			xyerror(D_SIZEOF_TYPE, "cannot apply sizeof to an "
18407c478bd9Sstevel@tonic-gate 			    "operand of unknown size\n");
18417c478bd9Sstevel@tonic-gate 		}
18427c478bd9Sstevel@tonic-gate 
18437c478bd9Sstevel@tonic-gate 		dt_node_type_assign(cp, dtp->dt_ddefs->dm_ctfp,
18447c478bd9Sstevel@tonic-gate 		    ctf_lookup_by_name(dtp->dt_ddefs->dm_ctfp, "size_t"));
18457c478bd9Sstevel@tonic-gate 
18467c478bd9Sstevel@tonic-gate 		cp->dn_kind = DT_NODE_INT;
18477c478bd9Sstevel@tonic-gate 		cp->dn_op = DT_TOK_INT;
18487c478bd9Sstevel@tonic-gate 		cp->dn_value = size;
18497c478bd9Sstevel@tonic-gate 
18507c478bd9Sstevel@tonic-gate 		return (cp);
18517c478bd9Sstevel@tonic-gate 	}
18527c478bd9Sstevel@tonic-gate 
18537c478bd9Sstevel@tonic-gate 	dnp = dt_node_alloc(DT_NODE_OP1);
18547c478bd9Sstevel@tonic-gate 	assert(op <= USHRT_MAX);
18557c478bd9Sstevel@tonic-gate 	dnp->dn_op = (ushort_t)op;
18567c478bd9Sstevel@tonic-gate 	dnp->dn_child = cp;
18577c478bd9Sstevel@tonic-gate 
18587c478bd9Sstevel@tonic-gate 	return (dnp);
18597c478bd9Sstevel@tonic-gate }
18607c478bd9Sstevel@tonic-gate 
1861*e5803b76SAdam H. Leventhal /*
1862*e5803b76SAdam H. Leventhal  * If an integer constant is being cast to another integer type, we can
1863*e5803b76SAdam H. Leventhal  * perform the cast as part of integer constant folding in this pass. We must
1864*e5803b76SAdam H. Leventhal  * take action when the integer is being cast to a smaller type or if it is
1865*e5803b76SAdam H. Leventhal  * changing signed-ness. If so, we first shift rp's bits bits high (losing
1866*e5803b76SAdam H. Leventhal  * excess bits if narrowing) and then shift them down with either a logical
1867*e5803b76SAdam H. Leventhal  * shift (unsigned) or arithmetic shift (signed).
1868*e5803b76SAdam H. Leventhal  */
1869*e5803b76SAdam H. Leventhal static void
1870*e5803b76SAdam H. Leventhal dt_cast(dt_node_t *lp, dt_node_t *rp)
1871*e5803b76SAdam H. Leventhal {
1872*e5803b76SAdam H. Leventhal 	size_t srcsize = dt_node_type_size(rp);
1873*e5803b76SAdam H. Leventhal 	size_t dstsize = dt_node_type_size(lp);
1874*e5803b76SAdam H. Leventhal 
1875*e5803b76SAdam H. Leventhal 	if (dstsize < srcsize) {
1876*e5803b76SAdam H. Leventhal 		int n = (sizeof (uint64_t) - dstsize) * NBBY;
1877*e5803b76SAdam H. Leventhal 		rp->dn_value <<= n;
1878*e5803b76SAdam H. Leventhal 		rp->dn_value >>= n;
1879*e5803b76SAdam H. Leventhal 	} else if (dstsize > srcsize) {
1880*e5803b76SAdam H. Leventhal 		int n = (sizeof (uint64_t) - srcsize) * NBBY;
1881*e5803b76SAdam H. Leventhal 		int s = (dstsize - srcsize) * NBBY;
1882*e5803b76SAdam H. Leventhal 
1883*e5803b76SAdam H. Leventhal 		rp->dn_value <<= n;
1884*e5803b76SAdam H. Leventhal 		if (rp->dn_flags & DT_NF_SIGNED) {
1885*e5803b76SAdam H. Leventhal 			rp->dn_value = (intmax_t)rp->dn_value >> s;
1886*e5803b76SAdam H. Leventhal 			rp->dn_value >>= n - s;
1887*e5803b76SAdam H. Leventhal 		} else {
1888*e5803b76SAdam H. Leventhal 			rp->dn_value >>= n;
1889*e5803b76SAdam H. Leventhal 		}
1890*e5803b76SAdam H. Leventhal 	}
1891*e5803b76SAdam H. Leventhal }
1892*e5803b76SAdam H. Leventhal 
18937c478bd9Sstevel@tonic-gate dt_node_t *
18947c478bd9Sstevel@tonic-gate dt_node_op2(int op, dt_node_t *lp, dt_node_t *rp)
18957c478bd9Sstevel@tonic-gate {
18967c478bd9Sstevel@tonic-gate 	dtrace_hdl_t *dtp = yypcb->pcb_hdl;
18977c478bd9Sstevel@tonic-gate 	dt_node_t *dnp;
18987c478bd9Sstevel@tonic-gate 
18997c478bd9Sstevel@tonic-gate 	/*
19007c478bd9Sstevel@tonic-gate 	 * First we check for operations that are illegal -- namely those that
19017c478bd9Sstevel@tonic-gate 	 * might result in integer division by zero, and abort if one is found.
19027c478bd9Sstevel@tonic-gate 	 */
19037c478bd9Sstevel@tonic-gate 	if (rp->dn_kind == DT_NODE_INT && rp->dn_value == 0 &&
19047c478bd9Sstevel@tonic-gate 	    (op == DT_TOK_MOD || op == DT_TOK_DIV ||
19057c478bd9Sstevel@tonic-gate 	    op == DT_TOK_MOD_EQ || op == DT_TOK_DIV_EQ))
19067c478bd9Sstevel@tonic-gate 		xyerror(D_DIV_ZERO, "expression contains division by zero\n");
19077c478bd9Sstevel@tonic-gate 
19087c478bd9Sstevel@tonic-gate 	/*
19097c478bd9Sstevel@tonic-gate 	 * If both children are immediate values, we can just perform inline
19107c478bd9Sstevel@tonic-gate 	 * calculation and return a new immediate node with the result.
19117c478bd9Sstevel@tonic-gate 	 */
19127c478bd9Sstevel@tonic-gate 	if (lp->dn_kind == DT_NODE_INT && rp->dn_kind == DT_NODE_INT) {
19137c478bd9Sstevel@tonic-gate 		uintmax_t l = lp->dn_value;
19147c478bd9Sstevel@tonic-gate 		uintmax_t r = rp->dn_value;
19157c478bd9Sstevel@tonic-gate 
19167c478bd9Sstevel@tonic-gate 		dnp = dt_node_int(0); /* allocate new integer node for result */
19177c478bd9Sstevel@tonic-gate 
19187c478bd9Sstevel@tonic-gate 		switch (op) {
19197c478bd9Sstevel@tonic-gate 		case DT_TOK_LOR:
19207c478bd9Sstevel@tonic-gate 			dnp->dn_value = l || r;
19217c478bd9Sstevel@tonic-gate 			dt_node_type_assign(dnp,
19227c478bd9Sstevel@tonic-gate 			    DT_INT_CTFP(dtp), DT_INT_TYPE(dtp));
19237c478bd9Sstevel@tonic-gate 			break;
19247c478bd9Sstevel@tonic-gate 		case DT_TOK_LXOR:
19257c478bd9Sstevel@tonic-gate 			dnp->dn_value = (l != 0) ^ (r != 0);
19267c478bd9Sstevel@tonic-gate 			dt_node_type_assign(dnp,
19277c478bd9Sstevel@tonic-gate 			    DT_INT_CTFP(dtp), DT_INT_TYPE(dtp));
19287c478bd9Sstevel@tonic-gate 			break;
19297c478bd9Sstevel@tonic-gate 		case DT_TOK_LAND:
19307c478bd9Sstevel@tonic-gate 			dnp->dn_value = l && r;
19317c478bd9Sstevel@tonic-gate 			dt_node_type_assign(dnp,
19327c478bd9Sstevel@tonic-gate 			    DT_INT_CTFP(dtp), DT_INT_TYPE(dtp));
19337c478bd9Sstevel@tonic-gate 			break;
19347c478bd9Sstevel@tonic-gate 		case DT_TOK_BOR:
19357c478bd9Sstevel@tonic-gate 			dnp->dn_value = l | r;
19367c478bd9Sstevel@tonic-gate 			dt_node_promote(lp, rp, dnp);
19377c478bd9Sstevel@tonic-gate 			break;
19387c478bd9Sstevel@tonic-gate 		case DT_TOK_XOR:
19397c478bd9Sstevel@tonic-gate 			dnp->dn_value = l ^ r;
19407c478bd9Sstevel@tonic-gate 			dt_node_promote(lp, rp, dnp);
19417c478bd9Sstevel@tonic-gate 			break;
19427c478bd9Sstevel@tonic-gate 		case DT_TOK_BAND:
19437c478bd9Sstevel@tonic-gate 			dnp->dn_value = l & r;
19447c478bd9Sstevel@tonic-gate 			dt_node_promote(lp, rp, dnp);
19457c478bd9Sstevel@tonic-gate 			break;
19467c478bd9Sstevel@tonic-gate 		case DT_TOK_EQU:
19477c478bd9Sstevel@tonic-gate 			dnp->dn_value = l == r;
19487c478bd9Sstevel@tonic-gate 			dt_node_type_assign(dnp,
19497c478bd9Sstevel@tonic-gate 			    DT_INT_CTFP(dtp), DT_INT_TYPE(dtp));
19507c478bd9Sstevel@tonic-gate 			break;
19517c478bd9Sstevel@tonic-gate 		case DT_TOK_NEQ:
19527c478bd9Sstevel@tonic-gate 			dnp->dn_value = l != r;
19537c478bd9Sstevel@tonic-gate 			dt_node_type_assign(dnp,
19547c478bd9Sstevel@tonic-gate 			    DT_INT_CTFP(dtp), DT_INT_TYPE(dtp));
19557c478bd9Sstevel@tonic-gate 			break;
19567c478bd9Sstevel@tonic-gate 		case DT_TOK_LT:
19577c478bd9Sstevel@tonic-gate 			dt_node_promote(lp, rp, dnp);
19587c478bd9Sstevel@tonic-gate 			if (dnp->dn_flags & DT_NF_SIGNED)
19597c478bd9Sstevel@tonic-gate 				dnp->dn_value = (intmax_t)l < (intmax_t)r;
19607c478bd9Sstevel@tonic-gate 			else
19617c478bd9Sstevel@tonic-gate 				dnp->dn_value = l < r;
19627c478bd9Sstevel@tonic-gate 			dt_node_type_assign(dnp,
19637c478bd9Sstevel@tonic-gate 			    DT_INT_CTFP(dtp), DT_INT_TYPE(dtp));
19647c478bd9Sstevel@tonic-gate 			break;
19657c478bd9Sstevel@tonic-gate 		case DT_TOK_LE:
19667c478bd9Sstevel@tonic-gate 			dt_node_promote(lp, rp, dnp);
19677c478bd9Sstevel@tonic-gate 			if (dnp->dn_flags & DT_NF_SIGNED)
19687c478bd9Sstevel@tonic-gate 				dnp->dn_value = (intmax_t)l <= (intmax_t)r;
19697c478bd9Sstevel@tonic-gate 			else
19707c478bd9Sstevel@tonic-gate 				dnp->dn_value = l <= r;
19717c478bd9Sstevel@tonic-gate 			dt_node_type_assign(dnp,
19727c478bd9Sstevel@tonic-gate 			    DT_INT_CTFP(dtp), DT_INT_TYPE(dtp));
19737c478bd9Sstevel@tonic-gate 			break;
19747c478bd9Sstevel@tonic-gate 		case DT_TOK_GT:
19757c478bd9Sstevel@tonic-gate 			dt_node_promote(lp, rp, dnp);
19767c478bd9Sstevel@tonic-gate 			if (dnp->dn_flags & DT_NF_SIGNED)
19777c478bd9Sstevel@tonic-gate 				dnp->dn_value = (intmax_t)l > (intmax_t)r;
19787c478bd9Sstevel@tonic-gate 			else
19797c478bd9Sstevel@tonic-gate 				dnp->dn_value = l > r;
19807c478bd9Sstevel@tonic-gate 			dt_node_type_assign(dnp,
19817c478bd9Sstevel@tonic-gate 			    DT_INT_CTFP(dtp), DT_INT_TYPE(dtp));
19827c478bd9Sstevel@tonic-gate 			break;
19837c478bd9Sstevel@tonic-gate 		case DT_TOK_GE:
19847c478bd9Sstevel@tonic-gate 			dt_node_promote(lp, rp, dnp);
19857c478bd9Sstevel@tonic-gate 			if (dnp->dn_flags & DT_NF_SIGNED)
19867c478bd9Sstevel@tonic-gate 				dnp->dn_value = (intmax_t)l >= (intmax_t)r;
19877c478bd9Sstevel@tonic-gate 			else
19887c478bd9Sstevel@tonic-gate 				dnp->dn_value = l >= r;
19897c478bd9Sstevel@tonic-gate 			dt_node_type_assign(dnp,
19907c478bd9Sstevel@tonic-gate 			    DT_INT_CTFP(dtp), DT_INT_TYPE(dtp));
19917c478bd9Sstevel@tonic-gate 			break;
19927c478bd9Sstevel@tonic-gate 		case DT_TOK_LSH:
19937c478bd9Sstevel@tonic-gate 			dnp->dn_value = l << r;
19947c478bd9Sstevel@tonic-gate 			dt_node_type_propagate(lp, dnp);
19957c478bd9Sstevel@tonic-gate 			dt_node_attr_assign(rp,
19967c478bd9Sstevel@tonic-gate 			    dt_attr_min(lp->dn_attr, rp->dn_attr));
19977c478bd9Sstevel@tonic-gate 			break;
19987c478bd9Sstevel@tonic-gate 		case DT_TOK_RSH:
19997c478bd9Sstevel@tonic-gate 			dnp->dn_value = l >> r;
20007c478bd9Sstevel@tonic-gate 			dt_node_type_propagate(lp, dnp);
20017c478bd9Sstevel@tonic-gate 			dt_node_attr_assign(rp,
20027c478bd9Sstevel@tonic-gate 			    dt_attr_min(lp->dn_attr, rp->dn_attr));
20037c478bd9Sstevel@tonic-gate 			break;
20047c478bd9Sstevel@tonic-gate 		case DT_TOK_ADD:
20057c478bd9Sstevel@tonic-gate 			dnp->dn_value = l + r;
20067c478bd9Sstevel@tonic-gate 			dt_node_promote(lp, rp, dnp);
20077c478bd9Sstevel@tonic-gate 			break;
20087c478bd9Sstevel@tonic-gate 		case DT_TOK_SUB:
20097c478bd9Sstevel@tonic-gate 			dnp->dn_value = l - r;
20107c478bd9Sstevel@tonic-gate 			dt_node_promote(lp, rp, dnp);
20117c478bd9Sstevel@tonic-gate 			break;
20127c478bd9Sstevel@tonic-gate 		case DT_TOK_MUL:
20137c478bd9Sstevel@tonic-gate 			dnp->dn_value = l * r;
20147c478bd9Sstevel@tonic-gate 			dt_node_promote(lp, rp, dnp);
20157c478bd9Sstevel@tonic-gate 			break;
20167c478bd9Sstevel@tonic-gate 		case DT_TOK_DIV:
20177c478bd9Sstevel@tonic-gate 			dt_node_promote(lp, rp, dnp);
20187c478bd9Sstevel@tonic-gate 			if (dnp->dn_flags & DT_NF_SIGNED)
20197c478bd9Sstevel@tonic-gate 				dnp->dn_value = (intmax_t)l / (intmax_t)r;
20207c478bd9Sstevel@tonic-gate 			else
20217c478bd9Sstevel@tonic-gate 				dnp->dn_value = l / r;
20227c478bd9Sstevel@tonic-gate 			break;
20237c478bd9Sstevel@tonic-gate 		case DT_TOK_MOD:
20247c478bd9Sstevel@tonic-gate 			dt_node_promote(lp, rp, dnp);
20257c478bd9Sstevel@tonic-gate 			if (dnp->dn_flags & DT_NF_SIGNED)
20267c478bd9Sstevel@tonic-gate 				dnp->dn_value = (intmax_t)l % (intmax_t)r;
20277c478bd9Sstevel@tonic-gate 			else
20287c478bd9Sstevel@tonic-gate 				dnp->dn_value = l % r;
20297c478bd9Sstevel@tonic-gate 			break;
20307c478bd9Sstevel@tonic-gate 		default:
20317c478bd9Sstevel@tonic-gate 			dt_node_free(dnp);
20327c478bd9Sstevel@tonic-gate 			dnp = NULL;
20337c478bd9Sstevel@tonic-gate 		}
20347c478bd9Sstevel@tonic-gate 
20357c478bd9Sstevel@tonic-gate 		if (dnp != NULL) {
20367c478bd9Sstevel@tonic-gate 			dt_node_free(lp);
20377c478bd9Sstevel@tonic-gate 			dt_node_free(rp);
20387c478bd9Sstevel@tonic-gate 			return (dnp);
20397c478bd9Sstevel@tonic-gate 		}
20407c478bd9Sstevel@tonic-gate 	}
20417c478bd9Sstevel@tonic-gate 
20427c478bd9Sstevel@tonic-gate 	if (op == DT_TOK_LPAR && rp->dn_kind == DT_NODE_INT &&
20437c478bd9Sstevel@tonic-gate 	    dt_node_is_integer(lp)) {
2044*e5803b76SAdam H. Leventhal 		dt_cast(lp, rp);
20457c478bd9Sstevel@tonic-gate 		dt_node_type_propagate(lp, rp);
20467c478bd9Sstevel@tonic-gate 		dt_node_attr_assign(rp, dt_attr_min(lp->dn_attr, rp->dn_attr));
20477c478bd9Sstevel@tonic-gate 		dt_node_free(lp);
20487c478bd9Sstevel@tonic-gate 
20497c478bd9Sstevel@tonic-gate 		return (rp);
20507c478bd9Sstevel@tonic-gate 	}
20517c478bd9Sstevel@tonic-gate 
20527c478bd9Sstevel@tonic-gate 	/*
20537c478bd9Sstevel@tonic-gate 	 * If no immediate optimizations are available, create an new OP2 node
20547c478bd9Sstevel@tonic-gate 	 * and glue the left and right children into place and return.
20557c478bd9Sstevel@tonic-gate 	 */
20567c478bd9Sstevel@tonic-gate 	dnp = dt_node_alloc(DT_NODE_OP2);
20577c478bd9Sstevel@tonic-gate 	assert(op <= USHRT_MAX);
20587c478bd9Sstevel@tonic-gate 	dnp->dn_op = (ushort_t)op;
20597c478bd9Sstevel@tonic-gate 	dnp->dn_left = lp;
20607c478bd9Sstevel@tonic-gate 	dnp->dn_right = rp;
20617c478bd9Sstevel@tonic-gate 
20627c478bd9Sstevel@tonic-gate 	return (dnp);
20637c478bd9Sstevel@tonic-gate }
20647c478bd9Sstevel@tonic-gate 
20657c478bd9Sstevel@tonic-gate dt_node_t *
20667c478bd9Sstevel@tonic-gate dt_node_op3(dt_node_t *expr, dt_node_t *lp, dt_node_t *rp)
20677c478bd9Sstevel@tonic-gate {
20687c478bd9Sstevel@tonic-gate 	dt_node_t *dnp;
20697c478bd9Sstevel@tonic-gate 
20707c478bd9Sstevel@tonic-gate 	if (expr->dn_kind == DT_NODE_INT)
20717c478bd9Sstevel@tonic-gate 		return (expr->dn_value != 0 ? lp : rp);
20727c478bd9Sstevel@tonic-gate 
20737c478bd9Sstevel@tonic-gate 	dnp = dt_node_alloc(DT_NODE_OP3);
20747c478bd9Sstevel@tonic-gate 	dnp->dn_op = DT_TOK_QUESTION;
20757c478bd9Sstevel@tonic-gate 	dnp->dn_expr = expr;
20767c478bd9Sstevel@tonic-gate 	dnp->dn_left = lp;
20777c478bd9Sstevel@tonic-gate 	dnp->dn_right = rp;
20787c478bd9Sstevel@tonic-gate 
20797c478bd9Sstevel@tonic-gate 	return (dnp);
20807c478bd9Sstevel@tonic-gate }
20817c478bd9Sstevel@tonic-gate 
20827c478bd9Sstevel@tonic-gate dt_node_t *
20837c478bd9Sstevel@tonic-gate dt_node_statement(dt_node_t *expr)
20847c478bd9Sstevel@tonic-gate {
20857c478bd9Sstevel@tonic-gate 	dt_node_t *dnp;
20867c478bd9Sstevel@tonic-gate 
20877c478bd9Sstevel@tonic-gate 	if (expr->dn_kind == DT_NODE_AGG)
20887c478bd9Sstevel@tonic-gate 		return (expr);
20897c478bd9Sstevel@tonic-gate 
20907c478bd9Sstevel@tonic-gate 	if (expr->dn_kind == DT_NODE_FUNC &&
20917c478bd9Sstevel@tonic-gate 	    expr->dn_ident->di_kind == DT_IDENT_ACTFUNC)
20927c478bd9Sstevel@tonic-gate 		dnp = dt_node_alloc(DT_NODE_DFUNC);
20937c478bd9Sstevel@tonic-gate 	else
20947c478bd9Sstevel@tonic-gate 		dnp = dt_node_alloc(DT_NODE_DEXPR);
20957c478bd9Sstevel@tonic-gate 
20967c478bd9Sstevel@tonic-gate 	dnp->dn_expr = expr;
20977c478bd9Sstevel@tonic-gate 	return (dnp);
20987c478bd9Sstevel@tonic-gate }
20997c478bd9Sstevel@tonic-gate 
21007c478bd9Sstevel@tonic-gate dt_node_t *
21017c478bd9Sstevel@tonic-gate dt_node_pdesc_by_name(char *spec)
21027c478bd9Sstevel@tonic-gate {
21037c478bd9Sstevel@tonic-gate 	dtrace_hdl_t *dtp = yypcb->pcb_hdl;
21047c478bd9Sstevel@tonic-gate 	dt_node_t *dnp;
21057c478bd9Sstevel@tonic-gate 
21067c478bd9Sstevel@tonic-gate 	if (spec == NULL)
21077c478bd9Sstevel@tonic-gate 		longjmp(yypcb->pcb_jmpbuf, EDT_NOMEM);
21087c478bd9Sstevel@tonic-gate 
21097c478bd9Sstevel@tonic-gate 	dnp = dt_node_alloc(DT_NODE_PDESC);
21107c478bd9Sstevel@tonic-gate 	dnp->dn_spec = spec;
21117c478bd9Sstevel@tonic-gate 	dnp->dn_desc = malloc(sizeof (dtrace_probedesc_t));
21127c478bd9Sstevel@tonic-gate 
21137c478bd9Sstevel@tonic-gate 	if (dnp->dn_desc == NULL)
21147c478bd9Sstevel@tonic-gate 		longjmp(yypcb->pcb_jmpbuf, EDT_NOMEM);
21157c478bd9Sstevel@tonic-gate 
21167c478bd9Sstevel@tonic-gate 	if (dtrace_xstr2desc(dtp, yypcb->pcb_pspec, dnp->dn_spec,
21177c478bd9Sstevel@tonic-gate 	    yypcb->pcb_sargc, yypcb->pcb_sargv, dnp->dn_desc) != 0) {
21187c478bd9Sstevel@tonic-gate 		xyerror(D_PDESC_INVAL, "invalid probe description \"%s\": %s\n",
21197c478bd9Sstevel@tonic-gate 		    dnp->dn_spec, dtrace_errmsg(dtp, dtrace_errno(dtp)));
21207c478bd9Sstevel@tonic-gate 	}
21217c478bd9Sstevel@tonic-gate 
21227c478bd9Sstevel@tonic-gate 	free(dnp->dn_spec);
21237c478bd9Sstevel@tonic-gate 	dnp->dn_spec = NULL;
21247c478bd9Sstevel@tonic-gate 
21257c478bd9Sstevel@tonic-gate 	return (dnp);
21267c478bd9Sstevel@tonic-gate }
21277c478bd9Sstevel@tonic-gate 
21287c478bd9Sstevel@tonic-gate dt_node_t *
21297c478bd9Sstevel@tonic-gate dt_node_pdesc_by_id(uintmax_t id)
21307c478bd9Sstevel@tonic-gate {
21317c478bd9Sstevel@tonic-gate 	static const char *const names[] = {
21327c478bd9Sstevel@tonic-gate 		"providers", "modules", "functions"
21337c478bd9Sstevel@tonic-gate 	};
21347c478bd9Sstevel@tonic-gate 
21357c478bd9Sstevel@tonic-gate 	dtrace_hdl_t *dtp = yypcb->pcb_hdl;
21367c478bd9Sstevel@tonic-gate 	dt_node_t *dnp = dt_node_alloc(DT_NODE_PDESC);
21377c478bd9Sstevel@tonic-gate 
21387c478bd9Sstevel@tonic-gate 	if ((dnp->dn_desc = malloc(sizeof (dtrace_probedesc_t))) == NULL)
21397c478bd9Sstevel@tonic-gate 		longjmp(yypcb->pcb_jmpbuf, EDT_NOMEM);
21407c478bd9Sstevel@tonic-gate 
21417c478bd9Sstevel@tonic-gate 	if (id > UINT_MAX) {
21427c478bd9Sstevel@tonic-gate 		xyerror(D_PDESC_INVAL, "identifier %llu exceeds maximum "
21437c478bd9Sstevel@tonic-gate 		    "probe id\n", (u_longlong_t)id);
21447c478bd9Sstevel@tonic-gate 	}
21457c478bd9Sstevel@tonic-gate 
21467c478bd9Sstevel@tonic-gate 	if (yypcb->pcb_pspec != DTRACE_PROBESPEC_NAME) {
21477c478bd9Sstevel@tonic-gate 		xyerror(D_PDESC_INVAL, "probe identifier %llu not permitted "
21487c478bd9Sstevel@tonic-gate 		    "when specifying %s\n", (u_longlong_t)id,
21497c478bd9Sstevel@tonic-gate 		    names[yypcb->pcb_pspec]);
21507c478bd9Sstevel@tonic-gate 	}
21517c478bd9Sstevel@tonic-gate 
21527c478bd9Sstevel@tonic-gate 	if (dtrace_id2desc(dtp, (dtrace_id_t)id, dnp->dn_desc) != 0) {
21537c478bd9Sstevel@tonic-gate 		xyerror(D_PDESC_INVAL, "invalid probe identifier %llu: %s\n",
21547c478bd9Sstevel@tonic-gate 		    (u_longlong_t)id, dtrace_errmsg(dtp, dtrace_errno(dtp)));
21557c478bd9Sstevel@tonic-gate 	}
21567c478bd9Sstevel@tonic-gate 
21577c478bd9Sstevel@tonic-gate 	return (dnp);
21587c478bd9Sstevel@tonic-gate }
21597c478bd9Sstevel@tonic-gate 
21607c478bd9Sstevel@tonic-gate dt_node_t *
21617c478bd9Sstevel@tonic-gate dt_node_clause(dt_node_t *pdescs, dt_node_t *pred, dt_node_t *acts)
21627c478bd9Sstevel@tonic-gate {
21637c478bd9Sstevel@tonic-gate 	dt_node_t *dnp = dt_node_alloc(DT_NODE_CLAUSE);
21647c478bd9Sstevel@tonic-gate 
21657c478bd9Sstevel@tonic-gate 	dnp->dn_pdescs = pdescs;
21667c478bd9Sstevel@tonic-gate 	dnp->dn_pred = pred;
21677c478bd9Sstevel@tonic-gate 	dnp->dn_acts = acts;
21687c478bd9Sstevel@tonic-gate 
21697c478bd9Sstevel@tonic-gate 	yybegin(YYS_CLAUSE);
21707c478bd9Sstevel@tonic-gate 	return (dnp);
21717c478bd9Sstevel@tonic-gate }
21727c478bd9Sstevel@tonic-gate 
21737c478bd9Sstevel@tonic-gate dt_node_t *
21747c478bd9Sstevel@tonic-gate dt_node_inline(dt_node_t *expr)
21757c478bd9Sstevel@tonic-gate {
21767c478bd9Sstevel@tonic-gate 	dtrace_hdl_t *dtp = yypcb->pcb_hdl;
21777c478bd9Sstevel@tonic-gate 	dt_scope_t *dsp = &yypcb->pcb_dstack;
21787c478bd9Sstevel@tonic-gate 	dt_decl_t *ddp = dt_decl_top();
21797c478bd9Sstevel@tonic-gate 
21807c478bd9Sstevel@tonic-gate 	char n[DT_TYPE_NAMELEN];
21817c478bd9Sstevel@tonic-gate 	dtrace_typeinfo_t dtt;
21827c478bd9Sstevel@tonic-gate 
21837c478bd9Sstevel@tonic-gate 	dt_ident_t *idp, *rdp;
21847c478bd9Sstevel@tonic-gate 	dt_idnode_t *inp;
21857c478bd9Sstevel@tonic-gate 	dt_node_t *dnp;
21867c478bd9Sstevel@tonic-gate 
21877c478bd9Sstevel@tonic-gate 	if (dt_decl_type(ddp, &dtt) != 0)
21887c478bd9Sstevel@tonic-gate 		longjmp(yypcb->pcb_jmpbuf, EDT_COMPILER);
21897c478bd9Sstevel@tonic-gate 
21907c478bd9Sstevel@tonic-gate 	if (dsp->ds_class != DT_DC_DEFAULT) {
21917c478bd9Sstevel@tonic-gate 		xyerror(D_DECL_BADCLASS, "specified storage class not "
21927c478bd9Sstevel@tonic-gate 		    "appropriate for inline declaration\n");
21937c478bd9Sstevel@tonic-gate 	}
21947c478bd9Sstevel@tonic-gate 
21957c478bd9Sstevel@tonic-gate 	if (dsp->ds_ident == NULL)
21967c478bd9Sstevel@tonic-gate 		xyerror(D_DECL_USELESS, "inline declaration requires a name\n");
21977c478bd9Sstevel@tonic-gate 
21987c478bd9Sstevel@tonic-gate 	if ((idp = dt_idstack_lookup(
21997c478bd9Sstevel@tonic-gate 	    &yypcb->pcb_globals, dsp->ds_ident)) != NULL) {
22007c478bd9Sstevel@tonic-gate 		xyerror(D_DECL_IDRED, "identifier redefined: %s\n\t current: "
22017c478bd9Sstevel@tonic-gate 		    "inline definition\n\tprevious: %s %s\n",
22027c478bd9Sstevel@tonic-gate 		    idp->di_name, dt_idkind_name(idp->di_kind),
22037c478bd9Sstevel@tonic-gate 		    (idp->di_flags & DT_IDFLG_INLINE) ? "inline" : "");
22047c478bd9Sstevel@tonic-gate 	}
22057c478bd9Sstevel@tonic-gate 
22067c478bd9Sstevel@tonic-gate 	/*
22077c478bd9Sstevel@tonic-gate 	 * If we are declaring an inlined array, verify that we have a tuple
22087c478bd9Sstevel@tonic-gate 	 * signature, and then recompute 'dtt' as the array's value type.
22097c478bd9Sstevel@tonic-gate 	 */
22107c478bd9Sstevel@tonic-gate 	if (ddp->dd_kind == CTF_K_ARRAY) {
22117c478bd9Sstevel@tonic-gate 		if (ddp->dd_node == NULL) {
22127c478bd9Sstevel@tonic-gate 			xyerror(D_DECL_ARRNULL, "inline declaration requires "
22137c478bd9Sstevel@tonic-gate 			    "array tuple signature: %s\n", dsp->ds_ident);
22147c478bd9Sstevel@tonic-gate 		}
22157c478bd9Sstevel@tonic-gate 
22167c478bd9Sstevel@tonic-gate 		if (ddp->dd_node->dn_kind != DT_NODE_TYPE) {
22177c478bd9Sstevel@tonic-gate 			xyerror(D_DECL_ARRNULL, "inline declaration cannot be "
22187c478bd9Sstevel@tonic-gate 			    "of scalar array type: %s\n", dsp->ds_ident);
22197c478bd9Sstevel@tonic-gate 		}
22207c478bd9Sstevel@tonic-gate 
22217c478bd9Sstevel@tonic-gate 		if (dt_decl_type(ddp->dd_next, &dtt) != 0)
22227c478bd9Sstevel@tonic-gate 			longjmp(yypcb->pcb_jmpbuf, EDT_COMPILER);
22237c478bd9Sstevel@tonic-gate 	}
22247c478bd9Sstevel@tonic-gate 
22257c478bd9Sstevel@tonic-gate 	/*
22267c478bd9Sstevel@tonic-gate 	 * If the inline identifier is not defined, then create it with the
22277c478bd9Sstevel@tonic-gate 	 * orphan flag set.  We do not insert the identifier into dt_globals
22287c478bd9Sstevel@tonic-gate 	 * until we have successfully cooked the right-hand expression, below.
22297c478bd9Sstevel@tonic-gate 	 */
22307c478bd9Sstevel@tonic-gate 	dnp = dt_node_alloc(DT_NODE_INLINE);
22317c478bd9Sstevel@tonic-gate 	dt_node_type_assign(dnp, dtt.dtt_ctfp, dtt.dtt_type);
22327c478bd9Sstevel@tonic-gate 	dt_node_attr_assign(dnp, _dtrace_defattr);
22337c478bd9Sstevel@tonic-gate 
22347c478bd9Sstevel@tonic-gate 	if (dt_node_is_void(dnp)) {
22357c478bd9Sstevel@tonic-gate 		xyerror(D_DECL_VOIDOBJ,
22367c478bd9Sstevel@tonic-gate 		    "cannot declare void inline: %s\n", dsp->ds_ident);
22377c478bd9Sstevel@tonic-gate 	}
22387c478bd9Sstevel@tonic-gate 
22397c478bd9Sstevel@tonic-gate 	if (ctf_type_kind(dnp->dn_ctfp, ctf_type_resolve(
22407c478bd9Sstevel@tonic-gate 	    dnp->dn_ctfp, dnp->dn_type)) == CTF_K_FORWARD) {
22417c478bd9Sstevel@tonic-gate 		xyerror(D_DECL_INCOMPLETE,
22427c478bd9Sstevel@tonic-gate 		    "incomplete struct/union/enum %s: %s\n",
22437c478bd9Sstevel@tonic-gate 		    dt_node_type_name(dnp, n, sizeof (n)), dsp->ds_ident);
22447c478bd9Sstevel@tonic-gate 	}
22457c478bd9Sstevel@tonic-gate 
22467c478bd9Sstevel@tonic-gate 	if ((inp = malloc(sizeof (dt_idnode_t))) == NULL)
22477c478bd9Sstevel@tonic-gate 		longjmp(yypcb->pcb_jmpbuf, EDT_NOMEM);
22487c478bd9Sstevel@tonic-gate 
22497c478bd9Sstevel@tonic-gate 	bzero(inp, sizeof (dt_idnode_t));
22507c478bd9Sstevel@tonic-gate 
22517c478bd9Sstevel@tonic-gate 	idp = dnp->dn_ident = dt_ident_create(dsp->ds_ident,
22527c478bd9Sstevel@tonic-gate 	    ddp->dd_kind == CTF_K_ARRAY ? DT_IDENT_ARRAY : DT_IDENT_SCALAR,
22537c478bd9Sstevel@tonic-gate 	    DT_IDFLG_INLINE | DT_IDFLG_REF | DT_IDFLG_DECL | DT_IDFLG_ORPHAN, 0,
22547c478bd9Sstevel@tonic-gate 	    _dtrace_defattr, 0, &dt_idops_inline, inp, dtp->dt_gen);
22557c478bd9Sstevel@tonic-gate 
22567c478bd9Sstevel@tonic-gate 	if (idp == NULL) {
22577c478bd9Sstevel@tonic-gate 		free(inp);
22587c478bd9Sstevel@tonic-gate 		longjmp(yypcb->pcb_jmpbuf, EDT_NOMEM);
22597c478bd9Sstevel@tonic-gate 	}
22607c478bd9Sstevel@tonic-gate 
22617c478bd9Sstevel@tonic-gate 	/*
22627c478bd9Sstevel@tonic-gate 	 * If we're inlining an associative array, create a private identifier
22637c478bd9Sstevel@tonic-gate 	 * hash containing the named parameters and store it in inp->din_hash.
22647c478bd9Sstevel@tonic-gate 	 * We then push this hash on to the top of the pcb_globals stack.
22657c478bd9Sstevel@tonic-gate 	 */
22667c478bd9Sstevel@tonic-gate 	if (ddp->dd_kind == CTF_K_ARRAY) {
22677c478bd9Sstevel@tonic-gate 		dt_idnode_t *pinp;
22687c478bd9Sstevel@tonic-gate 		dt_ident_t *pidp;
22697c478bd9Sstevel@tonic-gate 		dt_node_t *pnp;
22707c478bd9Sstevel@tonic-gate 		uint_t i = 0;
22717c478bd9Sstevel@tonic-gate 
22727c478bd9Sstevel@tonic-gate 		for (pnp = ddp->dd_node; pnp != NULL; pnp = pnp->dn_list)
22737c478bd9Sstevel@tonic-gate 			i++; /* count up parameters for din_argv[] */
22747c478bd9Sstevel@tonic-gate 
22757c478bd9Sstevel@tonic-gate 		inp->din_hash = dt_idhash_create("inline args", NULL, 0, 0);
22767c478bd9Sstevel@tonic-gate 		inp->din_argv = calloc(i, sizeof (dt_ident_t *));
22777c478bd9Sstevel@tonic-gate 
22787c478bd9Sstevel@tonic-gate 		if (inp->din_hash == NULL || inp->din_argv == NULL)
22797c478bd9Sstevel@tonic-gate 			longjmp(yypcb->pcb_jmpbuf, EDT_NOMEM);
22807c478bd9Sstevel@tonic-gate 
22817c478bd9Sstevel@tonic-gate 		/*
22827c478bd9Sstevel@tonic-gate 		 * Create an identifier for each parameter as a scalar inline,
22837c478bd9Sstevel@tonic-gate 		 * and store it in din_hash and in position in din_argv[].  The
22847c478bd9Sstevel@tonic-gate 		 * parameter identifiers also use dt_idops_inline, but we leave
22857c478bd9Sstevel@tonic-gate 		 * the dt_idnode_t argument 'pinp' zeroed.  This will be filled
22867c478bd9Sstevel@tonic-gate 		 * in by the code generation pass with references to the args.
22877c478bd9Sstevel@tonic-gate 		 */
22887c478bd9Sstevel@tonic-gate 		for (i = 0, pnp = ddp->dd_node;
22897c478bd9Sstevel@tonic-gate 		    pnp != NULL; pnp = pnp->dn_list, i++) {
22907c478bd9Sstevel@tonic-gate 
22917c478bd9Sstevel@tonic-gate 			if (pnp->dn_string == NULL)
22927c478bd9Sstevel@tonic-gate 				continue; /* ignore anonymous parameters */
22937c478bd9Sstevel@tonic-gate 
22947c478bd9Sstevel@tonic-gate 			if ((pinp = malloc(sizeof (dt_idnode_t))) == NULL)
22957c478bd9Sstevel@tonic-gate 				longjmp(yypcb->pcb_jmpbuf, EDT_NOMEM);
22967c478bd9Sstevel@tonic-gate 
22977c478bd9Sstevel@tonic-gate 			pidp = dt_idhash_insert(inp->din_hash, pnp->dn_string,
22987c478bd9Sstevel@tonic-gate 			    DT_IDENT_SCALAR, DT_IDFLG_DECL | DT_IDFLG_INLINE, 0,
22997c478bd9Sstevel@tonic-gate 			    _dtrace_defattr, 0, &dt_idops_inline,
23007c478bd9Sstevel@tonic-gate 			    pinp, dtp->dt_gen);
23017c478bd9Sstevel@tonic-gate 
23027c478bd9Sstevel@tonic-gate 			if (pidp == NULL) {
23037c478bd9Sstevel@tonic-gate 				free(pinp);
23047c478bd9Sstevel@tonic-gate 				longjmp(yypcb->pcb_jmpbuf, EDT_NOMEM);
23057c478bd9Sstevel@tonic-gate 			}
23067c478bd9Sstevel@tonic-gate 
23077c478bd9Sstevel@tonic-gate 			inp->din_argv[i] = pidp;
23087c478bd9Sstevel@tonic-gate 			bzero(pinp, sizeof (dt_idnode_t));
23097c478bd9Sstevel@tonic-gate 			dt_ident_type_assign(pidp, pnp->dn_ctfp, pnp->dn_type);
23107c478bd9Sstevel@tonic-gate 		}
23117c478bd9Sstevel@tonic-gate 
23127c478bd9Sstevel@tonic-gate 		dt_idstack_push(&yypcb->pcb_globals, inp->din_hash);
23137c478bd9Sstevel@tonic-gate 	}
23147c478bd9Sstevel@tonic-gate 
23157c478bd9Sstevel@tonic-gate 	/*
23167c478bd9Sstevel@tonic-gate 	 * Unlike most constructors, we need to explicitly cook the right-hand
23177c478bd9Sstevel@tonic-gate 	 * side of the inline definition immediately to prevent recursion.  If
23187c478bd9Sstevel@tonic-gate 	 * the right-hand side uses the inline itself, the cook will fail.
23197c478bd9Sstevel@tonic-gate 	 */
23207c478bd9Sstevel@tonic-gate 	expr = dt_node_cook(expr, DT_IDFLG_REF);
23217c478bd9Sstevel@tonic-gate 
23227c478bd9Sstevel@tonic-gate 	if (ddp->dd_kind == CTF_K_ARRAY)
23237c478bd9Sstevel@tonic-gate 		dt_idstack_pop(&yypcb->pcb_globals, inp->din_hash);
23247c478bd9Sstevel@tonic-gate 
23257c478bd9Sstevel@tonic-gate 	/*
23267c478bd9Sstevel@tonic-gate 	 * Set the type, attributes, and flags for the inline.  If the right-
23277c478bd9Sstevel@tonic-gate 	 * hand expression has an identifier, propagate its flags.  Then cook
23287c478bd9Sstevel@tonic-gate 	 * the identifier to fully initialize it: if we're declaring an inline
23297c478bd9Sstevel@tonic-gate 	 * associative array this will construct a type signature from 'ddp'.
23307c478bd9Sstevel@tonic-gate 	 */
23317c478bd9Sstevel@tonic-gate 	if (dt_node_is_dynamic(expr))
23327c478bd9Sstevel@tonic-gate 		rdp = dt_ident_resolve(expr->dn_ident);
23337c478bd9Sstevel@tonic-gate 	else if (expr->dn_kind == DT_NODE_VAR || expr->dn_kind == DT_NODE_SYM)
23347c478bd9Sstevel@tonic-gate 		rdp = expr->dn_ident;
23357c478bd9Sstevel@tonic-gate 	else
23367c478bd9Sstevel@tonic-gate 		rdp = NULL;
23377c478bd9Sstevel@tonic-gate 
23387c478bd9Sstevel@tonic-gate 	if (rdp != NULL) {
23397c478bd9Sstevel@tonic-gate 		idp->di_flags |= (rdp->di_flags &
23407c478bd9Sstevel@tonic-gate 		    (DT_IDFLG_WRITE | DT_IDFLG_USER | DT_IDFLG_PRIM));
23417c478bd9Sstevel@tonic-gate 	}
23427c478bd9Sstevel@tonic-gate 
23437c478bd9Sstevel@tonic-gate 	idp->di_attr = dt_attr_min(_dtrace_defattr, expr->dn_attr);
23447c478bd9Sstevel@tonic-gate 	dt_ident_type_assign(idp, dtt.dtt_ctfp, dtt.dtt_type);
23457c478bd9Sstevel@tonic-gate 	(void) dt_ident_cook(dnp, idp, &ddp->dd_node);
23467c478bd9Sstevel@tonic-gate 
23477c478bd9Sstevel@tonic-gate 	/*
23487c478bd9Sstevel@tonic-gate 	 * Store the parse tree nodes for 'expr' inside of idp->di_data ('inp')
23497c478bd9Sstevel@tonic-gate 	 * so that they will be preserved with this identifier.  Then pop the
23507c478bd9Sstevel@tonic-gate 	 * inline declaration from the declaration stack and restore the lexer.
23517c478bd9Sstevel@tonic-gate 	 */
23527c478bd9Sstevel@tonic-gate 	inp->din_list = yypcb->pcb_list;
23537c478bd9Sstevel@tonic-gate 	inp->din_root = expr;
23547c478bd9Sstevel@tonic-gate 
23557c478bd9Sstevel@tonic-gate 	dt_decl_free(dt_decl_pop());
23567c478bd9Sstevel@tonic-gate 	yybegin(YYS_CLAUSE);
23577c478bd9Sstevel@tonic-gate 
23587c478bd9Sstevel@tonic-gate 	/*
23597c478bd9Sstevel@tonic-gate 	 * Finally, insert the inline identifier into dt_globals to make it
23607c478bd9Sstevel@tonic-gate 	 * visible, and then cook 'dnp' to check its type against 'expr'.
23617c478bd9Sstevel@tonic-gate 	 */
23627c478bd9Sstevel@tonic-gate 	dt_idhash_xinsert(dtp->dt_globals, idp);
23637c478bd9Sstevel@tonic-gate 	return (dt_node_cook(dnp, DT_IDFLG_REF));
23647c478bd9Sstevel@tonic-gate }
23657c478bd9Sstevel@tonic-gate 
23667c478bd9Sstevel@tonic-gate dt_node_t *
23677c478bd9Sstevel@tonic-gate dt_node_member(dt_decl_t *ddp, char *name, dt_node_t *expr)
23687c478bd9Sstevel@tonic-gate {
23697c478bd9Sstevel@tonic-gate 	dtrace_typeinfo_t dtt;
23707c478bd9Sstevel@tonic-gate 	dt_node_t *dnp;
23717c478bd9Sstevel@tonic-gate 	int err;
23727c478bd9Sstevel@tonic-gate 
23737c478bd9Sstevel@tonic-gate 	if (ddp != NULL) {
23747c478bd9Sstevel@tonic-gate 		err = dt_decl_type(ddp, &dtt);
23757c478bd9Sstevel@tonic-gate 		dt_decl_free(ddp);
23767c478bd9Sstevel@tonic-gate 
23777c478bd9Sstevel@tonic-gate 		if (err != 0)
23787c478bd9Sstevel@tonic-gate 			longjmp(yypcb->pcb_jmpbuf, EDT_COMPILER);
23797c478bd9Sstevel@tonic-gate 	}
23807c478bd9Sstevel@tonic-gate 
23817c478bd9Sstevel@tonic-gate 	dnp = dt_node_alloc(DT_NODE_MEMBER);
23827c478bd9Sstevel@tonic-gate 	dnp->dn_membname = name;
23837c478bd9Sstevel@tonic-gate 	dnp->dn_membexpr = expr;
23847c478bd9Sstevel@tonic-gate 
23857c478bd9Sstevel@tonic-gate 	if (ddp != NULL)
23867c478bd9Sstevel@tonic-gate 		dt_node_type_assign(dnp, dtt.dtt_ctfp, dtt.dtt_type);
23877c478bd9Sstevel@tonic-gate 
23887c478bd9Sstevel@tonic-gate 	return (dnp);
23897c478bd9Sstevel@tonic-gate }
23907c478bd9Sstevel@tonic-gate 
23917c478bd9Sstevel@tonic-gate dt_node_t *
23927c478bd9Sstevel@tonic-gate dt_node_xlator(dt_decl_t *ddp, dt_decl_t *sdp, char *name, dt_node_t *members)
23937c478bd9Sstevel@tonic-gate {
23947c478bd9Sstevel@tonic-gate 	dtrace_hdl_t *dtp = yypcb->pcb_hdl;
23957c478bd9Sstevel@tonic-gate 	dtrace_typeinfo_t src, dst;
23967c478bd9Sstevel@tonic-gate 	dt_node_t sn, dn;
23977c478bd9Sstevel@tonic-gate 	dt_xlator_t *dxp;
23987c478bd9Sstevel@tonic-gate 	dt_node_t *dnp;
23997c478bd9Sstevel@tonic-gate 	int edst, esrc;
24001a7c1b72Smws 	uint_t kind;
24017c478bd9Sstevel@tonic-gate 
24027c478bd9Sstevel@tonic-gate 	char n1[DT_TYPE_NAMELEN];
24037c478bd9Sstevel@tonic-gate 	char n2[DT_TYPE_NAMELEN];
24047c478bd9Sstevel@tonic-gate 
24057c478bd9Sstevel@tonic-gate 	edst = dt_decl_type(ddp, &dst);
24067c478bd9Sstevel@tonic-gate 	dt_decl_free(ddp);
24077c478bd9Sstevel@tonic-gate 
24087c478bd9Sstevel@tonic-gate 	esrc = dt_decl_type(sdp, &src);
24097c478bd9Sstevel@tonic-gate 	dt_decl_free(sdp);
24107c478bd9Sstevel@tonic-gate 
24117c478bd9Sstevel@tonic-gate 	if (edst != 0 || esrc != 0) {
24127c478bd9Sstevel@tonic-gate 		free(name);
24137c478bd9Sstevel@tonic-gate 		longjmp(yypcb->pcb_jmpbuf, EDT_COMPILER);
24147c478bd9Sstevel@tonic-gate 	}
24157c478bd9Sstevel@tonic-gate 
24167c478bd9Sstevel@tonic-gate 	bzero(&sn, sizeof (sn));
24177c478bd9Sstevel@tonic-gate 	dt_node_type_assign(&sn, src.dtt_ctfp, src.dtt_type);
24187c478bd9Sstevel@tonic-gate 
24197c478bd9Sstevel@tonic-gate 	bzero(&dn, sizeof (dn));
24207c478bd9Sstevel@tonic-gate 	dt_node_type_assign(&dn, dst.dtt_ctfp, dst.dtt_type);
24217c478bd9Sstevel@tonic-gate 
24227c478bd9Sstevel@tonic-gate 	if (dt_xlator_lookup(dtp, &sn, &dn, DT_XLATE_EXACT) != NULL) {
24237c478bd9Sstevel@tonic-gate 		xyerror(D_XLATE_REDECL,
24247c478bd9Sstevel@tonic-gate 		    "translator from %s to %s has already been declared\n",
24257c478bd9Sstevel@tonic-gate 		    dt_node_type_name(&sn, n1, sizeof (n1)),
24267c478bd9Sstevel@tonic-gate 		    dt_node_type_name(&dn, n2, sizeof (n2)));
24277c478bd9Sstevel@tonic-gate 	}
24287c478bd9Sstevel@tonic-gate 
24291a7c1b72Smws 	kind = ctf_type_kind(dst.dtt_ctfp,
24301a7c1b72Smws 	    ctf_type_resolve(dst.dtt_ctfp, dst.dtt_type));
24311a7c1b72Smws 
24321a7c1b72Smws 	if (kind == CTF_K_FORWARD) {
24331a7c1b72Smws 		xyerror(D_XLATE_SOU, "incomplete struct/union/enum %s\n",
24341a7c1b72Smws 		    dt_type_name(dst.dtt_ctfp, dst.dtt_type, n1, sizeof (n1)));
24351a7c1b72Smws 	}
24361a7c1b72Smws 
24371a7c1b72Smws 	if (kind != CTF_K_STRUCT && kind != CTF_K_UNION) {
24381a7c1b72Smws 		xyerror(D_XLATE_SOU,
24391a7c1b72Smws 		    "translator output type must be a struct or union\n");
24401a7c1b72Smws 	}
24411a7c1b72Smws 
24427c478bd9Sstevel@tonic-gate 	dxp = dt_xlator_create(dtp, &src, &dst, name, members, yypcb->pcb_list);
24437c478bd9Sstevel@tonic-gate 	yybegin(YYS_CLAUSE);
24447c478bd9Sstevel@tonic-gate 	free(name);
24457c478bd9Sstevel@tonic-gate 
24467c478bd9Sstevel@tonic-gate 	if (dxp == NULL)
24477c478bd9Sstevel@tonic-gate 		longjmp(yypcb->pcb_jmpbuf, EDT_NOMEM);
24487c478bd9Sstevel@tonic-gate 
24497c478bd9Sstevel@tonic-gate 	dnp = dt_node_alloc(DT_NODE_XLATOR);
24507c478bd9Sstevel@tonic-gate 	dnp->dn_xlator = dxp;
24517c478bd9Sstevel@tonic-gate 	dnp->dn_members = members;
24527c478bd9Sstevel@tonic-gate 
24537c478bd9Sstevel@tonic-gate 	return (dt_node_cook(dnp, DT_IDFLG_REF));
24547c478bd9Sstevel@tonic-gate }
24557c478bd9Sstevel@tonic-gate 
24567c478bd9Sstevel@tonic-gate dt_node_t *
24571a7c1b72Smws dt_node_probe(char *s, int protoc, dt_node_t *nargs, dt_node_t *xargs)
24587c478bd9Sstevel@tonic-gate {
24597c478bd9Sstevel@tonic-gate 	dtrace_hdl_t *dtp = yypcb->pcb_hdl;
24607c478bd9Sstevel@tonic-gate 	int nargc, xargc;
24617c478bd9Sstevel@tonic-gate 	dt_node_t *dnp;
24627c478bd9Sstevel@tonic-gate 
24637c478bd9Sstevel@tonic-gate 	size_t len = strlen(s) + 3; /* +3 for :: and \0 */
24647c478bd9Sstevel@tonic-gate 	char *name = alloca(len);
24657c478bd9Sstevel@tonic-gate 
24667c478bd9Sstevel@tonic-gate 	(void) snprintf(name, len, "::%s", s);
24677c478bd9Sstevel@tonic-gate 	(void) strhyphenate(name);
24687c478bd9Sstevel@tonic-gate 	free(s);
24697c478bd9Sstevel@tonic-gate 
24707c478bd9Sstevel@tonic-gate 	if (strchr(name, '`') != NULL) {
24717c478bd9Sstevel@tonic-gate 		xyerror(D_PROV_BADNAME, "probe name may not "
24727c478bd9Sstevel@tonic-gate 		    "contain scoping operator: %s\n", name);
24737c478bd9Sstevel@tonic-gate 	}
24747c478bd9Sstevel@tonic-gate 
24757c478bd9Sstevel@tonic-gate 	if (strlen(name) - 2 >= DTRACE_NAMELEN) {
24767c478bd9Sstevel@tonic-gate 		xyerror(D_PROV_BADNAME, "probe name may not exceed %d "
24777c478bd9Sstevel@tonic-gate 		    "characters: %s\n", DTRACE_NAMELEN - 1, name);
24787c478bd9Sstevel@tonic-gate 	}
24797c478bd9Sstevel@tonic-gate 
24807c478bd9Sstevel@tonic-gate 	dnp = dt_node_alloc(DT_NODE_PROBE);
24817c478bd9Sstevel@tonic-gate 
24827c478bd9Sstevel@tonic-gate 	dnp->dn_ident = dt_ident_create(name, DT_IDENT_PROBE,
24837c478bd9Sstevel@tonic-gate 	    DT_IDFLG_ORPHAN, DTRACE_IDNONE, _dtrace_defattr, 0,
24847c478bd9Sstevel@tonic-gate 	    &dt_idops_probe, NULL, dtp->dt_gen);
24857c478bd9Sstevel@tonic-gate 
24867c478bd9Sstevel@tonic-gate 	nargc = dt_decl_prototype(nargs, nargs,
24877c478bd9Sstevel@tonic-gate 	    "probe input", DT_DP_VOID | DT_DP_ANON);
24887c478bd9Sstevel@tonic-gate 
24897c478bd9Sstevel@tonic-gate 	xargc = dt_decl_prototype(xargs, nargs,
24907c478bd9Sstevel@tonic-gate 	    "probe output", DT_DP_VOID);
24917c478bd9Sstevel@tonic-gate 
24927c478bd9Sstevel@tonic-gate 	if (nargc > UINT8_MAX) {
24937c478bd9Sstevel@tonic-gate 		xyerror(D_PROV_PRARGLEN, "probe %s input prototype exceeds %u "
24947c478bd9Sstevel@tonic-gate 		    "parameters: %d params used\n", name, UINT8_MAX, nargc);
24957c478bd9Sstevel@tonic-gate 	}
24967c478bd9Sstevel@tonic-gate 
24977c478bd9Sstevel@tonic-gate 	if (xargc > UINT8_MAX) {
24987c478bd9Sstevel@tonic-gate 		xyerror(D_PROV_PRARGLEN, "probe %s output prototype exceeds %u "
24997c478bd9Sstevel@tonic-gate 		    "parameters: %d params used\n", name, UINT8_MAX, xargc);
25007c478bd9Sstevel@tonic-gate 	}
25017c478bd9Sstevel@tonic-gate 
25027c478bd9Sstevel@tonic-gate 	if (dnp->dn_ident == NULL || dt_probe_create(dtp,
25031a7c1b72Smws 	    dnp->dn_ident, protoc, nargs, nargc, xargs, xargc) == NULL)
25047c478bd9Sstevel@tonic-gate 		longjmp(yypcb->pcb_jmpbuf, EDT_NOMEM);
25057c478bd9Sstevel@tonic-gate 
25067c478bd9Sstevel@tonic-gate 	return (dnp);
25077c478bd9Sstevel@tonic-gate }
25087c478bd9Sstevel@tonic-gate 
25097c478bd9Sstevel@tonic-gate dt_node_t *
25107c478bd9Sstevel@tonic-gate dt_node_provider(char *name, dt_node_t *probes)
25117c478bd9Sstevel@tonic-gate {
25127c478bd9Sstevel@tonic-gate 	dtrace_hdl_t *dtp = yypcb->pcb_hdl;
25137c478bd9Sstevel@tonic-gate 	dt_node_t *dnp = dt_node_alloc(DT_NODE_PROVIDER);
25141a7c1b72Smws 	dt_node_t *lnp;
2515900524f3Sahl 	size_t len;
25167c478bd9Sstevel@tonic-gate 
25177c478bd9Sstevel@tonic-gate 	dnp->dn_provname = name;
25187c478bd9Sstevel@tonic-gate 	dnp->dn_probes = probes;
25197c478bd9Sstevel@tonic-gate 
25207c478bd9Sstevel@tonic-gate 	if (strchr(name, '`') != NULL) {
25217c478bd9Sstevel@tonic-gate 		dnerror(dnp, D_PROV_BADNAME, "provider name may not "
25227c478bd9Sstevel@tonic-gate 		    "contain scoping operator: %s\n", name);
25237c478bd9Sstevel@tonic-gate 	}
25247c478bd9Sstevel@tonic-gate 
2525900524f3Sahl 	if ((len = strlen(name)) >= DTRACE_PROVNAMELEN) {
25267c478bd9Sstevel@tonic-gate 		dnerror(dnp, D_PROV_BADNAME, "provider name may not exceed %d "
25277c478bd9Sstevel@tonic-gate 		    "characters: %s\n", DTRACE_PROVNAMELEN - 1, name);
25287c478bd9Sstevel@tonic-gate 	}
25297c478bd9Sstevel@tonic-gate 
2530900524f3Sahl 	if (isdigit(name[len - 1])) {
2531900524f3Sahl 		dnerror(dnp, D_PROV_BADNAME, "provider name may not "
2532900524f3Sahl 		    "end with a digit: %s\n", name);
2533900524f3Sahl 	}
2534900524f3Sahl 
25357c478bd9Sstevel@tonic-gate 	/*
25367c478bd9Sstevel@tonic-gate 	 * Check to see if the provider is already defined or visible through
25377c478bd9Sstevel@tonic-gate 	 * dtrace(7D).  If so, set dn_provred to treat it as a re-declaration.
25387c478bd9Sstevel@tonic-gate 	 * If not, create a new provider and set its interface-only flag.  This
25397c478bd9Sstevel@tonic-gate 	 * flag may be cleared later by calls made to dt_probe_declare().
25407c478bd9Sstevel@tonic-gate 	 */
25417c478bd9Sstevel@tonic-gate 	if ((dnp->dn_provider = dt_provider_lookup(dtp, name)) != NULL)
25427c478bd9Sstevel@tonic-gate 		dnp->dn_provred = B_TRUE;
25437c478bd9Sstevel@tonic-gate 	else if ((dnp->dn_provider = dt_provider_create(dtp, name)) == NULL)
25447c478bd9Sstevel@tonic-gate 		longjmp(yypcb->pcb_jmpbuf, EDT_NOMEM);
25457c478bd9Sstevel@tonic-gate 	else
25467c478bd9Sstevel@tonic-gate 		dnp->dn_provider->pv_flags |= DT_PROVIDER_INTF;
25477c478bd9Sstevel@tonic-gate 
25487c478bd9Sstevel@tonic-gate 	/*
25491a7c1b72Smws 	 * Store all parse nodes created since we consumed the DT_KEY_PROVIDER
25507c478bd9Sstevel@tonic-gate 	 * token with the provider and then restore our lexing state to CLAUSE.
25511a7c1b72Smws 	 * Note that if dnp->dn_provred is true, we may end up storing dups of
25521a7c1b72Smws 	 * a provider's interface and implementation: we eat this space because
25531a7c1b72Smws 	 * the implementation will likely need to redeclare probe members, and
25541a7c1b72Smws 	 * therefore may result in those member nodes becoming persistent.
25557c478bd9Sstevel@tonic-gate 	 */
25561a7c1b72Smws 	for (lnp = yypcb->pcb_list; lnp->dn_link != NULL; lnp = lnp->dn_link)
25571a7c1b72Smws 		continue; /* skip to end of allocation list */
25581a7c1b72Smws 
25591a7c1b72Smws 	lnp->dn_link = dnp->dn_provider->pv_nodes;
25601a7c1b72Smws 	dnp->dn_provider->pv_nodes = yypcb->pcb_list;
25617c478bd9Sstevel@tonic-gate 
25627c478bd9Sstevel@tonic-gate 	yybegin(YYS_CLAUSE);
25637c478bd9Sstevel@tonic-gate 	return (dnp);
25647c478bd9Sstevel@tonic-gate }
25657c478bd9Sstevel@tonic-gate 
25667c478bd9Sstevel@tonic-gate dt_node_t *
25677c478bd9Sstevel@tonic-gate dt_node_program(dt_node_t *lnp)
25687c478bd9Sstevel@tonic-gate {
25697c478bd9Sstevel@tonic-gate 	dt_node_t *dnp = dt_node_alloc(DT_NODE_PROG);
25707c478bd9Sstevel@tonic-gate 	dnp->dn_list = lnp;
25717c478bd9Sstevel@tonic-gate 	return (dnp);
25727c478bd9Sstevel@tonic-gate }
25737c478bd9Sstevel@tonic-gate 
25747c478bd9Sstevel@tonic-gate /*
25757c478bd9Sstevel@tonic-gate  * This function provides the underlying implementation of cooking an
25767c478bd9Sstevel@tonic-gate  * identifier given its node, a hash of dynamic identifiers, an identifier
25777c478bd9Sstevel@tonic-gate  * kind, and a boolean flag indicating whether we are allowed to instantiate
25787c478bd9Sstevel@tonic-gate  * a new identifier if the string is not found.  This function is either
25797c478bd9Sstevel@tonic-gate  * called from dt_cook_ident(), below, or directly by the various cooking
25807c478bd9Sstevel@tonic-gate  * routines that are allowed to instantiate identifiers (e.g. op2 TOK_ASGN).
25817c478bd9Sstevel@tonic-gate  */
25827c478bd9Sstevel@tonic-gate static void
25837c478bd9Sstevel@tonic-gate dt_xcook_ident(dt_node_t *dnp, dt_idhash_t *dhp, uint_t idkind, int create)
25847c478bd9Sstevel@tonic-gate {
25857c478bd9Sstevel@tonic-gate 	dtrace_hdl_t *dtp = yypcb->pcb_hdl;
25867c478bd9Sstevel@tonic-gate 	const char *sname = dt_idhash_name(dhp);
25877c478bd9Sstevel@tonic-gate 	int uref = 0;
25887c478bd9Sstevel@tonic-gate 
25897c478bd9Sstevel@tonic-gate 	dtrace_attribute_t attr = _dtrace_defattr;
25907c478bd9Sstevel@tonic-gate 	dt_ident_t *idp;
25917c478bd9Sstevel@tonic-gate 	dtrace_syminfo_t dts;
25927c478bd9Sstevel@tonic-gate 	GElf_Sym sym;
25937c478bd9Sstevel@tonic-gate 
25947c478bd9Sstevel@tonic-gate 	const char *scope, *mark;
25957c478bd9Sstevel@tonic-gate 	uchar_t dnkind;
25967c478bd9Sstevel@tonic-gate 	char *name;
25977c478bd9Sstevel@tonic-gate 
25987c478bd9Sstevel@tonic-gate 	/*
25997c478bd9Sstevel@tonic-gate 	 * Look for scoping marks in the identifier.  If one is found, set our
26007c478bd9Sstevel@tonic-gate 	 * scope to either DTRACE_OBJ_KMODS or UMODS or to the first part of
26017c478bd9Sstevel@tonic-gate 	 * the string that specifies the scope using an explicit module name.
26027c478bd9Sstevel@tonic-gate 	 * If two marks in a row are found, set 'uref' (user symbol reference).
26037c478bd9Sstevel@tonic-gate 	 * Otherwise we set scope to DTRACE_OBJ_EXEC, indicating that normal
26047c478bd9Sstevel@tonic-gate 	 * scope is desired and we should search the specified idhash.
26057c478bd9Sstevel@tonic-gate 	 */
26067c478bd9Sstevel@tonic-gate 	if ((name = strrchr(dnp->dn_string, '`')) != NULL) {
26077c478bd9Sstevel@tonic-gate 		if (name > dnp->dn_string && name[-1] == '`') {
26087c478bd9Sstevel@tonic-gate 			uref++;
26097c478bd9Sstevel@tonic-gate 			name[-1] = '\0';
26107c478bd9Sstevel@tonic-gate 		}
26117c478bd9Sstevel@tonic-gate 
26127c478bd9Sstevel@tonic-gate 		if (name == dnp->dn_string + uref)
26137c478bd9Sstevel@tonic-gate 			scope = uref ? DTRACE_OBJ_UMODS : DTRACE_OBJ_KMODS;
26147c478bd9Sstevel@tonic-gate 		else
26157c478bd9Sstevel@tonic-gate 			scope = dnp->dn_string;
26167c478bd9Sstevel@tonic-gate 
26177c478bd9Sstevel@tonic-gate 		*name++ = '\0'; /* leave name pointing after scoping mark */
26187c478bd9Sstevel@tonic-gate 		dnkind = DT_NODE_VAR;
26197c478bd9Sstevel@tonic-gate 
26207c478bd9Sstevel@tonic-gate 	} else if (idkind == DT_IDENT_AGG) {
26217c478bd9Sstevel@tonic-gate 		scope = DTRACE_OBJ_EXEC;
26227c478bd9Sstevel@tonic-gate 		name = dnp->dn_string + 1;
26237c478bd9Sstevel@tonic-gate 		dnkind = DT_NODE_AGG;
26247c478bd9Sstevel@tonic-gate 	} else {
26257c478bd9Sstevel@tonic-gate 		scope = DTRACE_OBJ_EXEC;
26267c478bd9Sstevel@tonic-gate 		name = dnp->dn_string;
26277c478bd9Sstevel@tonic-gate 		dnkind = DT_NODE_VAR;
26287c478bd9Sstevel@tonic-gate 	}
26297c478bd9Sstevel@tonic-gate 
26307c478bd9Sstevel@tonic-gate 	/*
26317c478bd9Sstevel@tonic-gate 	 * If create is set to false, and we fail our idhash lookup, preset
26327c478bd9Sstevel@tonic-gate 	 * the errno code to EDT_NOVAR for our final error message below.
26337c478bd9Sstevel@tonic-gate 	 * If we end up calling dtrace_lookup_by_name(), it will reset the
26347c478bd9Sstevel@tonic-gate 	 * errno appropriately and that error will be reported instead.
26357c478bd9Sstevel@tonic-gate 	 */
26367c478bd9Sstevel@tonic-gate 	(void) dt_set_errno(dtp, EDT_NOVAR);
26377c478bd9Sstevel@tonic-gate 	mark = uref ? "``" : "`";
26387c478bd9Sstevel@tonic-gate 
26397c478bd9Sstevel@tonic-gate 	if (scope == DTRACE_OBJ_EXEC && (
26407c478bd9Sstevel@tonic-gate 	    (dhp != dtp->dt_globals &&
26417c478bd9Sstevel@tonic-gate 	    (idp = dt_idhash_lookup(dhp, name)) != NULL) ||
26427c478bd9Sstevel@tonic-gate 	    (dhp == dtp->dt_globals &&
26437c478bd9Sstevel@tonic-gate 	    (idp = dt_idstack_lookup(&yypcb->pcb_globals, name)) != NULL))) {
26447c478bd9Sstevel@tonic-gate 		/*
26457c478bd9Sstevel@tonic-gate 		 * Check that we are referencing the ident in the manner that
26467c478bd9Sstevel@tonic-gate 		 * matches its type if this is a global lookup.  In the TLS or
26477c478bd9Sstevel@tonic-gate 		 * local case, we don't know how the ident will be used until
26487c478bd9Sstevel@tonic-gate 		 * the time operator -> is seen; more parsing is needed.
26497c478bd9Sstevel@tonic-gate 		 */
26507c478bd9Sstevel@tonic-gate 		if (idp->di_kind != idkind && dhp == dtp->dt_globals) {
26517c478bd9Sstevel@tonic-gate 			xyerror(D_IDENT_BADREF, "%s '%s' may not be referenced "
26527c478bd9Sstevel@tonic-gate 			    "as %s\n", dt_idkind_name(idp->di_kind),
26537c478bd9Sstevel@tonic-gate 			    idp->di_name, dt_idkind_name(idkind));
26547c478bd9Sstevel@tonic-gate 		}
26557c478bd9Sstevel@tonic-gate 
26567c478bd9Sstevel@tonic-gate 		/*
26577c478bd9Sstevel@tonic-gate 		 * Arrays and aggregations are not cooked individually. They
26587c478bd9Sstevel@tonic-gate 		 * have dynamic types and must be referenced using operator [].
26597c478bd9Sstevel@tonic-gate 		 * This is handled explicitly by the code for DT_TOK_LBRAC.
26607c478bd9Sstevel@tonic-gate 		 */
26617c478bd9Sstevel@tonic-gate 		if (idp->di_kind != DT_IDENT_ARRAY &&
26627c478bd9Sstevel@tonic-gate 		    idp->di_kind != DT_IDENT_AGG)
26637c478bd9Sstevel@tonic-gate 			attr = dt_ident_cook(dnp, idp, NULL);
26647c478bd9Sstevel@tonic-gate 		else {
26657c478bd9Sstevel@tonic-gate 			dt_node_type_assign(dnp,
26667c478bd9Sstevel@tonic-gate 			    DT_DYN_CTFP(dtp), DT_DYN_TYPE(dtp));
26677c478bd9Sstevel@tonic-gate 			attr = idp->di_attr;
26687c478bd9Sstevel@tonic-gate 		}
26697c478bd9Sstevel@tonic-gate 
26707c478bd9Sstevel@tonic-gate 		free(dnp->dn_string);
26717c478bd9Sstevel@tonic-gate 		dnp->dn_string = NULL;
26727c478bd9Sstevel@tonic-gate 		dnp->dn_kind = dnkind;
26737c478bd9Sstevel@tonic-gate 		dnp->dn_ident = idp;
26747c478bd9Sstevel@tonic-gate 		dnp->dn_flags |= DT_NF_LVALUE;
26757c478bd9Sstevel@tonic-gate 
26767c478bd9Sstevel@tonic-gate 		if (idp->di_flags & DT_IDFLG_WRITE)
26777c478bd9Sstevel@tonic-gate 			dnp->dn_flags |= DT_NF_WRITABLE;
26787c478bd9Sstevel@tonic-gate 
26797c478bd9Sstevel@tonic-gate 		dt_node_attr_assign(dnp, attr);
26807c478bd9Sstevel@tonic-gate 
26817c478bd9Sstevel@tonic-gate 	} else if (dhp == dtp->dt_globals && scope != DTRACE_OBJ_EXEC &&
26827c478bd9Sstevel@tonic-gate 	    dtrace_lookup_by_name(dtp, scope, name, &sym, &dts) == 0) {
26837c478bd9Sstevel@tonic-gate 
26847c478bd9Sstevel@tonic-gate 		dt_module_t *mp = dt_module_lookup_by_name(dtp, dts.dts_object);
26857c478bd9Sstevel@tonic-gate 		int umod = (mp->dm_flags & DT_DM_KERNEL) == 0;
26867c478bd9Sstevel@tonic-gate 		static const char *const kunames[] = { "kernel", "user" };
26877c478bd9Sstevel@tonic-gate 
26887c478bd9Sstevel@tonic-gate 		dtrace_typeinfo_t dtt;
26897c478bd9Sstevel@tonic-gate 		dtrace_syminfo_t *sip;
26907c478bd9Sstevel@tonic-gate 
26917c478bd9Sstevel@tonic-gate 		if (uref ^ umod) {
26927c478bd9Sstevel@tonic-gate 			xyerror(D_SYM_BADREF, "%s module '%s' symbol '%s' may "
26937c478bd9Sstevel@tonic-gate 			    "not be referenced as a %s symbol\n", kunames[umod],
26947c478bd9Sstevel@tonic-gate 			    dts.dts_object, dts.dts_name, kunames[uref]);
26957c478bd9Sstevel@tonic-gate 		}
26967c478bd9Sstevel@tonic-gate 
26977c478bd9Sstevel@tonic-gate 		if (dtrace_symbol_type(dtp, &sym, &dts, &dtt) != 0) {
26987c478bd9Sstevel@tonic-gate 			/*
26997c478bd9Sstevel@tonic-gate 			 * For now, we special-case EDT_DATAMODEL to clarify
27007c478bd9Sstevel@tonic-gate 			 * that mixed data models are not currently supported.
27017c478bd9Sstevel@tonic-gate 			 */
27027c478bd9Sstevel@tonic-gate 			if (dtp->dt_errno == EDT_DATAMODEL) {
27037c478bd9Sstevel@tonic-gate 				xyerror(D_SYM_MODEL, "cannot use %s symbol "
27047c478bd9Sstevel@tonic-gate 				    "%s%s%s in a %s D program\n",
27057c478bd9Sstevel@tonic-gate 				    dt_module_modelname(mp),
27067c478bd9Sstevel@tonic-gate 				    dts.dts_object, mark, dts.dts_name,
27077c478bd9Sstevel@tonic-gate 				    dt_module_modelname(dtp->dt_ddefs));
27087c478bd9Sstevel@tonic-gate 			}
27097c478bd9Sstevel@tonic-gate 
27107c478bd9Sstevel@tonic-gate 			xyerror(D_SYM_NOTYPES,
27117c478bd9Sstevel@tonic-gate 			    "no symbolic type information is available for "
27127c478bd9Sstevel@tonic-gate 			    "%s%s%s: %s\n", dts.dts_object, mark, dts.dts_name,
27137c478bd9Sstevel@tonic-gate 			    dtrace_errmsg(dtp, dtrace_errno(dtp)));
27147c478bd9Sstevel@tonic-gate 		}
27157c478bd9Sstevel@tonic-gate 
27167c478bd9Sstevel@tonic-gate 		idp = dt_ident_create(name, DT_IDENT_SYMBOL, 0, 0,
27177c478bd9Sstevel@tonic-gate 		    _dtrace_symattr, 0, &dt_idops_thaw, NULL, dtp->dt_gen);
27187c478bd9Sstevel@tonic-gate 
27197c478bd9Sstevel@tonic-gate 		if (idp == NULL)
27207c478bd9Sstevel@tonic-gate 			longjmp(yypcb->pcb_jmpbuf, EDT_NOMEM);
27217c478bd9Sstevel@tonic-gate 
27227c478bd9Sstevel@tonic-gate 		if (mp->dm_flags & DT_DM_PRIMARY)
27237c478bd9Sstevel@tonic-gate 			idp->di_flags |= DT_IDFLG_PRIM;
27247c478bd9Sstevel@tonic-gate 
27257c478bd9Sstevel@tonic-gate 		idp->di_next = dtp->dt_externs;
27267c478bd9Sstevel@tonic-gate 		dtp->dt_externs = idp;
27277c478bd9Sstevel@tonic-gate 
27287c478bd9Sstevel@tonic-gate 		if ((sip = malloc(sizeof (dtrace_syminfo_t))) == NULL)
27297c478bd9Sstevel@tonic-gate 			longjmp(yypcb->pcb_jmpbuf, EDT_NOMEM);
27307c478bd9Sstevel@tonic-gate 
27317c478bd9Sstevel@tonic-gate 		bcopy(&dts, sip, sizeof (dtrace_syminfo_t));
27327c478bd9Sstevel@tonic-gate 		idp->di_data = sip;
27337c478bd9Sstevel@tonic-gate 		idp->di_ctfp = dtt.dtt_ctfp;
27347c478bd9Sstevel@tonic-gate 		idp->di_type = dtt.dtt_type;
27357c478bd9Sstevel@tonic-gate 
27367c478bd9Sstevel@tonic-gate 		free(dnp->dn_string);
27377c478bd9Sstevel@tonic-gate 		dnp->dn_string = NULL;
27387c478bd9Sstevel@tonic-gate 		dnp->dn_kind = DT_NODE_SYM;
27397c478bd9Sstevel@tonic-gate 		dnp->dn_ident = idp;
27407c478bd9Sstevel@tonic-gate 		dnp->dn_flags |= DT_NF_LVALUE;
27417c478bd9Sstevel@tonic-gate 
27427c478bd9Sstevel@tonic-gate 		dt_node_type_assign(dnp, dtt.dtt_ctfp, dtt.dtt_type);
27437c478bd9Sstevel@tonic-gate 		dt_node_attr_assign(dnp, _dtrace_symattr);
27447c478bd9Sstevel@tonic-gate 
27457c478bd9Sstevel@tonic-gate 		if (uref) {
27467c478bd9Sstevel@tonic-gate 			idp->di_flags |= DT_IDFLG_USER;
27477c478bd9Sstevel@tonic-gate 			dnp->dn_flags |= DT_NF_USERLAND;
27487c478bd9Sstevel@tonic-gate 		}
27497c478bd9Sstevel@tonic-gate 
27507c478bd9Sstevel@tonic-gate 	} else if (scope == DTRACE_OBJ_EXEC && create == B_TRUE) {
27517c478bd9Sstevel@tonic-gate 		uint_t flags = DT_IDFLG_WRITE;
27527c478bd9Sstevel@tonic-gate 		uint_t id;
27537c478bd9Sstevel@tonic-gate 
27547c478bd9Sstevel@tonic-gate 		if (dt_idhash_nextid(dhp, &id) == -1) {
27557c478bd9Sstevel@tonic-gate 			xyerror(D_ID_OFLOW, "cannot create %s: limit on number "
27567c478bd9Sstevel@tonic-gate 			    "of %s variables exceeded\n", name, sname);
27577c478bd9Sstevel@tonic-gate 		}
27587c478bd9Sstevel@tonic-gate 
27597c478bd9Sstevel@tonic-gate 		if (dhp == yypcb->pcb_locals)
27607c478bd9Sstevel@tonic-gate 			flags |= DT_IDFLG_LOCAL;
27617c478bd9Sstevel@tonic-gate 		else if (dhp == dtp->dt_tls)
27627c478bd9Sstevel@tonic-gate 			flags |= DT_IDFLG_TLS;
27637c478bd9Sstevel@tonic-gate 
27647c478bd9Sstevel@tonic-gate 		dt_dprintf("create %s %s variable %s, id=%u\n",
27657c478bd9Sstevel@tonic-gate 		    sname, dt_idkind_name(idkind), name, id);
27667c478bd9Sstevel@tonic-gate 
27677c478bd9Sstevel@tonic-gate 		if (idkind == DT_IDENT_ARRAY || idkind == DT_IDENT_AGG) {
27687c478bd9Sstevel@tonic-gate 			idp = dt_idhash_insert(dhp, name,
27697c478bd9Sstevel@tonic-gate 			    idkind, flags, id, _dtrace_defattr, 0,
27707c478bd9Sstevel@tonic-gate 			    &dt_idops_assc, NULL, dtp->dt_gen);
27717c478bd9Sstevel@tonic-gate 		} else {
27727c478bd9Sstevel@tonic-gate 			idp = dt_idhash_insert(dhp, name,
27737c478bd9Sstevel@tonic-gate 			    idkind, flags, id, _dtrace_defattr, 0,
27747c478bd9Sstevel@tonic-gate 			    &dt_idops_thaw, NULL, dtp->dt_gen);
27757c478bd9Sstevel@tonic-gate 		}
27767c478bd9Sstevel@tonic-gate 
27777c478bd9Sstevel@tonic-gate 		if (idp == NULL)
27787c478bd9Sstevel@tonic-gate 			longjmp(yypcb->pcb_jmpbuf, EDT_NOMEM);
27797c478bd9Sstevel@tonic-gate 
27807c478bd9Sstevel@tonic-gate 		/*
27817c478bd9Sstevel@tonic-gate 		 * Arrays and aggregations are not cooked individually. They
27827c478bd9Sstevel@tonic-gate 		 * have dynamic types and must be referenced using operator [].
27837c478bd9Sstevel@tonic-gate 		 * This is handled explicitly by the code for DT_TOK_LBRAC.
27847c478bd9Sstevel@tonic-gate 		 */
27857c478bd9Sstevel@tonic-gate 		if (idp->di_kind != DT_IDENT_ARRAY &&
27867c478bd9Sstevel@tonic-gate 		    idp->di_kind != DT_IDENT_AGG)
27877c478bd9Sstevel@tonic-gate 			attr = dt_ident_cook(dnp, idp, NULL);
27887c478bd9Sstevel@tonic-gate 		else {
27897c478bd9Sstevel@tonic-gate 			dt_node_type_assign(dnp,
27907c478bd9Sstevel@tonic-gate 			    DT_DYN_CTFP(dtp), DT_DYN_TYPE(dtp));
27917c478bd9Sstevel@tonic-gate 			attr = idp->di_attr;
27927c478bd9Sstevel@tonic-gate 		}
27937c478bd9Sstevel@tonic-gate 
27947c478bd9Sstevel@tonic-gate 		free(dnp->dn_string);
27957c478bd9Sstevel@tonic-gate 		dnp->dn_string = NULL;
27967c478bd9Sstevel@tonic-gate 		dnp->dn_kind = dnkind;
27977c478bd9Sstevel@tonic-gate 		dnp->dn_ident = idp;
27987c478bd9Sstevel@tonic-gate 		dnp->dn_flags |= DT_NF_LVALUE | DT_NF_WRITABLE;
27997c478bd9Sstevel@tonic-gate 
28007c478bd9Sstevel@tonic-gate 		dt_node_attr_assign(dnp, attr);
28017c478bd9Sstevel@tonic-gate 
28027c478bd9Sstevel@tonic-gate 	} else if (scope != DTRACE_OBJ_EXEC) {
28037c478bd9Sstevel@tonic-gate 		xyerror(D_IDENT_UNDEF, "failed to resolve %s%s%s: %s\n",
28047c478bd9Sstevel@tonic-gate 		    dnp->dn_string, mark, name,
28057c478bd9Sstevel@tonic-gate 		    dtrace_errmsg(dtp, dtrace_errno(dtp)));
28067c478bd9Sstevel@tonic-gate 	} else {
28077c478bd9Sstevel@tonic-gate 		xyerror(D_IDENT_UNDEF, "failed to resolve %s: %s\n",
28087c478bd9Sstevel@tonic-gate 		    dnp->dn_string, dtrace_errmsg(dtp, dtrace_errno(dtp)));
28097c478bd9Sstevel@tonic-gate 	}
28107c478bd9Sstevel@tonic-gate }
28117c478bd9Sstevel@tonic-gate 
28127c478bd9Sstevel@tonic-gate static dt_node_t *
28137c478bd9Sstevel@tonic-gate dt_cook_ident(dt_node_t *dnp, uint_t idflags)
28147c478bd9Sstevel@tonic-gate {
28157c478bd9Sstevel@tonic-gate 	dtrace_hdl_t *dtp = yypcb->pcb_hdl;
28167c478bd9Sstevel@tonic-gate 
28177c478bd9Sstevel@tonic-gate 	if (dnp->dn_op == DT_TOK_AGG)
28187c478bd9Sstevel@tonic-gate 		dt_xcook_ident(dnp, dtp->dt_aggs, DT_IDENT_AGG, B_FALSE);
28197c478bd9Sstevel@tonic-gate 	else
28207c478bd9Sstevel@tonic-gate 		dt_xcook_ident(dnp, dtp->dt_globals, DT_IDENT_SCALAR, B_FALSE);
28217c478bd9Sstevel@tonic-gate 
28227c478bd9Sstevel@tonic-gate 	return (dt_node_cook(dnp, idflags));
28237c478bd9Sstevel@tonic-gate }
28247c478bd9Sstevel@tonic-gate 
28257c478bd9Sstevel@tonic-gate /*
28267c478bd9Sstevel@tonic-gate  * Since operators [ and -> can instantiate new variables before we know
28277c478bd9Sstevel@tonic-gate  * whether the reference is for a read or a write, we need to check read
28287c478bd9Sstevel@tonic-gate  * references to determine if the identifier is currently dt_ident_unref().
28297c478bd9Sstevel@tonic-gate  * If so, we report that this first access was to an undefined variable.
28307c478bd9Sstevel@tonic-gate  */
28317c478bd9Sstevel@tonic-gate static dt_node_t *
28327c478bd9Sstevel@tonic-gate dt_cook_var(dt_node_t *dnp, uint_t idflags)
28337c478bd9Sstevel@tonic-gate {
28347c478bd9Sstevel@tonic-gate 	dt_ident_t *idp = dnp->dn_ident;
28357c478bd9Sstevel@tonic-gate 
28367c478bd9Sstevel@tonic-gate 	if ((idflags & DT_IDFLG_REF) && dt_ident_unref(idp)) {
28377c478bd9Sstevel@tonic-gate 		dnerror(dnp, D_VAR_UNDEF,
28387c478bd9Sstevel@tonic-gate 		    "%s%s has not yet been declared or assigned\n",
28397c478bd9Sstevel@tonic-gate 		    (idp->di_flags & DT_IDFLG_LOCAL) ? "this->" :
28407c478bd9Sstevel@tonic-gate 		    (idp->di_flags & DT_IDFLG_TLS) ? "self->" : "",
28417c478bd9Sstevel@tonic-gate 		    idp->di_name);
28427c478bd9Sstevel@tonic-gate 	}
28437c478bd9Sstevel@tonic-gate 
28447c478bd9Sstevel@tonic-gate 	dt_node_attr_assign(dnp, dt_ident_cook(dnp, idp, &dnp->dn_args));
28457c478bd9Sstevel@tonic-gate 	return (dnp);
28467c478bd9Sstevel@tonic-gate }
28477c478bd9Sstevel@tonic-gate 
28487c478bd9Sstevel@tonic-gate /*ARGSUSED*/
28497c478bd9Sstevel@tonic-gate static dt_node_t *
28507c478bd9Sstevel@tonic-gate dt_cook_func(dt_node_t *dnp, uint_t idflags)
28517c478bd9Sstevel@tonic-gate {
28527c478bd9Sstevel@tonic-gate 	dt_node_attr_assign(dnp,
28537c478bd9Sstevel@tonic-gate 	    dt_ident_cook(dnp, dnp->dn_ident, &dnp->dn_args));
28547c478bd9Sstevel@tonic-gate 
28557c478bd9Sstevel@tonic-gate 	return (dnp);
28567c478bd9Sstevel@tonic-gate }
28577c478bd9Sstevel@tonic-gate 
28587c478bd9Sstevel@tonic-gate static dt_node_t *
28597c478bd9Sstevel@tonic-gate dt_cook_op1(dt_node_t *dnp, uint_t idflags)
28607c478bd9Sstevel@tonic-gate {
28617c478bd9Sstevel@tonic-gate 	dtrace_hdl_t *dtp = yypcb->pcb_hdl;
28627c478bd9Sstevel@tonic-gate 	dt_node_t *cp = dnp->dn_child;
28637c478bd9Sstevel@tonic-gate 
28647c478bd9Sstevel@tonic-gate 	char n[DT_TYPE_NAMELEN];
28657c478bd9Sstevel@tonic-gate 	dtrace_typeinfo_t dtt;
28667c478bd9Sstevel@tonic-gate 	dt_ident_t *idp;
28677c478bd9Sstevel@tonic-gate 
28687c478bd9Sstevel@tonic-gate 	ctf_encoding_t e;
28697c478bd9Sstevel@tonic-gate 	ctf_arinfo_t r;
28707c478bd9Sstevel@tonic-gate 	ctf_id_t type, base;
28717c478bd9Sstevel@tonic-gate 	uint_t kind;
28727c478bd9Sstevel@tonic-gate 
28737c478bd9Sstevel@tonic-gate 	if (dnp->dn_op == DT_TOK_PREINC || dnp->dn_op == DT_TOK_POSTINC ||
28747c478bd9Sstevel@tonic-gate 	    dnp->dn_op == DT_TOK_PREDEC || dnp->dn_op == DT_TOK_POSTDEC)
28757c478bd9Sstevel@tonic-gate 		idflags = DT_IDFLG_REF | DT_IDFLG_MOD;
28767c478bd9Sstevel@tonic-gate 	else
28777c478bd9Sstevel@tonic-gate 		idflags = DT_IDFLG_REF;
28787c478bd9Sstevel@tonic-gate 
28797c478bd9Sstevel@tonic-gate 	/*
28807c478bd9Sstevel@tonic-gate 	 * We allow the unary ++ and -- operators to instantiate new scalar
28817c478bd9Sstevel@tonic-gate 	 * variables if applied to an identifier; otherwise just cook as usual.
28827c478bd9Sstevel@tonic-gate 	 */
28837c478bd9Sstevel@tonic-gate 	if (cp->dn_kind == DT_NODE_IDENT && (idflags & DT_IDFLG_MOD))
28847c478bd9Sstevel@tonic-gate 		dt_xcook_ident(cp, dtp->dt_globals, DT_IDENT_SCALAR, B_TRUE);
28857c478bd9Sstevel@tonic-gate 
28867c478bd9Sstevel@tonic-gate 	cp = dnp->dn_child = dt_node_cook(cp, 0); /* don't set idflags yet */
28877c478bd9Sstevel@tonic-gate 
28887c478bd9Sstevel@tonic-gate 	if (cp->dn_kind == DT_NODE_VAR && dt_ident_unref(cp->dn_ident)) {
28897c478bd9Sstevel@tonic-gate 		if (dt_type_lookup("int64_t", &dtt) != 0)
28907c478bd9Sstevel@tonic-gate 			xyerror(D_TYPE_ERR, "failed to lookup int64_t\n");
28917c478bd9Sstevel@tonic-gate 
28927c478bd9Sstevel@tonic-gate 		dt_ident_type_assign(cp->dn_ident, dtt.dtt_ctfp, dtt.dtt_type);
28937c478bd9Sstevel@tonic-gate 		dt_node_type_assign(cp, dtt.dtt_ctfp, dtt.dtt_type);
28947c478bd9Sstevel@tonic-gate 	}
28957c478bd9Sstevel@tonic-gate 
28967c478bd9Sstevel@tonic-gate 	if (cp->dn_kind == DT_NODE_VAR)
28977c478bd9Sstevel@tonic-gate 		cp->dn_ident->di_flags |= idflags;
28987c478bd9Sstevel@tonic-gate 
28997c478bd9Sstevel@tonic-gate 	switch (dnp->dn_op) {
29007c478bd9Sstevel@tonic-gate 	case DT_TOK_DEREF:
29017c478bd9Sstevel@tonic-gate 		/*
29027c478bd9Sstevel@tonic-gate 		 * If the deref operator is applied to a translated pointer,
2903*e5803b76SAdam H. Leventhal 		 * we set our output type to the output of the translation.
29047c478bd9Sstevel@tonic-gate 		 */
29057c478bd9Sstevel@tonic-gate 		if ((idp = dt_node_resolve(cp, DT_IDENT_XLPTR)) != NULL) {
29067c478bd9Sstevel@tonic-gate 			dt_xlator_t *dxp = idp->di_data;
29077c478bd9Sstevel@tonic-gate 
29087c478bd9Sstevel@tonic-gate 			dnp->dn_ident = &dxp->dx_souid;
29097c478bd9Sstevel@tonic-gate 			dt_node_type_assign(dnp,
2910*e5803b76SAdam H. Leventhal 			    dnp->dn_ident->di_ctfp, dnp->dn_ident->di_type);
29117c478bd9Sstevel@tonic-gate 			break;
29127c478bd9Sstevel@tonic-gate 		}
29137c478bd9Sstevel@tonic-gate 
29147c478bd9Sstevel@tonic-gate 		type = ctf_type_resolve(cp->dn_ctfp, cp->dn_type);
29157c478bd9Sstevel@tonic-gate 		kind = ctf_type_kind(cp->dn_ctfp, type);
29167c478bd9Sstevel@tonic-gate 
29177c478bd9Sstevel@tonic-gate 		if (kind == CTF_K_ARRAY) {
29187c478bd9Sstevel@tonic-gate 			if (ctf_array_info(cp->dn_ctfp, type, &r) != 0) {
29197c478bd9Sstevel@tonic-gate 				dtp->dt_ctferr = ctf_errno(cp->dn_ctfp);
29207c478bd9Sstevel@tonic-gate 				longjmp(yypcb->pcb_jmpbuf, EDT_CTF);
29217c478bd9Sstevel@tonic-gate 			} else
29227c478bd9Sstevel@tonic-gate 				type = r.ctr_contents;
29237c478bd9Sstevel@tonic-gate 		} else if (kind == CTF_K_POINTER) {
29247c478bd9Sstevel@tonic-gate 			type = ctf_type_reference(cp->dn_ctfp, type);
29257c478bd9Sstevel@tonic-gate 		} else {
29267c478bd9Sstevel@tonic-gate 			xyerror(D_DEREF_NONPTR,
29277c478bd9Sstevel@tonic-gate 			    "cannot dereference non-pointer type\n");
29287c478bd9Sstevel@tonic-gate 		}
29297c478bd9Sstevel@tonic-gate 
29307c478bd9Sstevel@tonic-gate 		dt_node_type_assign(dnp, cp->dn_ctfp, type);
29317c478bd9Sstevel@tonic-gate 		base = ctf_type_resolve(cp->dn_ctfp, type);
29327c478bd9Sstevel@tonic-gate 		kind = ctf_type_kind(cp->dn_ctfp, base);
29337c478bd9Sstevel@tonic-gate 
29347c478bd9Sstevel@tonic-gate 		if (kind == CTF_K_INTEGER && ctf_type_encoding(cp->dn_ctfp,
29357c478bd9Sstevel@tonic-gate 		    base, &e) == 0 && IS_VOID(e)) {
29367c478bd9Sstevel@tonic-gate 			xyerror(D_DEREF_VOID,
29377c478bd9Sstevel@tonic-gate 			    "cannot dereference pointer to void\n");
29387c478bd9Sstevel@tonic-gate 		}
29397c478bd9Sstevel@tonic-gate 
29407c478bd9Sstevel@tonic-gate 		if (kind == CTF_K_FUNCTION) {
29417c478bd9Sstevel@tonic-gate 			xyerror(D_DEREF_FUNC,
29427c478bd9Sstevel@tonic-gate 			    "cannot dereference pointer to function\n");
29437c478bd9Sstevel@tonic-gate 		}
29447c478bd9Sstevel@tonic-gate 
29457c478bd9Sstevel@tonic-gate 		if (kind != CTF_K_ARRAY || dt_node_is_string(dnp))
29467c478bd9Sstevel@tonic-gate 			dnp->dn_flags |= DT_NF_LVALUE; /* see K&R[A7.4.3] */
29477c478bd9Sstevel@tonic-gate 
29487c478bd9Sstevel@tonic-gate 		/*
29497c478bd9Sstevel@tonic-gate 		 * If we propagated the l-value bit and the child operand was
29507c478bd9Sstevel@tonic-gate 		 * a writable D variable or a binary operation of the form
29517c478bd9Sstevel@tonic-gate 		 * a + b where a is writable, then propagate the writable bit.
29527c478bd9Sstevel@tonic-gate 		 * This is necessary to permit assignments to scalar arrays,
29537c478bd9Sstevel@tonic-gate 		 * which are converted to expressions of the form *(a + i).
29547c478bd9Sstevel@tonic-gate 		 */
29557c478bd9Sstevel@tonic-gate 		if ((cp->dn_flags & DT_NF_WRITABLE) ||
29567c478bd9Sstevel@tonic-gate 		    (cp->dn_kind == DT_NODE_OP2 && cp->dn_op == DT_TOK_ADD &&
29577c478bd9Sstevel@tonic-gate 		    (cp->dn_left->dn_flags & DT_NF_WRITABLE)))
29587c478bd9Sstevel@tonic-gate 			dnp->dn_flags |= DT_NF_WRITABLE;
29597c478bd9Sstevel@tonic-gate 
29607c478bd9Sstevel@tonic-gate 		if ((cp->dn_flags & DT_NF_USERLAND) &&
29617c478bd9Sstevel@tonic-gate 		    (kind == CTF_K_POINTER || (dnp->dn_flags & DT_NF_REF)))
29627c478bd9Sstevel@tonic-gate 			dnp->dn_flags |= DT_NF_USERLAND;
29637c478bd9Sstevel@tonic-gate 		break;
29647c478bd9Sstevel@tonic-gate 
29657c478bd9Sstevel@tonic-gate 	case DT_TOK_IPOS:
29667c478bd9Sstevel@tonic-gate 	case DT_TOK_INEG:
29677c478bd9Sstevel@tonic-gate 		if (!dt_node_is_arith(cp)) {
29687c478bd9Sstevel@tonic-gate 			xyerror(D_OP_ARITH, "operator %s requires an operand "
29697c478bd9Sstevel@tonic-gate 			    "of arithmetic type\n", opstr(dnp->dn_op));
29707c478bd9Sstevel@tonic-gate 		}
29717c478bd9Sstevel@tonic-gate 		dt_node_type_propagate(cp, dnp); /* see K&R[A7.4.4-6] */
29727c478bd9Sstevel@tonic-gate 		break;
29737c478bd9Sstevel@tonic-gate 
29747c478bd9Sstevel@tonic-gate 	case DT_TOK_BNEG:
29757c478bd9Sstevel@tonic-gate 		if (!dt_node_is_integer(cp)) {
29767c478bd9Sstevel@tonic-gate 			xyerror(D_OP_INT, "operator %s requires an operand of "
29777c478bd9Sstevel@tonic-gate 			    "integral type\n", opstr(dnp->dn_op));
29787c478bd9Sstevel@tonic-gate 		}
29797c478bd9Sstevel@tonic-gate 		dt_node_type_propagate(cp, dnp); /* see K&R[A7.4.4-6] */
29807c478bd9Sstevel@tonic-gate 		break;
29817c478bd9Sstevel@tonic-gate 
29827c478bd9Sstevel@tonic-gate 	case DT_TOK_LNEG:
29837c478bd9Sstevel@tonic-gate 		if (!dt_node_is_scalar(cp)) {
29847c478bd9Sstevel@tonic-gate 			xyerror(D_OP_SCALAR, "operator %s requires an operand "
29857c478bd9Sstevel@tonic-gate 			    "of scalar type\n", opstr(dnp->dn_op));
29867c478bd9Sstevel@tonic-gate 		}
29877c478bd9Sstevel@tonic-gate 		dt_node_type_assign(dnp, DT_INT_CTFP(dtp), DT_INT_TYPE(dtp));
29887c478bd9Sstevel@tonic-gate 		break;
29897c478bd9Sstevel@tonic-gate 
29907c478bd9Sstevel@tonic-gate 	case DT_TOK_ADDROF:
29917c478bd9Sstevel@tonic-gate 		if (cp->dn_kind == DT_NODE_VAR || cp->dn_kind == DT_NODE_AGG) {
29927c478bd9Sstevel@tonic-gate 			xyerror(D_ADDROF_VAR,
29937c478bd9Sstevel@tonic-gate 			    "cannot take address of dynamic variable\n");
29947c478bd9Sstevel@tonic-gate 		}
29957c478bd9Sstevel@tonic-gate 
29967c478bd9Sstevel@tonic-gate 		if (dt_node_is_dynamic(cp)) {
29977c478bd9Sstevel@tonic-gate 			xyerror(D_ADDROF_VAR,
29987c478bd9Sstevel@tonic-gate 			    "cannot take address of dynamic object\n");
29997c478bd9Sstevel@tonic-gate 		}
30007c478bd9Sstevel@tonic-gate 
30017c478bd9Sstevel@tonic-gate 		if (!(cp->dn_flags & DT_NF_LVALUE)) {
30027c478bd9Sstevel@tonic-gate 			xyerror(D_ADDROF_LVAL, /* see K&R[A7.4.2] */
30037c478bd9Sstevel@tonic-gate 			    "unacceptable operand for unary & operator\n");
30047c478bd9Sstevel@tonic-gate 		}
30057c478bd9Sstevel@tonic-gate 
30067c478bd9Sstevel@tonic-gate 		if (cp->dn_flags & DT_NF_BITFIELD) {
30077c478bd9Sstevel@tonic-gate 			xyerror(D_ADDROF_BITFIELD,
30087c478bd9Sstevel@tonic-gate 			    "cannot take address of bit-field\n");
30097c478bd9Sstevel@tonic-gate 		}
30107c478bd9Sstevel@tonic-gate 
30117c478bd9Sstevel@tonic-gate 		dtt.dtt_object = NULL;
30127c478bd9Sstevel@tonic-gate 		dtt.dtt_ctfp = cp->dn_ctfp;
30137c478bd9Sstevel@tonic-gate 		dtt.dtt_type = cp->dn_type;
30147c478bd9Sstevel@tonic-gate 
30157c478bd9Sstevel@tonic-gate 		if (dt_type_pointer(&dtt) == -1) {
30167c478bd9Sstevel@tonic-gate 			xyerror(D_TYPE_ERR, "cannot find type for \"&\": %s*\n",
30177c478bd9Sstevel@tonic-gate 			    dt_node_type_name(cp, n, sizeof (n)));
30187c478bd9Sstevel@tonic-gate 		}
30197c478bd9Sstevel@tonic-gate 
30207c478bd9Sstevel@tonic-gate 		dt_node_type_assign(dnp, dtt.dtt_ctfp, dtt.dtt_type);
30217c478bd9Sstevel@tonic-gate 
30227c478bd9Sstevel@tonic-gate 		if (cp->dn_flags & DT_NF_USERLAND)
30237c478bd9Sstevel@tonic-gate 			dnp->dn_flags |= DT_NF_USERLAND;
30247c478bd9Sstevel@tonic-gate 		break;
30257c478bd9Sstevel@tonic-gate 
30267c478bd9Sstevel@tonic-gate 	case DT_TOK_SIZEOF:
30277c478bd9Sstevel@tonic-gate 		if (cp->dn_flags & DT_NF_BITFIELD) {
30287c478bd9Sstevel@tonic-gate 			xyerror(D_SIZEOF_BITFIELD,
30297c478bd9Sstevel@tonic-gate 			    "cannot apply sizeof to a bit-field\n");
30307c478bd9Sstevel@tonic-gate 		}
30317c478bd9Sstevel@tonic-gate 
30327c478bd9Sstevel@tonic-gate 		if (dt_node_sizeof(cp) == 0) {
30337c478bd9Sstevel@tonic-gate 			xyerror(D_SIZEOF_TYPE, "cannot apply sizeof to an "
30347c478bd9Sstevel@tonic-gate 			    "operand of unknown size\n");
30357c478bd9Sstevel@tonic-gate 		}
30367c478bd9Sstevel@tonic-gate 
30377c478bd9Sstevel@tonic-gate 		dt_node_type_assign(dnp, dtp->dt_ddefs->dm_ctfp,
30387c478bd9Sstevel@tonic-gate 		    ctf_lookup_by_name(dtp->dt_ddefs->dm_ctfp, "size_t"));
30397c478bd9Sstevel@tonic-gate 		break;
30407c478bd9Sstevel@tonic-gate 
30417c478bd9Sstevel@tonic-gate 	case DT_TOK_STRINGOF:
30427c478bd9Sstevel@tonic-gate 		if (!dt_node_is_scalar(cp) && !dt_node_is_pointer(cp) &&
30437c478bd9Sstevel@tonic-gate 		    !dt_node_is_strcompat(cp)) {
30447c478bd9Sstevel@tonic-gate 			xyerror(D_STRINGOF_TYPE,
30457c478bd9Sstevel@tonic-gate 			    "cannot apply stringof to a value of type %s\n",
30467c478bd9Sstevel@tonic-gate 			    dt_node_type_name(cp, n, sizeof (n)));
30477c478bd9Sstevel@tonic-gate 		}
30487c478bd9Sstevel@tonic-gate 		dt_node_type_assign(dnp, DT_STR_CTFP(dtp), DT_STR_TYPE(dtp));
30497c478bd9Sstevel@tonic-gate 		break;
30507c478bd9Sstevel@tonic-gate 
30517c478bd9Sstevel@tonic-gate 	case DT_TOK_PREINC:
30527c478bd9Sstevel@tonic-gate 	case DT_TOK_POSTINC:
30537c478bd9Sstevel@tonic-gate 	case DT_TOK_PREDEC:
30547c478bd9Sstevel@tonic-gate 	case DT_TOK_POSTDEC:
30557c478bd9Sstevel@tonic-gate 		if (dt_node_is_scalar(cp) == 0) {
30567c478bd9Sstevel@tonic-gate 			xyerror(D_OP_SCALAR, "operator %s requires operand of "
30577c478bd9Sstevel@tonic-gate 			    "scalar type\n", opstr(dnp->dn_op));
30587c478bd9Sstevel@tonic-gate 		}
30597c478bd9Sstevel@tonic-gate 
30607c478bd9Sstevel@tonic-gate 		if (dt_node_is_vfptr(cp)) {
30617c478bd9Sstevel@tonic-gate 			xyerror(D_OP_VFPTR, "operator %s requires an operand "
30627c478bd9Sstevel@tonic-gate 			    "of known size\n", opstr(dnp->dn_op));
30637c478bd9Sstevel@tonic-gate 		}
30647c478bd9Sstevel@tonic-gate 
30657c478bd9Sstevel@tonic-gate 		if (!(cp->dn_flags & DT_NF_LVALUE)) {
30667c478bd9Sstevel@tonic-gate 			xyerror(D_OP_LVAL, "operator %s requires modifiable "
30677c478bd9Sstevel@tonic-gate 			    "lvalue as an operand\n", opstr(dnp->dn_op));
30687c478bd9Sstevel@tonic-gate 		}
30697c478bd9Sstevel@tonic-gate 
30707c478bd9Sstevel@tonic-gate 		if (!(cp->dn_flags & DT_NF_WRITABLE)) {
30717c478bd9Sstevel@tonic-gate 			xyerror(D_OP_WRITE, "operator %s can only be applied "
30727c478bd9Sstevel@tonic-gate 			    "to a writable variable\n", opstr(dnp->dn_op));
30737c478bd9Sstevel@tonic-gate 		}
30747c478bd9Sstevel@tonic-gate 
30757c478bd9Sstevel@tonic-gate 		dt_node_type_propagate(cp, dnp); /* see K&R[A7.4.1] */
30767c478bd9Sstevel@tonic-gate 		break;
30777c478bd9Sstevel@tonic-gate 
30787c478bd9Sstevel@tonic-gate 	default:
30797c478bd9Sstevel@tonic-gate 		xyerror(D_UNKNOWN, "invalid unary op %s\n", opstr(dnp->dn_op));
30807c478bd9Sstevel@tonic-gate 	}
30817c478bd9Sstevel@tonic-gate 
30827c478bd9Sstevel@tonic-gate 	dt_node_attr_assign(dnp, cp->dn_attr);
30837c478bd9Sstevel@tonic-gate 	return (dnp);
30847c478bd9Sstevel@tonic-gate }
30857c478bd9Sstevel@tonic-gate 
3086*e5803b76SAdam H. Leventhal static void
3087*e5803b76SAdam H. Leventhal dt_assign_common(dt_node_t *dnp)
3088*e5803b76SAdam H. Leventhal {
3089*e5803b76SAdam H. Leventhal 	dt_node_t *lp = dnp->dn_left;
3090*e5803b76SAdam H. Leventhal 	dt_node_t *rp = dnp->dn_right;
3091*e5803b76SAdam H. Leventhal 	int op = dnp->dn_op;
3092*e5803b76SAdam H. Leventhal 
3093*e5803b76SAdam H. Leventhal 	if (rp->dn_kind == DT_NODE_INT)
3094*e5803b76SAdam H. Leventhal 		dt_cast(lp, rp);
3095*e5803b76SAdam H. Leventhal 
3096*e5803b76SAdam H. Leventhal 	if (!(lp->dn_flags & DT_NF_LVALUE)) {
3097*e5803b76SAdam H. Leventhal 		xyerror(D_OP_LVAL, "operator %s requires modifiable "
3098*e5803b76SAdam H. Leventhal 		    "lvalue as an operand\n", opstr(op));
3099*e5803b76SAdam H. Leventhal 		/* see K&R[A7.17] */
3100*e5803b76SAdam H. Leventhal 	}
3101*e5803b76SAdam H. Leventhal 
3102*e5803b76SAdam H. Leventhal 	if (!(lp->dn_flags & DT_NF_WRITABLE)) {
3103*e5803b76SAdam H. Leventhal 		xyerror(D_OP_WRITE, "operator %s can only be applied "
3104*e5803b76SAdam H. Leventhal 		    "to a writable variable\n", opstr(op));
3105*e5803b76SAdam H. Leventhal 	}
3106*e5803b76SAdam H. Leventhal 
3107*e5803b76SAdam H. Leventhal 	dt_node_type_propagate(lp, dnp); /* see K&R[A7.17] */
3108*e5803b76SAdam H. Leventhal 	dt_node_attr_assign(dnp, dt_attr_min(lp->dn_attr, rp->dn_attr));
3109*e5803b76SAdam H. Leventhal }
3110*e5803b76SAdam H. Leventhal 
31117c478bd9Sstevel@tonic-gate static dt_node_t *
31127c478bd9Sstevel@tonic-gate dt_cook_op2(dt_node_t *dnp, uint_t idflags)
31137c478bd9Sstevel@tonic-gate {
31147c478bd9Sstevel@tonic-gate 	dtrace_hdl_t *dtp = yypcb->pcb_hdl;
31157c478bd9Sstevel@tonic-gate 	dt_node_t *lp = dnp->dn_left;
31167c478bd9Sstevel@tonic-gate 	dt_node_t *rp = dnp->dn_right;
31177c478bd9Sstevel@tonic-gate 	int op = dnp->dn_op;
31187c478bd9Sstevel@tonic-gate 
31197c478bd9Sstevel@tonic-gate 	ctf_membinfo_t m;
31207c478bd9Sstevel@tonic-gate 	ctf_file_t *ctfp;
31217c478bd9Sstevel@tonic-gate 	ctf_id_t type;
31227c478bd9Sstevel@tonic-gate 	int kind, val, uref;
31237c478bd9Sstevel@tonic-gate 	dt_ident_t *idp;
31247c478bd9Sstevel@tonic-gate 
31257c478bd9Sstevel@tonic-gate 	char n1[DT_TYPE_NAMELEN];
31267c478bd9Sstevel@tonic-gate 	char n2[DT_TYPE_NAMELEN];
31277c478bd9Sstevel@tonic-gate 
31287c478bd9Sstevel@tonic-gate 	/*
31297c478bd9Sstevel@tonic-gate 	 * The expression E1[E2] is identical by definition to *((E1)+(E2)) so
31307c478bd9Sstevel@tonic-gate 	 * we convert "[" to "+" and glue on "*" at the end (see K&R[A7.3.1])
31317c478bd9Sstevel@tonic-gate 	 * unless the left-hand side is an untyped D scalar, associative array,
31327c478bd9Sstevel@tonic-gate 	 * or aggregation.  In these cases, we proceed to case DT_TOK_LBRAC and
31337c478bd9Sstevel@tonic-gate 	 * handle associative array and aggregation references there.
31347c478bd9Sstevel@tonic-gate 	 */
31357c478bd9Sstevel@tonic-gate 	if (op == DT_TOK_LBRAC) {
31367c478bd9Sstevel@tonic-gate 		if (lp->dn_kind == DT_NODE_IDENT) {
31377c478bd9Sstevel@tonic-gate 			dt_idhash_t *dhp;
31387c478bd9Sstevel@tonic-gate 			uint_t idkind;
31397c478bd9Sstevel@tonic-gate 
31407c478bd9Sstevel@tonic-gate 			if (lp->dn_op == DT_TOK_AGG) {
31417c478bd9Sstevel@tonic-gate 				dhp = dtp->dt_aggs;
31427c478bd9Sstevel@tonic-gate 				idp = dt_idhash_lookup(dhp, lp->dn_string + 1);
31437c478bd9Sstevel@tonic-gate 				idkind = DT_IDENT_AGG;
31447c478bd9Sstevel@tonic-gate 			} else {
31457c478bd9Sstevel@tonic-gate 				dhp = dtp->dt_globals;
31467c478bd9Sstevel@tonic-gate 				idp = dt_idstack_lookup(
31477c478bd9Sstevel@tonic-gate 				    &yypcb->pcb_globals, lp->dn_string);
31487c478bd9Sstevel@tonic-gate 				idkind = DT_IDENT_ARRAY;
31497c478bd9Sstevel@tonic-gate 			}
31507c478bd9Sstevel@tonic-gate 
31517c478bd9Sstevel@tonic-gate 			if (idp == NULL || dt_ident_unref(idp))
31527c478bd9Sstevel@tonic-gate 				dt_xcook_ident(lp, dhp, idkind, B_TRUE);
31537c478bd9Sstevel@tonic-gate 			else
31547c478bd9Sstevel@tonic-gate 				dt_xcook_ident(lp, dhp, idp->di_kind, B_FALSE);
31557c478bd9Sstevel@tonic-gate 		} else
31567c478bd9Sstevel@tonic-gate 			lp = dnp->dn_left = dt_node_cook(lp, 0);
31577c478bd9Sstevel@tonic-gate 
31587c478bd9Sstevel@tonic-gate 		/*
31597c478bd9Sstevel@tonic-gate 		 * Switch op to '+' for *(E1 + E2) array mode in these cases:
31607c478bd9Sstevel@tonic-gate 		 * (a) lp is a DT_IDENT_ARRAY variable that has already been
31617c478bd9Sstevel@tonic-gate 		 *	referenced using [] notation (dn_args != NULL).
31627c478bd9Sstevel@tonic-gate 		 * (b) lp is a non-ARRAY variable that has already been given
31637c478bd9Sstevel@tonic-gate 		 *	a type by assignment or declaration (!dt_ident_unref())
31647c478bd9Sstevel@tonic-gate 		 * (c) lp is neither a variable nor an aggregation
31657c478bd9Sstevel@tonic-gate 		 */
31667c478bd9Sstevel@tonic-gate 		if (lp->dn_kind == DT_NODE_VAR) {
31677c478bd9Sstevel@tonic-gate 			if (lp->dn_ident->di_kind == DT_IDENT_ARRAY) {
31687c478bd9Sstevel@tonic-gate 				if (lp->dn_args != NULL)
31697c478bd9Sstevel@tonic-gate 					op = DT_TOK_ADD;
31707c478bd9Sstevel@tonic-gate 			} else if (!dt_ident_unref(lp->dn_ident))
31717c478bd9Sstevel@tonic-gate 				op = DT_TOK_ADD;
31727c478bd9Sstevel@tonic-gate 		} else if (lp->dn_kind != DT_NODE_AGG)
31737c478bd9Sstevel@tonic-gate 			op = DT_TOK_ADD;
31747c478bd9Sstevel@tonic-gate 	}
31757c478bd9Sstevel@tonic-gate 
31767c478bd9Sstevel@tonic-gate 	switch (op) {
31777c478bd9Sstevel@tonic-gate 	case DT_TOK_BAND:
31787c478bd9Sstevel@tonic-gate 	case DT_TOK_XOR:
31797c478bd9Sstevel@tonic-gate 	case DT_TOK_BOR:
31807c478bd9Sstevel@tonic-gate 		lp = dnp->dn_left = dt_node_cook(lp, DT_IDFLG_REF);
31817c478bd9Sstevel@tonic-gate 		rp = dnp->dn_right = dt_node_cook(rp, DT_IDFLG_REF);
31827c478bd9Sstevel@tonic-gate 
31837c478bd9Sstevel@tonic-gate 		if (!dt_node_is_integer(lp) || !dt_node_is_integer(rp)) {
31847c478bd9Sstevel@tonic-gate 			xyerror(D_OP_INT, "operator %s requires operands of "
31857c478bd9Sstevel@tonic-gate 			    "integral type\n", opstr(op));
31867c478bd9Sstevel@tonic-gate 		}
31877c478bd9Sstevel@tonic-gate 
31887c478bd9Sstevel@tonic-gate 		dt_node_promote(lp, rp, dnp); /* see K&R[A7.11-13] */
31897c478bd9Sstevel@tonic-gate 		break;
31907c478bd9Sstevel@tonic-gate 
31917c478bd9Sstevel@tonic-gate 	case DT_TOK_LSH:
31927c478bd9Sstevel@tonic-gate 	case DT_TOK_RSH:
31937c478bd9Sstevel@tonic-gate 		lp = dnp->dn_left = dt_node_cook(lp, DT_IDFLG_REF);
31947c478bd9Sstevel@tonic-gate 		rp = dnp->dn_right = dt_node_cook(rp, DT_IDFLG_REF);
31957c478bd9Sstevel@tonic-gate 
31967c478bd9Sstevel@tonic-gate 		if (!dt_node_is_integer(lp) || !dt_node_is_integer(rp)) {
31977c478bd9Sstevel@tonic-gate 			xyerror(D_OP_INT, "operator %s requires operands of "
31987c478bd9Sstevel@tonic-gate 			    "integral type\n", opstr(op));
31997c478bd9Sstevel@tonic-gate 		}
32007c478bd9Sstevel@tonic-gate 
32017c478bd9Sstevel@tonic-gate 		dt_node_type_propagate(lp, dnp); /* see K&R[A7.8] */
32027c478bd9Sstevel@tonic-gate 		dt_node_attr_assign(dnp, dt_attr_min(lp->dn_attr, rp->dn_attr));
32037c478bd9Sstevel@tonic-gate 		break;
32047c478bd9Sstevel@tonic-gate 
32057c478bd9Sstevel@tonic-gate 	case DT_TOK_MOD:
32067c478bd9Sstevel@tonic-gate 		lp = dnp->dn_left = dt_node_cook(lp, DT_IDFLG_REF);
32077c478bd9Sstevel@tonic-gate 		rp = dnp->dn_right = dt_node_cook(rp, DT_IDFLG_REF);
32087c478bd9Sstevel@tonic-gate 
32097c478bd9Sstevel@tonic-gate 		if (!dt_node_is_integer(lp) || !dt_node_is_integer(rp)) {
32107c478bd9Sstevel@tonic-gate 			xyerror(D_OP_INT, "operator %s requires operands of "
32117c478bd9Sstevel@tonic-gate 			    "integral type\n", opstr(op));
32127c478bd9Sstevel@tonic-gate 		}
32137c478bd9Sstevel@tonic-gate 
32147c478bd9Sstevel@tonic-gate 		dt_node_promote(lp, rp, dnp); /* see K&R[A7.6] */
32157c478bd9Sstevel@tonic-gate 		break;
32167c478bd9Sstevel@tonic-gate 
32177c478bd9Sstevel@tonic-gate 	case DT_TOK_MUL:
32187c478bd9Sstevel@tonic-gate 	case DT_TOK_DIV:
32197c478bd9Sstevel@tonic-gate 		lp = dnp->dn_left = dt_node_cook(lp, DT_IDFLG_REF);
32207c478bd9Sstevel@tonic-gate 		rp = dnp->dn_right = dt_node_cook(rp, DT_IDFLG_REF);
32217c478bd9Sstevel@tonic-gate 
32227c478bd9Sstevel@tonic-gate 		if (!dt_node_is_arith(lp) || !dt_node_is_arith(rp)) {
32237c478bd9Sstevel@tonic-gate 			xyerror(D_OP_ARITH, "operator %s requires operands of "
32247c478bd9Sstevel@tonic-gate 			    "arithmetic type\n", opstr(op));
32257c478bd9Sstevel@tonic-gate 		}
32267c478bd9Sstevel@tonic-gate 
32277c478bd9Sstevel@tonic-gate 		dt_node_promote(lp, rp, dnp); /* see K&R[A7.6] */
32287c478bd9Sstevel@tonic-gate 		break;
32297c478bd9Sstevel@tonic-gate 
32307c478bd9Sstevel@tonic-gate 	case DT_TOK_LAND:
32317c478bd9Sstevel@tonic-gate 	case DT_TOK_LXOR:
32327c478bd9Sstevel@tonic-gate 	case DT_TOK_LOR:
32337c478bd9Sstevel@tonic-gate 		lp = dnp->dn_left = dt_node_cook(lp, DT_IDFLG_REF);
32347c478bd9Sstevel@tonic-gate 		rp = dnp->dn_right = dt_node_cook(rp, DT_IDFLG_REF);
32357c478bd9Sstevel@tonic-gate 
32367c478bd9Sstevel@tonic-gate 		if (!dt_node_is_scalar(lp) || !dt_node_is_scalar(rp)) {
32377c478bd9Sstevel@tonic-gate 			xyerror(D_OP_SCALAR, "operator %s requires operands "
32387c478bd9Sstevel@tonic-gate 			    "of scalar type\n", opstr(op));
32397c478bd9Sstevel@tonic-gate 		}
32407c478bd9Sstevel@tonic-gate 
32417c478bd9Sstevel@tonic-gate 		dt_node_type_assign(dnp, DT_INT_CTFP(dtp), DT_INT_TYPE(dtp));
32427c478bd9Sstevel@tonic-gate 		dt_node_attr_assign(dnp, dt_attr_min(lp->dn_attr, rp->dn_attr));
32437c478bd9Sstevel@tonic-gate 		break;
32447c478bd9Sstevel@tonic-gate 
32457c478bd9Sstevel@tonic-gate 	case DT_TOK_LT:
32467c478bd9Sstevel@tonic-gate 	case DT_TOK_LE:
32477c478bd9Sstevel@tonic-gate 	case DT_TOK_GT:
32487c478bd9Sstevel@tonic-gate 	case DT_TOK_GE:
32497c478bd9Sstevel@tonic-gate 	case DT_TOK_EQU:
32507c478bd9Sstevel@tonic-gate 	case DT_TOK_NEQ:
32517c478bd9Sstevel@tonic-gate 		/*
32527c478bd9Sstevel@tonic-gate 		 * The D comparison operators provide the ability to transform
32537c478bd9Sstevel@tonic-gate 		 * a right-hand identifier into a corresponding enum tag value
32547c478bd9Sstevel@tonic-gate 		 * if the left-hand side is an enum type.  To do this, we cook
32557c478bd9Sstevel@tonic-gate 		 * the left-hand side, and then see if the right-hand side is
32567c478bd9Sstevel@tonic-gate 		 * an unscoped identifier defined in the enum.  If so, we
32577c478bd9Sstevel@tonic-gate 		 * convert into an integer constant node with the tag's value.
32587c478bd9Sstevel@tonic-gate 		 */
32597c478bd9Sstevel@tonic-gate 		lp = dnp->dn_left = dt_node_cook(lp, DT_IDFLG_REF);
32607c478bd9Sstevel@tonic-gate 
32617c478bd9Sstevel@tonic-gate 		kind = ctf_type_kind(lp->dn_ctfp,
32627c478bd9Sstevel@tonic-gate 		    ctf_type_resolve(lp->dn_ctfp, lp->dn_type));
32637c478bd9Sstevel@tonic-gate 
32647c478bd9Sstevel@tonic-gate 		if (kind == CTF_K_ENUM && rp->dn_kind == DT_NODE_IDENT &&
32657c478bd9Sstevel@tonic-gate 		    strchr(rp->dn_string, '`') == NULL && ctf_enum_value(
32667c478bd9Sstevel@tonic-gate 		    lp->dn_ctfp, lp->dn_type, rp->dn_string, &val) == 0) {
32677c478bd9Sstevel@tonic-gate 
32687c478bd9Sstevel@tonic-gate 			if ((idp = dt_idstack_lookup(&yypcb->pcb_globals,
32697c478bd9Sstevel@tonic-gate 			    rp->dn_string)) != NULL) {
32707c478bd9Sstevel@tonic-gate 				xyerror(D_IDENT_AMBIG,
32717c478bd9Sstevel@tonic-gate 				    "ambiguous use of operator %s: %s is "
32727c478bd9Sstevel@tonic-gate 				    "both a %s enum tag and a global %s\n",
32737c478bd9Sstevel@tonic-gate 				    opstr(op), rp->dn_string,
32747c478bd9Sstevel@tonic-gate 				    dt_node_type_name(lp, n1, sizeof (n1)),
32757c478bd9Sstevel@tonic-gate 				    dt_idkind_name(idp->di_kind));
32767c478bd9Sstevel@tonic-gate 			}
32777c478bd9Sstevel@tonic-gate 
32787c478bd9Sstevel@tonic-gate 			free(rp->dn_string);
32797c478bd9Sstevel@tonic-gate 			rp->dn_string = NULL;
32807c478bd9Sstevel@tonic-gate 			rp->dn_kind = DT_NODE_INT;
32817c478bd9Sstevel@tonic-gate 			rp->dn_flags |= DT_NF_COOKED;
32827c478bd9Sstevel@tonic-gate 			rp->dn_op = DT_TOK_INT;
32837c478bd9Sstevel@tonic-gate 			rp->dn_value = (intmax_t)val;
32847c478bd9Sstevel@tonic-gate 
32857c478bd9Sstevel@tonic-gate 			dt_node_type_assign(rp, lp->dn_ctfp, lp->dn_type);
32867c478bd9Sstevel@tonic-gate 			dt_node_attr_assign(rp, _dtrace_symattr);
32877c478bd9Sstevel@tonic-gate 		}
32887c478bd9Sstevel@tonic-gate 
32897c478bd9Sstevel@tonic-gate 		rp = dnp->dn_right = dt_node_cook(rp, DT_IDFLG_REF);
32907c478bd9Sstevel@tonic-gate 
32917c478bd9Sstevel@tonic-gate 		/*
32927c478bd9Sstevel@tonic-gate 		 * The rules for type checking for the relational operators are
32937c478bd9Sstevel@tonic-gate 		 * described in the ANSI-C spec (see K&R[A7.9-10]).  We perform
32947c478bd9Sstevel@tonic-gate 		 * the various tests in order from least to most expensive.  We
32957c478bd9Sstevel@tonic-gate 		 * also allow derived strings to be compared as a first-class
32967c478bd9Sstevel@tonic-gate 		 * type (resulting in a strcmp(3C)-style comparison), and we
32977c478bd9Sstevel@tonic-gate 		 * slightly relax the A7.9 rules to permit void pointer
32987c478bd9Sstevel@tonic-gate 		 * comparisons as in A7.10.  Our users won't be confused by
32997c478bd9Sstevel@tonic-gate 		 * this since they understand pointers are just numbers, and
33007c478bd9Sstevel@tonic-gate 		 * relaxing this constraint simplifies the implementation.
33017c478bd9Sstevel@tonic-gate 		 */
33027c478bd9Sstevel@tonic-gate 		if (ctf_type_compat(lp->dn_ctfp, lp->dn_type,
33037c478bd9Sstevel@tonic-gate 		    rp->dn_ctfp, rp->dn_type))
33047c478bd9Sstevel@tonic-gate 			/*EMPTY*/;
33057c478bd9Sstevel@tonic-gate 		else if (dt_node_is_integer(lp) && dt_node_is_integer(rp))
33067c478bd9Sstevel@tonic-gate 			/*EMPTY*/;
33077c478bd9Sstevel@tonic-gate 		else if (dt_node_is_strcompat(lp) && dt_node_is_strcompat(rp) &&
33087c478bd9Sstevel@tonic-gate 		    (dt_node_is_string(lp) || dt_node_is_string(rp)))
33097c478bd9Sstevel@tonic-gate 			/*EMPTY*/;
33107c478bd9Sstevel@tonic-gate 		else if (dt_node_is_ptrcompat(lp, rp, NULL, NULL) == 0) {
33117c478bd9Sstevel@tonic-gate 			xyerror(D_OP_INCOMPAT, "operands have "
33127c478bd9Sstevel@tonic-gate 			    "incompatible types: \"%s\" %s \"%s\"\n",
33137c478bd9Sstevel@tonic-gate 			    dt_node_type_name(lp, n1, sizeof (n1)), opstr(op),
33147c478bd9Sstevel@tonic-gate 			    dt_node_type_name(rp, n2, sizeof (n2)));
33157c478bd9Sstevel@tonic-gate 		}
33167c478bd9Sstevel@tonic-gate 
33177c478bd9Sstevel@tonic-gate 		dt_node_type_assign(dnp, DT_INT_CTFP(dtp), DT_INT_TYPE(dtp));
33187c478bd9Sstevel@tonic-gate 		dt_node_attr_assign(dnp, dt_attr_min(lp->dn_attr, rp->dn_attr));
33197c478bd9Sstevel@tonic-gate 		break;
33207c478bd9Sstevel@tonic-gate 
33217c478bd9Sstevel@tonic-gate 	case DT_TOK_ADD:
33227c478bd9Sstevel@tonic-gate 	case DT_TOK_SUB: {
33237c478bd9Sstevel@tonic-gate 		/*
33247c478bd9Sstevel@tonic-gate 		 * The rules for type checking for the additive operators are
33257c478bd9Sstevel@tonic-gate 		 * described in the ANSI-C spec (see K&R[A7.7]).  Pointers and
3326e4586ebfSmws 		 * integers may be manipulated according to specific rules.  In
3327e4586ebfSmws 		 * these cases D permits strings to be treated as pointers.
33287c478bd9Sstevel@tonic-gate 		 */
33297c478bd9Sstevel@tonic-gate 		int lp_is_ptr, lp_is_int, rp_is_ptr, rp_is_int;
33307c478bd9Sstevel@tonic-gate 
33317c478bd9Sstevel@tonic-gate 		lp = dnp->dn_left = dt_node_cook(lp, DT_IDFLG_REF);
33327c478bd9Sstevel@tonic-gate 		rp = dnp->dn_right = dt_node_cook(rp, DT_IDFLG_REF);
33337c478bd9Sstevel@tonic-gate 
3334e4586ebfSmws 		lp_is_ptr = dt_node_is_string(lp) ||
3335e4586ebfSmws 		    (dt_node_is_pointer(lp) && !dt_node_is_vfptr(lp));
33367c478bd9Sstevel@tonic-gate 		lp_is_int = dt_node_is_integer(lp);
33377c478bd9Sstevel@tonic-gate 
3338e4586ebfSmws 		rp_is_ptr = dt_node_is_string(rp) ||
3339e4586ebfSmws 		    (dt_node_is_pointer(rp) && !dt_node_is_vfptr(rp));
33407c478bd9Sstevel@tonic-gate 		rp_is_int = dt_node_is_integer(rp);
33417c478bd9Sstevel@tonic-gate 
33427c478bd9Sstevel@tonic-gate 		if (lp_is_int && rp_is_int) {
33437c478bd9Sstevel@tonic-gate 			dt_type_promote(lp, rp, &ctfp, &type);
33447c478bd9Sstevel@tonic-gate 			uref = 0;
33457c478bd9Sstevel@tonic-gate 		} else if (lp_is_ptr && rp_is_int) {
33467c478bd9Sstevel@tonic-gate 			ctfp = lp->dn_ctfp;
33477c478bd9Sstevel@tonic-gate 			type = lp->dn_type;
33487c478bd9Sstevel@tonic-gate 			uref = lp->dn_flags & DT_NF_USERLAND;
33497c478bd9Sstevel@tonic-gate 		} else if (lp_is_int && rp_is_ptr && op == DT_TOK_ADD) {
33507c478bd9Sstevel@tonic-gate 			ctfp = rp->dn_ctfp;
33517c478bd9Sstevel@tonic-gate 			type = rp->dn_type;
33527c478bd9Sstevel@tonic-gate 			uref = rp->dn_flags & DT_NF_USERLAND;
33537c478bd9Sstevel@tonic-gate 		} else if (lp_is_ptr && rp_is_ptr && op == DT_TOK_SUB &&
33547c478bd9Sstevel@tonic-gate 		    dt_node_is_ptrcompat(lp, rp, NULL, NULL)) {
33557c478bd9Sstevel@tonic-gate 			ctfp = dtp->dt_ddefs->dm_ctfp;
33567c478bd9Sstevel@tonic-gate 			type = ctf_lookup_by_name(ctfp, "ptrdiff_t");
33577c478bd9Sstevel@tonic-gate 			uref = 0;
33587c478bd9Sstevel@tonic-gate 		} else {
33597c478bd9Sstevel@tonic-gate 			xyerror(D_OP_INCOMPAT, "operands have incompatible "
33607c478bd9Sstevel@tonic-gate 			    "types: \"%s\" %s \"%s\"\n",
33617c478bd9Sstevel@tonic-gate 			    dt_node_type_name(lp, n1, sizeof (n1)), opstr(op),
33627c478bd9Sstevel@tonic-gate 			    dt_node_type_name(rp, n2, sizeof (n2)));
33637c478bd9Sstevel@tonic-gate 		}
33647c478bd9Sstevel@tonic-gate 
33657c478bd9Sstevel@tonic-gate 		dt_node_type_assign(dnp, ctfp, type);
33667c478bd9Sstevel@tonic-gate 		dt_node_attr_assign(dnp, dt_attr_min(lp->dn_attr, rp->dn_attr));
33677c478bd9Sstevel@tonic-gate 
33687c478bd9Sstevel@tonic-gate 		if (uref)
33697c478bd9Sstevel@tonic-gate 			dnp->dn_flags |= DT_NF_USERLAND;
33707c478bd9Sstevel@tonic-gate 		break;
33717c478bd9Sstevel@tonic-gate 	}
33727c478bd9Sstevel@tonic-gate 
33737c478bd9Sstevel@tonic-gate 	case DT_TOK_OR_EQ:
33747c478bd9Sstevel@tonic-gate 	case DT_TOK_XOR_EQ:
33757c478bd9Sstevel@tonic-gate 	case DT_TOK_AND_EQ:
33767c478bd9Sstevel@tonic-gate 	case DT_TOK_LSH_EQ:
33777c478bd9Sstevel@tonic-gate 	case DT_TOK_RSH_EQ:
33787c478bd9Sstevel@tonic-gate 	case DT_TOK_MOD_EQ:
33797c478bd9Sstevel@tonic-gate 		if (lp->dn_kind == DT_NODE_IDENT) {
33807c478bd9Sstevel@tonic-gate 			dt_xcook_ident(lp, dtp->dt_globals,
33817c478bd9Sstevel@tonic-gate 			    DT_IDENT_SCALAR, B_TRUE);
33827c478bd9Sstevel@tonic-gate 		}
33837c478bd9Sstevel@tonic-gate 
33847c478bd9Sstevel@tonic-gate 		lp = dnp->dn_left =
33857c478bd9Sstevel@tonic-gate 		    dt_node_cook(lp, DT_IDFLG_REF | DT_IDFLG_MOD);
33867c478bd9Sstevel@tonic-gate 
33877c478bd9Sstevel@tonic-gate 		rp = dnp->dn_right =
33887c478bd9Sstevel@tonic-gate 		    dt_node_cook(rp, DT_IDFLG_REF | DT_IDFLG_MOD);
33897c478bd9Sstevel@tonic-gate 
33907c478bd9Sstevel@tonic-gate 		if (!dt_node_is_integer(lp) || !dt_node_is_integer(rp)) {
33917c478bd9Sstevel@tonic-gate 			xyerror(D_OP_INT, "operator %s requires operands of "
33927c478bd9Sstevel@tonic-gate 			    "integral type\n", opstr(op));
33937c478bd9Sstevel@tonic-gate 		}
33947c478bd9Sstevel@tonic-gate 		goto asgn_common;
33957c478bd9Sstevel@tonic-gate 
33967c478bd9Sstevel@tonic-gate 	case DT_TOK_MUL_EQ:
33977c478bd9Sstevel@tonic-gate 	case DT_TOK_DIV_EQ:
33987c478bd9Sstevel@tonic-gate 		if (lp->dn_kind == DT_NODE_IDENT) {
33997c478bd9Sstevel@tonic-gate 			dt_xcook_ident(lp, dtp->dt_globals,
34007c478bd9Sstevel@tonic-gate 			    DT_IDENT_SCALAR, B_TRUE);
34017c478bd9Sstevel@tonic-gate 		}
34027c478bd9Sstevel@tonic-gate 
34037c478bd9Sstevel@tonic-gate 		lp = dnp->dn_left =
34047c478bd9Sstevel@tonic-gate 		    dt_node_cook(lp, DT_IDFLG_REF | DT_IDFLG_MOD);
34057c478bd9Sstevel@tonic-gate 
34067c478bd9Sstevel@tonic-gate 		rp = dnp->dn_right =
34077c478bd9Sstevel@tonic-gate 		    dt_node_cook(rp, DT_IDFLG_REF | DT_IDFLG_MOD);
34087c478bd9Sstevel@tonic-gate 
34097c478bd9Sstevel@tonic-gate 		if (!dt_node_is_arith(lp) || !dt_node_is_arith(rp)) {
34107c478bd9Sstevel@tonic-gate 			xyerror(D_OP_ARITH, "operator %s requires operands of "
34117c478bd9Sstevel@tonic-gate 			    "arithmetic type\n", opstr(op));
34127c478bd9Sstevel@tonic-gate 		}
34137c478bd9Sstevel@tonic-gate 		goto asgn_common;
34147c478bd9Sstevel@tonic-gate 
34157c478bd9Sstevel@tonic-gate 	case DT_TOK_ASGN:
34167c478bd9Sstevel@tonic-gate 		/*
34177c478bd9Sstevel@tonic-gate 		 * If the left-hand side is an identifier, attempt to resolve
34187c478bd9Sstevel@tonic-gate 		 * it as either an aggregation or scalar variable.  We pass
34197c478bd9Sstevel@tonic-gate 		 * B_TRUE to dt_xcook_ident to indicate that a new variable can
34207c478bd9Sstevel@tonic-gate 		 * be created if no matching variable exists in the namespace.
34217c478bd9Sstevel@tonic-gate 		 */
34227c478bd9Sstevel@tonic-gate 		if (lp->dn_kind == DT_NODE_IDENT) {
34237c478bd9Sstevel@tonic-gate 			if (lp->dn_op == DT_TOK_AGG) {
34247c478bd9Sstevel@tonic-gate 				dt_xcook_ident(lp, dtp->dt_aggs,
34257c478bd9Sstevel@tonic-gate 				    DT_IDENT_AGG, B_TRUE);
34267c478bd9Sstevel@tonic-gate 			} else {
34277c478bd9Sstevel@tonic-gate 				dt_xcook_ident(lp, dtp->dt_globals,
34287c478bd9Sstevel@tonic-gate 				    DT_IDENT_SCALAR, B_TRUE);
34297c478bd9Sstevel@tonic-gate 			}
34307c478bd9Sstevel@tonic-gate 		}
34317c478bd9Sstevel@tonic-gate 
34327c478bd9Sstevel@tonic-gate 		lp = dnp->dn_left = dt_node_cook(lp, 0); /* don't set mod yet */
34337c478bd9Sstevel@tonic-gate 		rp = dnp->dn_right = dt_node_cook(rp, DT_IDFLG_REF);
34347c478bd9Sstevel@tonic-gate 
34357c478bd9Sstevel@tonic-gate 		/*
34367c478bd9Sstevel@tonic-gate 		 * If the left-hand side is an aggregation, verify that we are
34377c478bd9Sstevel@tonic-gate 		 * assigning it the result of an aggregating function.  Once
34387c478bd9Sstevel@tonic-gate 		 * we've done so, hide the func node in the aggregation and
34397c478bd9Sstevel@tonic-gate 		 * return the aggregation itself up to the parse tree parent.
34407c478bd9Sstevel@tonic-gate 		 * This transformation is legal since the assigned function
34417c478bd9Sstevel@tonic-gate 		 * cannot change identity across disjoint cooking passes and
34427c478bd9Sstevel@tonic-gate 		 * the argument list subtree is retained for later cooking.
34437c478bd9Sstevel@tonic-gate 		 */
34447c478bd9Sstevel@tonic-gate 		if (lp->dn_kind == DT_NODE_AGG) {
34457c478bd9Sstevel@tonic-gate 			const char *aname = lp->dn_ident->di_name;
34467c478bd9Sstevel@tonic-gate 			dt_ident_t *oid = lp->dn_ident->di_iarg;
34477c478bd9Sstevel@tonic-gate 
34487c478bd9Sstevel@tonic-gate 			if (rp->dn_kind != DT_NODE_FUNC ||
34497c478bd9Sstevel@tonic-gate 			    rp->dn_ident->di_kind != DT_IDENT_AGGFUNC) {
34507c478bd9Sstevel@tonic-gate 				xyerror(D_AGG_FUNC,
34517c478bd9Sstevel@tonic-gate 				    "@%s must be assigned the result of "
34527c478bd9Sstevel@tonic-gate 				    "an aggregating function\n", aname);
34537c478bd9Sstevel@tonic-gate 			}
34547c478bd9Sstevel@tonic-gate 
34557c478bd9Sstevel@tonic-gate 			if (oid != NULL && oid != rp->dn_ident) {
34567c478bd9Sstevel@tonic-gate 				xyerror(D_AGG_REDEF,
34577c478bd9Sstevel@tonic-gate 				    "aggregation redefined: @%s\n\t "
34587c478bd9Sstevel@tonic-gate 				    "current: @%s = %s( )\n\tprevious: @%s = "
34597c478bd9Sstevel@tonic-gate 				    "%s( ) : line %d\n", aname, aname,
34607c478bd9Sstevel@tonic-gate 				    rp->dn_ident->di_name, aname, oid->di_name,
34617c478bd9Sstevel@tonic-gate 				    lp->dn_ident->di_lineno);
34627c478bd9Sstevel@tonic-gate 			} else if (oid == NULL)
34637c478bd9Sstevel@tonic-gate 				lp->dn_ident->di_iarg = rp->dn_ident;
34647c478bd9Sstevel@tonic-gate 
34657c478bd9Sstevel@tonic-gate 			/*
34667c478bd9Sstevel@tonic-gate 			 * Do not allow multiple aggregation assignments in a
34677c478bd9Sstevel@tonic-gate 			 * single statement, e.g. (@a = count()) = count();
34687c478bd9Sstevel@tonic-gate 			 * We produce a message as if the result of aggregating
34697c478bd9Sstevel@tonic-gate 			 * function does not propagate DT_NF_LVALUE.
34707c478bd9Sstevel@tonic-gate 			 */
34717c478bd9Sstevel@tonic-gate 			if (lp->dn_aggfun != NULL) {
34727c478bd9Sstevel@tonic-gate 				xyerror(D_OP_LVAL, "operator = requires "
34737c478bd9Sstevel@tonic-gate 				    "modifiable lvalue as an operand\n");
34747c478bd9Sstevel@tonic-gate 			}
34757c478bd9Sstevel@tonic-gate 
34767c478bd9Sstevel@tonic-gate 			lp->dn_aggfun = rp;
34777c478bd9Sstevel@tonic-gate 			lp = dt_node_cook(lp, DT_IDFLG_MOD);
34787c478bd9Sstevel@tonic-gate 
34797c478bd9Sstevel@tonic-gate 			dnp->dn_left = dnp->dn_right = NULL;
34807c478bd9Sstevel@tonic-gate 			dt_node_free(dnp);
34817c478bd9Sstevel@tonic-gate 
34827c478bd9Sstevel@tonic-gate 			return (lp);
34837c478bd9Sstevel@tonic-gate 		}
34847c478bd9Sstevel@tonic-gate 
34857c478bd9Sstevel@tonic-gate 		/*
34867c478bd9Sstevel@tonic-gate 		 * If the right-hand side is a dynamic variable that is the
34877c478bd9Sstevel@tonic-gate 		 * output of a translator, our result is the translated type.
34887c478bd9Sstevel@tonic-gate 		 */
34897c478bd9Sstevel@tonic-gate 		if ((idp = dt_node_resolve(rp, DT_IDENT_XLSOU)) != NULL) {
34907c478bd9Sstevel@tonic-gate 			ctfp = idp->di_ctfp;
34917c478bd9Sstevel@tonic-gate 			type = idp->di_type;
34927c478bd9Sstevel@tonic-gate 			uref = idp->di_flags & DT_IDFLG_USER;
34937c478bd9Sstevel@tonic-gate 		} else {
34947c478bd9Sstevel@tonic-gate 			ctfp = rp->dn_ctfp;
34957c478bd9Sstevel@tonic-gate 			type = rp->dn_type;
34967c478bd9Sstevel@tonic-gate 			uref = rp->dn_flags & DT_NF_USERLAND;
34977c478bd9Sstevel@tonic-gate 		}
34987c478bd9Sstevel@tonic-gate 
34997c478bd9Sstevel@tonic-gate 		/*
35007c478bd9Sstevel@tonic-gate 		 * If the left-hand side of an assignment statement is a virgin
35017c478bd9Sstevel@tonic-gate 		 * variable created by this compilation pass, reset the type of
35027c478bd9Sstevel@tonic-gate 		 * this variable to the type of the right-hand side.
35037c478bd9Sstevel@tonic-gate 		 */
35047c478bd9Sstevel@tonic-gate 		if (lp->dn_kind == DT_NODE_VAR &&
35057c478bd9Sstevel@tonic-gate 		    dt_ident_unref(lp->dn_ident)) {
35067c478bd9Sstevel@tonic-gate 			dt_node_type_assign(lp, ctfp, type);
35077c478bd9Sstevel@tonic-gate 			dt_ident_type_assign(lp->dn_ident, ctfp, type);
35087c478bd9Sstevel@tonic-gate 
35097c478bd9Sstevel@tonic-gate 			if (uref) {
35107c478bd9Sstevel@tonic-gate 				lp->dn_flags |= DT_NF_USERLAND;
35117c478bd9Sstevel@tonic-gate 				lp->dn_ident->di_flags |= DT_IDFLG_USER;
35127c478bd9Sstevel@tonic-gate 			}
35137c478bd9Sstevel@tonic-gate 		}
35147c478bd9Sstevel@tonic-gate 
35157c478bd9Sstevel@tonic-gate 		if (lp->dn_kind == DT_NODE_VAR)
35167c478bd9Sstevel@tonic-gate 			lp->dn_ident->di_flags |= DT_IDFLG_MOD;
35177c478bd9Sstevel@tonic-gate 
35187c478bd9Sstevel@tonic-gate 		/*
35197c478bd9Sstevel@tonic-gate 		 * The rules for type checking for the assignment operators are
35207c478bd9Sstevel@tonic-gate 		 * described in the ANSI-C spec (see K&R[A7.17]).  We share
35217c478bd9Sstevel@tonic-gate 		 * most of this code with the argument list checking code.
35227c478bd9Sstevel@tonic-gate 		 */
35237c478bd9Sstevel@tonic-gate 		if (!dt_node_is_string(lp)) {
35247c478bd9Sstevel@tonic-gate 			kind = ctf_type_kind(lp->dn_ctfp,
35257c478bd9Sstevel@tonic-gate 			    ctf_type_resolve(lp->dn_ctfp, lp->dn_type));
35267c478bd9Sstevel@tonic-gate 
35277c478bd9Sstevel@tonic-gate 			if (kind == CTF_K_ARRAY || kind == CTF_K_FUNCTION) {
35287c478bd9Sstevel@tonic-gate 				xyerror(D_OP_ARRFUN, "operator %s may not be "
35297c478bd9Sstevel@tonic-gate 				    "applied to operand of type \"%s\"\n",
35307c478bd9Sstevel@tonic-gate 				    opstr(op),
35317c478bd9Sstevel@tonic-gate 				    dt_node_type_name(lp, n1, sizeof (n1)));
35327c478bd9Sstevel@tonic-gate 			}
35337c478bd9Sstevel@tonic-gate 		}
35347c478bd9Sstevel@tonic-gate 
35357c478bd9Sstevel@tonic-gate 		if (idp != NULL && idp->di_kind == DT_IDENT_XLSOU &&
35367c478bd9Sstevel@tonic-gate 		    ctf_type_compat(lp->dn_ctfp, lp->dn_type, ctfp, type))
35377c478bd9Sstevel@tonic-gate 			goto asgn_common;
35387c478bd9Sstevel@tonic-gate 
35397c478bd9Sstevel@tonic-gate 		if (dt_node_is_argcompat(lp, rp))
35407c478bd9Sstevel@tonic-gate 			goto asgn_common;
35417c478bd9Sstevel@tonic-gate 
35427c478bd9Sstevel@tonic-gate 		xyerror(D_OP_INCOMPAT,
35437c478bd9Sstevel@tonic-gate 		    "operands have incompatible types: \"%s\" %s \"%s\"\n",
35447c478bd9Sstevel@tonic-gate 		    dt_node_type_name(lp, n1, sizeof (n1)), opstr(op),
35457c478bd9Sstevel@tonic-gate 		    dt_node_type_name(rp, n2, sizeof (n2)));
35467c478bd9Sstevel@tonic-gate 		/*NOTREACHED*/
35477c478bd9Sstevel@tonic-gate 
35487c478bd9Sstevel@tonic-gate 	case DT_TOK_ADD_EQ:
35497c478bd9Sstevel@tonic-gate 	case DT_TOK_SUB_EQ:
35507c478bd9Sstevel@tonic-gate 		if (lp->dn_kind == DT_NODE_IDENT) {
35517c478bd9Sstevel@tonic-gate 			dt_xcook_ident(lp, dtp->dt_globals,
35527c478bd9Sstevel@tonic-gate 			    DT_IDENT_SCALAR, B_TRUE);
35537c478bd9Sstevel@tonic-gate 		}
35547c478bd9Sstevel@tonic-gate 
35557c478bd9Sstevel@tonic-gate 		lp = dnp->dn_left =
35567c478bd9Sstevel@tonic-gate 		    dt_node_cook(lp, DT_IDFLG_REF | DT_IDFLG_MOD);
35577c478bd9Sstevel@tonic-gate 
35587c478bd9Sstevel@tonic-gate 		rp = dnp->dn_right =
35597c478bd9Sstevel@tonic-gate 		    dt_node_cook(rp, DT_IDFLG_REF | DT_IDFLG_MOD);
35607c478bd9Sstevel@tonic-gate 
35617c478bd9Sstevel@tonic-gate 		if (dt_node_is_string(lp) || dt_node_is_string(rp)) {
35627c478bd9Sstevel@tonic-gate 			xyerror(D_OP_INCOMPAT, "operands have "
35637c478bd9Sstevel@tonic-gate 			    "incompatible types: \"%s\" %s \"%s\"\n",
35647c478bd9Sstevel@tonic-gate 			    dt_node_type_name(lp, n1, sizeof (n1)), opstr(op),
35657c478bd9Sstevel@tonic-gate 			    dt_node_type_name(rp, n2, sizeof (n2)));
35667c478bd9Sstevel@tonic-gate 		}
35677c478bd9Sstevel@tonic-gate 
35687c478bd9Sstevel@tonic-gate 		/*
35697c478bd9Sstevel@tonic-gate 		 * The rules for type checking for the assignment operators are
35707c478bd9Sstevel@tonic-gate 		 * described in the ANSI-C spec (see K&R[A7.17]).  To these
35717c478bd9Sstevel@tonic-gate 		 * rules we add that only writable D nodes can be modified.
35727c478bd9Sstevel@tonic-gate 		 */
35737c478bd9Sstevel@tonic-gate 		if (dt_node_is_integer(lp) == 0 ||
35747c478bd9Sstevel@tonic-gate 		    dt_node_is_integer(rp) == 0) {
35757c478bd9Sstevel@tonic-gate 			if (!dt_node_is_pointer(lp) || dt_node_is_vfptr(lp)) {
35767c478bd9Sstevel@tonic-gate 				xyerror(D_OP_VFPTR,
35777c478bd9Sstevel@tonic-gate 				    "operator %s requires left-hand scalar "
35787c478bd9Sstevel@tonic-gate 				    "operand of known size\n", opstr(op));
35797c478bd9Sstevel@tonic-gate 			} else if (dt_node_is_integer(rp) == 0 &&
35807c478bd9Sstevel@tonic-gate 			    dt_node_is_ptrcompat(lp, rp, NULL, NULL) == 0) {
35817c478bd9Sstevel@tonic-gate 				xyerror(D_OP_INCOMPAT, "operands have "
35827c478bd9Sstevel@tonic-gate 				    "incompatible types: \"%s\" %s \"%s\"\n",
35837c478bd9Sstevel@tonic-gate 				    dt_node_type_name(lp, n1, sizeof (n1)),
35847c478bd9Sstevel@tonic-gate 				    opstr(op),
35857c478bd9Sstevel@tonic-gate 				    dt_node_type_name(rp, n2, sizeof (n2)));
35867c478bd9Sstevel@tonic-gate 			}
35877c478bd9Sstevel@tonic-gate 		}
35887c478bd9Sstevel@tonic-gate asgn_common:
3589*e5803b76SAdam H. Leventhal 		dt_assign_common(dnp);
35907c478bd9Sstevel@tonic-gate 		break;
35917c478bd9Sstevel@tonic-gate 
35927c478bd9Sstevel@tonic-gate 	case DT_TOK_PTR:
35937c478bd9Sstevel@tonic-gate 		/*
35947c478bd9Sstevel@tonic-gate 		 * If the left-hand side of operator -> is the name "self",
35957c478bd9Sstevel@tonic-gate 		 * then we permit a TLS variable to be created or referenced.
35967c478bd9Sstevel@tonic-gate 		 */
35977c478bd9Sstevel@tonic-gate 		if (lp->dn_kind == DT_NODE_IDENT &&
35987c478bd9Sstevel@tonic-gate 		    strcmp(lp->dn_string, "self") == 0) {
35997c478bd9Sstevel@tonic-gate 			if (rp->dn_kind != DT_NODE_VAR) {
36007c478bd9Sstevel@tonic-gate 				dt_xcook_ident(rp, dtp->dt_tls,
36017c478bd9Sstevel@tonic-gate 				    DT_IDENT_SCALAR, B_TRUE);
36027c478bd9Sstevel@tonic-gate 			}
36037c478bd9Sstevel@tonic-gate 
36047c478bd9Sstevel@tonic-gate 			if (idflags != 0)
36057c478bd9Sstevel@tonic-gate 				rp = dt_node_cook(rp, idflags);
36067c478bd9Sstevel@tonic-gate 
36077c478bd9Sstevel@tonic-gate 			dnp->dn_right = dnp->dn_left; /* avoid freeing rp */
36087c478bd9Sstevel@tonic-gate 			dt_node_free(dnp);
36097c478bd9Sstevel@tonic-gate 			return (rp);
36107c478bd9Sstevel@tonic-gate 		}
36117c478bd9Sstevel@tonic-gate 
36127c478bd9Sstevel@tonic-gate 		/*
36137c478bd9Sstevel@tonic-gate 		 * If the left-hand side of operator -> is the name "this",
36147c478bd9Sstevel@tonic-gate 		 * then we permit a local variable to be created or referenced.
36157c478bd9Sstevel@tonic-gate 		 */
36167c478bd9Sstevel@tonic-gate 		if (lp->dn_kind == DT_NODE_IDENT &&
36177c478bd9Sstevel@tonic-gate 		    strcmp(lp->dn_string, "this") == 0) {
36187c478bd9Sstevel@tonic-gate 			if (rp->dn_kind != DT_NODE_VAR) {
36197c478bd9Sstevel@tonic-gate 				dt_xcook_ident(rp, yypcb->pcb_locals,
36207c478bd9Sstevel@tonic-gate 				    DT_IDENT_SCALAR, B_TRUE);
36217c478bd9Sstevel@tonic-gate 			}
36227c478bd9Sstevel@tonic-gate 
36237c478bd9Sstevel@tonic-gate 			if (idflags != 0)
36247c478bd9Sstevel@tonic-gate 				rp = dt_node_cook(rp, idflags);
36257c478bd9Sstevel@tonic-gate 
36267c478bd9Sstevel@tonic-gate 			dnp->dn_right = dnp->dn_left; /* avoid freeing rp */
36277c478bd9Sstevel@tonic-gate 			dt_node_free(dnp);
36287c478bd9Sstevel@tonic-gate 			return (rp);
36297c478bd9Sstevel@tonic-gate 		}
36307c478bd9Sstevel@tonic-gate 
36317c478bd9Sstevel@tonic-gate 		/*FALLTHRU*/
36327c478bd9Sstevel@tonic-gate 
36337c478bd9Sstevel@tonic-gate 	case DT_TOK_DOT:
36347c478bd9Sstevel@tonic-gate 		lp = dnp->dn_left = dt_node_cook(lp, DT_IDFLG_REF);
36357c478bd9Sstevel@tonic-gate 
36367c478bd9Sstevel@tonic-gate 		if (rp->dn_kind != DT_NODE_IDENT) {
36377c478bd9Sstevel@tonic-gate 			xyerror(D_OP_IDENT, "operator %s must be followed by "
36387c478bd9Sstevel@tonic-gate 			    "an identifier\n", opstr(op));
36397c478bd9Sstevel@tonic-gate 		}
36407c478bd9Sstevel@tonic-gate 
36417c478bd9Sstevel@tonic-gate 		if ((idp = dt_node_resolve(lp, DT_IDENT_XLSOU)) != NULL ||
36427c478bd9Sstevel@tonic-gate 		    (idp = dt_node_resolve(lp, DT_IDENT_XLPTR)) != NULL) {
36437c478bd9Sstevel@tonic-gate 			/*
36447c478bd9Sstevel@tonic-gate 			 * If the left-hand side is a translated struct or ptr,
36457c478bd9Sstevel@tonic-gate 			 * the type of the left is the translation output type.
36467c478bd9Sstevel@tonic-gate 			 */
36477c478bd9Sstevel@tonic-gate 			dt_xlator_t *dxp = idp->di_data;
36487c478bd9Sstevel@tonic-gate 
36497c478bd9Sstevel@tonic-gate 			if (dt_xlator_member(dxp, rp->dn_string) == NULL) {
36507c478bd9Sstevel@tonic-gate 				xyerror(D_XLATE_NOCONV,
36517c478bd9Sstevel@tonic-gate 				    "translator does not define conversion "
36527c478bd9Sstevel@tonic-gate 				    "for member: %s\n", rp->dn_string);
36537c478bd9Sstevel@tonic-gate 			}
36547c478bd9Sstevel@tonic-gate 
36557c478bd9Sstevel@tonic-gate 			ctfp = idp->di_ctfp;
36567c478bd9Sstevel@tonic-gate 			type = ctf_type_resolve(ctfp, idp->di_type);
36577c478bd9Sstevel@tonic-gate 			uref = idp->di_flags & DT_IDFLG_USER;
36587c478bd9Sstevel@tonic-gate 		} else {
36597c478bd9Sstevel@tonic-gate 			ctfp = lp->dn_ctfp;
36607c478bd9Sstevel@tonic-gate 			type = ctf_type_resolve(ctfp, lp->dn_type);
36617c478bd9Sstevel@tonic-gate 			uref = lp->dn_flags & DT_NF_USERLAND;
36627c478bd9Sstevel@tonic-gate 		}
36637c478bd9Sstevel@tonic-gate 
36647c478bd9Sstevel@tonic-gate 		kind = ctf_type_kind(ctfp, type);
36657c478bd9Sstevel@tonic-gate 
36667c478bd9Sstevel@tonic-gate 		if (op == DT_TOK_PTR) {
36677c478bd9Sstevel@tonic-gate 			if (kind != CTF_K_POINTER) {
36687c478bd9Sstevel@tonic-gate 				xyerror(D_OP_PTR, "operator %s must be "
36697c478bd9Sstevel@tonic-gate 				    "applied to a pointer\n", opstr(op));
36707c478bd9Sstevel@tonic-gate 			}
36717c478bd9Sstevel@tonic-gate 			type = ctf_type_reference(ctfp, type);
36727c478bd9Sstevel@tonic-gate 			type = ctf_type_resolve(ctfp, type);
36737c478bd9Sstevel@tonic-gate 			kind = ctf_type_kind(ctfp, type);
36747c478bd9Sstevel@tonic-gate 		}
36757c478bd9Sstevel@tonic-gate 
36767c478bd9Sstevel@tonic-gate 		/*
36777c478bd9Sstevel@tonic-gate 		 * If we follow a reference to a forward declaration tag,
36787c478bd9Sstevel@tonic-gate 		 * search the entire type space for the actual definition.
36797c478bd9Sstevel@tonic-gate 		 */
36807c478bd9Sstevel@tonic-gate 		while (kind == CTF_K_FORWARD) {
36817c478bd9Sstevel@tonic-gate 			char *tag = ctf_type_name(ctfp, type, n1, sizeof (n1));
36827c478bd9Sstevel@tonic-gate 			dtrace_typeinfo_t dtt;
36837c478bd9Sstevel@tonic-gate 
36847c478bd9Sstevel@tonic-gate 			if (tag != NULL && dt_type_lookup(tag, &dtt) == 0 &&
36857c478bd9Sstevel@tonic-gate 			    (dtt.dtt_ctfp != ctfp || dtt.dtt_type != type)) {
36867c478bd9Sstevel@tonic-gate 				ctfp = dtt.dtt_ctfp;
36877c478bd9Sstevel@tonic-gate 				type = ctf_type_resolve(ctfp, dtt.dtt_type);
36887c478bd9Sstevel@tonic-gate 				kind = ctf_type_kind(ctfp, type);
36897c478bd9Sstevel@tonic-gate 			} else {
36907c478bd9Sstevel@tonic-gate 				xyerror(D_OP_INCOMPLETE,
36917c478bd9Sstevel@tonic-gate 				    "operator %s cannot be applied to a "
36927c478bd9Sstevel@tonic-gate 				    "forward declaration: no %s definition "
36937c478bd9Sstevel@tonic-gate 				    "is available\n", opstr(op), tag);
36947c478bd9Sstevel@tonic-gate 			}
36957c478bd9Sstevel@tonic-gate 		}
36967c478bd9Sstevel@tonic-gate 
36977c478bd9Sstevel@tonic-gate 		if (kind != CTF_K_STRUCT && kind != CTF_K_UNION) {
36987c478bd9Sstevel@tonic-gate 			if (op == DT_TOK_PTR) {
36997c478bd9Sstevel@tonic-gate 				xyerror(D_OP_SOU, "operator -> cannot be "
37007c478bd9Sstevel@tonic-gate 				    "applied to pointer to type \"%s\"; must "
37017c478bd9Sstevel@tonic-gate 				    "be applied to a struct or union pointer\n",
37027c478bd9Sstevel@tonic-gate 				    ctf_type_name(ctfp, type, n1, sizeof (n1)));
37037c478bd9Sstevel@tonic-gate 			} else {
37047c478bd9Sstevel@tonic-gate 				xyerror(D_OP_SOU, "operator %s cannot be "
37057c478bd9Sstevel@tonic-gate 				    "applied to type \"%s\"; must be applied "
37067c478bd9Sstevel@tonic-gate 				    "to a struct or union\n", opstr(op),
37077c478bd9Sstevel@tonic-gate 				    ctf_type_name(ctfp, type, n1, sizeof (n1)));
37087c478bd9Sstevel@tonic-gate 			}
37097c478bd9Sstevel@tonic-gate 		}
37107c478bd9Sstevel@tonic-gate 
37117c478bd9Sstevel@tonic-gate 		if (ctf_member_info(ctfp, type, rp->dn_string, &m) == CTF_ERR) {
37127c478bd9Sstevel@tonic-gate 			xyerror(D_TYPE_MEMBER,
37137c478bd9Sstevel@tonic-gate 			    "%s is not a member of %s\n", rp->dn_string,
37147c478bd9Sstevel@tonic-gate 			    ctf_type_name(ctfp, type, n1, sizeof (n1)));
37157c478bd9Sstevel@tonic-gate 		}
37167c478bd9Sstevel@tonic-gate 
37177c478bd9Sstevel@tonic-gate 		type = ctf_type_resolve(ctfp, m.ctm_type);
37187c478bd9Sstevel@tonic-gate 		kind = ctf_type_kind(ctfp, type);
37197c478bd9Sstevel@tonic-gate 
37207c478bd9Sstevel@tonic-gate 		dt_node_type_assign(dnp, ctfp, m.ctm_type);
37217c478bd9Sstevel@tonic-gate 		dt_node_attr_assign(dnp, lp->dn_attr);
37227c478bd9Sstevel@tonic-gate 
37237c478bd9Sstevel@tonic-gate 		if (op == DT_TOK_PTR && (kind != CTF_K_ARRAY ||
37247c478bd9Sstevel@tonic-gate 		    dt_node_is_string(dnp)))
37257c478bd9Sstevel@tonic-gate 			dnp->dn_flags |= DT_NF_LVALUE; /* see K&R[A7.3.3] */
37267c478bd9Sstevel@tonic-gate 
37277c478bd9Sstevel@tonic-gate 		if (op == DT_TOK_DOT && (lp->dn_flags & DT_NF_LVALUE) &&
37287c478bd9Sstevel@tonic-gate 		    (kind != CTF_K_ARRAY || dt_node_is_string(dnp)))
37297c478bd9Sstevel@tonic-gate 			dnp->dn_flags |= DT_NF_LVALUE; /* see K&R[A7.3.3] */
37307c478bd9Sstevel@tonic-gate 
37317c478bd9Sstevel@tonic-gate 		if (lp->dn_flags & DT_NF_WRITABLE)
37327c478bd9Sstevel@tonic-gate 			dnp->dn_flags |= DT_NF_WRITABLE;
37337c478bd9Sstevel@tonic-gate 
37347c478bd9Sstevel@tonic-gate 		if (uref && (kind == CTF_K_POINTER ||
37357c478bd9Sstevel@tonic-gate 		    (dnp->dn_flags & DT_NF_REF)))
37367c478bd9Sstevel@tonic-gate 			dnp->dn_flags |= DT_NF_USERLAND;
37377c478bd9Sstevel@tonic-gate 		break;
37387c478bd9Sstevel@tonic-gate 
37397c478bd9Sstevel@tonic-gate 	case DT_TOK_LBRAC: {
37407c478bd9Sstevel@tonic-gate 		/*
37417c478bd9Sstevel@tonic-gate 		 * If op is DT_TOK_LBRAC, we know from the special-case code at
37427c478bd9Sstevel@tonic-gate 		 * the top that lp is either a D variable or an aggregation.
37437c478bd9Sstevel@tonic-gate 		 */
37447c478bd9Sstevel@tonic-gate 		dt_node_t *lnp;
37457c478bd9Sstevel@tonic-gate 
37467c478bd9Sstevel@tonic-gate 		/*
37477c478bd9Sstevel@tonic-gate 		 * If the left-hand side is an aggregation, just set dn_aggtup
37487c478bd9Sstevel@tonic-gate 		 * to the right-hand side and return the cooked aggregation.
37497c478bd9Sstevel@tonic-gate 		 * This transformation is legal since we are just collapsing
37507c478bd9Sstevel@tonic-gate 		 * nodes to simplify later processing, and the entire aggtup
37517c478bd9Sstevel@tonic-gate 		 * parse subtree is retained for subsequent cooking passes.
37527c478bd9Sstevel@tonic-gate 		 */
37537c478bd9Sstevel@tonic-gate 		if (lp->dn_kind == DT_NODE_AGG) {
37547c478bd9Sstevel@tonic-gate 			if (lp->dn_aggtup != NULL) {
37557c478bd9Sstevel@tonic-gate 				xyerror(D_AGG_MDIM, "improper attempt to "
37567c478bd9Sstevel@tonic-gate 				    "reference @%s as a multi-dimensional "
37577c478bd9Sstevel@tonic-gate 				    "array\n", lp->dn_ident->di_name);
37587c478bd9Sstevel@tonic-gate 			}
37597c478bd9Sstevel@tonic-gate 
37607c478bd9Sstevel@tonic-gate 			lp->dn_aggtup = rp;
37617c478bd9Sstevel@tonic-gate 			lp = dt_node_cook(lp, 0);
37627c478bd9Sstevel@tonic-gate 
37637c478bd9Sstevel@tonic-gate 			dnp->dn_left = dnp->dn_right = NULL;
37647c478bd9Sstevel@tonic-gate 			dt_node_free(dnp);
37657c478bd9Sstevel@tonic-gate 
37667c478bd9Sstevel@tonic-gate 			return (lp);
37677c478bd9Sstevel@tonic-gate 		}
37687c478bd9Sstevel@tonic-gate 
37697c478bd9Sstevel@tonic-gate 		assert(lp->dn_kind == DT_NODE_VAR);
37707c478bd9Sstevel@tonic-gate 		idp = lp->dn_ident;
37717c478bd9Sstevel@tonic-gate 
37727c478bd9Sstevel@tonic-gate 		/*
37737c478bd9Sstevel@tonic-gate 		 * If the left-hand side is a non-global scalar that hasn't yet
37747c478bd9Sstevel@tonic-gate 		 * been referenced or modified, it was just created by self->
37757c478bd9Sstevel@tonic-gate 		 * or this-> and we can convert it from scalar to assoc array.
37767c478bd9Sstevel@tonic-gate 		 */
37777c478bd9Sstevel@tonic-gate 		if (idp->di_kind == DT_IDENT_SCALAR && dt_ident_unref(idp) &&
37787c478bd9Sstevel@tonic-gate 		    (idp->di_flags & (DT_IDFLG_LOCAL | DT_IDFLG_TLS)) != 0) {
37797c478bd9Sstevel@tonic-gate 
37807c478bd9Sstevel@tonic-gate 			if (idp->di_flags & DT_IDFLG_LOCAL) {
37817c478bd9Sstevel@tonic-gate 				xyerror(D_ARR_LOCAL,
37827c478bd9Sstevel@tonic-gate 				    "local variables may not be used as "
37837c478bd9Sstevel@tonic-gate 				    "associative arrays: %s\n", idp->di_name);
37847c478bd9Sstevel@tonic-gate 			}
37857c478bd9Sstevel@tonic-gate 
37867c478bd9Sstevel@tonic-gate 			dt_dprintf("morph variable %s (id %u) from scalar to "
37877c478bd9Sstevel@tonic-gate 			    "array\n", idp->di_name, idp->di_id);
37887c478bd9Sstevel@tonic-gate 
37897c478bd9Sstevel@tonic-gate 			dt_ident_morph(idp, DT_IDENT_ARRAY,
37907c478bd9Sstevel@tonic-gate 			    &dt_idops_assc, NULL);
37917c478bd9Sstevel@tonic-gate 		}
37927c478bd9Sstevel@tonic-gate 
37937c478bd9Sstevel@tonic-gate 		if (idp->di_kind != DT_IDENT_ARRAY) {
37947c478bd9Sstevel@tonic-gate 			xyerror(D_IDENT_BADREF, "%s '%s' may not be referenced "
37957c478bd9Sstevel@tonic-gate 			    "as %s\n", dt_idkind_name(idp->di_kind),
37967c478bd9Sstevel@tonic-gate 			    idp->di_name, dt_idkind_name(DT_IDENT_ARRAY));
37977c478bd9Sstevel@tonic-gate 		}
37987c478bd9Sstevel@tonic-gate 
37997c478bd9Sstevel@tonic-gate 		/*
38007c478bd9Sstevel@tonic-gate 		 * Now that we've confirmed our left-hand side is a DT_NODE_VAR
38017c478bd9Sstevel@tonic-gate 		 * of idkind DT_IDENT_ARRAY, we need to splice the [ node from
38027c478bd9Sstevel@tonic-gate 		 * the parse tree and leave a cooked DT_NODE_VAR in its place
38037c478bd9Sstevel@tonic-gate 		 * where dn_args for the VAR node is the right-hand 'rp' tree,
38047c478bd9Sstevel@tonic-gate 		 * as shown in the parse tree diagram below:
38057c478bd9Sstevel@tonic-gate 		 *
38067c478bd9Sstevel@tonic-gate 		 *	  /			    /
38077c478bd9Sstevel@tonic-gate 		 * [ OP2 "[" ]=dnp		[ VAR ]=dnp
38087c478bd9Sstevel@tonic-gate 		 *	 /	\	  =>	   |
38097c478bd9Sstevel@tonic-gate 		 *	/	 \		   +- dn_args -> [ ??? ]=rp
38107c478bd9Sstevel@tonic-gate 		 * [ VAR ]=lp  [ ??? ]=rp
38117c478bd9Sstevel@tonic-gate 		 *
38127c478bd9Sstevel@tonic-gate 		 * Since the final dt_node_cook(dnp) can fail using longjmp we
38137c478bd9Sstevel@tonic-gate 		 * must perform the transformations as a group first by over-
38147c478bd9Sstevel@tonic-gate 		 * writing 'dnp' to become the VAR node, so that the parse tree
38157c478bd9Sstevel@tonic-gate 		 * is guaranteed to be in a consistent state if the cook fails.
38167c478bd9Sstevel@tonic-gate 		 */
38177c478bd9Sstevel@tonic-gate 		assert(lp->dn_kind == DT_NODE_VAR);
38187c478bd9Sstevel@tonic-gate 		assert(lp->dn_args == NULL);
38197c478bd9Sstevel@tonic-gate 
38207c478bd9Sstevel@tonic-gate 		lnp = dnp->dn_link;
38217c478bd9Sstevel@tonic-gate 		bcopy(lp, dnp, sizeof (dt_node_t));
38227c478bd9Sstevel@tonic-gate 		dnp->dn_link = lnp;
38237c478bd9Sstevel@tonic-gate 
38247c478bd9Sstevel@tonic-gate 		dnp->dn_args = rp;
38257c478bd9Sstevel@tonic-gate 		dnp->dn_list = NULL;
38267c478bd9Sstevel@tonic-gate 
38277c478bd9Sstevel@tonic-gate 		dt_node_free(lp);
38287c478bd9Sstevel@tonic-gate 		return (dt_node_cook(dnp, idflags));
38297c478bd9Sstevel@tonic-gate 	}
38307c478bd9Sstevel@tonic-gate 
38317c478bd9Sstevel@tonic-gate 	case DT_TOK_XLATE: {
38327c478bd9Sstevel@tonic-gate 		dt_xlator_t *dxp;
38337c478bd9Sstevel@tonic-gate 
38347c478bd9Sstevel@tonic-gate 		assert(lp->dn_kind == DT_NODE_TYPE);
38357c478bd9Sstevel@tonic-gate 		rp = dnp->dn_right = dt_node_cook(rp, DT_IDFLG_REF);
38367c478bd9Sstevel@tonic-gate 		dxp = dt_xlator_lookup(dtp, rp, lp, DT_XLATE_FUZZY);
38377c478bd9Sstevel@tonic-gate 
38387c478bd9Sstevel@tonic-gate 		if (dxp == NULL) {
38397c478bd9Sstevel@tonic-gate 			xyerror(D_XLATE_NONE,
38407c478bd9Sstevel@tonic-gate 			    "cannot translate from \"%s\" to \"%s\"\n",
38417c478bd9Sstevel@tonic-gate 			    dt_node_type_name(rp, n1, sizeof (n1)),
38427c478bd9Sstevel@tonic-gate 			    dt_node_type_name(lp, n2, sizeof (n2)));
38437c478bd9Sstevel@tonic-gate 		}
38447c478bd9Sstevel@tonic-gate 
38457c478bd9Sstevel@tonic-gate 		dnp->dn_ident = dt_xlator_ident(dxp, lp->dn_ctfp, lp->dn_type);
38467c478bd9Sstevel@tonic-gate 		dt_node_type_assign(dnp, DT_DYN_CTFP(dtp), DT_DYN_TYPE(dtp));
38477c478bd9Sstevel@tonic-gate 		dt_node_attr_assign(dnp,
38487c478bd9Sstevel@tonic-gate 		    dt_attr_min(rp->dn_attr, dnp->dn_ident->di_attr));
38497c478bd9Sstevel@tonic-gate 		break;
38507c478bd9Sstevel@tonic-gate 	}
38517c478bd9Sstevel@tonic-gate 
38527c478bd9Sstevel@tonic-gate 	case DT_TOK_LPAR: {
38537c478bd9Sstevel@tonic-gate 		ctf_id_t ltype, rtype;
38547c478bd9Sstevel@tonic-gate 		uint_t lkind, rkind;
38557c478bd9Sstevel@tonic-gate 
38567c478bd9Sstevel@tonic-gate 		assert(lp->dn_kind == DT_NODE_TYPE);
38577c478bd9Sstevel@tonic-gate 		rp = dnp->dn_right = dt_node_cook(rp, DT_IDFLG_REF);
38587c478bd9Sstevel@tonic-gate 
38597c478bd9Sstevel@tonic-gate 		ltype = ctf_type_resolve(lp->dn_ctfp, lp->dn_type);
38607c478bd9Sstevel@tonic-gate 		lkind = ctf_type_kind(lp->dn_ctfp, ltype);
38617c478bd9Sstevel@tonic-gate 
38627c478bd9Sstevel@tonic-gate 		rtype = ctf_type_resolve(rp->dn_ctfp, rp->dn_type);
38637c478bd9Sstevel@tonic-gate 		rkind = ctf_type_kind(rp->dn_ctfp, rtype);
38647c478bd9Sstevel@tonic-gate 
38657c478bd9Sstevel@tonic-gate 		/*
38667c478bd9Sstevel@tonic-gate 		 * The rules for casting are loosely explained in K&R[A7.5]
38677c478bd9Sstevel@tonic-gate 		 * and K&R[A6].  Basically, we can cast to the same type or
38687c478bd9Sstevel@tonic-gate 		 * same base type, between any kind of scalar values, from
38697c478bd9Sstevel@tonic-gate 		 * arrays to pointers, and we can cast anything to void.
38707c478bd9Sstevel@tonic-gate 		 * To these rules D adds casts from scalars to strings.
38717c478bd9Sstevel@tonic-gate 		 */
38727c478bd9Sstevel@tonic-gate 		if (ctf_type_compat(lp->dn_ctfp, lp->dn_type,
38737c478bd9Sstevel@tonic-gate 		    rp->dn_ctfp, rp->dn_type))
38747c478bd9Sstevel@tonic-gate 			/*EMPTY*/;
38757c478bd9Sstevel@tonic-gate 		else if (dt_node_is_scalar(lp) &&
38767c478bd9Sstevel@tonic-gate 		    (dt_node_is_scalar(rp) || rkind == CTF_K_FUNCTION))
38777c478bd9Sstevel@tonic-gate 			/*EMPTY*/;
38787c478bd9Sstevel@tonic-gate 		else if (dt_node_is_void(lp))
38797c478bd9Sstevel@tonic-gate 			/*EMPTY*/;
38807c478bd9Sstevel@tonic-gate 		else if (lkind == CTF_K_POINTER && dt_node_is_pointer(rp))
38817c478bd9Sstevel@tonic-gate 			/*EMPTY*/;
38827c478bd9Sstevel@tonic-gate 		else if (dt_node_is_string(lp) && (dt_node_is_scalar(rp) ||
38837c478bd9Sstevel@tonic-gate 		    dt_node_is_pointer(rp) || dt_node_is_strcompat(rp)))
38847c478bd9Sstevel@tonic-gate 			/*EMPTY*/;
38857c478bd9Sstevel@tonic-gate 		else {
38867c478bd9Sstevel@tonic-gate 			xyerror(D_CAST_INVAL,
38877c478bd9Sstevel@tonic-gate 			    "invalid cast expression: \"%s\" to \"%s\"\n",
38887c478bd9Sstevel@tonic-gate 			    dt_node_type_name(rp, n1, sizeof (n1)),
38897c478bd9Sstevel@tonic-gate 			    dt_node_type_name(lp, n2, sizeof (n2)));
38907c478bd9Sstevel@tonic-gate 		}
38917c478bd9Sstevel@tonic-gate 
38927c478bd9Sstevel@tonic-gate 		dt_node_type_propagate(lp, dnp); /* see K&R[A7.5] */
38937c478bd9Sstevel@tonic-gate 		dt_node_attr_assign(dnp, dt_attr_min(lp->dn_attr, rp->dn_attr));
3894*e5803b76SAdam H. Leventhal 
3895*e5803b76SAdam H. Leventhal 		/*
3896*e5803b76SAdam H. Leventhal 		 * If it's a pointer then should be able to (attempt to)
3897*e5803b76SAdam H. Leventhal 		 * assign to it.
3898*e5803b76SAdam H. Leventhal 		 */
3899*e5803b76SAdam H. Leventhal 		if (lkind == CTF_K_POINTER)
3900*e5803b76SAdam H. Leventhal 			dnp->dn_flags |= DT_NF_WRITABLE;
3901*e5803b76SAdam H. Leventhal 
39027c478bd9Sstevel@tonic-gate 		break;
39037c478bd9Sstevel@tonic-gate 	}
39047c478bd9Sstevel@tonic-gate 
39057c478bd9Sstevel@tonic-gate 	case DT_TOK_COMMA:
39067c478bd9Sstevel@tonic-gate 		lp = dnp->dn_left = dt_node_cook(lp, DT_IDFLG_REF);
39077c478bd9Sstevel@tonic-gate 		rp = dnp->dn_right = dt_node_cook(rp, DT_IDFLG_REF);
39087c478bd9Sstevel@tonic-gate 
39097c478bd9Sstevel@tonic-gate 		if (dt_node_is_dynamic(lp) || dt_node_is_dynamic(rp)) {
39107c478bd9Sstevel@tonic-gate 			xyerror(D_OP_DYN, "operator %s operands "
39117c478bd9Sstevel@tonic-gate 			    "cannot be of dynamic type\n", opstr(op));
39127c478bd9Sstevel@tonic-gate 		}
39137c478bd9Sstevel@tonic-gate 
39147c478bd9Sstevel@tonic-gate 		if (dt_node_is_actfunc(lp) || dt_node_is_actfunc(rp)) {
39157c478bd9Sstevel@tonic-gate 			xyerror(D_OP_ACT, "operator %s operands "
39167c478bd9Sstevel@tonic-gate 			    "cannot be actions\n", opstr(op));
39177c478bd9Sstevel@tonic-gate 		}
39187c478bd9Sstevel@tonic-gate 
39197c478bd9Sstevel@tonic-gate 		dt_node_type_propagate(rp, dnp); /* see K&R[A7.18] */
39207c478bd9Sstevel@tonic-gate 		dt_node_attr_assign(dnp, dt_attr_min(lp->dn_attr, rp->dn_attr));
39217c478bd9Sstevel@tonic-gate 		break;
39227c478bd9Sstevel@tonic-gate 
39237c478bd9Sstevel@tonic-gate 	default:
39247c478bd9Sstevel@tonic-gate 		xyerror(D_UNKNOWN, "invalid binary op %s\n", opstr(op));
39257c478bd9Sstevel@tonic-gate 	}
39267c478bd9Sstevel@tonic-gate 
39277c478bd9Sstevel@tonic-gate 	/*
39287c478bd9Sstevel@tonic-gate 	 * Complete the conversion of E1[E2] to *((E1)+(E2)) that we started
39297c478bd9Sstevel@tonic-gate 	 * at the top of our switch() above (see K&R[A7.3.1]).  Since E2 is
39307c478bd9Sstevel@tonic-gate 	 * parsed as an argument_expression_list by dt_grammar.y, we can
39317c478bd9Sstevel@tonic-gate 	 * end up with a comma-separated list inside of a non-associative
39327c478bd9Sstevel@tonic-gate 	 * array reference.  We check for this and report an appropriate error.
39337c478bd9Sstevel@tonic-gate 	 */
39347c478bd9Sstevel@tonic-gate 	if (dnp->dn_op == DT_TOK_LBRAC && op == DT_TOK_ADD) {
39357c478bd9Sstevel@tonic-gate 		dt_node_t *pnp;
39367c478bd9Sstevel@tonic-gate 
39377c478bd9Sstevel@tonic-gate 		if (rp->dn_list != NULL) {
39387c478bd9Sstevel@tonic-gate 			xyerror(D_ARR_BADREF,
39397c478bd9Sstevel@tonic-gate 			    "cannot access %s as an associative array\n",
39407c478bd9Sstevel@tonic-gate 			    dt_node_name(lp, n1, sizeof (n1)));
39417c478bd9Sstevel@tonic-gate 		}
39427c478bd9Sstevel@tonic-gate 
39437c478bd9Sstevel@tonic-gate 		dnp->dn_op = DT_TOK_ADD;
39447c478bd9Sstevel@tonic-gate 		pnp = dt_node_op1(DT_TOK_DEREF, dnp);
39457c478bd9Sstevel@tonic-gate 
39467c478bd9Sstevel@tonic-gate 		/*
39477c478bd9Sstevel@tonic-gate 		 * Cook callbacks are not typically permitted to allocate nodes.
39487c478bd9Sstevel@tonic-gate 		 * When we do, we must insert them in the middle of an existing
39497c478bd9Sstevel@tonic-gate 		 * allocation list rather than having them appended to the pcb
39507c478bd9Sstevel@tonic-gate 		 * list because the sub-expression may be part of a definition.
39517c478bd9Sstevel@tonic-gate 		 */
39527c478bd9Sstevel@tonic-gate 		assert(yypcb->pcb_list == pnp);
39537c478bd9Sstevel@tonic-gate 		yypcb->pcb_list = pnp->dn_link;
39547c478bd9Sstevel@tonic-gate 
39557c478bd9Sstevel@tonic-gate 		pnp->dn_link = dnp->dn_link;
39567c478bd9Sstevel@tonic-gate 		dnp->dn_link = pnp;
39577c478bd9Sstevel@tonic-gate 
39587c478bd9Sstevel@tonic-gate 		return (dt_node_cook(pnp, DT_IDFLG_REF));
39597c478bd9Sstevel@tonic-gate 	}
39607c478bd9Sstevel@tonic-gate 
39617c478bd9Sstevel@tonic-gate 	return (dnp);
39627c478bd9Sstevel@tonic-gate }
39637c478bd9Sstevel@tonic-gate 
39647c478bd9Sstevel@tonic-gate /*ARGSUSED*/
39657c478bd9Sstevel@tonic-gate static dt_node_t *
39667c478bd9Sstevel@tonic-gate dt_cook_op3(dt_node_t *dnp, uint_t idflags)
39677c478bd9Sstevel@tonic-gate {
39687c478bd9Sstevel@tonic-gate 	dt_node_t *lp, *rp;
39697c478bd9Sstevel@tonic-gate 	ctf_file_t *ctfp;
39707c478bd9Sstevel@tonic-gate 	ctf_id_t type;
39717c478bd9Sstevel@tonic-gate 
39727c478bd9Sstevel@tonic-gate 	dnp->dn_expr = dt_node_cook(dnp->dn_expr, DT_IDFLG_REF);
39737c478bd9Sstevel@tonic-gate 	lp = dnp->dn_left = dt_node_cook(dnp->dn_left, DT_IDFLG_REF);
39747c478bd9Sstevel@tonic-gate 	rp = dnp->dn_right = dt_node_cook(dnp->dn_right, DT_IDFLG_REF);
39757c478bd9Sstevel@tonic-gate 
39767c478bd9Sstevel@tonic-gate 	if (!dt_node_is_scalar(dnp->dn_expr)) {
39777c478bd9Sstevel@tonic-gate 		xyerror(D_OP_SCALAR,
39787c478bd9Sstevel@tonic-gate 		    "operator ?: expression must be of scalar type\n");
39797c478bd9Sstevel@tonic-gate 	}
39807c478bd9Sstevel@tonic-gate 
39817c478bd9Sstevel@tonic-gate 	if (dt_node_is_dynamic(lp) || dt_node_is_dynamic(rp)) {
39827c478bd9Sstevel@tonic-gate 		xyerror(D_OP_DYN,
39837c478bd9Sstevel@tonic-gate 		    "operator ?: operands cannot be of dynamic type\n");
39847c478bd9Sstevel@tonic-gate 	}
39857c478bd9Sstevel@tonic-gate 
39867c478bd9Sstevel@tonic-gate 	/*
39877c478bd9Sstevel@tonic-gate 	 * The rules for type checking for the ternary operator are complex and
39887c478bd9Sstevel@tonic-gate 	 * are described in the ANSI-C spec (see K&R[A7.16]).  We implement
39897c478bd9Sstevel@tonic-gate 	 * the various tests in order from least to most expensive.
39907c478bd9Sstevel@tonic-gate 	 */
39917c478bd9Sstevel@tonic-gate 	if (ctf_type_compat(lp->dn_ctfp, lp->dn_type,
39927c478bd9Sstevel@tonic-gate 	    rp->dn_ctfp, rp->dn_type)) {
39937c478bd9Sstevel@tonic-gate 		ctfp = lp->dn_ctfp;
39947c478bd9Sstevel@tonic-gate 		type = lp->dn_type;
39957c478bd9Sstevel@tonic-gate 	} else if (dt_node_is_integer(lp) && dt_node_is_integer(rp)) {
39967c478bd9Sstevel@tonic-gate 		dt_type_promote(lp, rp, &ctfp, &type);
39977c478bd9Sstevel@tonic-gate 	} else if (dt_node_is_strcompat(lp) && dt_node_is_strcompat(rp) &&
39987c478bd9Sstevel@tonic-gate 	    (dt_node_is_string(lp) || dt_node_is_string(rp))) {
39997c478bd9Sstevel@tonic-gate 		ctfp = DT_STR_CTFP(yypcb->pcb_hdl);
40007c478bd9Sstevel@tonic-gate 		type = DT_STR_TYPE(yypcb->pcb_hdl);
40017c478bd9Sstevel@tonic-gate 	} else if (dt_node_is_ptrcompat(lp, rp, &ctfp, &type) == 0) {
40027c478bd9Sstevel@tonic-gate 		xyerror(D_OP_INCOMPAT,
40037c478bd9Sstevel@tonic-gate 		    "operator ?: operands must have compatible types\n");
40047c478bd9Sstevel@tonic-gate 	}
40057c478bd9Sstevel@tonic-gate 
40067c478bd9Sstevel@tonic-gate 	if (dt_node_is_actfunc(lp) || dt_node_is_actfunc(rp)) {
40077c478bd9Sstevel@tonic-gate 		xyerror(D_OP_ACT, "action cannot be "
40087c478bd9Sstevel@tonic-gate 		    "used in a conditional context\n");
40097c478bd9Sstevel@tonic-gate 	}
40107c478bd9Sstevel@tonic-gate 
40117c478bd9Sstevel@tonic-gate 	dt_node_type_assign(dnp, ctfp, type);
40127c478bd9Sstevel@tonic-gate 	dt_node_attr_assign(dnp, dt_attr_min(dnp->dn_expr->dn_attr,
40137c478bd9Sstevel@tonic-gate 	    dt_attr_min(lp->dn_attr, rp->dn_attr)));
40147c478bd9Sstevel@tonic-gate 
40157c478bd9Sstevel@tonic-gate 	return (dnp);
40167c478bd9Sstevel@tonic-gate }
40177c478bd9Sstevel@tonic-gate 
40187c478bd9Sstevel@tonic-gate static dt_node_t *
40197c478bd9Sstevel@tonic-gate dt_cook_statement(dt_node_t *dnp, uint_t idflags)
40207c478bd9Sstevel@tonic-gate {
40217c478bd9Sstevel@tonic-gate 	dnp->dn_expr = dt_node_cook(dnp->dn_expr, idflags);
40227c478bd9Sstevel@tonic-gate 	dt_node_attr_assign(dnp, dnp->dn_expr->dn_attr);
40237c478bd9Sstevel@tonic-gate 
40247c478bd9Sstevel@tonic-gate 	return (dnp);
40257c478bd9Sstevel@tonic-gate }
40267c478bd9Sstevel@tonic-gate 
40277c478bd9Sstevel@tonic-gate /*
40287c478bd9Sstevel@tonic-gate  * If dn_aggfun is set, this node is a collapsed aggregation assignment (see
40297c478bd9Sstevel@tonic-gate  * the special case code for DT_TOK_ASGN in dt_cook_op2() above), in which
40307c478bd9Sstevel@tonic-gate  * case we cook both the tuple and the function call.  If dn_aggfun is NULL,
40317c478bd9Sstevel@tonic-gate  * this node is just a reference to the aggregation's type and attributes.
40327c478bd9Sstevel@tonic-gate  */
40337c478bd9Sstevel@tonic-gate /*ARGSUSED*/
40347c478bd9Sstevel@tonic-gate static dt_node_t *
40357c478bd9Sstevel@tonic-gate dt_cook_aggregation(dt_node_t *dnp, uint_t idflags)
40367c478bd9Sstevel@tonic-gate {
40377c478bd9Sstevel@tonic-gate 	dtrace_hdl_t *dtp = yypcb->pcb_hdl;
40387c478bd9Sstevel@tonic-gate 
40397c478bd9Sstevel@tonic-gate 	if (dnp->dn_aggfun != NULL) {
40407c478bd9Sstevel@tonic-gate 		dnp->dn_aggfun = dt_node_cook(dnp->dn_aggfun, DT_IDFLG_REF);
40417c478bd9Sstevel@tonic-gate 		dt_node_attr_assign(dnp, dt_ident_cook(dnp,
40427c478bd9Sstevel@tonic-gate 		    dnp->dn_ident, &dnp->dn_aggtup));
40437c478bd9Sstevel@tonic-gate 	} else {
40447c478bd9Sstevel@tonic-gate 		dt_node_type_assign(dnp, DT_DYN_CTFP(dtp), DT_DYN_TYPE(dtp));
40457c478bd9Sstevel@tonic-gate 		dt_node_attr_assign(dnp, dnp->dn_ident->di_attr);
40467c478bd9Sstevel@tonic-gate 	}
40477c478bd9Sstevel@tonic-gate 
40487c478bd9Sstevel@tonic-gate 	return (dnp);
40497c478bd9Sstevel@tonic-gate }
40507c478bd9Sstevel@tonic-gate 
40517c478bd9Sstevel@tonic-gate /*
40527c478bd9Sstevel@tonic-gate  * Since D permits new variable identifiers to be instantiated in any program
40537c478bd9Sstevel@tonic-gate  * expression, we may need to cook a clause's predicate either before or after
40547c478bd9Sstevel@tonic-gate  * the action list depending on the program code in question.  Consider:
40557c478bd9Sstevel@tonic-gate  *
40567c478bd9Sstevel@tonic-gate  * probe-description-list	probe-description-list
40577c478bd9Sstevel@tonic-gate  * /x++/			/x == 0/
40587c478bd9Sstevel@tonic-gate  * {				{
40597c478bd9Sstevel@tonic-gate  *     trace(x);		    trace(x++);
40607c478bd9Sstevel@tonic-gate  * }				}
40617c478bd9Sstevel@tonic-gate  *
40627c478bd9Sstevel@tonic-gate  * In the left-hand example, the predicate uses operator ++ to instantiate 'x'
40637c478bd9Sstevel@tonic-gate  * as a variable of type int64_t.  The predicate must be cooked first because
40647c478bd9Sstevel@tonic-gate  * otherwise the statement trace(x) refers to an unknown identifier.  In the
40657c478bd9Sstevel@tonic-gate  * right-hand example, the action list uses ++ to instantiate 'x'; the action
40667c478bd9Sstevel@tonic-gate  * list must be cooked first because otherwise the predicate x == 0 refers to
40677c478bd9Sstevel@tonic-gate  * an unknown identifier.  In order to simplify programming, we support both.
40687c478bd9Sstevel@tonic-gate  *
40697c478bd9Sstevel@tonic-gate  * When cooking a clause, we cook the action statements before the predicate by
40707c478bd9Sstevel@tonic-gate  * default, since it seems more common to create or modify identifiers in the
40717c478bd9Sstevel@tonic-gate  * action list.  If cooking fails due to an unknown identifier, we attempt to
40727c478bd9Sstevel@tonic-gate  * cook the predicate (i.e. do it first) and then go back and cook the actions.
40737c478bd9Sstevel@tonic-gate  * If this, too, fails (or if we get an error other than D_IDENT_UNDEF) we give
40747c478bd9Sstevel@tonic-gate  * up and report failure back to the user.  There are five possible paths:
40757c478bd9Sstevel@tonic-gate  *
40767c478bd9Sstevel@tonic-gate  * cook actions = OK, cook predicate = OK -> OK
40777c478bd9Sstevel@tonic-gate  * cook actions = OK, cook predicate = ERR -> ERR
40787c478bd9Sstevel@tonic-gate  * cook actions = ERR, cook predicate = ERR -> ERR
40797c478bd9Sstevel@tonic-gate  * cook actions = ERR, cook predicate = OK, cook actions = OK -> OK
40807c478bd9Sstevel@tonic-gate  * cook actions = ERR, cook predicate = OK, cook actions = ERR -> ERR
40817c478bd9Sstevel@tonic-gate  *
40827c478bd9Sstevel@tonic-gate  * The programmer can still defeat our scheme by creating circular definition
40837c478bd9Sstevel@tonic-gate  * dependencies between predicates and actions, as in this example clause:
40847c478bd9Sstevel@tonic-gate  *
40857c478bd9Sstevel@tonic-gate  * probe-description-list
40867c478bd9Sstevel@tonic-gate  * /x++ && y == 0/
40877c478bd9Sstevel@tonic-gate  * {
40887c478bd9Sstevel@tonic-gate  * 	trace(x + y++);
40897c478bd9Sstevel@tonic-gate  * }
40907c478bd9Sstevel@tonic-gate  *
40917c478bd9Sstevel@tonic-gate  * but it doesn't seem worth the complexity to handle such rare cases.  The
40927c478bd9Sstevel@tonic-gate  * user can simply use the D variable declaration syntax to work around them.
40937c478bd9Sstevel@tonic-gate  */
40947c478bd9Sstevel@tonic-gate static dt_node_t *
40957c478bd9Sstevel@tonic-gate dt_cook_clause(dt_node_t *dnp, uint_t idflags)
40967c478bd9Sstevel@tonic-gate {
40977c478bd9Sstevel@tonic-gate 	volatile int err, tries;
40987c478bd9Sstevel@tonic-gate 	jmp_buf ojb;
40997c478bd9Sstevel@tonic-gate 
41007c478bd9Sstevel@tonic-gate 	/*
41017c478bd9Sstevel@tonic-gate 	 * Before assigning dn_ctxattr, temporarily assign the probe attribute
41027c478bd9Sstevel@tonic-gate 	 * to 'dnp' itself to force an attribute check and minimum violation.
41037c478bd9Sstevel@tonic-gate 	 */
41047c478bd9Sstevel@tonic-gate 	dt_node_attr_assign(dnp, yypcb->pcb_pinfo.dtp_attr);
41057c478bd9Sstevel@tonic-gate 	dnp->dn_ctxattr = yypcb->pcb_pinfo.dtp_attr;
41067c478bd9Sstevel@tonic-gate 
41077c478bd9Sstevel@tonic-gate 	bcopy(yypcb->pcb_jmpbuf, ojb, sizeof (jmp_buf));
41087c478bd9Sstevel@tonic-gate 	tries = 0;
41097c478bd9Sstevel@tonic-gate 
41107c478bd9Sstevel@tonic-gate 	if (dnp->dn_pred != NULL && (err = setjmp(yypcb->pcb_jmpbuf)) != 0) {
41117c478bd9Sstevel@tonic-gate 		bcopy(ojb, yypcb->pcb_jmpbuf, sizeof (jmp_buf));
41127c478bd9Sstevel@tonic-gate 		if (tries++ != 0 || err != EDT_COMPILER || (
41137c478bd9Sstevel@tonic-gate 		    yypcb->pcb_hdl->dt_errtag != dt_errtag(D_IDENT_UNDEF) &&
41147c478bd9Sstevel@tonic-gate 		    yypcb->pcb_hdl->dt_errtag != dt_errtag(D_VAR_UNDEF)))
41157c478bd9Sstevel@tonic-gate 			longjmp(yypcb->pcb_jmpbuf, err);
41167c478bd9Sstevel@tonic-gate 	}
41177c478bd9Sstevel@tonic-gate 
41187c478bd9Sstevel@tonic-gate 	if (tries == 0) {
41197c478bd9Sstevel@tonic-gate 		yylabel("action list");
41207c478bd9Sstevel@tonic-gate 
41217c478bd9Sstevel@tonic-gate 		dt_node_attr_assign(dnp,
41227c478bd9Sstevel@tonic-gate 		    dt_node_list_cook(&dnp->dn_acts, idflags));
41237c478bd9Sstevel@tonic-gate 
41247c478bd9Sstevel@tonic-gate 		bcopy(ojb, yypcb->pcb_jmpbuf, sizeof (jmp_buf));
41257c478bd9Sstevel@tonic-gate 		yylabel(NULL);
41267c478bd9Sstevel@tonic-gate 	}
41277c478bd9Sstevel@tonic-gate 
41287c478bd9Sstevel@tonic-gate 	if (dnp->dn_pred != NULL) {
41297c478bd9Sstevel@tonic-gate 		yylabel("predicate");
41307c478bd9Sstevel@tonic-gate 
41317c478bd9Sstevel@tonic-gate 		dnp->dn_pred = dt_node_cook(dnp->dn_pred, idflags);
41327c478bd9Sstevel@tonic-gate 		dt_node_attr_assign(dnp,
41337c478bd9Sstevel@tonic-gate 		    dt_attr_min(dnp->dn_attr, dnp->dn_pred->dn_attr));
41347c478bd9Sstevel@tonic-gate 
41357c478bd9Sstevel@tonic-gate 		if (!dt_node_is_scalar(dnp->dn_pred)) {
41367c478bd9Sstevel@tonic-gate 			xyerror(D_PRED_SCALAR,
41377c478bd9Sstevel@tonic-gate 			    "predicate result must be of scalar type\n");
41387c478bd9Sstevel@tonic-gate 		}
41397c478bd9Sstevel@tonic-gate 
41407c478bd9Sstevel@tonic-gate 		yylabel(NULL);
41417c478bd9Sstevel@tonic-gate 	}
41427c478bd9Sstevel@tonic-gate 
41437c478bd9Sstevel@tonic-gate 	if (tries != 0) {
41447c478bd9Sstevel@tonic-gate 		yylabel("action list");
41457c478bd9Sstevel@tonic-gate 
41467c478bd9Sstevel@tonic-gate 		dt_node_attr_assign(dnp,
41477c478bd9Sstevel@tonic-gate 		    dt_node_list_cook(&dnp->dn_acts, idflags));
41487c478bd9Sstevel@tonic-gate 
41497c478bd9Sstevel@tonic-gate 		yylabel(NULL);
41507c478bd9Sstevel@tonic-gate 	}
41517c478bd9Sstevel@tonic-gate 
41527c478bd9Sstevel@tonic-gate 	return (dnp);
41537c478bd9Sstevel@tonic-gate }
41547c478bd9Sstevel@tonic-gate 
41557c478bd9Sstevel@tonic-gate /*ARGSUSED*/
41567c478bd9Sstevel@tonic-gate static dt_node_t *
41577c478bd9Sstevel@tonic-gate dt_cook_inline(dt_node_t *dnp, uint_t idflags)
41587c478bd9Sstevel@tonic-gate {
41597c478bd9Sstevel@tonic-gate 	dt_idnode_t *inp = dnp->dn_ident->di_iarg;
41607c478bd9Sstevel@tonic-gate 	dt_ident_t *rdp;
41617c478bd9Sstevel@tonic-gate 
41627c478bd9Sstevel@tonic-gate 	char n1[DT_TYPE_NAMELEN];
41637c478bd9Sstevel@tonic-gate 	char n2[DT_TYPE_NAMELEN];
41647c478bd9Sstevel@tonic-gate 
41657c478bd9Sstevel@tonic-gate 	assert(dnp->dn_ident->di_flags & DT_IDFLG_INLINE);
41667c478bd9Sstevel@tonic-gate 	assert(inp->din_root->dn_flags & DT_NF_COOKED);
41677c478bd9Sstevel@tonic-gate 
41687c478bd9Sstevel@tonic-gate 	/*
41697c478bd9Sstevel@tonic-gate 	 * If we are inlining a translation, verify that the inline declaration
41707c478bd9Sstevel@tonic-gate 	 * type exactly matches the type that is returned by the translation.
41717c478bd9Sstevel@tonic-gate 	 * Otherwise just use dt_node_is_argcompat() to check the types.
41727c478bd9Sstevel@tonic-gate 	 */
41737c478bd9Sstevel@tonic-gate 	if ((rdp = dt_node_resolve(inp->din_root, DT_IDENT_XLSOU)) != NULL ||
41747c478bd9Sstevel@tonic-gate 	    (rdp = dt_node_resolve(inp->din_root, DT_IDENT_XLPTR)) != NULL) {
41757c478bd9Sstevel@tonic-gate 
41767c478bd9Sstevel@tonic-gate 		ctf_file_t *lctfp = dnp->dn_ctfp;
41777c478bd9Sstevel@tonic-gate 		ctf_id_t ltype = ctf_type_resolve(lctfp, dnp->dn_type);
41787c478bd9Sstevel@tonic-gate 
41797c478bd9Sstevel@tonic-gate 		dt_xlator_t *dxp = rdp->di_data;
41807c478bd9Sstevel@tonic-gate 		ctf_file_t *rctfp = dxp->dx_dst_ctfp;
41817c478bd9Sstevel@tonic-gate 		ctf_id_t rtype = dxp->dx_dst_base;
41827c478bd9Sstevel@tonic-gate 
41837c478bd9Sstevel@tonic-gate 		if (ctf_type_kind(lctfp, ltype) == CTF_K_POINTER) {
41847c478bd9Sstevel@tonic-gate 			ltype = ctf_type_reference(lctfp, ltype);
41857c478bd9Sstevel@tonic-gate 			ltype = ctf_type_resolve(lctfp, ltype);
41867c478bd9Sstevel@tonic-gate 		}
41877c478bd9Sstevel@tonic-gate 
41887c478bd9Sstevel@tonic-gate 		if (ctf_type_compat(lctfp, ltype, rctfp, rtype) == 0) {
41897c478bd9Sstevel@tonic-gate 			dnerror(dnp, D_OP_INCOMPAT,
41907c478bd9Sstevel@tonic-gate 			    "inline %s definition uses incompatible types: "
41917c478bd9Sstevel@tonic-gate 			    "\"%s\" = \"%s\"\n", dnp->dn_ident->di_name,
41927c478bd9Sstevel@tonic-gate 			    dt_type_name(lctfp, ltype, n1, sizeof (n1)),
41937c478bd9Sstevel@tonic-gate 			    dt_type_name(rctfp, rtype, n2, sizeof (n2)));
41947c478bd9Sstevel@tonic-gate 		}
41957c478bd9Sstevel@tonic-gate 
41967c478bd9Sstevel@tonic-gate 	} else if (dt_node_is_argcompat(dnp, inp->din_root) == 0) {
41977c478bd9Sstevel@tonic-gate 		dnerror(dnp, D_OP_INCOMPAT,
41987c478bd9Sstevel@tonic-gate 		    "inline %s definition uses incompatible types: "
41997c478bd9Sstevel@tonic-gate 		    "\"%s\" = \"%s\"\n", dnp->dn_ident->di_name,
42007c478bd9Sstevel@tonic-gate 		    dt_node_type_name(dnp, n1, sizeof (n1)),
42017c478bd9Sstevel@tonic-gate 		    dt_node_type_name(inp->din_root, n2, sizeof (n2)));
42027c478bd9Sstevel@tonic-gate 	}
42037c478bd9Sstevel@tonic-gate 
42047c478bd9Sstevel@tonic-gate 	return (dnp);
42057c478bd9Sstevel@tonic-gate }
42067c478bd9Sstevel@tonic-gate 
42077c478bd9Sstevel@tonic-gate static dt_node_t *
42087c478bd9Sstevel@tonic-gate dt_cook_member(dt_node_t *dnp, uint_t idflags)
42097c478bd9Sstevel@tonic-gate {
42107c478bd9Sstevel@tonic-gate 	dnp->dn_membexpr = dt_node_cook(dnp->dn_membexpr, idflags);
42117c478bd9Sstevel@tonic-gate 	dt_node_attr_assign(dnp, dnp->dn_membexpr->dn_attr);
42127c478bd9Sstevel@tonic-gate 	return (dnp);
42137c478bd9Sstevel@tonic-gate }
42147c478bd9Sstevel@tonic-gate 
42157c478bd9Sstevel@tonic-gate /*ARGSUSED*/
42167c478bd9Sstevel@tonic-gate static dt_node_t *
42177c478bd9Sstevel@tonic-gate dt_cook_xlator(dt_node_t *dnp, uint_t idflags)
42187c478bd9Sstevel@tonic-gate {
42197c478bd9Sstevel@tonic-gate 	dtrace_hdl_t *dtp = yypcb->pcb_hdl;
42207c478bd9Sstevel@tonic-gate 	dt_xlator_t *dxp = dnp->dn_xlator;
42217c478bd9Sstevel@tonic-gate 	dt_node_t *mnp;
42227c478bd9Sstevel@tonic-gate 
42237c478bd9Sstevel@tonic-gate 	char n1[DT_TYPE_NAMELEN];
42247c478bd9Sstevel@tonic-gate 	char n2[DT_TYPE_NAMELEN];
42257c478bd9Sstevel@tonic-gate 
42267c478bd9Sstevel@tonic-gate 	dtrace_attribute_t attr = _dtrace_maxattr;
42277c478bd9Sstevel@tonic-gate 	ctf_membinfo_t ctm;
42287c478bd9Sstevel@tonic-gate 
42297c478bd9Sstevel@tonic-gate 	/*
42307c478bd9Sstevel@tonic-gate 	 * Before cooking each translator member, we push a reference to the
42317c478bd9Sstevel@tonic-gate 	 * hash containing translator-local identifiers on to pcb_globals to
42327c478bd9Sstevel@tonic-gate 	 * temporarily interpose these identifiers in front of other globals.
42337c478bd9Sstevel@tonic-gate 	 */
42347c478bd9Sstevel@tonic-gate 	dt_idstack_push(&yypcb->pcb_globals, dxp->dx_locals);
42357c478bd9Sstevel@tonic-gate 
42367c478bd9Sstevel@tonic-gate 	for (mnp = dnp->dn_members; mnp != NULL; mnp = mnp->dn_list) {
42377c478bd9Sstevel@tonic-gate 		if (ctf_member_info(dxp->dx_dst_ctfp, dxp->dx_dst_type,
42387c478bd9Sstevel@tonic-gate 		    mnp->dn_membname, &ctm) == CTF_ERR) {
42397c478bd9Sstevel@tonic-gate 			xyerror(D_XLATE_MEMB,
42407c478bd9Sstevel@tonic-gate 			    "translator member %s is not a member of %s\n",
42417c478bd9Sstevel@tonic-gate 			    mnp->dn_membname, ctf_type_name(dxp->dx_dst_ctfp,
42427c478bd9Sstevel@tonic-gate 			    dxp->dx_dst_type, n1, sizeof (n1)));
42437c478bd9Sstevel@tonic-gate 		}
42447c478bd9Sstevel@tonic-gate 
42457c478bd9Sstevel@tonic-gate 		(void) dt_node_cook(mnp, DT_IDFLG_REF);
42467c478bd9Sstevel@tonic-gate 		dt_node_type_assign(mnp, dxp->dx_dst_ctfp, ctm.ctm_type);
42477c478bd9Sstevel@tonic-gate 		attr = dt_attr_min(attr, mnp->dn_attr);
42487c478bd9Sstevel@tonic-gate 
42497c478bd9Sstevel@tonic-gate 		if (dt_node_is_argcompat(mnp, mnp->dn_membexpr) == 0) {
42507c478bd9Sstevel@tonic-gate 			xyerror(D_XLATE_INCOMPAT,
42517c478bd9Sstevel@tonic-gate 			    "translator member %s definition uses "
42527c478bd9Sstevel@tonic-gate 			    "incompatible types: \"%s\" = \"%s\"\n",
42537c478bd9Sstevel@tonic-gate 			    mnp->dn_membname,
42547c478bd9Sstevel@tonic-gate 			    dt_node_type_name(mnp, n1, sizeof (n1)),
42557c478bd9Sstevel@tonic-gate 			    dt_node_type_name(mnp->dn_membexpr,
42567c478bd9Sstevel@tonic-gate 			    n2, sizeof (n2)));
42577c478bd9Sstevel@tonic-gate 		}
42587c478bd9Sstevel@tonic-gate 	}
42597c478bd9Sstevel@tonic-gate 
42607c478bd9Sstevel@tonic-gate 	dt_idstack_pop(&yypcb->pcb_globals, dxp->dx_locals);
42617c478bd9Sstevel@tonic-gate 
42627c478bd9Sstevel@tonic-gate 	dxp->dx_souid.di_attr = attr;
42637c478bd9Sstevel@tonic-gate 	dxp->dx_ptrid.di_attr = attr;
42647c478bd9Sstevel@tonic-gate 
42657c478bd9Sstevel@tonic-gate 	dt_node_type_assign(dnp, DT_DYN_CTFP(dtp), DT_DYN_TYPE(dtp));
42667c478bd9Sstevel@tonic-gate 	dt_node_attr_assign(dnp, _dtrace_defattr);
42677c478bd9Sstevel@tonic-gate 
42687c478bd9Sstevel@tonic-gate 	return (dnp);
42697c478bd9Sstevel@tonic-gate }
42707c478bd9Sstevel@tonic-gate 
42717c478bd9Sstevel@tonic-gate static void
42727c478bd9Sstevel@tonic-gate dt_node_provider_cmp_argv(dt_provider_t *pvp, dt_node_t *pnp, const char *kind,
42737c478bd9Sstevel@tonic-gate     uint_t old_argc, dt_node_t *old_argv, uint_t new_argc, dt_node_t *new_argv)
42747c478bd9Sstevel@tonic-gate {
42757c478bd9Sstevel@tonic-gate 	dt_probe_t *prp = pnp->dn_ident->di_data;
42767c478bd9Sstevel@tonic-gate 	uint_t i;
42777c478bd9Sstevel@tonic-gate 
42787c478bd9Sstevel@tonic-gate 	char n1[DT_TYPE_NAMELEN];
42797c478bd9Sstevel@tonic-gate 	char n2[DT_TYPE_NAMELEN];
42807c478bd9Sstevel@tonic-gate 
42817c478bd9Sstevel@tonic-gate 	if (old_argc != new_argc) {
42827c478bd9Sstevel@tonic-gate 		dnerror(pnp, D_PROV_INCOMPAT,
42837c478bd9Sstevel@tonic-gate 		    "probe %s:%s %s prototype mismatch:\n"
42847c478bd9Sstevel@tonic-gate 		    "\t current: %u arg%s\n\tprevious: %u arg%s\n",
42857c478bd9Sstevel@tonic-gate 		    pvp->pv_desc.dtvd_name, prp->pr_ident->di_name, kind,
42867c478bd9Sstevel@tonic-gate 		    new_argc, new_argc != 1 ? "s" : "",
42877c478bd9Sstevel@tonic-gate 		    old_argc, old_argc != 1 ? "s" : "");
42887c478bd9Sstevel@tonic-gate 	}
42897c478bd9Sstevel@tonic-gate 
42907c478bd9Sstevel@tonic-gate 	for (i = 0; i < old_argc; i++,
42917c478bd9Sstevel@tonic-gate 	    old_argv = old_argv->dn_list, new_argv = new_argv->dn_list) {
42927c478bd9Sstevel@tonic-gate 		if (ctf_type_cmp(old_argv->dn_ctfp, old_argv->dn_type,
42937c478bd9Sstevel@tonic-gate 		    new_argv->dn_ctfp, new_argv->dn_type) == 0)
42947c478bd9Sstevel@tonic-gate 			continue;
42957c478bd9Sstevel@tonic-gate 
42967c478bd9Sstevel@tonic-gate 		dnerror(pnp, D_PROV_INCOMPAT,
42977c478bd9Sstevel@tonic-gate 		    "probe %s:%s %s prototype argument #%u mismatch:\n"
42987c478bd9Sstevel@tonic-gate 		    "\t current: %s\n\tprevious: %s\n",
42997c478bd9Sstevel@tonic-gate 		    pvp->pv_desc.dtvd_name, prp->pr_ident->di_name, kind, i + 1,
43007c478bd9Sstevel@tonic-gate 		    dt_node_type_name(new_argv, n1, sizeof (n1)),
43017c478bd9Sstevel@tonic-gate 		    dt_node_type_name(old_argv, n2, sizeof (n2)));
43027c478bd9Sstevel@tonic-gate 	}
43037c478bd9Sstevel@tonic-gate }
43047c478bd9Sstevel@tonic-gate 
43057c478bd9Sstevel@tonic-gate /*
43067c478bd9Sstevel@tonic-gate  * Compare a new probe declaration with an existing probe definition (either
43071a7c1b72Smws  * from a previous declaration or cached from the kernel).  If the existing
43081a7c1b72Smws  * definition and declaration both have an input and output parameter list,
43091a7c1b72Smws  * compare both lists.  Otherwise compare only the output parameter lists.
43107c478bd9Sstevel@tonic-gate  */
43117c478bd9Sstevel@tonic-gate static void
43127c478bd9Sstevel@tonic-gate dt_node_provider_cmp(dt_provider_t *pvp, dt_node_t *pnp,
43137c478bd9Sstevel@tonic-gate     dt_probe_t *old, dt_probe_t *new)
43147c478bd9Sstevel@tonic-gate {
43157c478bd9Sstevel@tonic-gate 	dt_node_provider_cmp_argv(pvp, pnp, "output",
43167c478bd9Sstevel@tonic-gate 	    old->pr_xargc, old->pr_xargs, new->pr_xargc, new->pr_xargs);
43177c478bd9Sstevel@tonic-gate 
43181a7c1b72Smws 	if (old->pr_nargs != old->pr_xargs && new->pr_nargs != new->pr_xargs) {
43197c478bd9Sstevel@tonic-gate 		dt_node_provider_cmp_argv(pvp, pnp, "input",
43207c478bd9Sstevel@tonic-gate 		    old->pr_nargc, old->pr_nargs, new->pr_nargc, new->pr_nargs);
43217c478bd9Sstevel@tonic-gate 	}
43221a7c1b72Smws 
43231a7c1b72Smws 	if (old->pr_nargs == old->pr_xargs && new->pr_nargs != new->pr_xargs) {
43241a7c1b72Smws 		if (pvp->pv_flags & DT_PROVIDER_IMPL) {
43251a7c1b72Smws 			dnerror(pnp, D_PROV_INCOMPAT,
43261a7c1b72Smws 			    "provider interface mismatch: %s\n"
43271a7c1b72Smws 			    "\t current: probe %s:%s has an output prototype\n"
43281a7c1b72Smws 			    "\tprevious: probe %s:%s has no output prototype\n",
43291a7c1b72Smws 			    pvp->pv_desc.dtvd_name, pvp->pv_desc.dtvd_name,
43301a7c1b72Smws 			    new->pr_ident->di_name, pvp->pv_desc.dtvd_name,
43311a7c1b72Smws 			    old->pr_ident->di_name);
43321a7c1b72Smws 		}
43331a7c1b72Smws 
43341a7c1b72Smws 		if (old->pr_ident->di_gen == yypcb->pcb_hdl->dt_gen)
43351a7c1b72Smws 			old->pr_ident->di_flags |= DT_IDFLG_ORPHAN;
43361a7c1b72Smws 
43371a7c1b72Smws 		dt_idhash_delete(pvp->pv_probes, old->pr_ident);
43381a7c1b72Smws 		dt_probe_declare(pvp, new);
43391a7c1b72Smws 	}
43401a7c1b72Smws }
43411a7c1b72Smws 
43421a7c1b72Smws static void
43431a7c1b72Smws dt_cook_probe(dt_node_t *dnp, dt_provider_t *pvp)
43441a7c1b72Smws {
43451a7c1b72Smws 	dtrace_hdl_t *dtp = yypcb->pcb_hdl;
43461a7c1b72Smws 	dt_probe_t *prp = dnp->dn_ident->di_data;
43471a7c1b72Smws 
43481a7c1b72Smws 	dt_xlator_t *dxp;
43491a7c1b72Smws 	uint_t i;
43501a7c1b72Smws 
43511a7c1b72Smws 	char n1[DT_TYPE_NAMELEN];
43521a7c1b72Smws 	char n2[DT_TYPE_NAMELEN];
43531a7c1b72Smws 
43541a7c1b72Smws 	if (prp->pr_nargs == prp->pr_xargs)
43551a7c1b72Smws 		return;
43561a7c1b72Smws 
43571a7c1b72Smws 	for (i = 0; i < prp->pr_xargc; i++) {
43581a7c1b72Smws 		dt_node_t *xnp = prp->pr_xargv[i];
43591a7c1b72Smws 		dt_node_t *nnp = prp->pr_nargv[prp->pr_mapping[i]];
43601a7c1b72Smws 
43611a7c1b72Smws 		if ((dxp = dt_xlator_lookup(dtp,
43621a7c1b72Smws 		    nnp, xnp, DT_XLATE_FUZZY)) != NULL) {
43631a7c1b72Smws 			if (dt_provider_xref(dtp, pvp, dxp->dx_id) != 0)
43641a7c1b72Smws 				longjmp(yypcb->pcb_jmpbuf, EDT_NOMEM);
43651a7c1b72Smws 			continue;
43661a7c1b72Smws 		}
43671a7c1b72Smws 
43681a7c1b72Smws 		if (dt_node_is_argcompat(nnp, xnp))
43691a7c1b72Smws 			continue; /* no translator defined and none required */
43701a7c1b72Smws 
43711a7c1b72Smws 		dnerror(dnp, D_PROV_PRXLATOR, "translator for %s:%s output "
43721a7c1b72Smws 		    "argument #%u from %s to %s is not defined\n",
43731a7c1b72Smws 		    pvp->pv_desc.dtvd_name, dnp->dn_ident->di_name, i + 1,
43741a7c1b72Smws 		    dt_node_type_name(nnp, n1, sizeof (n1)),
43751a7c1b72Smws 		    dt_node_type_name(xnp, n2, sizeof (n2)));
43761a7c1b72Smws 	}
43777c478bd9Sstevel@tonic-gate }
43787c478bd9Sstevel@tonic-gate 
43797c478bd9Sstevel@tonic-gate /*ARGSUSED*/
43807c478bd9Sstevel@tonic-gate static dt_node_t *
43817c478bd9Sstevel@tonic-gate dt_cook_provider(dt_node_t *dnp, uint_t idflags)
43827c478bd9Sstevel@tonic-gate {
43837c478bd9Sstevel@tonic-gate 	dt_provider_t *pvp = dnp->dn_provider;
43847c478bd9Sstevel@tonic-gate 	dt_node_t *pnp;
43857c478bd9Sstevel@tonic-gate 
43867c478bd9Sstevel@tonic-gate 	/*
43877c478bd9Sstevel@tonic-gate 	 * If we're declaring a provider for the first time and it is unknown
43887c478bd9Sstevel@tonic-gate 	 * to dtrace(7D), insert the probe definitions into the provider's hash.
43897c478bd9Sstevel@tonic-gate 	 * If we're redeclaring a known provider, verify the interface matches.
43907c478bd9Sstevel@tonic-gate 	 */
43917c478bd9Sstevel@tonic-gate 	for (pnp = dnp->dn_probes; pnp != NULL; pnp = pnp->dn_list) {
43927c478bd9Sstevel@tonic-gate 		const char *probename = pnp->dn_ident->di_name;
43937c478bd9Sstevel@tonic-gate 		dt_probe_t *prp = dt_probe_lookup(pvp, probename);
43947c478bd9Sstevel@tonic-gate 
43957c478bd9Sstevel@tonic-gate 		assert(pnp->dn_kind == DT_NODE_PROBE);
43967c478bd9Sstevel@tonic-gate 
43977c478bd9Sstevel@tonic-gate 		if (prp != NULL && dnp->dn_provred) {
43987c478bd9Sstevel@tonic-gate 			dt_node_provider_cmp(pvp, pnp,
43997c478bd9Sstevel@tonic-gate 			    prp, pnp->dn_ident->di_data);
44007c478bd9Sstevel@tonic-gate 		} else if (prp == NULL && dnp->dn_provred) {
44017c478bd9Sstevel@tonic-gate 			dnerror(pnp, D_PROV_INCOMPAT,
44027c478bd9Sstevel@tonic-gate 			    "provider interface mismatch: %s\n"
44037c478bd9Sstevel@tonic-gate 			    "\t current: probe %s:%s defined\n"
44047c478bd9Sstevel@tonic-gate 			    "\tprevious: probe %s:%s not defined\n",
44057c478bd9Sstevel@tonic-gate 			    dnp->dn_provname, dnp->dn_provname,
44067c478bd9Sstevel@tonic-gate 			    probename, dnp->dn_provname, probename);
44077c478bd9Sstevel@tonic-gate 		} else if (prp != NULL) {
44087c478bd9Sstevel@tonic-gate 			dnerror(pnp, D_PROV_PRDUP, "probe redeclared: %s:%s\n",
44097c478bd9Sstevel@tonic-gate 			    dnp->dn_provname, probename);
44107c478bd9Sstevel@tonic-gate 		} else
44117c478bd9Sstevel@tonic-gate 			dt_probe_declare(pvp, pnp->dn_ident->di_data);
44121a7c1b72Smws 
44131a7c1b72Smws 		dt_cook_probe(pnp, pvp);
44147c478bd9Sstevel@tonic-gate 	}
44157c478bd9Sstevel@tonic-gate 
44167c478bd9Sstevel@tonic-gate 	return (dnp);
44177c478bd9Sstevel@tonic-gate }
44187c478bd9Sstevel@tonic-gate 
44197c478bd9Sstevel@tonic-gate /*ARGSUSED*/
44207c478bd9Sstevel@tonic-gate static dt_node_t *
44217c478bd9Sstevel@tonic-gate dt_cook_none(dt_node_t *dnp, uint_t idflags)
44227c478bd9Sstevel@tonic-gate {
44237c478bd9Sstevel@tonic-gate 	return (dnp);
44247c478bd9Sstevel@tonic-gate }
44257c478bd9Sstevel@tonic-gate 
44267c478bd9Sstevel@tonic-gate static dt_node_t *(*dt_cook_funcs[])(dt_node_t *, uint_t) = {
44277c478bd9Sstevel@tonic-gate 	dt_cook_none,		/* DT_NODE_FREE */
44287c478bd9Sstevel@tonic-gate 	dt_cook_none,		/* DT_NODE_INT */
44297c478bd9Sstevel@tonic-gate 	dt_cook_none,		/* DT_NODE_STRING */
44307c478bd9Sstevel@tonic-gate 	dt_cook_ident,		/* DT_NODE_IDENT */
44317c478bd9Sstevel@tonic-gate 	dt_cook_var,		/* DT_NODE_VAR */
44327c478bd9Sstevel@tonic-gate 	dt_cook_none,		/* DT_NODE_SYM */
44337c478bd9Sstevel@tonic-gate 	dt_cook_none,		/* DT_NODE_TYPE */
44347c478bd9Sstevel@tonic-gate 	dt_cook_func,		/* DT_NODE_FUNC */
44357c478bd9Sstevel@tonic-gate 	dt_cook_op1,		/* DT_NODE_OP1 */
44367c478bd9Sstevel@tonic-gate 	dt_cook_op2,		/* DT_NODE_OP2 */
44377c478bd9Sstevel@tonic-gate 	dt_cook_op3,		/* DT_NODE_OP3 */
44387c478bd9Sstevel@tonic-gate 	dt_cook_statement,	/* DT_NODE_DEXPR */
44397c478bd9Sstevel@tonic-gate 	dt_cook_statement,	/* DT_NODE_DFUNC */
44407c478bd9Sstevel@tonic-gate 	dt_cook_aggregation,	/* DT_NODE_AGG */
44417c478bd9Sstevel@tonic-gate 	dt_cook_none,		/* DT_NODE_PDESC */
44427c478bd9Sstevel@tonic-gate 	dt_cook_clause,		/* DT_NODE_CLAUSE */
44437c478bd9Sstevel@tonic-gate 	dt_cook_inline,		/* DT_NODE_INLINE */
44447c478bd9Sstevel@tonic-gate 	dt_cook_member,		/* DT_NODE_MEMBER */
44457c478bd9Sstevel@tonic-gate 	dt_cook_xlator,		/* DT_NODE_XLATOR */
44467c478bd9Sstevel@tonic-gate 	dt_cook_none,		/* DT_NODE_PROBE */
44477c478bd9Sstevel@tonic-gate 	dt_cook_provider,	/* DT_NODE_PROVIDER */
44487c478bd9Sstevel@tonic-gate 	dt_cook_none		/* DT_NODE_PROG */
44497c478bd9Sstevel@tonic-gate };
44507c478bd9Sstevel@tonic-gate 
44517c478bd9Sstevel@tonic-gate /*
44527c478bd9Sstevel@tonic-gate  * Recursively cook the parse tree starting at the specified node.  The idflags
44537c478bd9Sstevel@tonic-gate  * parameter is used to indicate the type of reference (r/w) and is applied to
44547c478bd9Sstevel@tonic-gate  * the resulting identifier if it is a D variable or D aggregation.
44557c478bd9Sstevel@tonic-gate  */
44567c478bd9Sstevel@tonic-gate dt_node_t *
44577c478bd9Sstevel@tonic-gate dt_node_cook(dt_node_t *dnp, uint_t idflags)
44587c478bd9Sstevel@tonic-gate {
44597c478bd9Sstevel@tonic-gate 	int oldlineno = yylineno;
44607c478bd9Sstevel@tonic-gate 
44617c478bd9Sstevel@tonic-gate 	yylineno = dnp->dn_line;
44627c478bd9Sstevel@tonic-gate 
44637c478bd9Sstevel@tonic-gate 	dnp = dt_cook_funcs[dnp->dn_kind](dnp, idflags);
44647c478bd9Sstevel@tonic-gate 	dnp->dn_flags |= DT_NF_COOKED;
44657c478bd9Sstevel@tonic-gate 
44667c478bd9Sstevel@tonic-gate 	if (dnp->dn_kind == DT_NODE_VAR || dnp->dn_kind == DT_NODE_AGG)
44677c478bd9Sstevel@tonic-gate 		dnp->dn_ident->di_flags |= idflags;
44687c478bd9Sstevel@tonic-gate 
44697c478bd9Sstevel@tonic-gate 	yylineno = oldlineno;
44707c478bd9Sstevel@tonic-gate 	return (dnp);
44717c478bd9Sstevel@tonic-gate }
44727c478bd9Sstevel@tonic-gate 
44737c478bd9Sstevel@tonic-gate dtrace_attribute_t
44747c478bd9Sstevel@tonic-gate dt_node_list_cook(dt_node_t **pnp, uint_t idflags)
44757c478bd9Sstevel@tonic-gate {
44767c478bd9Sstevel@tonic-gate 	dtrace_attribute_t attr = _dtrace_defattr;
44777c478bd9Sstevel@tonic-gate 	dt_node_t *dnp, *nnp;
44787c478bd9Sstevel@tonic-gate 
44797c478bd9Sstevel@tonic-gate 	for (dnp = (pnp != NULL ? *pnp : NULL); dnp != NULL; dnp = nnp) {
44807c478bd9Sstevel@tonic-gate 		nnp = dnp->dn_list;
44817c478bd9Sstevel@tonic-gate 		dnp = *pnp = dt_node_cook(dnp, idflags);
44827c478bd9Sstevel@tonic-gate 		attr = dt_attr_min(attr, dnp->dn_attr);
44837c478bd9Sstevel@tonic-gate 		dnp->dn_list = nnp;
44847c478bd9Sstevel@tonic-gate 		pnp = &dnp->dn_list;
44857c478bd9Sstevel@tonic-gate 	}
44867c478bd9Sstevel@tonic-gate 
44877c478bd9Sstevel@tonic-gate 	return (attr);
44887c478bd9Sstevel@tonic-gate }
44897c478bd9Sstevel@tonic-gate 
44907c478bd9Sstevel@tonic-gate void
44917c478bd9Sstevel@tonic-gate dt_node_list_free(dt_node_t **pnp)
44927c478bd9Sstevel@tonic-gate {
44937c478bd9Sstevel@tonic-gate 	dt_node_t *dnp, *nnp;
44947c478bd9Sstevel@tonic-gate 
44957c478bd9Sstevel@tonic-gate 	for (dnp = (pnp != NULL ? *pnp : NULL); dnp != NULL; dnp = nnp) {
44967c478bd9Sstevel@tonic-gate 		nnp = dnp->dn_list;
44977c478bd9Sstevel@tonic-gate 		dt_node_free(dnp);
44987c478bd9Sstevel@tonic-gate 	}
44997c478bd9Sstevel@tonic-gate 
45007c478bd9Sstevel@tonic-gate 	if (pnp != NULL)
45017c478bd9Sstevel@tonic-gate 		*pnp = NULL;
45027c478bd9Sstevel@tonic-gate }
45037c478bd9Sstevel@tonic-gate 
45047c478bd9Sstevel@tonic-gate void
45057c478bd9Sstevel@tonic-gate dt_node_link_free(dt_node_t **pnp)
45067c478bd9Sstevel@tonic-gate {
45077c478bd9Sstevel@tonic-gate 	dt_node_t *dnp, *nnp;
45087c478bd9Sstevel@tonic-gate 
45097c478bd9Sstevel@tonic-gate 	for (dnp = (pnp != NULL ? *pnp : NULL); dnp != NULL; dnp = nnp) {
45107c478bd9Sstevel@tonic-gate 		nnp = dnp->dn_link;
45117c478bd9Sstevel@tonic-gate 		dt_node_free(dnp);
45127c478bd9Sstevel@tonic-gate 	}
45137c478bd9Sstevel@tonic-gate 
45147c478bd9Sstevel@tonic-gate 	for (dnp = (pnp != NULL ? *pnp : NULL); dnp != NULL; dnp = nnp) {
45157c478bd9Sstevel@tonic-gate 		nnp = dnp->dn_link;
45167c478bd9Sstevel@tonic-gate 		free(dnp);
45177c478bd9Sstevel@tonic-gate 	}
45187c478bd9Sstevel@tonic-gate 
45197c478bd9Sstevel@tonic-gate 	if (pnp != NULL)
45207c478bd9Sstevel@tonic-gate 		*pnp = NULL;
45217c478bd9Sstevel@tonic-gate }
45227c478bd9Sstevel@tonic-gate 
45237c478bd9Sstevel@tonic-gate dt_node_t *
45247c478bd9Sstevel@tonic-gate dt_node_link(dt_node_t *lp, dt_node_t *rp)
45257c478bd9Sstevel@tonic-gate {
45267c478bd9Sstevel@tonic-gate 	dt_node_t *dnp;
45277c478bd9Sstevel@tonic-gate 
45287c478bd9Sstevel@tonic-gate 	if (lp == NULL)
45297c478bd9Sstevel@tonic-gate 		return (rp);
45307c478bd9Sstevel@tonic-gate 	else if (rp == NULL)
45317c478bd9Sstevel@tonic-gate 		return (lp);
45327c478bd9Sstevel@tonic-gate 
45337c478bd9Sstevel@tonic-gate 	for (dnp = lp; dnp->dn_list != NULL; dnp = dnp->dn_list)
45347c478bd9Sstevel@tonic-gate 		continue;
45357c478bd9Sstevel@tonic-gate 
45367c478bd9Sstevel@tonic-gate 	dnp->dn_list = rp;
45377c478bd9Sstevel@tonic-gate 	return (lp);
45387c478bd9Sstevel@tonic-gate }
45397c478bd9Sstevel@tonic-gate 
45401a7c1b72Smws /*
45411a7c1b72Smws  * Compute the DOF dtrace_diftype_t representation of a node's type.  This is
45421a7c1b72Smws  * called from a variety of places in the library so it cannot assume yypcb
45431a7c1b72Smws  * is valid: any references to handle-specific data must be made through 'dtp'.
45441a7c1b72Smws  */
45457c478bd9Sstevel@tonic-gate void
45461a7c1b72Smws dt_node_diftype(dtrace_hdl_t *dtp, const dt_node_t *dnp, dtrace_diftype_t *tp)
45477c478bd9Sstevel@tonic-gate {
45481a7c1b72Smws 	if (dnp->dn_ctfp == DT_STR_CTFP(dtp) &&
45491a7c1b72Smws 	    dnp->dn_type == DT_STR_TYPE(dtp)) {
45507c478bd9Sstevel@tonic-gate 		tp->dtdt_kind = DIF_TYPE_STRING;
45517c478bd9Sstevel@tonic-gate 		tp->dtdt_ckind = CTF_K_UNKNOWN;
45527c478bd9Sstevel@tonic-gate 	} else {
45537c478bd9Sstevel@tonic-gate 		tp->dtdt_kind = DIF_TYPE_CTF;
45547c478bd9Sstevel@tonic-gate 		tp->dtdt_ckind = ctf_type_kind(dnp->dn_ctfp,
45557c478bd9Sstevel@tonic-gate 		    ctf_type_resolve(dnp->dn_ctfp, dnp->dn_type));
45567c478bd9Sstevel@tonic-gate 	}
45577c478bd9Sstevel@tonic-gate 
45587c478bd9Sstevel@tonic-gate 	tp->dtdt_flags = (dnp->dn_flags & DT_NF_REF) ? DIF_TF_BYREF : 0;
45597c478bd9Sstevel@tonic-gate 	tp->dtdt_pad = 0;
45607c478bd9Sstevel@tonic-gate 	tp->dtdt_size = ctf_type_size(dnp->dn_ctfp, dnp->dn_type);
45617c478bd9Sstevel@tonic-gate }
45627c478bd9Sstevel@tonic-gate 
45637c478bd9Sstevel@tonic-gate void
45647c478bd9Sstevel@tonic-gate dt_node_printr(dt_node_t *dnp, FILE *fp, int depth)
45657c478bd9Sstevel@tonic-gate {
45667c478bd9Sstevel@tonic-gate 	char n[DT_TYPE_NAMELEN], buf[BUFSIZ], a[8];
45677c478bd9Sstevel@tonic-gate 	const dtrace_syminfo_t *dts;
45687c478bd9Sstevel@tonic-gate 	const dt_idnode_t *inp;
45697c478bd9Sstevel@tonic-gate 	dt_node_t *arg;
45707c478bd9Sstevel@tonic-gate 
45717c478bd9Sstevel@tonic-gate 	(void) fprintf(fp, "%*s", depth * 2, "");
45727c478bd9Sstevel@tonic-gate 	(void) dt_attr_str(dnp->dn_attr, a, sizeof (a));
45737c478bd9Sstevel@tonic-gate 
45747c478bd9Sstevel@tonic-gate 	if (dnp->dn_ctfp != NULL && dnp->dn_type != CTF_ERR &&
45757c478bd9Sstevel@tonic-gate 	    ctf_type_name(dnp->dn_ctfp, dnp->dn_type, n, sizeof (n)) != NULL) {
45767c478bd9Sstevel@tonic-gate 		(void) snprintf(buf, BUFSIZ, "type=<%s> attr=%s flags=", n, a);
45777c478bd9Sstevel@tonic-gate 	} else {
45787c478bd9Sstevel@tonic-gate 		(void) snprintf(buf, BUFSIZ, "type=<%ld> attr=%s flags=",
45797c478bd9Sstevel@tonic-gate 		    dnp->dn_type, a);
45807c478bd9Sstevel@tonic-gate 	}
45817c478bd9Sstevel@tonic-gate 
45827c478bd9Sstevel@tonic-gate 	if (dnp->dn_flags != 0) {
45837c478bd9Sstevel@tonic-gate 		n[0] = '\0';
45847c478bd9Sstevel@tonic-gate 		if (dnp->dn_flags & DT_NF_SIGNED)
45857c478bd9Sstevel@tonic-gate 			(void) strcat(n, ",SIGN");
45867c478bd9Sstevel@tonic-gate 		if (dnp->dn_flags & DT_NF_COOKED)
45877c478bd9Sstevel@tonic-gate 			(void) strcat(n, ",COOK");
45887c478bd9Sstevel@tonic-gate 		if (dnp->dn_flags & DT_NF_REF)
45897c478bd9Sstevel@tonic-gate 			(void) strcat(n, ",REF");
45907c478bd9Sstevel@tonic-gate 		if (dnp->dn_flags & DT_NF_LVALUE)
45917c478bd9Sstevel@tonic-gate 			(void) strcat(n, ",LVAL");
45927c478bd9Sstevel@tonic-gate 		if (dnp->dn_flags & DT_NF_WRITABLE)
45937c478bd9Sstevel@tonic-gate 			(void) strcat(n, ",WRITE");
45947c478bd9Sstevel@tonic-gate 		if (dnp->dn_flags & DT_NF_BITFIELD)
45957c478bd9Sstevel@tonic-gate 			(void) strcat(n, ",BITF");
45967c478bd9Sstevel@tonic-gate 		if (dnp->dn_flags & DT_NF_USERLAND)
45977c478bd9Sstevel@tonic-gate 			(void) strcat(n, ",USER");
45987c478bd9Sstevel@tonic-gate 		(void) strcat(buf, n + 1);
45997c478bd9Sstevel@tonic-gate 	} else
46007c478bd9Sstevel@tonic-gate 		(void) strcat(buf, "0");
46017c478bd9Sstevel@tonic-gate 
46027c478bd9Sstevel@tonic-gate 	switch (dnp->dn_kind) {
46037c478bd9Sstevel@tonic-gate 	case DT_NODE_FREE:
46047c478bd9Sstevel@tonic-gate 		(void) fprintf(fp, "FREE <node %p>\n", (void *)dnp);
46057c478bd9Sstevel@tonic-gate 		break;
46067c478bd9Sstevel@tonic-gate 
46077c478bd9Sstevel@tonic-gate 	case DT_NODE_INT:
46087c478bd9Sstevel@tonic-gate 		(void) fprintf(fp, "INT 0x%llx (%s)\n",
46097c478bd9Sstevel@tonic-gate 		    (u_longlong_t)dnp->dn_value, buf);
46107c478bd9Sstevel@tonic-gate 		break;
46117c478bd9Sstevel@tonic-gate 
46127c478bd9Sstevel@tonic-gate 	case DT_NODE_STRING:
46137c478bd9Sstevel@tonic-gate 		(void) fprintf(fp, "STRING \"%s\" (%s)\n", dnp->dn_string, buf);
46147c478bd9Sstevel@tonic-gate 		break;
46157c478bd9Sstevel@tonic-gate 
46167c478bd9Sstevel@tonic-gate 	case DT_NODE_IDENT:
46177c478bd9Sstevel@tonic-gate 		(void) fprintf(fp, "IDENT %s (%s)\n", dnp->dn_string, buf);
46187c478bd9Sstevel@tonic-gate 		break;
46197c478bd9Sstevel@tonic-gate 
46207c478bd9Sstevel@tonic-gate 	case DT_NODE_VAR:
46217c478bd9Sstevel@tonic-gate 		(void) fprintf(fp, "VARIABLE %s%s (%s)\n",
46227c478bd9Sstevel@tonic-gate 		    (dnp->dn_ident->di_flags & DT_IDFLG_LOCAL) ? "this->" :
46237c478bd9Sstevel@tonic-gate 		    (dnp->dn_ident->di_flags & DT_IDFLG_TLS) ? "self->" : "",
46247c478bd9Sstevel@tonic-gate 		    dnp->dn_ident->di_name, buf);
46257c478bd9Sstevel@tonic-gate 
46267c478bd9Sstevel@tonic-gate 		if (dnp->dn_args != NULL)
46277c478bd9Sstevel@tonic-gate 			(void) fprintf(fp, "%*s[\n", depth * 2, "");
46287c478bd9Sstevel@tonic-gate 
46297c478bd9Sstevel@tonic-gate 		for (arg = dnp->dn_args; arg != NULL; arg = arg->dn_list) {
46307c478bd9Sstevel@tonic-gate 			dt_node_printr(arg, fp, depth + 1);
46317c478bd9Sstevel@tonic-gate 			if (arg->dn_list != NULL)
46327c478bd9Sstevel@tonic-gate 				(void) fprintf(fp, "%*s,\n", depth * 2, "");
46337c478bd9Sstevel@tonic-gate 		}
46347c478bd9Sstevel@tonic-gate 
46357c478bd9Sstevel@tonic-gate 		if (dnp->dn_args != NULL)
46367c478bd9Sstevel@tonic-gate 			(void) fprintf(fp, "%*s]\n", depth * 2, "");
46377c478bd9Sstevel@tonic-gate 		break;
46387c478bd9Sstevel@tonic-gate 
46397c478bd9Sstevel@tonic-gate 	case DT_NODE_SYM:
46407c478bd9Sstevel@tonic-gate 		dts = dnp->dn_ident->di_data;
46417c478bd9Sstevel@tonic-gate 		(void) fprintf(fp, "SYMBOL %s`%s (%s)\n",
46427c478bd9Sstevel@tonic-gate 		    dts->dts_object, dts->dts_name, buf);
46437c478bd9Sstevel@tonic-gate 		break;
46447c478bd9Sstevel@tonic-gate 
46457c478bd9Sstevel@tonic-gate 	case DT_NODE_TYPE:
46467c478bd9Sstevel@tonic-gate 		if (dnp->dn_string != NULL) {
46477c478bd9Sstevel@tonic-gate 			(void) fprintf(fp, "TYPE (%s) %s\n",
46487c478bd9Sstevel@tonic-gate 			    buf, dnp->dn_string);
46497c478bd9Sstevel@tonic-gate 		} else
46507c478bd9Sstevel@tonic-gate 			(void) fprintf(fp, "TYPE (%s)\n", buf);
46517c478bd9Sstevel@tonic-gate 		break;
46527c478bd9Sstevel@tonic-gate 
46537c478bd9Sstevel@tonic-gate 	case DT_NODE_FUNC:
46547c478bd9Sstevel@tonic-gate 		(void) fprintf(fp, "FUNC %s (%s)\n",
46557c478bd9Sstevel@tonic-gate 		    dnp->dn_ident->di_name, buf);
46567c478bd9Sstevel@tonic-gate 
46577c478bd9Sstevel@tonic-gate 		for (arg = dnp->dn_args; arg != NULL; arg = arg->dn_list) {
46587c478bd9Sstevel@tonic-gate 			dt_node_printr(arg, fp, depth + 1);
46597c478bd9Sstevel@tonic-gate 			if (arg->dn_list != NULL)
46607c478bd9Sstevel@tonic-gate 				(void) fprintf(fp, "%*s,\n", depth * 2, "");
46617c478bd9Sstevel@tonic-gate 		}
46627c478bd9Sstevel@tonic-gate 		break;
46637c478bd9Sstevel@tonic-gate 
46647c478bd9Sstevel@tonic-gate 	case DT_NODE_OP1:
46657c478bd9Sstevel@tonic-gate 		(void) fprintf(fp, "OP1 %s (%s)\n", opstr(dnp->dn_op), buf);
46667c478bd9Sstevel@tonic-gate 		dt_node_printr(dnp->dn_child, fp, depth + 1);
46677c478bd9Sstevel@tonic-gate 		break;
46687c478bd9Sstevel@tonic-gate 
46697c478bd9Sstevel@tonic-gate 	case DT_NODE_OP2:
46707c478bd9Sstevel@tonic-gate 		(void) fprintf(fp, "OP2 %s (%s)\n", opstr(dnp->dn_op), buf);
46717c478bd9Sstevel@tonic-gate 		dt_node_printr(dnp->dn_left, fp, depth + 1);
46727c478bd9Sstevel@tonic-gate 		dt_node_printr(dnp->dn_right, fp, depth + 1);
46737c478bd9Sstevel@tonic-gate 		break;
46747c478bd9Sstevel@tonic-gate 
46757c478bd9Sstevel@tonic-gate 	case DT_NODE_OP3:
46767c478bd9Sstevel@tonic-gate 		(void) fprintf(fp, "OP3 (%s)\n", buf);
46777c478bd9Sstevel@tonic-gate 		dt_node_printr(dnp->dn_expr, fp, depth + 1);
46787c478bd9Sstevel@tonic-gate 		(void) fprintf(fp, "%*s?\n", depth * 2, "");
46797c478bd9Sstevel@tonic-gate 		dt_node_printr(dnp->dn_left, fp, depth + 1);
46807c478bd9Sstevel@tonic-gate 		(void) fprintf(fp, "%*s:\n", depth * 2, "");
46817c478bd9Sstevel@tonic-gate 		dt_node_printr(dnp->dn_right, fp, depth + 1);
46827c478bd9Sstevel@tonic-gate 		break;
46837c478bd9Sstevel@tonic-gate 
46847c478bd9Sstevel@tonic-gate 	case DT_NODE_DEXPR:
46857c478bd9Sstevel@tonic-gate 	case DT_NODE_DFUNC:
46867c478bd9Sstevel@tonic-gate 		(void) fprintf(fp, "D EXPRESSION attr=%s\n", a);
46877c478bd9Sstevel@tonic-gate 		dt_node_printr(dnp->dn_expr, fp, depth + 1);
46887c478bd9Sstevel@tonic-gate 		break;
46897c478bd9Sstevel@tonic-gate 
46907c478bd9Sstevel@tonic-gate 	case DT_NODE_AGG:
46917c478bd9Sstevel@tonic-gate 		(void) fprintf(fp, "AGGREGATE @%s attr=%s [\n",
46927c478bd9Sstevel@tonic-gate 		    dnp->dn_ident->di_name, a);
46937c478bd9Sstevel@tonic-gate 
46947c478bd9Sstevel@tonic-gate 		for (arg = dnp->dn_aggtup; arg != NULL; arg = arg->dn_list) {
46957c478bd9Sstevel@tonic-gate 			dt_node_printr(arg, fp, depth + 1);
46967c478bd9Sstevel@tonic-gate 			if (arg->dn_list != NULL)
46977c478bd9Sstevel@tonic-gate 				(void) fprintf(fp, "%*s,\n", depth * 2, "");
46987c478bd9Sstevel@tonic-gate 		}
46997c478bd9Sstevel@tonic-gate 
47007c478bd9Sstevel@tonic-gate 		if (dnp->dn_aggfun) {
47017c478bd9Sstevel@tonic-gate 			(void) fprintf(fp, "%*s] = ", depth * 2, "");
47027c478bd9Sstevel@tonic-gate 			dt_node_printr(dnp->dn_aggfun, fp, depth + 1);
47037c478bd9Sstevel@tonic-gate 		} else
47047c478bd9Sstevel@tonic-gate 			(void) fprintf(fp, "%*s]\n", depth * 2, "");
47057c478bd9Sstevel@tonic-gate 
47067c478bd9Sstevel@tonic-gate 		if (dnp->dn_aggfun)
47077c478bd9Sstevel@tonic-gate 			(void) fprintf(fp, "%*s)\n", depth * 2, "");
47087c478bd9Sstevel@tonic-gate 		break;
47097c478bd9Sstevel@tonic-gate 
47107c478bd9Sstevel@tonic-gate 	case DT_NODE_PDESC:
47117c478bd9Sstevel@tonic-gate 		(void) fprintf(fp, "PDESC %s:%s:%s:%s [%u]\n",
47127c478bd9Sstevel@tonic-gate 		    dnp->dn_desc->dtpd_provider, dnp->dn_desc->dtpd_mod,
47137c478bd9Sstevel@tonic-gate 		    dnp->dn_desc->dtpd_func, dnp->dn_desc->dtpd_name,
47147c478bd9Sstevel@tonic-gate 		    dnp->dn_desc->dtpd_id);
47157c478bd9Sstevel@tonic-gate 		break;
47167c478bd9Sstevel@tonic-gate 
47177c478bd9Sstevel@tonic-gate 	case DT_NODE_CLAUSE:
47187c478bd9Sstevel@tonic-gate 		(void) fprintf(fp, "CLAUSE attr=%s\n", a);
47197c478bd9Sstevel@tonic-gate 
47207c478bd9Sstevel@tonic-gate 		for (arg = dnp->dn_pdescs; arg != NULL; arg = arg->dn_list)
47217c478bd9Sstevel@tonic-gate 			dt_node_printr(arg, fp, depth + 1);
47227c478bd9Sstevel@tonic-gate 
47237c478bd9Sstevel@tonic-gate 		(void) fprintf(fp, "%*sCTXATTR %s\n", depth * 2, "",
47247c478bd9Sstevel@tonic-gate 		    dt_attr_str(dnp->dn_ctxattr, a, sizeof (a)));
47257c478bd9Sstevel@tonic-gate 
47267c478bd9Sstevel@tonic-gate 		if (dnp->dn_pred != NULL) {
47277c478bd9Sstevel@tonic-gate 			(void) fprintf(fp, "%*sPREDICATE /\n", depth * 2, "");
47287c478bd9Sstevel@tonic-gate 			dt_node_printr(dnp->dn_pred, fp, depth + 1);
47297c478bd9Sstevel@tonic-gate 			(void) fprintf(fp, "%*s/\n", depth * 2, "");
47307c478bd9Sstevel@tonic-gate 		}
47317c478bd9Sstevel@tonic-gate 
47327c478bd9Sstevel@tonic-gate 		for (arg = dnp->dn_acts; arg != NULL; arg = arg->dn_list)
47337c478bd9Sstevel@tonic-gate 			dt_node_printr(arg, fp, depth + 1);
47347c478bd9Sstevel@tonic-gate 		break;
47357c478bd9Sstevel@tonic-gate 
47367c478bd9Sstevel@tonic-gate 	case DT_NODE_INLINE:
47377c478bd9Sstevel@tonic-gate 		inp = dnp->dn_ident->di_iarg;
47387c478bd9Sstevel@tonic-gate 
47397c478bd9Sstevel@tonic-gate 		(void) fprintf(fp, "INLINE %s (%s)\n",
47407c478bd9Sstevel@tonic-gate 		    dnp->dn_ident->di_name, buf);
47417c478bd9Sstevel@tonic-gate 		dt_node_printr(inp->din_root, fp, depth + 1);
47427c478bd9Sstevel@tonic-gate 		break;
47437c478bd9Sstevel@tonic-gate 
47447c478bd9Sstevel@tonic-gate 	case DT_NODE_MEMBER:
47457c478bd9Sstevel@tonic-gate 		(void) fprintf(fp, "MEMBER %s (%s)\n", dnp->dn_membname, buf);
47467c478bd9Sstevel@tonic-gate 		if (dnp->dn_membexpr)
47477c478bd9Sstevel@tonic-gate 			dt_node_printr(dnp->dn_membexpr, fp, depth + 1);
47487c478bd9Sstevel@tonic-gate 		break;
47497c478bd9Sstevel@tonic-gate 
47507c478bd9Sstevel@tonic-gate 	case DT_NODE_XLATOR:
47517c478bd9Sstevel@tonic-gate 		(void) fprintf(fp, "XLATOR (%s)", buf);
47527c478bd9Sstevel@tonic-gate 
47537c478bd9Sstevel@tonic-gate 		if (ctf_type_name(dnp->dn_xlator->dx_src_ctfp,
47547c478bd9Sstevel@tonic-gate 		    dnp->dn_xlator->dx_src_type, n, sizeof (n)) != NULL)
47557c478bd9Sstevel@tonic-gate 			(void) fprintf(fp, " from <%s>", n);
47567c478bd9Sstevel@tonic-gate 
47577c478bd9Sstevel@tonic-gate 		if (ctf_type_name(dnp->dn_xlator->dx_dst_ctfp,
47587c478bd9Sstevel@tonic-gate 		    dnp->dn_xlator->dx_dst_type, n, sizeof (n)) != NULL)
47597c478bd9Sstevel@tonic-gate 			(void) fprintf(fp, " to <%s>", n);
47607c478bd9Sstevel@tonic-gate 
47617c478bd9Sstevel@tonic-gate 		(void) fprintf(fp, "\n");
47627c478bd9Sstevel@tonic-gate 
47637c478bd9Sstevel@tonic-gate 		for (arg = dnp->dn_members; arg != NULL; arg = arg->dn_list)
47647c478bd9Sstevel@tonic-gate 			dt_node_printr(arg, fp, depth + 1);
47657c478bd9Sstevel@tonic-gate 		break;
47667c478bd9Sstevel@tonic-gate 
47677c478bd9Sstevel@tonic-gate 	case DT_NODE_PROBE:
47687c478bd9Sstevel@tonic-gate 		(void) fprintf(fp, "PROBE %s\n", dnp->dn_ident->di_name);
47697c478bd9Sstevel@tonic-gate 		break;
47707c478bd9Sstevel@tonic-gate 
47717c478bd9Sstevel@tonic-gate 	case DT_NODE_PROVIDER:
47727c478bd9Sstevel@tonic-gate 		(void) fprintf(fp, "PROVIDER %s (%s)\n",
47737c478bd9Sstevel@tonic-gate 		    dnp->dn_provname, dnp->dn_provred ? "redecl" : "decl");
47747c478bd9Sstevel@tonic-gate 		for (arg = dnp->dn_probes; arg != NULL; arg = arg->dn_list)
47757c478bd9Sstevel@tonic-gate 			dt_node_printr(arg, fp, depth + 1);
47767c478bd9Sstevel@tonic-gate 		break;
47777c478bd9Sstevel@tonic-gate 
47787c478bd9Sstevel@tonic-gate 	case DT_NODE_PROG:
47797c478bd9Sstevel@tonic-gate 		(void) fprintf(fp, "PROGRAM attr=%s\n", a);
47807c478bd9Sstevel@tonic-gate 		for (arg = dnp->dn_list; arg != NULL; arg = arg->dn_list)
47817c478bd9Sstevel@tonic-gate 			dt_node_printr(arg, fp, depth + 1);
47827c478bd9Sstevel@tonic-gate 		break;
47837c478bd9Sstevel@tonic-gate 
47847c478bd9Sstevel@tonic-gate 	default:
47857c478bd9Sstevel@tonic-gate 		(void) fprintf(fp, "<bad node %p, kind %d>\n",
47867c478bd9Sstevel@tonic-gate 		    (void *)dnp, dnp->dn_kind);
47877c478bd9Sstevel@tonic-gate 	}
47887c478bd9Sstevel@tonic-gate }
47897c478bd9Sstevel@tonic-gate 
47907c478bd9Sstevel@tonic-gate int
47917c478bd9Sstevel@tonic-gate dt_node_root(dt_node_t *dnp)
47927c478bd9Sstevel@tonic-gate {
47937c478bd9Sstevel@tonic-gate 	yypcb->pcb_root = dnp;
47947c478bd9Sstevel@tonic-gate 	return (0);
47957c478bd9Sstevel@tonic-gate }
47967c478bd9Sstevel@tonic-gate 
47977c478bd9Sstevel@tonic-gate /*PRINTFLIKE3*/
47987c478bd9Sstevel@tonic-gate void
47997c478bd9Sstevel@tonic-gate dnerror(const dt_node_t *dnp, dt_errtag_t tag, const char *format, ...)
48007c478bd9Sstevel@tonic-gate {
48017c478bd9Sstevel@tonic-gate 	int oldlineno = yylineno;
48027c478bd9Sstevel@tonic-gate 	va_list ap;
48037c478bd9Sstevel@tonic-gate 
48047c478bd9Sstevel@tonic-gate 	yylineno = dnp->dn_line;
48057c478bd9Sstevel@tonic-gate 
48067c478bd9Sstevel@tonic-gate 	va_start(ap, format);
48077c478bd9Sstevel@tonic-gate 	xyvwarn(tag, format, ap);
48087c478bd9Sstevel@tonic-gate 	va_end(ap);
48097c478bd9Sstevel@tonic-gate 
48107c478bd9Sstevel@tonic-gate 	yylineno = oldlineno;
48117c478bd9Sstevel@tonic-gate 	longjmp(yypcb->pcb_jmpbuf, EDT_COMPILER);
48127c478bd9Sstevel@tonic-gate }
48137c478bd9Sstevel@tonic-gate 
48147c478bd9Sstevel@tonic-gate /*PRINTFLIKE3*/
48157c478bd9Sstevel@tonic-gate void
48167c478bd9Sstevel@tonic-gate dnwarn(const dt_node_t *dnp, dt_errtag_t tag, const char *format, ...)
48177c478bd9Sstevel@tonic-gate {
48187c478bd9Sstevel@tonic-gate 	int oldlineno = yylineno;
48197c478bd9Sstevel@tonic-gate 	va_list ap;
48207c478bd9Sstevel@tonic-gate 
48217c478bd9Sstevel@tonic-gate 	yylineno = dnp->dn_line;
48227c478bd9Sstevel@tonic-gate 
48237c478bd9Sstevel@tonic-gate 	va_start(ap, format);
48247c478bd9Sstevel@tonic-gate 	xyvwarn(tag, format, ap);
48257c478bd9Sstevel@tonic-gate 	va_end(ap);
48267c478bd9Sstevel@tonic-gate 
48277c478bd9Sstevel@tonic-gate 	yylineno = oldlineno;
48287c478bd9Sstevel@tonic-gate }
48297c478bd9Sstevel@tonic-gate 
48307c478bd9Sstevel@tonic-gate /*PRINTFLIKE2*/
48317c478bd9Sstevel@tonic-gate void
48327c478bd9Sstevel@tonic-gate xyerror(dt_errtag_t tag, const char *format, ...)
48337c478bd9Sstevel@tonic-gate {
48347c478bd9Sstevel@tonic-gate 	va_list ap;
48357c478bd9Sstevel@tonic-gate 
48367c478bd9Sstevel@tonic-gate 	va_start(ap, format);
48377c478bd9Sstevel@tonic-gate 	xyvwarn(tag, format, ap);
48387c478bd9Sstevel@tonic-gate 	va_end(ap);
48397c478bd9Sstevel@tonic-gate 
48407c478bd9Sstevel@tonic-gate 	longjmp(yypcb->pcb_jmpbuf, EDT_COMPILER);
48417c478bd9Sstevel@tonic-gate }
48427c478bd9Sstevel@tonic-gate 
48437c478bd9Sstevel@tonic-gate /*PRINTFLIKE2*/
48447c478bd9Sstevel@tonic-gate void
48457c478bd9Sstevel@tonic-gate xywarn(dt_errtag_t tag, const char *format, ...)
48467c478bd9Sstevel@tonic-gate {
48477c478bd9Sstevel@tonic-gate 	va_list ap;
48487c478bd9Sstevel@tonic-gate 
48497c478bd9Sstevel@tonic-gate 	va_start(ap, format);
48507c478bd9Sstevel@tonic-gate 	xyvwarn(tag, format, ap);
48517c478bd9Sstevel@tonic-gate 	va_end(ap);
48527c478bd9Sstevel@tonic-gate }
48537c478bd9Sstevel@tonic-gate 
48547c478bd9Sstevel@tonic-gate void
48557c478bd9Sstevel@tonic-gate xyvwarn(dt_errtag_t tag, const char *format, va_list ap)
48567c478bd9Sstevel@tonic-gate {
48577c478bd9Sstevel@tonic-gate 	if (yypcb == NULL)
48587c478bd9Sstevel@tonic-gate 		return; /* compiler is not currently active: act as a no-op */
48597c478bd9Sstevel@tonic-gate 
48607c478bd9Sstevel@tonic-gate 	dt_set_errmsg(yypcb->pcb_hdl, dt_errtag(tag), yypcb->pcb_region,
48617c478bd9Sstevel@tonic-gate 	    yypcb->pcb_filetag, yypcb->pcb_fileptr ? yylineno : 0, format, ap);
48627c478bd9Sstevel@tonic-gate }
48637c478bd9Sstevel@tonic-gate 
48647c478bd9Sstevel@tonic-gate /*PRINTFLIKE1*/
48657c478bd9Sstevel@tonic-gate void
48667c478bd9Sstevel@tonic-gate yyerror(const char *format, ...)
48677c478bd9Sstevel@tonic-gate {
48687c478bd9Sstevel@tonic-gate 	va_list ap;
48697c478bd9Sstevel@tonic-gate 
48707c478bd9Sstevel@tonic-gate 	va_start(ap, format);
48717c478bd9Sstevel@tonic-gate 	yyvwarn(format, ap);
48727c478bd9Sstevel@tonic-gate 	va_end(ap);
48737c478bd9Sstevel@tonic-gate 
48747c478bd9Sstevel@tonic-gate 	longjmp(yypcb->pcb_jmpbuf, EDT_COMPILER);
48757c478bd9Sstevel@tonic-gate }
48767c478bd9Sstevel@tonic-gate 
48777c478bd9Sstevel@tonic-gate /*PRINTFLIKE1*/
48787c478bd9Sstevel@tonic-gate void
48797c478bd9Sstevel@tonic-gate yywarn(const char *format, ...)
48807c478bd9Sstevel@tonic-gate {
48817c478bd9Sstevel@tonic-gate 	va_list ap;
48827c478bd9Sstevel@tonic-gate 
48837c478bd9Sstevel@tonic-gate 	va_start(ap, format);
48847c478bd9Sstevel@tonic-gate 	yyvwarn(format, ap);
48857c478bd9Sstevel@tonic-gate 	va_end(ap);
48867c478bd9Sstevel@tonic-gate }
48877c478bd9Sstevel@tonic-gate 
48887c478bd9Sstevel@tonic-gate void
48897c478bd9Sstevel@tonic-gate yyvwarn(const char *format, va_list ap)
48907c478bd9Sstevel@tonic-gate {
48917c478bd9Sstevel@tonic-gate 	if (yypcb == NULL)
48927c478bd9Sstevel@tonic-gate 		return; /* compiler is not currently active: act as a no-op */
48937c478bd9Sstevel@tonic-gate 
48947c478bd9Sstevel@tonic-gate 	dt_set_errmsg(yypcb->pcb_hdl, dt_errtag(D_SYNTAX), yypcb->pcb_region,
48957c478bd9Sstevel@tonic-gate 	    yypcb->pcb_filetag, yypcb->pcb_fileptr ? yylineno : 0, format, ap);
48967c478bd9Sstevel@tonic-gate 
48977c478bd9Sstevel@tonic-gate 	if (strchr(format, '\n') == NULL) {
48987c478bd9Sstevel@tonic-gate 		dtrace_hdl_t *dtp = yypcb->pcb_hdl;
48997c478bd9Sstevel@tonic-gate 		size_t len = strlen(dtp->dt_errmsg);
49007c478bd9Sstevel@tonic-gate 		char *p, *s = dtp->dt_errmsg + len;
49017c478bd9Sstevel@tonic-gate 		size_t n = sizeof (dtp->dt_errmsg) - len;
49027c478bd9Sstevel@tonic-gate 
49037c478bd9Sstevel@tonic-gate 		if (yytext[0] == '\0')
49047c478bd9Sstevel@tonic-gate 			(void) snprintf(s, n, " near end of input");
49057c478bd9Sstevel@tonic-gate 		else if (yytext[0] == '\n')
49067c478bd9Sstevel@tonic-gate 			(void) snprintf(s, n, " near end of line");
49077c478bd9Sstevel@tonic-gate 		else {
49087c478bd9Sstevel@tonic-gate 			if ((p = strchr(yytext, '\n')) != NULL)
49097c478bd9Sstevel@tonic-gate 				*p = '\0'; /* crop at newline */
49107c478bd9Sstevel@tonic-gate 			(void) snprintf(s, n, " near \"%s\"", yytext);
49117c478bd9Sstevel@tonic-gate 		}
49127c478bd9Sstevel@tonic-gate 	}
49137c478bd9Sstevel@tonic-gate }
49147c478bd9Sstevel@tonic-gate 
49157c478bd9Sstevel@tonic-gate void
49167c478bd9Sstevel@tonic-gate yylabel(const char *label)
49177c478bd9Sstevel@tonic-gate {
49187c478bd9Sstevel@tonic-gate 	dt_dprintf("set label to <%s>\n", label ? label : "NULL");
49197c478bd9Sstevel@tonic-gate 	yypcb->pcb_region = label;
49207c478bd9Sstevel@tonic-gate }
49217c478bd9Sstevel@tonic-gate 
49227c478bd9Sstevel@tonic-gate int
49237c478bd9Sstevel@tonic-gate yywrap(void)
49247c478bd9Sstevel@tonic-gate {
49257c478bd9Sstevel@tonic-gate 	return (1); /* indicate that lex should return a zero token for EOF */
49267c478bd9Sstevel@tonic-gate }
4927