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 57c478bd9Sstevel@tonic-gate * Common Development and Distribution License, Version 1.0 only 67c478bd9Sstevel@tonic-gate * (the "License"). You may not use this file except in compliance 77c478bd9Sstevel@tonic-gate * with the License. 87c478bd9Sstevel@tonic-gate * 97c478bd9Sstevel@tonic-gate * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE 107c478bd9Sstevel@tonic-gate * or http://www.opensolaris.org/os/licensing. 117c478bd9Sstevel@tonic-gate * See the License for the specific language governing permissions 127c478bd9Sstevel@tonic-gate * and limitations under the License. 137c478bd9Sstevel@tonic-gate * 147c478bd9Sstevel@tonic-gate * When distributing Covered Code, include this CDDL HEADER in each 157c478bd9Sstevel@tonic-gate * file and include the License file at usr/src/OPENSOLARIS.LICENSE. 167c478bd9Sstevel@tonic-gate * If applicable, add the following below this CDDL HEADER, with the 177c478bd9Sstevel@tonic-gate * fields enclosed by brackets "[]" replaced with your own identifying 187c478bd9Sstevel@tonic-gate * information: Portions Copyright [yyyy] [name of copyright owner] 197c478bd9Sstevel@tonic-gate * 207c478bd9Sstevel@tonic-gate * CDDL HEADER END 217c478bd9Sstevel@tonic-gate */ 227c478bd9Sstevel@tonic-gate /* 237c478bd9Sstevel@tonic-gate * Copyright 2005 Sun Microsystems, Inc. All rights reserved. 247c478bd9Sstevel@tonic-gate * Use is subject to license terms. 257c478bd9Sstevel@tonic-gate */ 267c478bd9Sstevel@tonic-gate 277c478bd9Sstevel@tonic-gate #pragma ident "%Z%%M% %I% %E% SMI" 287c478bd9Sstevel@tonic-gate 297c478bd9Sstevel@tonic-gate /* 307c478bd9Sstevel@tonic-gate * DTrace D Language Parser 317c478bd9Sstevel@tonic-gate * 327c478bd9Sstevel@tonic-gate * The D Parser is a lex/yacc parser consisting of the lexer dt_lex.l, the 337c478bd9Sstevel@tonic-gate * parsing grammar dt_grammar.y, and this file, dt_parser.c, which handles 347c478bd9Sstevel@tonic-gate * the construction of the parse tree nodes and their syntactic validation. 357c478bd9Sstevel@tonic-gate * The parse tree is constructed of dt_node_t structures (see <dt_parser.h>) 367c478bd9Sstevel@tonic-gate * that are built in two passes: (1) the "create" pass, where the parse tree 377c478bd9Sstevel@tonic-gate * nodes are allocated by calls from the grammar to dt_node_*() subroutines, 387c478bd9Sstevel@tonic-gate * and (2) the "cook" pass, where nodes are coalesced, assigned D types, and 397c478bd9Sstevel@tonic-gate * validated according to the syntactic rules of the language. 407c478bd9Sstevel@tonic-gate * 417c478bd9Sstevel@tonic-gate * All node allocations are performed using dt_node_alloc(). All node frees 427c478bd9Sstevel@tonic-gate * during the parsing phase are performed by dt_node_free(), which frees node- 437c478bd9Sstevel@tonic-gate * internal state but does not actually free the nodes. All final node frees 447c478bd9Sstevel@tonic-gate * are done as part of the end of dt_compile() or as part of destroying 457c478bd9Sstevel@tonic-gate * persistent identifiers or translators which have embedded nodes. 467c478bd9Sstevel@tonic-gate * 477c478bd9Sstevel@tonic-gate * The dt_node_* routines that implement pass (1) may allocate new nodes. The 487c478bd9Sstevel@tonic-gate * dt_cook_* routines that implement pass (2) may *not* allocate new nodes. 497c478bd9Sstevel@tonic-gate * They may free existing nodes using dt_node_free(), but they may not actually 507c478bd9Sstevel@tonic-gate * deallocate any dt_node_t's. Currently dt_cook_op2() is an exception to this 517c478bd9Sstevel@tonic-gate * rule: see the comments therein for how this issue is resolved. 527c478bd9Sstevel@tonic-gate * 537c478bd9Sstevel@tonic-gate * The dt_cook_* routines are responsible for (at minimum) setting the final 547c478bd9Sstevel@tonic-gate * node type (dn_ctfp/dn_type) and attributes (dn_attr). If dn_ctfp/dn_type 557c478bd9Sstevel@tonic-gate * are set manually (i.e. not by one of the type assignment functions), then 567c478bd9Sstevel@tonic-gate * the DT_NF_COOKED flag must be set manually on the node. 577c478bd9Sstevel@tonic-gate * 587c478bd9Sstevel@tonic-gate * The cooking pass can be applied to the same parse tree more than once (used 597c478bd9Sstevel@tonic-gate * in the case of a comma-separated list of probe descriptions). As such, the 607c478bd9Sstevel@tonic-gate * cook routines must not perform any parse tree transformations which would 617c478bd9Sstevel@tonic-gate * be invalid if the tree were subsequently cooked using a different context. 627c478bd9Sstevel@tonic-gate * 637c478bd9Sstevel@tonic-gate * The dn_ctfp and dn_type fields form the type of the node. This tuple can 647c478bd9Sstevel@tonic-gate * take on the following set of values, which form our type invariants: 657c478bd9Sstevel@tonic-gate * 667c478bd9Sstevel@tonic-gate * 1. dn_ctfp = NULL, dn_type = CTF_ERR 677c478bd9Sstevel@tonic-gate * 687c478bd9Sstevel@tonic-gate * In this state, the node has unknown type and is not yet cooked. The 697c478bd9Sstevel@tonic-gate * DT_NF_COOKED flag is not yet set on the node. 707c478bd9Sstevel@tonic-gate * 717c478bd9Sstevel@tonic-gate * 2. dn_ctfp = DT_DYN_CTFP(dtp), dn_type = DT_DYN_TYPE(dtp) 727c478bd9Sstevel@tonic-gate * 737c478bd9Sstevel@tonic-gate * In this state, the node is a dynamic D type. This means that generic 747c478bd9Sstevel@tonic-gate * operations are not valid on this node and only code that knows how to 757c478bd9Sstevel@tonic-gate * examine the inner details of the node can operate on it. A <DYN> node 767c478bd9Sstevel@tonic-gate * must have dn_ident set to point to an identifier describing the object 777c478bd9Sstevel@tonic-gate * and its type. The DT_NF_REF flag is set for all nodes of type <DYN>. 787c478bd9Sstevel@tonic-gate * At present, the D compiler uses the <DYN> type for: 797c478bd9Sstevel@tonic-gate * 807c478bd9Sstevel@tonic-gate * - associative arrays that do not yet have a value type defined 817c478bd9Sstevel@tonic-gate * - translated data (i.e. the result of the xlate operator) 827c478bd9Sstevel@tonic-gate * - aggregations 837c478bd9Sstevel@tonic-gate * 847c478bd9Sstevel@tonic-gate * 3. dn_ctfp = DT_STR_CTFP(dtp), dn_type = DT_STR_TYPE(dtp) 857c478bd9Sstevel@tonic-gate * 867c478bd9Sstevel@tonic-gate * In this state, the node is of type D string. The string type is really 877c478bd9Sstevel@tonic-gate * a char[0] typedef, but requires special handling throughout the compiler. 887c478bd9Sstevel@tonic-gate * 897c478bd9Sstevel@tonic-gate * 4. dn_ctfp != NULL, dn_type = any other type ID 907c478bd9Sstevel@tonic-gate * 917c478bd9Sstevel@tonic-gate * In this state, the node is of some known D/CTF type. The normal libctf 927c478bd9Sstevel@tonic-gate * APIs can be used to learn more about the type name or structure. When 937c478bd9Sstevel@tonic-gate * the type is assigned, the DT_NF_SIGNED, DT_NF_REF, and DT_NF_BITFIELD 947c478bd9Sstevel@tonic-gate * flags cache the corresponding attributes of the underlying CTF type. 957c478bd9Sstevel@tonic-gate */ 967c478bd9Sstevel@tonic-gate 977c478bd9Sstevel@tonic-gate #include <sys/param.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, 4747c478bd9Sstevel@tonic-gate dnp->dn_xlator->dx_dst_type, n1, sizeof (n1)), 4757c478bd9Sstevel@tonic-gate dt_type_name(dnp->dn_xlator->dx_src_ctfp, 4767c478bd9Sstevel@tonic-gate 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 { 7257c478bd9Sstevel@tonic-gate if (dnp->dn_kind == DT_NODE_STRING) 7267c478bd9Sstevel@tonic-gate return (strlen(dnp->dn_string) + 1); 7277c478bd9Sstevel@tonic-gate 7287c478bd9Sstevel@tonic-gate if (dt_node_is_dynamic(dnp) && dnp->dn_ident != NULL) 7297c478bd9Sstevel@tonic-gate return (dt_ident_size(dnp->dn_ident)); 7307c478bd9Sstevel@tonic-gate 7317c478bd9Sstevel@tonic-gate return (ctf_type_size(dnp->dn_ctfp, dnp->dn_type)); 7327c478bd9Sstevel@tonic-gate } 7337c478bd9Sstevel@tonic-gate 7347c478bd9Sstevel@tonic-gate /* 7357c478bd9Sstevel@tonic-gate * Determine if the specified parse tree node references an identifier of the 7367c478bd9Sstevel@tonic-gate * specified kind, and if so return a pointer to it; otherwise return NULL. 7377c478bd9Sstevel@tonic-gate * This function resolves the identifier itself, following through any inlines. 7387c478bd9Sstevel@tonic-gate */ 7397c478bd9Sstevel@tonic-gate dt_ident_t * 7407c478bd9Sstevel@tonic-gate dt_node_resolve(const dt_node_t *dnp, uint_t idkind) 7417c478bd9Sstevel@tonic-gate { 7427c478bd9Sstevel@tonic-gate dt_ident_t *idp; 7437c478bd9Sstevel@tonic-gate 7447c478bd9Sstevel@tonic-gate switch (dnp->dn_kind) { 7457c478bd9Sstevel@tonic-gate case DT_NODE_VAR: 7467c478bd9Sstevel@tonic-gate case DT_NODE_SYM: 7477c478bd9Sstevel@tonic-gate case DT_NODE_FUNC: 7487c478bd9Sstevel@tonic-gate case DT_NODE_AGG: 7497c478bd9Sstevel@tonic-gate case DT_NODE_INLINE: 7507c478bd9Sstevel@tonic-gate case DT_NODE_PROBE: 7517c478bd9Sstevel@tonic-gate idp = dt_ident_resolve(dnp->dn_ident); 7527c478bd9Sstevel@tonic-gate return (idp->di_kind == idkind ? idp : NULL); 7537c478bd9Sstevel@tonic-gate } 7547c478bd9Sstevel@tonic-gate 7557c478bd9Sstevel@tonic-gate if (dt_node_is_dynamic(dnp)) { 7567c478bd9Sstevel@tonic-gate idp = dt_ident_resolve(dnp->dn_ident); 7577c478bd9Sstevel@tonic-gate return (idp->di_kind == idkind ? idp : NULL); 7587c478bd9Sstevel@tonic-gate } 7597c478bd9Sstevel@tonic-gate 7607c478bd9Sstevel@tonic-gate return (NULL); 7617c478bd9Sstevel@tonic-gate } 7627c478bd9Sstevel@tonic-gate 7637c478bd9Sstevel@tonic-gate size_t 7647c478bd9Sstevel@tonic-gate dt_node_sizeof(const dt_node_t *dnp) 7657c478bd9Sstevel@tonic-gate { 7667c478bd9Sstevel@tonic-gate dtrace_syminfo_t *sip; 7677c478bd9Sstevel@tonic-gate GElf_Sym sym; 7687c478bd9Sstevel@tonic-gate dtrace_hdl_t *dtp = yypcb->pcb_hdl; 7697c478bd9Sstevel@tonic-gate 7707c478bd9Sstevel@tonic-gate /* 7717c478bd9Sstevel@tonic-gate * The size of the node as used for the sizeof() operator depends on 7727c478bd9Sstevel@tonic-gate * the kind of the node. If the node is a SYM, the size is obtained 7737c478bd9Sstevel@tonic-gate * from the symbol table; if it is not a SYM, the size is determined 7747c478bd9Sstevel@tonic-gate * from the node's type. This is slightly different from C's sizeof() 7757c478bd9Sstevel@tonic-gate * operator in that (for example) when applied to a function, sizeof() 7767c478bd9Sstevel@tonic-gate * will evaluate to the length of the function rather than the size of 7777c478bd9Sstevel@tonic-gate * the function type. 7787c478bd9Sstevel@tonic-gate */ 7797c478bd9Sstevel@tonic-gate if (dnp->dn_kind != DT_NODE_SYM) 7807c478bd9Sstevel@tonic-gate return (dt_node_type_size(dnp)); 7817c478bd9Sstevel@tonic-gate 7827c478bd9Sstevel@tonic-gate sip = dnp->dn_ident->di_data; 7837c478bd9Sstevel@tonic-gate 7847c478bd9Sstevel@tonic-gate if (dtrace_lookup_by_name(dtp, sip->dts_object, 7857c478bd9Sstevel@tonic-gate sip->dts_name, &sym, NULL) == -1) 7867c478bd9Sstevel@tonic-gate return (0); 7877c478bd9Sstevel@tonic-gate 7887c478bd9Sstevel@tonic-gate return (sym.st_size); 7897c478bd9Sstevel@tonic-gate } 7907c478bd9Sstevel@tonic-gate 7917c478bd9Sstevel@tonic-gate int 7927c478bd9Sstevel@tonic-gate dt_node_is_integer(const dt_node_t *dnp) 7937c478bd9Sstevel@tonic-gate { 7947c478bd9Sstevel@tonic-gate ctf_file_t *fp = dnp->dn_ctfp; 7957c478bd9Sstevel@tonic-gate ctf_encoding_t e; 7967c478bd9Sstevel@tonic-gate ctf_id_t type; 7977c478bd9Sstevel@tonic-gate uint_t kind; 7987c478bd9Sstevel@tonic-gate 7997c478bd9Sstevel@tonic-gate assert(dnp->dn_flags & DT_NF_COOKED); 8007c478bd9Sstevel@tonic-gate 8017c478bd9Sstevel@tonic-gate type = ctf_type_resolve(fp, dnp->dn_type); 8027c478bd9Sstevel@tonic-gate kind = ctf_type_kind(fp, type); 8037c478bd9Sstevel@tonic-gate 8047c478bd9Sstevel@tonic-gate if (kind == CTF_K_INTEGER && 8057c478bd9Sstevel@tonic-gate ctf_type_encoding(fp, type, &e) == 0 && IS_VOID(e)) 8067c478bd9Sstevel@tonic-gate return (0); /* void integer */ 8077c478bd9Sstevel@tonic-gate 8087c478bd9Sstevel@tonic-gate return (kind == CTF_K_INTEGER || kind == CTF_K_ENUM); 8097c478bd9Sstevel@tonic-gate } 8107c478bd9Sstevel@tonic-gate 8117c478bd9Sstevel@tonic-gate int 8127c478bd9Sstevel@tonic-gate dt_node_is_float(const dt_node_t *dnp) 8137c478bd9Sstevel@tonic-gate { 8147c478bd9Sstevel@tonic-gate ctf_file_t *fp = dnp->dn_ctfp; 8157c478bd9Sstevel@tonic-gate ctf_encoding_t e; 8167c478bd9Sstevel@tonic-gate ctf_id_t type; 8177c478bd9Sstevel@tonic-gate uint_t kind; 8187c478bd9Sstevel@tonic-gate 8197c478bd9Sstevel@tonic-gate assert(dnp->dn_flags & DT_NF_COOKED); 8207c478bd9Sstevel@tonic-gate 8217c478bd9Sstevel@tonic-gate type = ctf_type_resolve(fp, dnp->dn_type); 8227c478bd9Sstevel@tonic-gate kind = ctf_type_kind(fp, type); 8237c478bd9Sstevel@tonic-gate 8247c478bd9Sstevel@tonic-gate return (kind == CTF_K_FLOAT && 8257c478bd9Sstevel@tonic-gate ctf_type_encoding(dnp->dn_ctfp, type, &e) == 0 && ( 8267c478bd9Sstevel@tonic-gate e.cte_format == CTF_FP_SINGLE || e.cte_format == CTF_FP_DOUBLE || 8277c478bd9Sstevel@tonic-gate e.cte_format == CTF_FP_LDOUBLE)); 8287c478bd9Sstevel@tonic-gate } 8297c478bd9Sstevel@tonic-gate 8307c478bd9Sstevel@tonic-gate int 8317c478bd9Sstevel@tonic-gate dt_node_is_scalar(const dt_node_t *dnp) 8327c478bd9Sstevel@tonic-gate { 8337c478bd9Sstevel@tonic-gate ctf_file_t *fp = dnp->dn_ctfp; 8347c478bd9Sstevel@tonic-gate ctf_encoding_t e; 8357c478bd9Sstevel@tonic-gate ctf_id_t type; 8367c478bd9Sstevel@tonic-gate uint_t kind; 8377c478bd9Sstevel@tonic-gate 8387c478bd9Sstevel@tonic-gate assert(dnp->dn_flags & DT_NF_COOKED); 8397c478bd9Sstevel@tonic-gate 8407c478bd9Sstevel@tonic-gate type = ctf_type_resolve(fp, dnp->dn_type); 8417c478bd9Sstevel@tonic-gate kind = ctf_type_kind(fp, type); 8427c478bd9Sstevel@tonic-gate 8437c478bd9Sstevel@tonic-gate if (kind == CTF_K_INTEGER && 8447c478bd9Sstevel@tonic-gate ctf_type_encoding(fp, type, &e) == 0 && IS_VOID(e)) 8457c478bd9Sstevel@tonic-gate return (0); /* void cannot be used as a scalar */ 8467c478bd9Sstevel@tonic-gate 8477c478bd9Sstevel@tonic-gate return (kind == CTF_K_INTEGER || kind == CTF_K_ENUM || 8487c478bd9Sstevel@tonic-gate kind == CTF_K_POINTER); 8497c478bd9Sstevel@tonic-gate } 8507c478bd9Sstevel@tonic-gate 8517c478bd9Sstevel@tonic-gate int 8527c478bd9Sstevel@tonic-gate dt_node_is_arith(const dt_node_t *dnp) 8537c478bd9Sstevel@tonic-gate { 8547c478bd9Sstevel@tonic-gate ctf_file_t *fp = dnp->dn_ctfp; 8557c478bd9Sstevel@tonic-gate ctf_encoding_t e; 8567c478bd9Sstevel@tonic-gate ctf_id_t type; 8577c478bd9Sstevel@tonic-gate uint_t kind; 8587c478bd9Sstevel@tonic-gate 8597c478bd9Sstevel@tonic-gate assert(dnp->dn_flags & DT_NF_COOKED); 8607c478bd9Sstevel@tonic-gate 8617c478bd9Sstevel@tonic-gate type = ctf_type_resolve(fp, dnp->dn_type); 8627c478bd9Sstevel@tonic-gate kind = ctf_type_kind(fp, type); 8637c478bd9Sstevel@tonic-gate 8647c478bd9Sstevel@tonic-gate if (kind == CTF_K_INTEGER) 8657c478bd9Sstevel@tonic-gate return (ctf_type_encoding(fp, type, &e) == 0 && !IS_VOID(e)); 8667c478bd9Sstevel@tonic-gate else 8677c478bd9Sstevel@tonic-gate return (kind == CTF_K_ENUM); 8687c478bd9Sstevel@tonic-gate } 8697c478bd9Sstevel@tonic-gate 8707c478bd9Sstevel@tonic-gate int 8717c478bd9Sstevel@tonic-gate dt_node_is_vfptr(const dt_node_t *dnp) 8727c478bd9Sstevel@tonic-gate { 8737c478bd9Sstevel@tonic-gate ctf_file_t *fp = dnp->dn_ctfp; 8747c478bd9Sstevel@tonic-gate ctf_encoding_t e; 8757c478bd9Sstevel@tonic-gate ctf_id_t type; 8767c478bd9Sstevel@tonic-gate uint_t kind; 8777c478bd9Sstevel@tonic-gate 8787c478bd9Sstevel@tonic-gate assert(dnp->dn_flags & DT_NF_COOKED); 8797c478bd9Sstevel@tonic-gate 8807c478bd9Sstevel@tonic-gate type = ctf_type_resolve(fp, dnp->dn_type); 8817c478bd9Sstevel@tonic-gate if (ctf_type_kind(fp, type) != CTF_K_POINTER) 8827c478bd9Sstevel@tonic-gate return (0); /* type is not a pointer */ 8837c478bd9Sstevel@tonic-gate 8847c478bd9Sstevel@tonic-gate type = ctf_type_resolve(fp, ctf_type_reference(fp, type)); 8857c478bd9Sstevel@tonic-gate kind = ctf_type_kind(fp, type); 8867c478bd9Sstevel@tonic-gate 8877c478bd9Sstevel@tonic-gate return (kind == CTF_K_FUNCTION || (kind == CTF_K_INTEGER && 8887c478bd9Sstevel@tonic-gate ctf_type_encoding(fp, type, &e) == 0 && IS_VOID(e))); 8897c478bd9Sstevel@tonic-gate } 8907c478bd9Sstevel@tonic-gate 8917c478bd9Sstevel@tonic-gate int 8927c478bd9Sstevel@tonic-gate dt_node_is_dynamic(const dt_node_t *dnp) 8937c478bd9Sstevel@tonic-gate { 8947c478bd9Sstevel@tonic-gate if (dnp->dn_kind == DT_NODE_VAR && 8957c478bd9Sstevel@tonic-gate (dnp->dn_ident->di_flags & DT_IDFLG_INLINE)) { 8967c478bd9Sstevel@tonic-gate const dt_idnode_t *inp = dnp->dn_ident->di_iarg; 8971a7c1b72Smws return (inp->din_root ? dt_node_is_dynamic(inp->din_root) : 0); 8987c478bd9Sstevel@tonic-gate } 8997c478bd9Sstevel@tonic-gate 9007c478bd9Sstevel@tonic-gate return (dnp->dn_ctfp == DT_DYN_CTFP(yypcb->pcb_hdl) && 9017c478bd9Sstevel@tonic-gate dnp->dn_type == DT_DYN_TYPE(yypcb->pcb_hdl)); 9027c478bd9Sstevel@tonic-gate } 9037c478bd9Sstevel@tonic-gate 9047c478bd9Sstevel@tonic-gate int 9057c478bd9Sstevel@tonic-gate dt_node_is_string(const dt_node_t *dnp) 9067c478bd9Sstevel@tonic-gate { 9077c478bd9Sstevel@tonic-gate return (dnp->dn_ctfp == DT_STR_CTFP(yypcb->pcb_hdl) && 9087c478bd9Sstevel@tonic-gate dnp->dn_type == DT_STR_TYPE(yypcb->pcb_hdl)); 9097c478bd9Sstevel@tonic-gate } 9107c478bd9Sstevel@tonic-gate 9117c478bd9Sstevel@tonic-gate int 9127c478bd9Sstevel@tonic-gate dt_node_is_stack(const dt_node_t *dnp) 9137c478bd9Sstevel@tonic-gate { 9147c478bd9Sstevel@tonic-gate return (dnp->dn_ctfp == DT_STACK_CTFP(yypcb->pcb_hdl) && 9157c478bd9Sstevel@tonic-gate dnp->dn_type == DT_STACK_TYPE(yypcb->pcb_hdl)); 9167c478bd9Sstevel@tonic-gate } 9177c478bd9Sstevel@tonic-gate 918*a1b5e537Sbmc int 919*a1b5e537Sbmc dt_node_is_symaddr(const dt_node_t *dnp) 920*a1b5e537Sbmc { 921*a1b5e537Sbmc return (dnp->dn_ctfp == DT_SYMADDR_CTFP(yypcb->pcb_hdl) && 922*a1b5e537Sbmc dnp->dn_type == DT_SYMADDR_TYPE(yypcb->pcb_hdl)); 923*a1b5e537Sbmc } 924*a1b5e537Sbmc 925*a1b5e537Sbmc int 926*a1b5e537Sbmc dt_node_is_usymaddr(const dt_node_t *dnp) 927*a1b5e537Sbmc { 928*a1b5e537Sbmc return (dnp->dn_ctfp == DT_USYMADDR_CTFP(yypcb->pcb_hdl) && 929*a1b5e537Sbmc dnp->dn_type == DT_USYMADDR_TYPE(yypcb->pcb_hdl)); 930*a1b5e537Sbmc } 931*a1b5e537Sbmc 9327c478bd9Sstevel@tonic-gate int 9337c478bd9Sstevel@tonic-gate dt_node_is_strcompat(const dt_node_t *dnp) 9347c478bd9Sstevel@tonic-gate { 9357c478bd9Sstevel@tonic-gate ctf_file_t *fp = dnp->dn_ctfp; 9367c478bd9Sstevel@tonic-gate ctf_encoding_t e; 9377c478bd9Sstevel@tonic-gate ctf_arinfo_t r; 9387c478bd9Sstevel@tonic-gate ctf_id_t base; 9397c478bd9Sstevel@tonic-gate uint_t kind; 9407c478bd9Sstevel@tonic-gate 9417c478bd9Sstevel@tonic-gate assert(dnp->dn_flags & DT_NF_COOKED); 9427c478bd9Sstevel@tonic-gate 9437c478bd9Sstevel@tonic-gate base = ctf_type_resolve(fp, dnp->dn_type); 9447c478bd9Sstevel@tonic-gate kind = ctf_type_kind(fp, base); 9457c478bd9Sstevel@tonic-gate 9467c478bd9Sstevel@tonic-gate if (kind == CTF_K_POINTER && 9477c478bd9Sstevel@tonic-gate (base = ctf_type_reference(fp, base)) != CTF_ERR && 9487c478bd9Sstevel@tonic-gate (base = ctf_type_resolve(fp, base)) != CTF_ERR && 9497c478bd9Sstevel@tonic-gate ctf_type_encoding(fp, base, &e) == 0 && IS_CHAR(e)) 9507c478bd9Sstevel@tonic-gate return (1); /* promote char pointer to string */ 9517c478bd9Sstevel@tonic-gate 9527c478bd9Sstevel@tonic-gate if (kind == CTF_K_ARRAY && ctf_array_info(fp, base, &r) == 0 && 9537c478bd9Sstevel@tonic-gate (base = ctf_type_resolve(fp, r.ctr_contents)) != CTF_ERR && 9547c478bd9Sstevel@tonic-gate ctf_type_encoding(fp, base, &e) == 0 && IS_CHAR(e)) 9557c478bd9Sstevel@tonic-gate return (1); /* promote char array to string */ 9567c478bd9Sstevel@tonic-gate 9577c478bd9Sstevel@tonic-gate return (0); 9587c478bd9Sstevel@tonic-gate } 9597c478bd9Sstevel@tonic-gate 9607c478bd9Sstevel@tonic-gate int 9617c478bd9Sstevel@tonic-gate dt_node_is_pointer(const dt_node_t *dnp) 9627c478bd9Sstevel@tonic-gate { 9637c478bd9Sstevel@tonic-gate ctf_file_t *fp = dnp->dn_ctfp; 9647c478bd9Sstevel@tonic-gate uint_t kind; 9657c478bd9Sstevel@tonic-gate 9667c478bd9Sstevel@tonic-gate assert(dnp->dn_flags & DT_NF_COOKED); 9677c478bd9Sstevel@tonic-gate 9687c478bd9Sstevel@tonic-gate if (dt_node_is_string(dnp)) 9697c478bd9Sstevel@tonic-gate return (0); /* string are pass-by-ref but act like structs */ 9707c478bd9Sstevel@tonic-gate 9717c478bd9Sstevel@tonic-gate kind = ctf_type_kind(fp, ctf_type_resolve(fp, dnp->dn_type)); 9727c478bd9Sstevel@tonic-gate return (kind == CTF_K_POINTER || kind == CTF_K_ARRAY); 9737c478bd9Sstevel@tonic-gate } 9747c478bd9Sstevel@tonic-gate 9757c478bd9Sstevel@tonic-gate int 9767c478bd9Sstevel@tonic-gate dt_node_is_void(const dt_node_t *dnp) 9777c478bd9Sstevel@tonic-gate { 9787c478bd9Sstevel@tonic-gate ctf_file_t *fp = dnp->dn_ctfp; 9797c478bd9Sstevel@tonic-gate ctf_encoding_t e; 9807c478bd9Sstevel@tonic-gate ctf_id_t type; 9817c478bd9Sstevel@tonic-gate 9827c478bd9Sstevel@tonic-gate if (dt_node_is_dynamic(dnp)) 9837c478bd9Sstevel@tonic-gate return (0); /* <DYN> is an alias for void but not the same */ 9847c478bd9Sstevel@tonic-gate 9857c478bd9Sstevel@tonic-gate if (dt_node_is_stack(dnp)) 9867c478bd9Sstevel@tonic-gate return (0); 9877c478bd9Sstevel@tonic-gate 988*a1b5e537Sbmc if (dt_node_is_symaddr(dnp) || dt_node_is_usymaddr(dnp)) 989*a1b5e537Sbmc return (0); 990*a1b5e537Sbmc 9917c478bd9Sstevel@tonic-gate type = ctf_type_resolve(fp, dnp->dn_type); 9927c478bd9Sstevel@tonic-gate 9937c478bd9Sstevel@tonic-gate return (ctf_type_kind(fp, type) == CTF_K_INTEGER && 9947c478bd9Sstevel@tonic-gate ctf_type_encoding(fp, type, &e) == 0 && IS_VOID(e)); 9957c478bd9Sstevel@tonic-gate } 9967c478bd9Sstevel@tonic-gate 9977c478bd9Sstevel@tonic-gate int 9987c478bd9Sstevel@tonic-gate dt_node_is_ptrcompat(const dt_node_t *lp, const dt_node_t *rp, 9997c478bd9Sstevel@tonic-gate ctf_file_t **fpp, ctf_id_t *tp) 10007c478bd9Sstevel@tonic-gate { 10017c478bd9Sstevel@tonic-gate ctf_file_t *lfp = lp->dn_ctfp; 10027c478bd9Sstevel@tonic-gate ctf_file_t *rfp = rp->dn_ctfp; 10037c478bd9Sstevel@tonic-gate 10047c478bd9Sstevel@tonic-gate ctf_id_t lbase = CTF_ERR, rbase = CTF_ERR; 10057c478bd9Sstevel@tonic-gate ctf_id_t lref = CTF_ERR, rref = CTF_ERR; 10067c478bd9Sstevel@tonic-gate 10077c478bd9Sstevel@tonic-gate int lp_is_void, rp_is_void, lp_is_int, rp_is_int, compat; 10087c478bd9Sstevel@tonic-gate uint_t lkind, rkind; 10097c478bd9Sstevel@tonic-gate ctf_encoding_t e; 10107c478bd9Sstevel@tonic-gate ctf_arinfo_t r; 10117c478bd9Sstevel@tonic-gate 10127c478bd9Sstevel@tonic-gate assert(lp->dn_flags & DT_NF_COOKED); 10137c478bd9Sstevel@tonic-gate assert(rp->dn_flags & DT_NF_COOKED); 10147c478bd9Sstevel@tonic-gate 10157c478bd9Sstevel@tonic-gate if (dt_node_is_dynamic(lp) || dt_node_is_dynamic(rp)) 10167c478bd9Sstevel@tonic-gate return (0); /* fail if either node is a dynamic variable */ 10177c478bd9Sstevel@tonic-gate 10187c478bd9Sstevel@tonic-gate lp_is_int = dt_node_is_integer(lp); 10197c478bd9Sstevel@tonic-gate rp_is_int = dt_node_is_integer(rp); 10207c478bd9Sstevel@tonic-gate 10217c478bd9Sstevel@tonic-gate if (lp_is_int && rp_is_int) 10227c478bd9Sstevel@tonic-gate return (0); /* fail if both nodes are integers */ 10237c478bd9Sstevel@tonic-gate 10247c478bd9Sstevel@tonic-gate if (lp_is_int && (lp->dn_kind != DT_NODE_INT || lp->dn_value != 0)) 10257c478bd9Sstevel@tonic-gate return (0); /* fail if lp is an integer that isn't 0 constant */ 10267c478bd9Sstevel@tonic-gate 10277c478bd9Sstevel@tonic-gate if (rp_is_int && (rp->dn_kind != DT_NODE_INT || rp->dn_value != 0)) 10287c478bd9Sstevel@tonic-gate return (0); /* fail if rp is an integer that isn't 0 constant */ 10297c478bd9Sstevel@tonic-gate 10307c478bd9Sstevel@tonic-gate if ((lp_is_int == 0 && rp_is_int == 0) && ( 10317c478bd9Sstevel@tonic-gate (lp->dn_flags & DT_NF_USERLAND) ^ (rp->dn_flags & DT_NF_USERLAND))) 10327c478bd9Sstevel@tonic-gate return (0); /* fail if only one pointer is a userland address */ 10337c478bd9Sstevel@tonic-gate 10347c478bd9Sstevel@tonic-gate /* 10357c478bd9Sstevel@tonic-gate * Resolve the left-hand and right-hand types to their base type, and 10367c478bd9Sstevel@tonic-gate * then resolve the referenced type as well (assuming the base type 10377c478bd9Sstevel@tonic-gate * is CTF_K_POINTER or CTF_K_ARRAY). Otherwise [lr]ref = CTF_ERR. 10387c478bd9Sstevel@tonic-gate */ 10397c478bd9Sstevel@tonic-gate if (!lp_is_int) { 10407c478bd9Sstevel@tonic-gate lbase = ctf_type_resolve(lfp, lp->dn_type); 10417c478bd9Sstevel@tonic-gate lkind = ctf_type_kind(lfp, lbase); 10427c478bd9Sstevel@tonic-gate 10437c478bd9Sstevel@tonic-gate if (lkind == CTF_K_POINTER) { 10447c478bd9Sstevel@tonic-gate lref = ctf_type_resolve(lfp, 10457c478bd9Sstevel@tonic-gate ctf_type_reference(lfp, lbase)); 10467c478bd9Sstevel@tonic-gate } else if (lkind == CTF_K_ARRAY && 10477c478bd9Sstevel@tonic-gate ctf_array_info(lfp, lbase, &r) == 0) { 10487c478bd9Sstevel@tonic-gate lref = ctf_type_resolve(lfp, r.ctr_contents); 10497c478bd9Sstevel@tonic-gate } 10507c478bd9Sstevel@tonic-gate } 10517c478bd9Sstevel@tonic-gate 10527c478bd9Sstevel@tonic-gate if (!rp_is_int) { 10537c478bd9Sstevel@tonic-gate rbase = ctf_type_resolve(rfp, rp->dn_type); 10547c478bd9Sstevel@tonic-gate rkind = ctf_type_kind(rfp, rbase); 10557c478bd9Sstevel@tonic-gate 10567c478bd9Sstevel@tonic-gate if (rkind == CTF_K_POINTER) { 10577c478bd9Sstevel@tonic-gate rref = ctf_type_resolve(rfp, 10587c478bd9Sstevel@tonic-gate ctf_type_reference(rfp, rbase)); 10597c478bd9Sstevel@tonic-gate } else if (rkind == CTF_K_ARRAY && 10607c478bd9Sstevel@tonic-gate ctf_array_info(rfp, rbase, &r) == 0) { 10617c478bd9Sstevel@tonic-gate rref = ctf_type_resolve(rfp, r.ctr_contents); 10627c478bd9Sstevel@tonic-gate } 10637c478bd9Sstevel@tonic-gate } 10647c478bd9Sstevel@tonic-gate 10657c478bd9Sstevel@tonic-gate /* 10667c478bd9Sstevel@tonic-gate * We know that one or the other type may still be a zero-valued 10677c478bd9Sstevel@tonic-gate * integer constant. To simplify the code below, set the integer 10687c478bd9Sstevel@tonic-gate * type variables equal to the non-integer types and proceed. 10697c478bd9Sstevel@tonic-gate */ 10707c478bd9Sstevel@tonic-gate if (lp_is_int) { 10717c478bd9Sstevel@tonic-gate lbase = rbase; 10727c478bd9Sstevel@tonic-gate lkind = rkind; 10737c478bd9Sstevel@tonic-gate lref = rref; 10747c478bd9Sstevel@tonic-gate lfp = rfp; 10757c478bd9Sstevel@tonic-gate } else if (rp_is_int) { 10767c478bd9Sstevel@tonic-gate rbase = lbase; 10777c478bd9Sstevel@tonic-gate rkind = lkind; 10787c478bd9Sstevel@tonic-gate rref = lref; 10797c478bd9Sstevel@tonic-gate rfp = lfp; 10807c478bd9Sstevel@tonic-gate } 10817c478bd9Sstevel@tonic-gate 10827c478bd9Sstevel@tonic-gate lp_is_void = ctf_type_encoding(lfp, lref, &e) == 0 && IS_VOID(e); 10837c478bd9Sstevel@tonic-gate rp_is_void = ctf_type_encoding(rfp, rref, &e) == 0 && IS_VOID(e); 10847c478bd9Sstevel@tonic-gate 10857c478bd9Sstevel@tonic-gate /* 10867c478bd9Sstevel@tonic-gate * The types are compatible if both are pointers to the same type, or 10877c478bd9Sstevel@tonic-gate * if either pointer is a void pointer. If they are compatible, set 10887c478bd9Sstevel@tonic-gate * tp to point to the more specific pointer type and return it. 10897c478bd9Sstevel@tonic-gate */ 10907c478bd9Sstevel@tonic-gate compat = (lkind == CTF_K_POINTER || lkind == CTF_K_ARRAY) && 10917c478bd9Sstevel@tonic-gate (rkind == CTF_K_POINTER || rkind == CTF_K_ARRAY) && 10927c478bd9Sstevel@tonic-gate (lp_is_void || rp_is_void || ctf_type_compat(lfp, lref, rfp, rref)); 10937c478bd9Sstevel@tonic-gate 10947c478bd9Sstevel@tonic-gate if (compat) { 10957c478bd9Sstevel@tonic-gate if (fpp != NULL) 10967c478bd9Sstevel@tonic-gate *fpp = rp_is_void ? lfp : rfp; 10977c478bd9Sstevel@tonic-gate if (tp != NULL) 10987c478bd9Sstevel@tonic-gate *tp = rp_is_void ? lbase : rbase; 10997c478bd9Sstevel@tonic-gate } 11007c478bd9Sstevel@tonic-gate 11017c478bd9Sstevel@tonic-gate return (compat); 11027c478bd9Sstevel@tonic-gate } 11037c478bd9Sstevel@tonic-gate 11047c478bd9Sstevel@tonic-gate /* 11057c478bd9Sstevel@tonic-gate * The rules for checking argument types against parameter types are described 11067c478bd9Sstevel@tonic-gate * in the ANSI-C spec (see K&R[A7.3.2] and K&R[A7.17]). We use the same rule 11077c478bd9Sstevel@tonic-gate * set to determine whether associative array arguments match the prototype. 11087c478bd9Sstevel@tonic-gate */ 11097c478bd9Sstevel@tonic-gate int 11107c478bd9Sstevel@tonic-gate dt_node_is_argcompat(const dt_node_t *lp, const dt_node_t *rp) 11117c478bd9Sstevel@tonic-gate { 11127c478bd9Sstevel@tonic-gate ctf_file_t *lfp = lp->dn_ctfp; 11137c478bd9Sstevel@tonic-gate ctf_file_t *rfp = rp->dn_ctfp; 11147c478bd9Sstevel@tonic-gate 11157c478bd9Sstevel@tonic-gate assert(lp->dn_flags & DT_NF_COOKED); 11167c478bd9Sstevel@tonic-gate assert(rp->dn_flags & DT_NF_COOKED); 11177c478bd9Sstevel@tonic-gate 11187c478bd9Sstevel@tonic-gate if (dt_node_is_integer(lp) && dt_node_is_integer(rp)) 11197c478bd9Sstevel@tonic-gate return (1); /* integer types are compatible */ 11207c478bd9Sstevel@tonic-gate 11217c478bd9Sstevel@tonic-gate if (dt_node_is_strcompat(lp) && dt_node_is_strcompat(rp)) 11227c478bd9Sstevel@tonic-gate return (1); /* string types are compatible */ 11237c478bd9Sstevel@tonic-gate 11247c478bd9Sstevel@tonic-gate if (dt_node_is_stack(lp) && dt_node_is_stack(rp)) 11257c478bd9Sstevel@tonic-gate return (1); /* stack types are compatible */ 11267c478bd9Sstevel@tonic-gate 1127*a1b5e537Sbmc if (dt_node_is_symaddr(lp) && dt_node_is_symaddr(rp)) 1128*a1b5e537Sbmc return (1); /* symaddr types are compatible */ 1129*a1b5e537Sbmc 1130*a1b5e537Sbmc if (dt_node_is_usymaddr(lp) && dt_node_is_usymaddr(rp)) 1131*a1b5e537Sbmc return (1); /* usymaddr types are compatible */ 1132*a1b5e537Sbmc 11337c478bd9Sstevel@tonic-gate switch (ctf_type_kind(lfp, ctf_type_resolve(lfp, lp->dn_type))) { 11347c478bd9Sstevel@tonic-gate case CTF_K_FUNCTION: 11357c478bd9Sstevel@tonic-gate case CTF_K_STRUCT: 11367c478bd9Sstevel@tonic-gate case CTF_K_UNION: 11377c478bd9Sstevel@tonic-gate return (ctf_type_compat(lfp, lp->dn_type, rfp, rp->dn_type)); 11387c478bd9Sstevel@tonic-gate default: 11397c478bd9Sstevel@tonic-gate return (dt_node_is_ptrcompat(lp, rp, NULL, NULL)); 11407c478bd9Sstevel@tonic-gate } 11417c478bd9Sstevel@tonic-gate } 11427c478bd9Sstevel@tonic-gate 11437c478bd9Sstevel@tonic-gate /* 11447c478bd9Sstevel@tonic-gate * We provide dt_node_is_posconst() as a convenience routine for callers who 11457c478bd9Sstevel@tonic-gate * wish to verify that an argument is a positive non-zero integer constant. 11467c478bd9Sstevel@tonic-gate */ 11477c478bd9Sstevel@tonic-gate int 11487c478bd9Sstevel@tonic-gate dt_node_is_posconst(const dt_node_t *dnp) 11497c478bd9Sstevel@tonic-gate { 11507c478bd9Sstevel@tonic-gate return (dnp->dn_kind == DT_NODE_INT && dnp->dn_value != 0 && ( 11517c478bd9Sstevel@tonic-gate (dnp->dn_flags & DT_NF_SIGNED) == 0 || (int64_t)dnp->dn_value > 0)); 11527c478bd9Sstevel@tonic-gate } 11537c478bd9Sstevel@tonic-gate 11547c478bd9Sstevel@tonic-gate int 11557c478bd9Sstevel@tonic-gate dt_node_is_actfunc(const dt_node_t *dnp) 11567c478bd9Sstevel@tonic-gate { 11577c478bd9Sstevel@tonic-gate return (dnp->dn_kind == DT_NODE_FUNC && 11587c478bd9Sstevel@tonic-gate dnp->dn_ident->di_kind == DT_IDENT_ACTFUNC); 11597c478bd9Sstevel@tonic-gate } 11607c478bd9Sstevel@tonic-gate 11617c478bd9Sstevel@tonic-gate /* 11627c478bd9Sstevel@tonic-gate * The original rules for integer constant typing are described in K&R[A2.5.1]. 11637c478bd9Sstevel@tonic-gate * However, since we support long long, we instead use the rules from ISO C99 11647c478bd9Sstevel@tonic-gate * clause 6.4.4.1 since that is where long longs are formally described. The 11657c478bd9Sstevel@tonic-gate * rules require us to know whether the constant was specified in decimal or 11667c478bd9Sstevel@tonic-gate * in octal or hex, which we do by looking at our lexer's 'yyintdecimal' flag. 11677c478bd9Sstevel@tonic-gate * The type of an integer constant is the first of the corresponding list in 11687c478bd9Sstevel@tonic-gate * which its value can be represented: 11697c478bd9Sstevel@tonic-gate * 11707c478bd9Sstevel@tonic-gate * unsuffixed decimal: int, long, long long 11717c478bd9Sstevel@tonic-gate * unsuffixed oct/hex: int, unsigned int, long, unsigned long, 11727c478bd9Sstevel@tonic-gate * long long, unsigned long long 11737c478bd9Sstevel@tonic-gate * suffix [uU]: unsigned int, unsigned long, unsigned long long 11747c478bd9Sstevel@tonic-gate * suffix [lL] decimal: long, long long 11757c478bd9Sstevel@tonic-gate * suffix [lL] oct/hex: long, unsigned long, long long, unsigned long long 11767c478bd9Sstevel@tonic-gate * suffix [uU][Ll]: unsigned long, unsigned long long 11777c478bd9Sstevel@tonic-gate * suffix ll/LL decimal: long long 11787c478bd9Sstevel@tonic-gate * suffix ll/LL oct/hex: long long, unsigned long long 11797c478bd9Sstevel@tonic-gate * suffix [uU][ll/LL]: unsigned long long 11807c478bd9Sstevel@tonic-gate * 11817c478bd9Sstevel@tonic-gate * Given that our lexer has already validated the suffixes by regexp matching, 11827c478bd9Sstevel@tonic-gate * there is an obvious way to concisely encode these rules: construct an array 11837c478bd9Sstevel@tonic-gate * of the types in the order int, unsigned int, long, unsigned long, long long, 11847c478bd9Sstevel@tonic-gate * unsigned long long. Compute an integer array starting index based on the 11857c478bd9Sstevel@tonic-gate * suffix (e.g. none = 0, u = 1, ull = 5), and compute an increment based on 11867c478bd9Sstevel@tonic-gate * the specifier (dec/oct/hex) and suffix (u). Then iterate from the starting 11877c478bd9Sstevel@tonic-gate * index to the end, advancing using the increment, and searching until we 11887c478bd9Sstevel@tonic-gate * find a limit that matches or we run out of choices (overflow). To make it 11897c478bd9Sstevel@tonic-gate * even faster, we precompute the table of type information in dtrace_open(). 11907c478bd9Sstevel@tonic-gate */ 11917c478bd9Sstevel@tonic-gate dt_node_t * 11927c478bd9Sstevel@tonic-gate dt_node_int(uintmax_t value) 11937c478bd9Sstevel@tonic-gate { 11947c478bd9Sstevel@tonic-gate dt_node_t *dnp = dt_node_alloc(DT_NODE_INT); 11957c478bd9Sstevel@tonic-gate dtrace_hdl_t *dtp = yypcb->pcb_hdl; 11967c478bd9Sstevel@tonic-gate 11977c478bd9Sstevel@tonic-gate int n = (yyintdecimal | (yyintsuffix[0] == 'u')) + 1; 11987c478bd9Sstevel@tonic-gate int i = 0; 11997c478bd9Sstevel@tonic-gate 12007c478bd9Sstevel@tonic-gate const char *p; 12017c478bd9Sstevel@tonic-gate char c; 12027c478bd9Sstevel@tonic-gate 12037c478bd9Sstevel@tonic-gate dnp->dn_op = DT_TOK_INT; 12047c478bd9Sstevel@tonic-gate dnp->dn_value = value; 12057c478bd9Sstevel@tonic-gate 12067c478bd9Sstevel@tonic-gate for (p = yyintsuffix; (c = *p) != '\0'; p++) { 12077c478bd9Sstevel@tonic-gate if (c == 'U' || c == 'u') 12087c478bd9Sstevel@tonic-gate i += 1; 12097c478bd9Sstevel@tonic-gate else if (c == 'L' || c == 'l') 12107c478bd9Sstevel@tonic-gate i += 2; 12117c478bd9Sstevel@tonic-gate } 12127c478bd9Sstevel@tonic-gate 12137c478bd9Sstevel@tonic-gate for (; i < sizeof (dtp->dt_ints) / sizeof (dtp->dt_ints[0]); i += n) { 12147c478bd9Sstevel@tonic-gate if (value <= dtp->dt_ints[i].did_limit) { 12157c478bd9Sstevel@tonic-gate dt_node_type_assign(dnp, 12167c478bd9Sstevel@tonic-gate dtp->dt_ints[i].did_ctfp, 12177c478bd9Sstevel@tonic-gate dtp->dt_ints[i].did_type); 12187c478bd9Sstevel@tonic-gate 12197c478bd9Sstevel@tonic-gate /* 12207c478bd9Sstevel@tonic-gate * If a prefix character is present in macro text, add 12217c478bd9Sstevel@tonic-gate * in the corresponding operator node (see dt_lex.l). 12227c478bd9Sstevel@tonic-gate */ 12237c478bd9Sstevel@tonic-gate switch (yyintprefix) { 12247c478bd9Sstevel@tonic-gate case '+': 12257c478bd9Sstevel@tonic-gate return (dt_node_op1(DT_TOK_IPOS, dnp)); 12267c478bd9Sstevel@tonic-gate case '-': 12277c478bd9Sstevel@tonic-gate return (dt_node_op1(DT_TOK_INEG, dnp)); 12287c478bd9Sstevel@tonic-gate default: 12297c478bd9Sstevel@tonic-gate return (dnp); 12307c478bd9Sstevel@tonic-gate } 12317c478bd9Sstevel@tonic-gate } 12327c478bd9Sstevel@tonic-gate } 12337c478bd9Sstevel@tonic-gate 12347c478bd9Sstevel@tonic-gate xyerror(D_INT_OFLOW, "integer constant 0x%llx cannot be represented " 12357c478bd9Sstevel@tonic-gate "in any built-in integral type\n", (u_longlong_t)value); 12367c478bd9Sstevel@tonic-gate /*NOTREACHED*/ 12377c478bd9Sstevel@tonic-gate return (NULL); /* keep gcc happy */ 12387c478bd9Sstevel@tonic-gate } 12397c478bd9Sstevel@tonic-gate 12407c478bd9Sstevel@tonic-gate dt_node_t * 12417c478bd9Sstevel@tonic-gate dt_node_string(char *string) 12427c478bd9Sstevel@tonic-gate { 12437c478bd9Sstevel@tonic-gate dtrace_hdl_t *dtp = yypcb->pcb_hdl; 12447c478bd9Sstevel@tonic-gate dt_node_t *dnp; 12457c478bd9Sstevel@tonic-gate 12467c478bd9Sstevel@tonic-gate if (string == NULL) 12477c478bd9Sstevel@tonic-gate longjmp(yypcb->pcb_jmpbuf, EDT_NOMEM); 12487c478bd9Sstevel@tonic-gate 12497c478bd9Sstevel@tonic-gate dnp = dt_node_alloc(DT_NODE_STRING); 12507c478bd9Sstevel@tonic-gate dnp->dn_op = DT_TOK_STRING; 12517c478bd9Sstevel@tonic-gate dnp->dn_string = string; 12527c478bd9Sstevel@tonic-gate dt_node_type_assign(dnp, DT_STR_CTFP(dtp), DT_STR_TYPE(dtp)); 12537c478bd9Sstevel@tonic-gate 12547c478bd9Sstevel@tonic-gate return (dnp); 12557c478bd9Sstevel@tonic-gate } 12567c478bd9Sstevel@tonic-gate 12577c478bd9Sstevel@tonic-gate dt_node_t * 12587c478bd9Sstevel@tonic-gate dt_node_ident(char *name) 12597c478bd9Sstevel@tonic-gate { 12607c478bd9Sstevel@tonic-gate dt_ident_t *idp; 12617c478bd9Sstevel@tonic-gate dt_node_t *dnp; 12627c478bd9Sstevel@tonic-gate 12637c478bd9Sstevel@tonic-gate if (name == NULL) 12647c478bd9Sstevel@tonic-gate longjmp(yypcb->pcb_jmpbuf, EDT_NOMEM); 12657c478bd9Sstevel@tonic-gate 12667c478bd9Sstevel@tonic-gate /* 12677c478bd9Sstevel@tonic-gate * If the identifier is an inlined integer constant, then create an INT 12687c478bd9Sstevel@tonic-gate * node that is a clone of the inline parse tree node and return that 12697c478bd9Sstevel@tonic-gate * immediately, allowing this inline to be used in parsing contexts 12707c478bd9Sstevel@tonic-gate * that require constant expressions (e.g. scalar array sizes). 12717c478bd9Sstevel@tonic-gate */ 12727c478bd9Sstevel@tonic-gate if ((idp = dt_idstack_lookup(&yypcb->pcb_globals, name)) != NULL && 12737c478bd9Sstevel@tonic-gate (idp->di_flags & DT_IDFLG_INLINE)) { 12747c478bd9Sstevel@tonic-gate dt_idnode_t *inp = idp->di_iarg; 12757c478bd9Sstevel@tonic-gate 12761a7c1b72Smws if (inp->din_root != NULL && 12771a7c1b72Smws inp->din_root->dn_kind == DT_NODE_INT) { 12787c478bd9Sstevel@tonic-gate free(name); 12797c478bd9Sstevel@tonic-gate 12807c478bd9Sstevel@tonic-gate dnp = dt_node_alloc(DT_NODE_INT); 12817c478bd9Sstevel@tonic-gate dnp->dn_op = DT_TOK_INT; 12827c478bd9Sstevel@tonic-gate dnp->dn_value = inp->din_root->dn_value; 12837c478bd9Sstevel@tonic-gate dt_node_type_propagate(inp->din_root, dnp); 12847c478bd9Sstevel@tonic-gate 12857c478bd9Sstevel@tonic-gate return (dnp); 12867c478bd9Sstevel@tonic-gate } 12877c478bd9Sstevel@tonic-gate } 12887c478bd9Sstevel@tonic-gate 12897c478bd9Sstevel@tonic-gate dnp = dt_node_alloc(DT_NODE_IDENT); 12907c478bd9Sstevel@tonic-gate dnp->dn_op = name[0] == '@' ? DT_TOK_AGG : DT_TOK_IDENT; 12917c478bd9Sstevel@tonic-gate dnp->dn_string = name; 12927c478bd9Sstevel@tonic-gate 12937c478bd9Sstevel@tonic-gate return (dnp); 12947c478bd9Sstevel@tonic-gate } 12957c478bd9Sstevel@tonic-gate 12967c478bd9Sstevel@tonic-gate /* 12977c478bd9Sstevel@tonic-gate * Create an empty node of type corresponding to the given declaration. 12987c478bd9Sstevel@tonic-gate * Explicit references to user types (C or D) are assigned the default 12997c478bd9Sstevel@tonic-gate * stability; references to other types are _dtrace_typattr (Private). 13007c478bd9Sstevel@tonic-gate */ 13017c478bd9Sstevel@tonic-gate dt_node_t * 13027c478bd9Sstevel@tonic-gate dt_node_type(dt_decl_t *ddp) 13037c478bd9Sstevel@tonic-gate { 13047c478bd9Sstevel@tonic-gate dtrace_hdl_t *dtp = yypcb->pcb_hdl; 13057c478bd9Sstevel@tonic-gate dtrace_typeinfo_t dtt; 13067c478bd9Sstevel@tonic-gate dt_node_t *dnp; 13077c478bd9Sstevel@tonic-gate char *name = NULL; 13087c478bd9Sstevel@tonic-gate int err; 13097c478bd9Sstevel@tonic-gate 13107c478bd9Sstevel@tonic-gate /* 13117c478bd9Sstevel@tonic-gate * If 'ddp' is NULL, we get a decl by popping the decl stack. This 13127c478bd9Sstevel@tonic-gate * form of dt_node_type() is used by parameter rules in dt_grammar.y. 13137c478bd9Sstevel@tonic-gate */ 13147c478bd9Sstevel@tonic-gate if (ddp == NULL) 13157c478bd9Sstevel@tonic-gate ddp = dt_decl_pop_param(&name); 13167c478bd9Sstevel@tonic-gate 13177c478bd9Sstevel@tonic-gate err = dt_decl_type(ddp, &dtt); 13187c478bd9Sstevel@tonic-gate dt_decl_free(ddp); 13197c478bd9Sstevel@tonic-gate 13207c478bd9Sstevel@tonic-gate if (err != 0) { 13217c478bd9Sstevel@tonic-gate free(name); 13227c478bd9Sstevel@tonic-gate longjmp(yypcb->pcb_jmpbuf, EDT_COMPILER); 13237c478bd9Sstevel@tonic-gate } 13247c478bd9Sstevel@tonic-gate 13257c478bd9Sstevel@tonic-gate dnp = dt_node_alloc(DT_NODE_TYPE); 13267c478bd9Sstevel@tonic-gate dnp->dn_op = DT_TOK_IDENT; 13277c478bd9Sstevel@tonic-gate dnp->dn_string = name; 13287c478bd9Sstevel@tonic-gate dt_node_type_assign(dnp, dtt.dtt_ctfp, dtt.dtt_type); 13297c478bd9Sstevel@tonic-gate 13307c478bd9Sstevel@tonic-gate if (dtt.dtt_ctfp == dtp->dt_cdefs->dm_ctfp || 13317c478bd9Sstevel@tonic-gate dtt.dtt_ctfp == dtp->dt_ddefs->dm_ctfp) 13327c478bd9Sstevel@tonic-gate dt_node_attr_assign(dnp, _dtrace_defattr); 13337c478bd9Sstevel@tonic-gate else 13347c478bd9Sstevel@tonic-gate dt_node_attr_assign(dnp, _dtrace_typattr); 13357c478bd9Sstevel@tonic-gate 13367c478bd9Sstevel@tonic-gate return (dnp); 13377c478bd9Sstevel@tonic-gate } 13387c478bd9Sstevel@tonic-gate 13397c478bd9Sstevel@tonic-gate /* 13407c478bd9Sstevel@tonic-gate * Create a type node corresponding to a varargs (...) parameter by just 13417c478bd9Sstevel@tonic-gate * assigning it type CTF_ERR. The decl processing code will handle this. 13427c478bd9Sstevel@tonic-gate */ 13437c478bd9Sstevel@tonic-gate dt_node_t * 13447c478bd9Sstevel@tonic-gate dt_node_vatype(void) 13457c478bd9Sstevel@tonic-gate { 13467c478bd9Sstevel@tonic-gate dt_node_t *dnp = dt_node_alloc(DT_NODE_TYPE); 13477c478bd9Sstevel@tonic-gate 13487c478bd9Sstevel@tonic-gate dnp->dn_op = DT_TOK_IDENT; 13497c478bd9Sstevel@tonic-gate dnp->dn_ctfp = yypcb->pcb_hdl->dt_cdefs->dm_ctfp; 13507c478bd9Sstevel@tonic-gate dnp->dn_type = CTF_ERR; 13517c478bd9Sstevel@tonic-gate dnp->dn_attr = _dtrace_defattr; 13527c478bd9Sstevel@tonic-gate 13537c478bd9Sstevel@tonic-gate return (dnp); 13547c478bd9Sstevel@tonic-gate } 13557c478bd9Sstevel@tonic-gate 13567c478bd9Sstevel@tonic-gate /* 13577c478bd9Sstevel@tonic-gate * Instantiate a decl using the contents of the current declaration stack. As 13587c478bd9Sstevel@tonic-gate * we do not currently permit decls to be initialized, this function currently 13597c478bd9Sstevel@tonic-gate * returns NULL and no parse node is created. When this function is called, 13607c478bd9Sstevel@tonic-gate * the topmost scope's ds_ident pointer will be set to NULL (indicating no 13617c478bd9Sstevel@tonic-gate * init_declarator rule was matched) or will point to the identifier to use. 13627c478bd9Sstevel@tonic-gate */ 13637c478bd9Sstevel@tonic-gate dt_node_t * 13647c478bd9Sstevel@tonic-gate dt_node_decl(void) 13657c478bd9Sstevel@tonic-gate { 13667c478bd9Sstevel@tonic-gate dtrace_hdl_t *dtp = yypcb->pcb_hdl; 13677c478bd9Sstevel@tonic-gate dt_scope_t *dsp = &yypcb->pcb_dstack; 13687c478bd9Sstevel@tonic-gate dt_dclass_t class = dsp->ds_class; 13697c478bd9Sstevel@tonic-gate dt_decl_t *ddp = dt_decl_top(); 13707c478bd9Sstevel@tonic-gate 13717c478bd9Sstevel@tonic-gate dt_module_t *dmp; 13727c478bd9Sstevel@tonic-gate dtrace_typeinfo_t dtt; 13737c478bd9Sstevel@tonic-gate ctf_id_t type; 13747c478bd9Sstevel@tonic-gate 13757c478bd9Sstevel@tonic-gate char n1[DT_TYPE_NAMELEN]; 13767c478bd9Sstevel@tonic-gate char n2[DT_TYPE_NAMELEN]; 13777c478bd9Sstevel@tonic-gate 13787c478bd9Sstevel@tonic-gate if (dt_decl_type(ddp, &dtt) != 0) 13797c478bd9Sstevel@tonic-gate longjmp(yypcb->pcb_jmpbuf, EDT_COMPILER); 13807c478bd9Sstevel@tonic-gate 13817c478bd9Sstevel@tonic-gate /* 13827c478bd9Sstevel@tonic-gate * If we have no declaration identifier, then this is either a spurious 13837c478bd9Sstevel@tonic-gate * declaration of an intrinsic type (e.g. "extern int;") or declaration 13847c478bd9Sstevel@tonic-gate * or redeclaration of a struct, union, or enum type or tag. 13857c478bd9Sstevel@tonic-gate */ 13867c478bd9Sstevel@tonic-gate if (dsp->ds_ident == NULL) { 13877c478bd9Sstevel@tonic-gate if (ddp->dd_kind != CTF_K_STRUCT && 13887c478bd9Sstevel@tonic-gate ddp->dd_kind != CTF_K_UNION && ddp->dd_kind != CTF_K_ENUM) 13897c478bd9Sstevel@tonic-gate xyerror(D_DECL_USELESS, "useless declaration\n"); 13907c478bd9Sstevel@tonic-gate 13917c478bd9Sstevel@tonic-gate dt_dprintf("type %s added as id %ld\n", dt_type_name( 13927c478bd9Sstevel@tonic-gate ddp->dd_ctfp, ddp->dd_type, n1, sizeof (n1)), ddp->dd_type); 13937c478bd9Sstevel@tonic-gate 13947c478bd9Sstevel@tonic-gate return (NULL); 13957c478bd9Sstevel@tonic-gate } 13967c478bd9Sstevel@tonic-gate 13977c478bd9Sstevel@tonic-gate if (strchr(dsp->ds_ident, '`') != NULL) { 13987c478bd9Sstevel@tonic-gate xyerror(D_DECL_SCOPE, "D scoping operator may not be used in " 13997c478bd9Sstevel@tonic-gate "a declaration name (%s)\n", dsp->ds_ident); 14007c478bd9Sstevel@tonic-gate } 14017c478bd9Sstevel@tonic-gate 14027c478bd9Sstevel@tonic-gate /* 14037c478bd9Sstevel@tonic-gate * If we are nested inside of a C include file, add the declaration to 14047c478bd9Sstevel@tonic-gate * the C definition module; otherwise use the D definition module. 14057c478bd9Sstevel@tonic-gate */ 14067c478bd9Sstevel@tonic-gate if (yypcb->pcb_idepth != 0) 14077c478bd9Sstevel@tonic-gate dmp = dtp->dt_cdefs; 14087c478bd9Sstevel@tonic-gate else 14097c478bd9Sstevel@tonic-gate dmp = dtp->dt_ddefs; 14107c478bd9Sstevel@tonic-gate 14117c478bd9Sstevel@tonic-gate /* 14127c478bd9Sstevel@tonic-gate * If we see a global or static declaration of a function prototype, 14137c478bd9Sstevel@tonic-gate * treat this as equivalent to a D extern declaration. 14147c478bd9Sstevel@tonic-gate */ 14157c478bd9Sstevel@tonic-gate if (ctf_type_kind(dtt.dtt_ctfp, dtt.dtt_type) == CTF_K_FUNCTION && 14167c478bd9Sstevel@tonic-gate (class == DT_DC_DEFAULT || class == DT_DC_STATIC)) 14177c478bd9Sstevel@tonic-gate class = DT_DC_EXTERN; 14187c478bd9Sstevel@tonic-gate 14197c478bd9Sstevel@tonic-gate switch (class) { 14207c478bd9Sstevel@tonic-gate case DT_DC_AUTO: 14217c478bd9Sstevel@tonic-gate case DT_DC_REGISTER: 14227c478bd9Sstevel@tonic-gate case DT_DC_STATIC: 14237c478bd9Sstevel@tonic-gate xyerror(D_DECL_BADCLASS, "specified storage class not " 14247c478bd9Sstevel@tonic-gate "appropriate in D\n"); 14257c478bd9Sstevel@tonic-gate /*NOTREACHED*/ 14267c478bd9Sstevel@tonic-gate 14277c478bd9Sstevel@tonic-gate case DT_DC_EXTERN: { 14287c478bd9Sstevel@tonic-gate dtrace_typeinfo_t ott; 14297c478bd9Sstevel@tonic-gate dtrace_syminfo_t dts; 14307c478bd9Sstevel@tonic-gate GElf_Sym sym; 14317c478bd9Sstevel@tonic-gate 14327c478bd9Sstevel@tonic-gate int exists = dtrace_lookup_by_name(dtp, 14337c478bd9Sstevel@tonic-gate dmp->dm_name, dsp->ds_ident, &sym, &dts) == 0; 14347c478bd9Sstevel@tonic-gate 14357c478bd9Sstevel@tonic-gate if (exists && (dtrace_symbol_type(dtp, &sym, &dts, &ott) != 0 || 14367c478bd9Sstevel@tonic-gate ctf_type_cmp(dtt.dtt_ctfp, dtt.dtt_type, 14377c478bd9Sstevel@tonic-gate ott.dtt_ctfp, ott.dtt_type) != 0)) { 14387c478bd9Sstevel@tonic-gate xyerror(D_DECL_IDRED, "identifier redeclared: %s`%s\n" 14397c478bd9Sstevel@tonic-gate "\t current: %s\n\tprevious: %s\n", 14407c478bd9Sstevel@tonic-gate dmp->dm_name, dsp->ds_ident, 14417c478bd9Sstevel@tonic-gate dt_type_name(dtt.dtt_ctfp, dtt.dtt_type, 14427c478bd9Sstevel@tonic-gate n1, sizeof (n1)), 14437c478bd9Sstevel@tonic-gate dt_type_name(ott.dtt_ctfp, ott.dtt_type, 14447c478bd9Sstevel@tonic-gate n2, sizeof (n2))); 14457c478bd9Sstevel@tonic-gate } else if (!exists && dt_module_extern(dtp, dmp, 14467c478bd9Sstevel@tonic-gate dsp->ds_ident, &dtt) == NULL) { 14477c478bd9Sstevel@tonic-gate xyerror(D_UNKNOWN, 14487c478bd9Sstevel@tonic-gate "failed to extern %s: %s\n", dsp->ds_ident, 14497c478bd9Sstevel@tonic-gate dtrace_errmsg(dtp, dtrace_errno(dtp))); 14507c478bd9Sstevel@tonic-gate } else { 14517c478bd9Sstevel@tonic-gate dt_dprintf("extern %s`%s type=<%s>\n", 14527c478bd9Sstevel@tonic-gate dmp->dm_name, dsp->ds_ident, 14537c478bd9Sstevel@tonic-gate dt_type_name(dtt.dtt_ctfp, dtt.dtt_type, 14547c478bd9Sstevel@tonic-gate n1, sizeof (n1))); 14557c478bd9Sstevel@tonic-gate } 14567c478bd9Sstevel@tonic-gate break; 14577c478bd9Sstevel@tonic-gate } 14587c478bd9Sstevel@tonic-gate 14597c478bd9Sstevel@tonic-gate case DT_DC_TYPEDEF: 14607c478bd9Sstevel@tonic-gate /* 14617c478bd9Sstevel@tonic-gate * If the source type for the typedef is not defined in the 14627c478bd9Sstevel@tonic-gate * target container or its parent, copy the type to the target 14637c478bd9Sstevel@tonic-gate * container and reset dtt_ctfp and dtt_type to the copy. 14647c478bd9Sstevel@tonic-gate */ 14657c478bd9Sstevel@tonic-gate if (dtt.dtt_ctfp != dmp->dm_ctfp && 14667c478bd9Sstevel@tonic-gate dtt.dtt_ctfp != ctf_parent_file(dmp->dm_ctfp)) { 14677c478bd9Sstevel@tonic-gate 14687c478bd9Sstevel@tonic-gate dtt.dtt_type = ctf_add_type(dmp->dm_ctfp, 14697c478bd9Sstevel@tonic-gate dtt.dtt_ctfp, dtt.dtt_type); 14707c478bd9Sstevel@tonic-gate dtt.dtt_ctfp = dmp->dm_ctfp; 14717c478bd9Sstevel@tonic-gate 14727c478bd9Sstevel@tonic-gate if (dtt.dtt_type == CTF_ERR || 14737c478bd9Sstevel@tonic-gate ctf_update(dtt.dtt_ctfp) == CTF_ERR) { 14747c478bd9Sstevel@tonic-gate xyerror(D_UNKNOWN, "failed to copy typedef %s " 14757c478bd9Sstevel@tonic-gate "source type: %s\n", dsp->ds_ident, 14767c478bd9Sstevel@tonic-gate ctf_errmsg(ctf_errno(dtt.dtt_ctfp))); 14777c478bd9Sstevel@tonic-gate } 14787c478bd9Sstevel@tonic-gate } 14797c478bd9Sstevel@tonic-gate 14807c478bd9Sstevel@tonic-gate type = ctf_add_typedef(dmp->dm_ctfp, 14817c478bd9Sstevel@tonic-gate CTF_ADD_ROOT, dsp->ds_ident, dtt.dtt_type); 14827c478bd9Sstevel@tonic-gate 14837c478bd9Sstevel@tonic-gate if (type == CTF_ERR || ctf_update(dmp->dm_ctfp) == CTF_ERR) { 14847c478bd9Sstevel@tonic-gate xyerror(D_UNKNOWN, "failed to typedef %s: %s\n", 14857c478bd9Sstevel@tonic-gate dsp->ds_ident, ctf_errmsg(ctf_errno(dmp->dm_ctfp))); 14867c478bd9Sstevel@tonic-gate } 14877c478bd9Sstevel@tonic-gate 14887c478bd9Sstevel@tonic-gate dt_dprintf("typedef %s added as id %ld\n", dsp->ds_ident, type); 14897c478bd9Sstevel@tonic-gate break; 14907c478bd9Sstevel@tonic-gate 14917c478bd9Sstevel@tonic-gate default: { 14927c478bd9Sstevel@tonic-gate ctf_encoding_t cte; 14937c478bd9Sstevel@tonic-gate dt_idhash_t *dhp; 14947c478bd9Sstevel@tonic-gate dt_ident_t *idp; 14957c478bd9Sstevel@tonic-gate dt_node_t idn; 14967c478bd9Sstevel@tonic-gate int assc, idkind; 14977c478bd9Sstevel@tonic-gate uint_t id, kind; 14987c478bd9Sstevel@tonic-gate ushort_t idflags; 14997c478bd9Sstevel@tonic-gate 15007c478bd9Sstevel@tonic-gate switch (class) { 15017c478bd9Sstevel@tonic-gate case DT_DC_THIS: 15027c478bd9Sstevel@tonic-gate dhp = yypcb->pcb_locals; 15037c478bd9Sstevel@tonic-gate idflags = DT_IDFLG_LOCAL; 15047c478bd9Sstevel@tonic-gate idp = dt_idhash_lookup(dhp, dsp->ds_ident); 15057c478bd9Sstevel@tonic-gate break; 15067c478bd9Sstevel@tonic-gate case DT_DC_SELF: 15077c478bd9Sstevel@tonic-gate dhp = dtp->dt_tls; 15087c478bd9Sstevel@tonic-gate idflags = DT_IDFLG_TLS; 15097c478bd9Sstevel@tonic-gate idp = dt_idhash_lookup(dhp, dsp->ds_ident); 15107c478bd9Sstevel@tonic-gate break; 15117c478bd9Sstevel@tonic-gate default: 15127c478bd9Sstevel@tonic-gate dhp = dtp->dt_globals; 15137c478bd9Sstevel@tonic-gate idflags = 0; 15147c478bd9Sstevel@tonic-gate idp = dt_idstack_lookup( 15157c478bd9Sstevel@tonic-gate &yypcb->pcb_globals, dsp->ds_ident); 15167c478bd9Sstevel@tonic-gate break; 15177c478bd9Sstevel@tonic-gate } 15187c478bd9Sstevel@tonic-gate 15197c478bd9Sstevel@tonic-gate if (ddp->dd_kind == CTF_K_ARRAY && ddp->dd_node == NULL) { 15207c478bd9Sstevel@tonic-gate xyerror(D_DECL_ARRNULL, 15217c478bd9Sstevel@tonic-gate "array declaration requires array dimension or " 15227c478bd9Sstevel@tonic-gate "tuple signature: %s\n", dsp->ds_ident); 15237c478bd9Sstevel@tonic-gate } 15247c478bd9Sstevel@tonic-gate 15257c478bd9Sstevel@tonic-gate if (idp != NULL && idp->di_gen == 0) { 15267c478bd9Sstevel@tonic-gate xyerror(D_DECL_IDRED, "built-in identifier " 15277c478bd9Sstevel@tonic-gate "redeclared: %s\n", idp->di_name); 15287c478bd9Sstevel@tonic-gate } 15297c478bd9Sstevel@tonic-gate 15307c478bd9Sstevel@tonic-gate /* 15317c478bd9Sstevel@tonic-gate * Cache some attributes of the decl to make the rest of this 15327c478bd9Sstevel@tonic-gate * code simpler: if the decl is an array which is subscripted 15337c478bd9Sstevel@tonic-gate * by a type rather than an integer, then it's an associative 15347c478bd9Sstevel@tonic-gate * array (assc). We then expect to match either DT_IDENT_ARRAY 15357c478bd9Sstevel@tonic-gate * for associative arrays or DT_IDENT_SCALAR for anything else. 15367c478bd9Sstevel@tonic-gate */ 15377c478bd9Sstevel@tonic-gate assc = ddp->dd_kind == CTF_K_ARRAY && 15387c478bd9Sstevel@tonic-gate ddp->dd_node->dn_kind == DT_NODE_TYPE; 15397c478bd9Sstevel@tonic-gate 15407c478bd9Sstevel@tonic-gate idkind = assc ? DT_IDENT_ARRAY : DT_IDENT_SCALAR; 15417c478bd9Sstevel@tonic-gate 15427c478bd9Sstevel@tonic-gate /* 15437c478bd9Sstevel@tonic-gate * Create a fake dt_node_t on the stack so we can determine the 15447c478bd9Sstevel@tonic-gate * type of any matching identifier by assigning to this node. 15457c478bd9Sstevel@tonic-gate * If the pre-existing ident has its di_type set, propagate 15467c478bd9Sstevel@tonic-gate * the type by hand so as not to trigger a prototype check for 15477c478bd9Sstevel@tonic-gate * arrays (yet); otherwise we use dt_ident_cook() on the ident 15487c478bd9Sstevel@tonic-gate * to ensure it is fully initialized before looking at it. 15497c478bd9Sstevel@tonic-gate */ 15507c478bd9Sstevel@tonic-gate bzero(&idn, sizeof (dt_node_t)); 15517c478bd9Sstevel@tonic-gate 15527c478bd9Sstevel@tonic-gate if (idp != NULL && idp->di_type != CTF_ERR) 15537c478bd9Sstevel@tonic-gate dt_node_type_assign(&idn, idp->di_ctfp, idp->di_type); 15547c478bd9Sstevel@tonic-gate else if (idp != NULL) 15557c478bd9Sstevel@tonic-gate (void) dt_ident_cook(&idn, idp, NULL); 15567c478bd9Sstevel@tonic-gate 15577c478bd9Sstevel@tonic-gate if (assc) { 15587c478bd9Sstevel@tonic-gate if (class == DT_DC_THIS) { 15597c478bd9Sstevel@tonic-gate xyerror(D_DECL_LOCASSC, "associative arrays " 15607c478bd9Sstevel@tonic-gate "may not be declared as local variables:" 15617c478bd9Sstevel@tonic-gate " %s\n", dsp->ds_ident); 15627c478bd9Sstevel@tonic-gate } 15637c478bd9Sstevel@tonic-gate 15647c478bd9Sstevel@tonic-gate if (dt_decl_type(ddp->dd_next, &dtt) != 0) 15657c478bd9Sstevel@tonic-gate longjmp(yypcb->pcb_jmpbuf, EDT_COMPILER); 15667c478bd9Sstevel@tonic-gate } 15677c478bd9Sstevel@tonic-gate 15687c478bd9Sstevel@tonic-gate if (idp != NULL && (idp->di_kind != idkind || 15697c478bd9Sstevel@tonic-gate ctf_type_cmp(dtt.dtt_ctfp, dtt.dtt_type, 15707c478bd9Sstevel@tonic-gate idn.dn_ctfp, idn.dn_type) != 0)) { 15717c478bd9Sstevel@tonic-gate xyerror(D_DECL_IDRED, "identifier redeclared: %s\n" 15727c478bd9Sstevel@tonic-gate "\t current: %s %s\n\tprevious: %s %s\n", 15737c478bd9Sstevel@tonic-gate dsp->ds_ident, dt_idkind_name(idkind), 15747c478bd9Sstevel@tonic-gate dt_type_name(dtt.dtt_ctfp, 15757c478bd9Sstevel@tonic-gate dtt.dtt_type, n1, sizeof (n1)), 15767c478bd9Sstevel@tonic-gate dt_idkind_name(idp->di_kind), 15777c478bd9Sstevel@tonic-gate dt_node_type_name(&idn, n2, sizeof (n2))); 15787c478bd9Sstevel@tonic-gate 15797c478bd9Sstevel@tonic-gate } else if (idp != NULL && assc) { 15807c478bd9Sstevel@tonic-gate const dt_idsig_t *isp = idp->di_data; 15817c478bd9Sstevel@tonic-gate dt_node_t *dnp = ddp->dd_node; 15827c478bd9Sstevel@tonic-gate int argc = 0; 15837c478bd9Sstevel@tonic-gate 15847c478bd9Sstevel@tonic-gate for (; dnp != NULL; dnp = dnp->dn_list, argc++) { 15857c478bd9Sstevel@tonic-gate const dt_node_t *pnp = &isp->dis_args[argc]; 15867c478bd9Sstevel@tonic-gate 15877c478bd9Sstevel@tonic-gate if (argc >= isp->dis_argc) 15887c478bd9Sstevel@tonic-gate continue; /* tuple length mismatch */ 15897c478bd9Sstevel@tonic-gate 15907c478bd9Sstevel@tonic-gate if (ctf_type_cmp(dnp->dn_ctfp, dnp->dn_type, 15917c478bd9Sstevel@tonic-gate pnp->dn_ctfp, pnp->dn_type) == 0) 15927c478bd9Sstevel@tonic-gate continue; 15937c478bd9Sstevel@tonic-gate 15947c478bd9Sstevel@tonic-gate xyerror(D_DECL_IDRED, 15957c478bd9Sstevel@tonic-gate "identifier redeclared: %s\n" 15967c478bd9Sstevel@tonic-gate "\t current: %s, key #%d of type %s\n" 15977c478bd9Sstevel@tonic-gate "\tprevious: %s, key #%d of type %s\n", 15987c478bd9Sstevel@tonic-gate dsp->ds_ident, 15997c478bd9Sstevel@tonic-gate dt_idkind_name(idkind), argc + 1, 16007c478bd9Sstevel@tonic-gate dt_node_type_name(dnp, n1, sizeof (n1)), 16017c478bd9Sstevel@tonic-gate dt_idkind_name(idp->di_kind), argc + 1, 16027c478bd9Sstevel@tonic-gate dt_node_type_name(pnp, n2, sizeof (n2))); 16037c478bd9Sstevel@tonic-gate } 16047c478bd9Sstevel@tonic-gate 16057c478bd9Sstevel@tonic-gate if (isp->dis_argc != argc) { 16067c478bd9Sstevel@tonic-gate xyerror(D_DECL_IDRED, 16077c478bd9Sstevel@tonic-gate "identifier redeclared: %s\n" 16087c478bd9Sstevel@tonic-gate "\t current: %s of %s, tuple length %d\n" 16097c478bd9Sstevel@tonic-gate "\tprevious: %s of %s, tuple length %d\n", 16107c478bd9Sstevel@tonic-gate dsp->ds_ident, dt_idkind_name(idkind), 16117c478bd9Sstevel@tonic-gate dt_type_name(dtt.dtt_ctfp, dtt.dtt_type, 16127c478bd9Sstevel@tonic-gate n1, sizeof (n1)), argc, 16137c478bd9Sstevel@tonic-gate dt_idkind_name(idp->di_kind), 16147c478bd9Sstevel@tonic-gate dt_node_type_name(&idn, n2, sizeof (n2)), 16157c478bd9Sstevel@tonic-gate isp->dis_argc); 16167c478bd9Sstevel@tonic-gate } 16177c478bd9Sstevel@tonic-gate 16187c478bd9Sstevel@tonic-gate } else if (idp == NULL) { 16197c478bd9Sstevel@tonic-gate type = ctf_type_resolve(dtt.dtt_ctfp, dtt.dtt_type); 16207c478bd9Sstevel@tonic-gate kind = ctf_type_kind(dtt.dtt_ctfp, type); 16217c478bd9Sstevel@tonic-gate 16227c478bd9Sstevel@tonic-gate switch (kind) { 16237c478bd9Sstevel@tonic-gate case CTF_K_INTEGER: 16247c478bd9Sstevel@tonic-gate if (ctf_type_encoding(dtt.dtt_ctfp, type, 16257c478bd9Sstevel@tonic-gate &cte) == 0 && IS_VOID(cte)) { 16267c478bd9Sstevel@tonic-gate xyerror(D_DECL_VOIDOBJ, "cannot have " 16277c478bd9Sstevel@tonic-gate "void object: %s\n", dsp->ds_ident); 16287c478bd9Sstevel@tonic-gate } 16297c478bd9Sstevel@tonic-gate break; 16307c478bd9Sstevel@tonic-gate case CTF_K_STRUCT: 16317c478bd9Sstevel@tonic-gate case CTF_K_UNION: 16327c478bd9Sstevel@tonic-gate if (ctf_type_size(dtt.dtt_ctfp, type) != 0) 16337c478bd9Sstevel@tonic-gate break; /* proceed to declaring */ 16347c478bd9Sstevel@tonic-gate /*FALLTHRU*/ 16357c478bd9Sstevel@tonic-gate case CTF_K_FORWARD: 16367c478bd9Sstevel@tonic-gate xyerror(D_DECL_INCOMPLETE, 16377c478bd9Sstevel@tonic-gate "incomplete struct/union/enum %s: %s\n", 16387c478bd9Sstevel@tonic-gate dt_type_name(dtt.dtt_ctfp, dtt.dtt_type, 16397c478bd9Sstevel@tonic-gate n1, sizeof (n1)), dsp->ds_ident); 16407c478bd9Sstevel@tonic-gate /*NOTREACHED*/ 16417c478bd9Sstevel@tonic-gate } 16427c478bd9Sstevel@tonic-gate 16437c478bd9Sstevel@tonic-gate if (dt_idhash_nextid(dhp, &id) == -1) { 16447c478bd9Sstevel@tonic-gate xyerror(D_ID_OFLOW, "cannot create %s: limit " 16457c478bd9Sstevel@tonic-gate "on number of %s variables exceeded\n", 16467c478bd9Sstevel@tonic-gate dsp->ds_ident, dt_idhash_name(dhp)); 16477c478bd9Sstevel@tonic-gate } 16487c478bd9Sstevel@tonic-gate 16497c478bd9Sstevel@tonic-gate dt_dprintf("declare %s %s variable %s, id=%u\n", 16507c478bd9Sstevel@tonic-gate dt_idhash_name(dhp), dt_idkind_name(idkind), 16517c478bd9Sstevel@tonic-gate dsp->ds_ident, id); 16527c478bd9Sstevel@tonic-gate 16537c478bd9Sstevel@tonic-gate idp = dt_idhash_insert(dhp, dsp->ds_ident, idkind, 16547c478bd9Sstevel@tonic-gate idflags | DT_IDFLG_WRITE | DT_IDFLG_DECL, id, 16557c478bd9Sstevel@tonic-gate _dtrace_defattr, 0, assc ? &dt_idops_assc : 16567c478bd9Sstevel@tonic-gate &dt_idops_thaw, NULL, dtp->dt_gen); 16577c478bd9Sstevel@tonic-gate 16587c478bd9Sstevel@tonic-gate if (idp == NULL) 16597c478bd9Sstevel@tonic-gate longjmp(yypcb->pcb_jmpbuf, EDT_NOMEM); 16607c478bd9Sstevel@tonic-gate 16617c478bd9Sstevel@tonic-gate dt_ident_type_assign(idp, dtt.dtt_ctfp, dtt.dtt_type); 16627c478bd9Sstevel@tonic-gate 16637c478bd9Sstevel@tonic-gate /* 16647c478bd9Sstevel@tonic-gate * If we are declaring an associative array, use our 16657c478bd9Sstevel@tonic-gate * fake parse node to cook the new assoc identifier. 16667c478bd9Sstevel@tonic-gate * This will force the ident code to instantiate the 16677c478bd9Sstevel@tonic-gate * array type signature corresponding to the list of 16687c478bd9Sstevel@tonic-gate * types pointed to by ddp->dd_node. We also reset 16697c478bd9Sstevel@tonic-gate * the identifier's attributes based upon the result. 16707c478bd9Sstevel@tonic-gate */ 16717c478bd9Sstevel@tonic-gate if (assc) { 16727c478bd9Sstevel@tonic-gate idp->di_attr = 16737c478bd9Sstevel@tonic-gate dt_ident_cook(&idn, idp, &ddp->dd_node); 16747c478bd9Sstevel@tonic-gate } 16757c478bd9Sstevel@tonic-gate } 16767c478bd9Sstevel@tonic-gate } 16777c478bd9Sstevel@tonic-gate 16787c478bd9Sstevel@tonic-gate } /* end of switch */ 16797c478bd9Sstevel@tonic-gate 16807c478bd9Sstevel@tonic-gate free(dsp->ds_ident); 16817c478bd9Sstevel@tonic-gate dsp->ds_ident = NULL; 16827c478bd9Sstevel@tonic-gate 16837c478bd9Sstevel@tonic-gate return (NULL); 16847c478bd9Sstevel@tonic-gate } 16857c478bd9Sstevel@tonic-gate 16867c478bd9Sstevel@tonic-gate dt_node_t * 16877c478bd9Sstevel@tonic-gate dt_node_func(dt_node_t *dnp, dt_node_t *args) 16887c478bd9Sstevel@tonic-gate { 16897c478bd9Sstevel@tonic-gate dt_ident_t *idp; 16907c478bd9Sstevel@tonic-gate 16917c478bd9Sstevel@tonic-gate if (dnp->dn_kind != DT_NODE_IDENT) { 16927c478bd9Sstevel@tonic-gate xyerror(D_FUNC_IDENT, 16937c478bd9Sstevel@tonic-gate "function designator is not of function type\n"); 16947c478bd9Sstevel@tonic-gate } 16957c478bd9Sstevel@tonic-gate 16967c478bd9Sstevel@tonic-gate idp = dt_idstack_lookup(&yypcb->pcb_globals, dnp->dn_string); 16977c478bd9Sstevel@tonic-gate 16987c478bd9Sstevel@tonic-gate if (idp == NULL) { 16997c478bd9Sstevel@tonic-gate xyerror(D_FUNC_UNDEF, 17007c478bd9Sstevel@tonic-gate "undefined function name: %s\n", dnp->dn_string); 17017c478bd9Sstevel@tonic-gate } 17027c478bd9Sstevel@tonic-gate 17037c478bd9Sstevel@tonic-gate if (idp->di_kind != DT_IDENT_FUNC && 17047c478bd9Sstevel@tonic-gate idp->di_kind != DT_IDENT_AGGFUNC && 17057c478bd9Sstevel@tonic-gate idp->di_kind != DT_IDENT_ACTFUNC) { 17067c478bd9Sstevel@tonic-gate xyerror(D_FUNC_IDKIND, "%s '%s' may not be referenced as a " 17077c478bd9Sstevel@tonic-gate "function\n", dt_idkind_name(idp->di_kind), idp->di_name); 17087c478bd9Sstevel@tonic-gate } 17097c478bd9Sstevel@tonic-gate 17107c478bd9Sstevel@tonic-gate free(dnp->dn_string); 17117c478bd9Sstevel@tonic-gate dnp->dn_string = NULL; 17127c478bd9Sstevel@tonic-gate 17137c478bd9Sstevel@tonic-gate dnp->dn_kind = DT_NODE_FUNC; 17147c478bd9Sstevel@tonic-gate dnp->dn_flags &= ~DT_NF_COOKED; 17157c478bd9Sstevel@tonic-gate dnp->dn_ident = idp; 17167c478bd9Sstevel@tonic-gate dnp->dn_args = args; 17177c478bd9Sstevel@tonic-gate dnp->dn_list = NULL; 17187c478bd9Sstevel@tonic-gate 17197c478bd9Sstevel@tonic-gate return (dnp); 17207c478bd9Sstevel@tonic-gate } 17217c478bd9Sstevel@tonic-gate 17227c478bd9Sstevel@tonic-gate /* 17237c478bd9Sstevel@tonic-gate * The offsetof() function is special because it takes a type name as an 17247c478bd9Sstevel@tonic-gate * argument. It does not actually construct its own node; after looking up the 17257c478bd9Sstevel@tonic-gate * structure or union offset, we just return an integer node with the offset. 17267c478bd9Sstevel@tonic-gate */ 17277c478bd9Sstevel@tonic-gate dt_node_t * 17287c478bd9Sstevel@tonic-gate dt_node_offsetof(dt_decl_t *ddp, char *s) 17297c478bd9Sstevel@tonic-gate { 17307c478bd9Sstevel@tonic-gate dtrace_typeinfo_t dtt; 17317c478bd9Sstevel@tonic-gate dt_node_t dn; 17327c478bd9Sstevel@tonic-gate char *name; 17337c478bd9Sstevel@tonic-gate int err; 17347c478bd9Sstevel@tonic-gate 17357c478bd9Sstevel@tonic-gate ctf_membinfo_t ctm; 17367c478bd9Sstevel@tonic-gate ctf_id_t type; 17377c478bd9Sstevel@tonic-gate uint_t kind; 17387c478bd9Sstevel@tonic-gate 17397c478bd9Sstevel@tonic-gate name = alloca(strlen(s) + 1); 17407c478bd9Sstevel@tonic-gate (void) strcpy(name, s); 17417c478bd9Sstevel@tonic-gate free(s); 17427c478bd9Sstevel@tonic-gate 17437c478bd9Sstevel@tonic-gate err = dt_decl_type(ddp, &dtt); 17447c478bd9Sstevel@tonic-gate dt_decl_free(ddp); 17457c478bd9Sstevel@tonic-gate 17467c478bd9Sstevel@tonic-gate if (err != 0) 17477c478bd9Sstevel@tonic-gate longjmp(yypcb->pcb_jmpbuf, EDT_COMPILER); 17487c478bd9Sstevel@tonic-gate 17497c478bd9Sstevel@tonic-gate type = ctf_type_resolve(dtt.dtt_ctfp, dtt.dtt_type); 17507c478bd9Sstevel@tonic-gate kind = ctf_type_kind(dtt.dtt_ctfp, type); 17517c478bd9Sstevel@tonic-gate 17527c478bd9Sstevel@tonic-gate if (kind != CTF_K_STRUCT && kind != CTF_K_UNION) { 17537c478bd9Sstevel@tonic-gate xyerror(D_OFFSETOF_TYPE, 17547c478bd9Sstevel@tonic-gate "offsetof operand must be a struct or union type\n"); 17557c478bd9Sstevel@tonic-gate } 17567c478bd9Sstevel@tonic-gate 17577c478bd9Sstevel@tonic-gate if (ctf_member_info(dtt.dtt_ctfp, type, name, &ctm) == CTF_ERR) { 17587c478bd9Sstevel@tonic-gate xyerror(D_UNKNOWN, "failed to determine offset of %s: %s\n", 17597c478bd9Sstevel@tonic-gate name, ctf_errmsg(ctf_errno(dtt.dtt_ctfp))); 17607c478bd9Sstevel@tonic-gate } 17617c478bd9Sstevel@tonic-gate 17627c478bd9Sstevel@tonic-gate bzero(&dn, sizeof (dn)); 17637c478bd9Sstevel@tonic-gate dt_node_type_assign(&dn, dtt.dtt_ctfp, ctm.ctm_type); 17647c478bd9Sstevel@tonic-gate 17657c478bd9Sstevel@tonic-gate if (dn.dn_flags & DT_NF_BITFIELD) { 17667c478bd9Sstevel@tonic-gate xyerror(D_OFFSETOF_BITFIELD, 17677c478bd9Sstevel@tonic-gate "cannot take offset of a bit-field: %s\n", name); 17687c478bd9Sstevel@tonic-gate } 17697c478bd9Sstevel@tonic-gate 17707c478bd9Sstevel@tonic-gate return (dt_node_int(ctm.ctm_offset / NBBY)); 17717c478bd9Sstevel@tonic-gate } 17727c478bd9Sstevel@tonic-gate 17737c478bd9Sstevel@tonic-gate dt_node_t * 17747c478bd9Sstevel@tonic-gate dt_node_op1(int op, dt_node_t *cp) 17757c478bd9Sstevel@tonic-gate { 17767c478bd9Sstevel@tonic-gate dt_node_t *dnp; 17777c478bd9Sstevel@tonic-gate 17787c478bd9Sstevel@tonic-gate if (cp->dn_kind == DT_NODE_INT) { 17797c478bd9Sstevel@tonic-gate switch (op) { 17807c478bd9Sstevel@tonic-gate case DT_TOK_INEG: 17817c478bd9Sstevel@tonic-gate /* 17827c478bd9Sstevel@tonic-gate * If we're negating an unsigned integer, zero out any 17837c478bd9Sstevel@tonic-gate * extra top bits to truncate the value to the size of 17847c478bd9Sstevel@tonic-gate * the effective type determined by dt_node_int(). 17857c478bd9Sstevel@tonic-gate */ 17867c478bd9Sstevel@tonic-gate cp->dn_value = -cp->dn_value; 17877c478bd9Sstevel@tonic-gate if (!(cp->dn_flags & DT_NF_SIGNED)) { 17887c478bd9Sstevel@tonic-gate cp->dn_value &= ~0ULL >> 17897c478bd9Sstevel@tonic-gate (64 - dt_node_type_size(cp) * NBBY); 17907c478bd9Sstevel@tonic-gate } 17917c478bd9Sstevel@tonic-gate /*FALLTHRU*/ 17927c478bd9Sstevel@tonic-gate case DT_TOK_IPOS: 17937c478bd9Sstevel@tonic-gate return (cp); 17947c478bd9Sstevel@tonic-gate case DT_TOK_BNEG: 17957c478bd9Sstevel@tonic-gate cp->dn_value = ~cp->dn_value; 17967c478bd9Sstevel@tonic-gate return (cp); 17977c478bd9Sstevel@tonic-gate case DT_TOK_LNEG: 17987c478bd9Sstevel@tonic-gate cp->dn_value = !cp->dn_value; 17997c478bd9Sstevel@tonic-gate return (cp); 18007c478bd9Sstevel@tonic-gate } 18017c478bd9Sstevel@tonic-gate } 18027c478bd9Sstevel@tonic-gate 18037c478bd9Sstevel@tonic-gate /* 18047c478bd9Sstevel@tonic-gate * If sizeof is applied to a type_name or string constant, we can 18057c478bd9Sstevel@tonic-gate * transform 'cp' into an integer constant in the node construction 18067c478bd9Sstevel@tonic-gate * pass so that it can then be used for arithmetic in this pass. 18077c478bd9Sstevel@tonic-gate */ 18087c478bd9Sstevel@tonic-gate if (op == DT_TOK_SIZEOF && 18097c478bd9Sstevel@tonic-gate (cp->dn_kind == DT_NODE_STRING || cp->dn_kind == DT_NODE_TYPE)) { 18107c478bd9Sstevel@tonic-gate dtrace_hdl_t *dtp = yypcb->pcb_hdl; 18117c478bd9Sstevel@tonic-gate size_t size = dt_node_type_size(cp); 18127c478bd9Sstevel@tonic-gate 18137c478bd9Sstevel@tonic-gate if (size == 0) { 18147c478bd9Sstevel@tonic-gate xyerror(D_SIZEOF_TYPE, "cannot apply sizeof to an " 18157c478bd9Sstevel@tonic-gate "operand of unknown size\n"); 18167c478bd9Sstevel@tonic-gate } 18177c478bd9Sstevel@tonic-gate 18187c478bd9Sstevel@tonic-gate dt_node_type_assign(cp, dtp->dt_ddefs->dm_ctfp, 18197c478bd9Sstevel@tonic-gate ctf_lookup_by_name(dtp->dt_ddefs->dm_ctfp, "size_t")); 18207c478bd9Sstevel@tonic-gate 18217c478bd9Sstevel@tonic-gate cp->dn_kind = DT_NODE_INT; 18227c478bd9Sstevel@tonic-gate cp->dn_op = DT_TOK_INT; 18237c478bd9Sstevel@tonic-gate cp->dn_value = size; 18247c478bd9Sstevel@tonic-gate 18257c478bd9Sstevel@tonic-gate return (cp); 18267c478bd9Sstevel@tonic-gate } 18277c478bd9Sstevel@tonic-gate 18287c478bd9Sstevel@tonic-gate dnp = dt_node_alloc(DT_NODE_OP1); 18297c478bd9Sstevel@tonic-gate assert(op <= USHRT_MAX); 18307c478bd9Sstevel@tonic-gate dnp->dn_op = (ushort_t)op; 18317c478bd9Sstevel@tonic-gate dnp->dn_child = cp; 18327c478bd9Sstevel@tonic-gate 18337c478bd9Sstevel@tonic-gate return (dnp); 18347c478bd9Sstevel@tonic-gate } 18357c478bd9Sstevel@tonic-gate 18367c478bd9Sstevel@tonic-gate dt_node_t * 18377c478bd9Sstevel@tonic-gate dt_node_op2(int op, dt_node_t *lp, dt_node_t *rp) 18387c478bd9Sstevel@tonic-gate { 18397c478bd9Sstevel@tonic-gate dtrace_hdl_t *dtp = yypcb->pcb_hdl; 18407c478bd9Sstevel@tonic-gate dt_node_t *dnp; 18417c478bd9Sstevel@tonic-gate 18427c478bd9Sstevel@tonic-gate /* 18437c478bd9Sstevel@tonic-gate * First we check for operations that are illegal -- namely those that 18447c478bd9Sstevel@tonic-gate * might result in integer division by zero, and abort if one is found. 18457c478bd9Sstevel@tonic-gate */ 18467c478bd9Sstevel@tonic-gate if (rp->dn_kind == DT_NODE_INT && rp->dn_value == 0 && 18477c478bd9Sstevel@tonic-gate (op == DT_TOK_MOD || op == DT_TOK_DIV || 18487c478bd9Sstevel@tonic-gate op == DT_TOK_MOD_EQ || op == DT_TOK_DIV_EQ)) 18497c478bd9Sstevel@tonic-gate xyerror(D_DIV_ZERO, "expression contains division by zero\n"); 18507c478bd9Sstevel@tonic-gate 18517c478bd9Sstevel@tonic-gate /* 18527c478bd9Sstevel@tonic-gate * If both children are immediate values, we can just perform inline 18537c478bd9Sstevel@tonic-gate * calculation and return a new immediate node with the result. 18547c478bd9Sstevel@tonic-gate */ 18557c478bd9Sstevel@tonic-gate if (lp->dn_kind == DT_NODE_INT && rp->dn_kind == DT_NODE_INT) { 18567c478bd9Sstevel@tonic-gate uintmax_t l = lp->dn_value; 18577c478bd9Sstevel@tonic-gate uintmax_t r = rp->dn_value; 18587c478bd9Sstevel@tonic-gate 18597c478bd9Sstevel@tonic-gate dnp = dt_node_int(0); /* allocate new integer node for result */ 18607c478bd9Sstevel@tonic-gate 18617c478bd9Sstevel@tonic-gate switch (op) { 18627c478bd9Sstevel@tonic-gate case DT_TOK_LOR: 18637c478bd9Sstevel@tonic-gate dnp->dn_value = l || r; 18647c478bd9Sstevel@tonic-gate dt_node_type_assign(dnp, 18657c478bd9Sstevel@tonic-gate DT_INT_CTFP(dtp), DT_INT_TYPE(dtp)); 18667c478bd9Sstevel@tonic-gate break; 18677c478bd9Sstevel@tonic-gate case DT_TOK_LXOR: 18687c478bd9Sstevel@tonic-gate dnp->dn_value = (l != 0) ^ (r != 0); 18697c478bd9Sstevel@tonic-gate dt_node_type_assign(dnp, 18707c478bd9Sstevel@tonic-gate DT_INT_CTFP(dtp), DT_INT_TYPE(dtp)); 18717c478bd9Sstevel@tonic-gate break; 18727c478bd9Sstevel@tonic-gate case DT_TOK_LAND: 18737c478bd9Sstevel@tonic-gate dnp->dn_value = l && r; 18747c478bd9Sstevel@tonic-gate dt_node_type_assign(dnp, 18757c478bd9Sstevel@tonic-gate DT_INT_CTFP(dtp), DT_INT_TYPE(dtp)); 18767c478bd9Sstevel@tonic-gate break; 18777c478bd9Sstevel@tonic-gate case DT_TOK_BOR: 18787c478bd9Sstevel@tonic-gate dnp->dn_value = l | r; 18797c478bd9Sstevel@tonic-gate dt_node_promote(lp, rp, dnp); 18807c478bd9Sstevel@tonic-gate break; 18817c478bd9Sstevel@tonic-gate case DT_TOK_XOR: 18827c478bd9Sstevel@tonic-gate dnp->dn_value = l ^ r; 18837c478bd9Sstevel@tonic-gate dt_node_promote(lp, rp, dnp); 18847c478bd9Sstevel@tonic-gate break; 18857c478bd9Sstevel@tonic-gate case DT_TOK_BAND: 18867c478bd9Sstevel@tonic-gate dnp->dn_value = l & r; 18877c478bd9Sstevel@tonic-gate dt_node_promote(lp, rp, dnp); 18887c478bd9Sstevel@tonic-gate break; 18897c478bd9Sstevel@tonic-gate case DT_TOK_EQU: 18907c478bd9Sstevel@tonic-gate dnp->dn_value = l == r; 18917c478bd9Sstevel@tonic-gate dt_node_type_assign(dnp, 18927c478bd9Sstevel@tonic-gate DT_INT_CTFP(dtp), DT_INT_TYPE(dtp)); 18937c478bd9Sstevel@tonic-gate break; 18947c478bd9Sstevel@tonic-gate case DT_TOK_NEQ: 18957c478bd9Sstevel@tonic-gate dnp->dn_value = l != r; 18967c478bd9Sstevel@tonic-gate dt_node_type_assign(dnp, 18977c478bd9Sstevel@tonic-gate DT_INT_CTFP(dtp), DT_INT_TYPE(dtp)); 18987c478bd9Sstevel@tonic-gate break; 18997c478bd9Sstevel@tonic-gate case DT_TOK_LT: 19007c478bd9Sstevel@tonic-gate dt_node_promote(lp, rp, dnp); 19017c478bd9Sstevel@tonic-gate if (dnp->dn_flags & DT_NF_SIGNED) 19027c478bd9Sstevel@tonic-gate dnp->dn_value = (intmax_t)l < (intmax_t)r; 19037c478bd9Sstevel@tonic-gate else 19047c478bd9Sstevel@tonic-gate dnp->dn_value = l < r; 19057c478bd9Sstevel@tonic-gate dt_node_type_assign(dnp, 19067c478bd9Sstevel@tonic-gate DT_INT_CTFP(dtp), DT_INT_TYPE(dtp)); 19077c478bd9Sstevel@tonic-gate break; 19087c478bd9Sstevel@tonic-gate case DT_TOK_LE: 19097c478bd9Sstevel@tonic-gate dt_node_promote(lp, rp, dnp); 19107c478bd9Sstevel@tonic-gate if (dnp->dn_flags & DT_NF_SIGNED) 19117c478bd9Sstevel@tonic-gate dnp->dn_value = (intmax_t)l <= (intmax_t)r; 19127c478bd9Sstevel@tonic-gate else 19137c478bd9Sstevel@tonic-gate dnp->dn_value = l <= r; 19147c478bd9Sstevel@tonic-gate dt_node_type_assign(dnp, 19157c478bd9Sstevel@tonic-gate DT_INT_CTFP(dtp), DT_INT_TYPE(dtp)); 19167c478bd9Sstevel@tonic-gate break; 19177c478bd9Sstevel@tonic-gate case DT_TOK_GT: 19187c478bd9Sstevel@tonic-gate dt_node_promote(lp, rp, dnp); 19197c478bd9Sstevel@tonic-gate if (dnp->dn_flags & DT_NF_SIGNED) 19207c478bd9Sstevel@tonic-gate dnp->dn_value = (intmax_t)l > (intmax_t)r; 19217c478bd9Sstevel@tonic-gate else 19227c478bd9Sstevel@tonic-gate dnp->dn_value = l > r; 19237c478bd9Sstevel@tonic-gate dt_node_type_assign(dnp, 19247c478bd9Sstevel@tonic-gate DT_INT_CTFP(dtp), DT_INT_TYPE(dtp)); 19257c478bd9Sstevel@tonic-gate break; 19267c478bd9Sstevel@tonic-gate case DT_TOK_GE: 19277c478bd9Sstevel@tonic-gate dt_node_promote(lp, rp, dnp); 19287c478bd9Sstevel@tonic-gate if (dnp->dn_flags & DT_NF_SIGNED) 19297c478bd9Sstevel@tonic-gate dnp->dn_value = (intmax_t)l >= (intmax_t)r; 19307c478bd9Sstevel@tonic-gate else 19317c478bd9Sstevel@tonic-gate dnp->dn_value = l >= r; 19327c478bd9Sstevel@tonic-gate dt_node_type_assign(dnp, 19337c478bd9Sstevel@tonic-gate DT_INT_CTFP(dtp), DT_INT_TYPE(dtp)); 19347c478bd9Sstevel@tonic-gate break; 19357c478bd9Sstevel@tonic-gate case DT_TOK_LSH: 19367c478bd9Sstevel@tonic-gate dnp->dn_value = l << r; 19377c478bd9Sstevel@tonic-gate dt_node_type_propagate(lp, dnp); 19387c478bd9Sstevel@tonic-gate dt_node_attr_assign(rp, 19397c478bd9Sstevel@tonic-gate dt_attr_min(lp->dn_attr, rp->dn_attr)); 19407c478bd9Sstevel@tonic-gate break; 19417c478bd9Sstevel@tonic-gate case DT_TOK_RSH: 19427c478bd9Sstevel@tonic-gate dnp->dn_value = l >> r; 19437c478bd9Sstevel@tonic-gate dt_node_type_propagate(lp, dnp); 19447c478bd9Sstevel@tonic-gate dt_node_attr_assign(rp, 19457c478bd9Sstevel@tonic-gate dt_attr_min(lp->dn_attr, rp->dn_attr)); 19467c478bd9Sstevel@tonic-gate break; 19477c478bd9Sstevel@tonic-gate case DT_TOK_ADD: 19487c478bd9Sstevel@tonic-gate dnp->dn_value = l + r; 19497c478bd9Sstevel@tonic-gate dt_node_promote(lp, rp, dnp); 19507c478bd9Sstevel@tonic-gate break; 19517c478bd9Sstevel@tonic-gate case DT_TOK_SUB: 19527c478bd9Sstevel@tonic-gate dnp->dn_value = l - r; 19537c478bd9Sstevel@tonic-gate dt_node_promote(lp, rp, dnp); 19547c478bd9Sstevel@tonic-gate break; 19557c478bd9Sstevel@tonic-gate case DT_TOK_MUL: 19567c478bd9Sstevel@tonic-gate dnp->dn_value = l * r; 19577c478bd9Sstevel@tonic-gate dt_node_promote(lp, rp, dnp); 19587c478bd9Sstevel@tonic-gate break; 19597c478bd9Sstevel@tonic-gate case DT_TOK_DIV: 19607c478bd9Sstevel@tonic-gate dt_node_promote(lp, rp, dnp); 19617c478bd9Sstevel@tonic-gate if (dnp->dn_flags & DT_NF_SIGNED) 19627c478bd9Sstevel@tonic-gate dnp->dn_value = (intmax_t)l / (intmax_t)r; 19637c478bd9Sstevel@tonic-gate else 19647c478bd9Sstevel@tonic-gate dnp->dn_value = l / r; 19657c478bd9Sstevel@tonic-gate break; 19667c478bd9Sstevel@tonic-gate case DT_TOK_MOD: 19677c478bd9Sstevel@tonic-gate dt_node_promote(lp, rp, dnp); 19687c478bd9Sstevel@tonic-gate if (dnp->dn_flags & DT_NF_SIGNED) 19697c478bd9Sstevel@tonic-gate dnp->dn_value = (intmax_t)l % (intmax_t)r; 19707c478bd9Sstevel@tonic-gate else 19717c478bd9Sstevel@tonic-gate dnp->dn_value = l % r; 19727c478bd9Sstevel@tonic-gate break; 19737c478bd9Sstevel@tonic-gate default: 19747c478bd9Sstevel@tonic-gate dt_node_free(dnp); 19757c478bd9Sstevel@tonic-gate dnp = NULL; 19767c478bd9Sstevel@tonic-gate } 19777c478bd9Sstevel@tonic-gate 19787c478bd9Sstevel@tonic-gate if (dnp != NULL) { 19797c478bd9Sstevel@tonic-gate dt_node_free(lp); 19807c478bd9Sstevel@tonic-gate dt_node_free(rp); 19817c478bd9Sstevel@tonic-gate return (dnp); 19827c478bd9Sstevel@tonic-gate } 19837c478bd9Sstevel@tonic-gate } 19847c478bd9Sstevel@tonic-gate 19857c478bd9Sstevel@tonic-gate /* 19867c478bd9Sstevel@tonic-gate * If an integer constant is being cast to another integer type, we can 19877c478bd9Sstevel@tonic-gate * perform the cast as part of integer constant folding in this pass. 19887c478bd9Sstevel@tonic-gate * We must take action when the integer is being cast to a smaller type 19897c478bd9Sstevel@tonic-gate * or if it is changing signed-ness. If so, we first shift rp's bits 19907c478bd9Sstevel@tonic-gate * bits high (losing excess bits if narrowing) and then shift them down 19917c478bd9Sstevel@tonic-gate * with either a logical shift (unsigned) or arithmetic shift (signed). 19927c478bd9Sstevel@tonic-gate */ 19937c478bd9Sstevel@tonic-gate if (op == DT_TOK_LPAR && rp->dn_kind == DT_NODE_INT && 19947c478bd9Sstevel@tonic-gate dt_node_is_integer(lp)) { 19957c478bd9Sstevel@tonic-gate size_t srcsize = dt_node_type_size(rp); 19967c478bd9Sstevel@tonic-gate size_t dstsize = dt_node_type_size(lp); 19977c478bd9Sstevel@tonic-gate 19987c478bd9Sstevel@tonic-gate if ((dstsize < srcsize) || ((lp->dn_flags & DT_NF_SIGNED) ^ 19997c478bd9Sstevel@tonic-gate (rp->dn_flags & DT_NF_SIGNED))) { 20007c478bd9Sstevel@tonic-gate int n = dstsize < srcsize ? 20017c478bd9Sstevel@tonic-gate (sizeof (uint64_t) * NBBY - dstsize * NBBY) : 20027c478bd9Sstevel@tonic-gate (sizeof (uint64_t) * NBBY - srcsize * NBBY); 20037c478bd9Sstevel@tonic-gate 20047c478bd9Sstevel@tonic-gate rp->dn_value <<= n; 20057c478bd9Sstevel@tonic-gate if (lp->dn_flags & DT_NF_SIGNED) 20067c478bd9Sstevel@tonic-gate rp->dn_value = (intmax_t)rp->dn_value >> n; 20077c478bd9Sstevel@tonic-gate else 20087c478bd9Sstevel@tonic-gate rp->dn_value = rp->dn_value >> n; 20097c478bd9Sstevel@tonic-gate } 20107c478bd9Sstevel@tonic-gate 20117c478bd9Sstevel@tonic-gate dt_node_type_propagate(lp, rp); 20127c478bd9Sstevel@tonic-gate dt_node_attr_assign(rp, dt_attr_min(lp->dn_attr, rp->dn_attr)); 20137c478bd9Sstevel@tonic-gate dt_node_free(lp); 20147c478bd9Sstevel@tonic-gate 20157c478bd9Sstevel@tonic-gate return (rp); 20167c478bd9Sstevel@tonic-gate } 20177c478bd9Sstevel@tonic-gate 20187c478bd9Sstevel@tonic-gate /* 20197c478bd9Sstevel@tonic-gate * If no immediate optimizations are available, create an new OP2 node 20207c478bd9Sstevel@tonic-gate * and glue the left and right children into place and return. 20217c478bd9Sstevel@tonic-gate */ 20227c478bd9Sstevel@tonic-gate dnp = dt_node_alloc(DT_NODE_OP2); 20237c478bd9Sstevel@tonic-gate assert(op <= USHRT_MAX); 20247c478bd9Sstevel@tonic-gate dnp->dn_op = (ushort_t)op; 20257c478bd9Sstevel@tonic-gate dnp->dn_left = lp; 20267c478bd9Sstevel@tonic-gate dnp->dn_right = rp; 20277c478bd9Sstevel@tonic-gate 20287c478bd9Sstevel@tonic-gate return (dnp); 20297c478bd9Sstevel@tonic-gate } 20307c478bd9Sstevel@tonic-gate 20317c478bd9Sstevel@tonic-gate dt_node_t * 20327c478bd9Sstevel@tonic-gate dt_node_op3(dt_node_t *expr, dt_node_t *lp, dt_node_t *rp) 20337c478bd9Sstevel@tonic-gate { 20347c478bd9Sstevel@tonic-gate dt_node_t *dnp; 20357c478bd9Sstevel@tonic-gate 20367c478bd9Sstevel@tonic-gate if (expr->dn_kind == DT_NODE_INT) 20377c478bd9Sstevel@tonic-gate return (expr->dn_value != 0 ? lp : rp); 20387c478bd9Sstevel@tonic-gate 20397c478bd9Sstevel@tonic-gate dnp = dt_node_alloc(DT_NODE_OP3); 20407c478bd9Sstevel@tonic-gate dnp->dn_op = DT_TOK_QUESTION; 20417c478bd9Sstevel@tonic-gate dnp->dn_expr = expr; 20427c478bd9Sstevel@tonic-gate dnp->dn_left = lp; 20437c478bd9Sstevel@tonic-gate dnp->dn_right = rp; 20447c478bd9Sstevel@tonic-gate 20457c478bd9Sstevel@tonic-gate return (dnp); 20467c478bd9Sstevel@tonic-gate } 20477c478bd9Sstevel@tonic-gate 20487c478bd9Sstevel@tonic-gate dt_node_t * 20497c478bd9Sstevel@tonic-gate dt_node_statement(dt_node_t *expr) 20507c478bd9Sstevel@tonic-gate { 20517c478bd9Sstevel@tonic-gate dt_node_t *dnp; 20527c478bd9Sstevel@tonic-gate 20537c478bd9Sstevel@tonic-gate if (expr->dn_kind == DT_NODE_AGG) 20547c478bd9Sstevel@tonic-gate return (expr); 20557c478bd9Sstevel@tonic-gate 20567c478bd9Sstevel@tonic-gate if (expr->dn_kind == DT_NODE_FUNC && 20577c478bd9Sstevel@tonic-gate expr->dn_ident->di_kind == DT_IDENT_ACTFUNC) 20587c478bd9Sstevel@tonic-gate dnp = dt_node_alloc(DT_NODE_DFUNC); 20597c478bd9Sstevel@tonic-gate else 20607c478bd9Sstevel@tonic-gate dnp = dt_node_alloc(DT_NODE_DEXPR); 20617c478bd9Sstevel@tonic-gate 20627c478bd9Sstevel@tonic-gate dnp->dn_expr = expr; 20637c478bd9Sstevel@tonic-gate return (dnp); 20647c478bd9Sstevel@tonic-gate } 20657c478bd9Sstevel@tonic-gate 20667c478bd9Sstevel@tonic-gate dt_node_t * 20677c478bd9Sstevel@tonic-gate dt_node_pdesc_by_name(char *spec) 20687c478bd9Sstevel@tonic-gate { 20697c478bd9Sstevel@tonic-gate dtrace_hdl_t *dtp = yypcb->pcb_hdl; 20707c478bd9Sstevel@tonic-gate dt_node_t *dnp; 20717c478bd9Sstevel@tonic-gate 20727c478bd9Sstevel@tonic-gate if (spec == NULL) 20737c478bd9Sstevel@tonic-gate longjmp(yypcb->pcb_jmpbuf, EDT_NOMEM); 20747c478bd9Sstevel@tonic-gate 20757c478bd9Sstevel@tonic-gate dnp = dt_node_alloc(DT_NODE_PDESC); 20767c478bd9Sstevel@tonic-gate dnp->dn_spec = spec; 20777c478bd9Sstevel@tonic-gate dnp->dn_desc = malloc(sizeof (dtrace_probedesc_t)); 20787c478bd9Sstevel@tonic-gate 20797c478bd9Sstevel@tonic-gate if (dnp->dn_desc == NULL) 20807c478bd9Sstevel@tonic-gate longjmp(yypcb->pcb_jmpbuf, EDT_NOMEM); 20817c478bd9Sstevel@tonic-gate 20827c478bd9Sstevel@tonic-gate if (dtrace_xstr2desc(dtp, yypcb->pcb_pspec, dnp->dn_spec, 20837c478bd9Sstevel@tonic-gate yypcb->pcb_sargc, yypcb->pcb_sargv, dnp->dn_desc) != 0) { 20847c478bd9Sstevel@tonic-gate xyerror(D_PDESC_INVAL, "invalid probe description \"%s\": %s\n", 20857c478bd9Sstevel@tonic-gate dnp->dn_spec, dtrace_errmsg(dtp, dtrace_errno(dtp))); 20867c478bd9Sstevel@tonic-gate } 20877c478bd9Sstevel@tonic-gate 20887c478bd9Sstevel@tonic-gate free(dnp->dn_spec); 20897c478bd9Sstevel@tonic-gate dnp->dn_spec = NULL; 20907c478bd9Sstevel@tonic-gate 20917c478bd9Sstevel@tonic-gate return (dnp); 20927c478bd9Sstevel@tonic-gate } 20937c478bd9Sstevel@tonic-gate 20947c478bd9Sstevel@tonic-gate dt_node_t * 20957c478bd9Sstevel@tonic-gate dt_node_pdesc_by_id(uintmax_t id) 20967c478bd9Sstevel@tonic-gate { 20977c478bd9Sstevel@tonic-gate static const char *const names[] = { 20987c478bd9Sstevel@tonic-gate "providers", "modules", "functions" 20997c478bd9Sstevel@tonic-gate }; 21007c478bd9Sstevel@tonic-gate 21017c478bd9Sstevel@tonic-gate dtrace_hdl_t *dtp = yypcb->pcb_hdl; 21027c478bd9Sstevel@tonic-gate dt_node_t *dnp = dt_node_alloc(DT_NODE_PDESC); 21037c478bd9Sstevel@tonic-gate 21047c478bd9Sstevel@tonic-gate if ((dnp->dn_desc = malloc(sizeof (dtrace_probedesc_t))) == NULL) 21057c478bd9Sstevel@tonic-gate longjmp(yypcb->pcb_jmpbuf, EDT_NOMEM); 21067c478bd9Sstevel@tonic-gate 21077c478bd9Sstevel@tonic-gate if (id > UINT_MAX) { 21087c478bd9Sstevel@tonic-gate xyerror(D_PDESC_INVAL, "identifier %llu exceeds maximum " 21097c478bd9Sstevel@tonic-gate "probe id\n", (u_longlong_t)id); 21107c478bd9Sstevel@tonic-gate } 21117c478bd9Sstevel@tonic-gate 21127c478bd9Sstevel@tonic-gate if (yypcb->pcb_pspec != DTRACE_PROBESPEC_NAME) { 21137c478bd9Sstevel@tonic-gate xyerror(D_PDESC_INVAL, "probe identifier %llu not permitted " 21147c478bd9Sstevel@tonic-gate "when specifying %s\n", (u_longlong_t)id, 21157c478bd9Sstevel@tonic-gate names[yypcb->pcb_pspec]); 21167c478bd9Sstevel@tonic-gate } 21177c478bd9Sstevel@tonic-gate 21187c478bd9Sstevel@tonic-gate if (dtrace_id2desc(dtp, (dtrace_id_t)id, dnp->dn_desc) != 0) { 21197c478bd9Sstevel@tonic-gate xyerror(D_PDESC_INVAL, "invalid probe identifier %llu: %s\n", 21207c478bd9Sstevel@tonic-gate (u_longlong_t)id, dtrace_errmsg(dtp, dtrace_errno(dtp))); 21217c478bd9Sstevel@tonic-gate } 21227c478bd9Sstevel@tonic-gate 21237c478bd9Sstevel@tonic-gate return (dnp); 21247c478bd9Sstevel@tonic-gate } 21257c478bd9Sstevel@tonic-gate 21267c478bd9Sstevel@tonic-gate dt_node_t * 21277c478bd9Sstevel@tonic-gate dt_node_clause(dt_node_t *pdescs, dt_node_t *pred, dt_node_t *acts) 21287c478bd9Sstevel@tonic-gate { 21297c478bd9Sstevel@tonic-gate dt_node_t *dnp = dt_node_alloc(DT_NODE_CLAUSE); 21307c478bd9Sstevel@tonic-gate 21317c478bd9Sstevel@tonic-gate dnp->dn_pdescs = pdescs; 21327c478bd9Sstevel@tonic-gate dnp->dn_pred = pred; 21337c478bd9Sstevel@tonic-gate dnp->dn_acts = acts; 21347c478bd9Sstevel@tonic-gate 21357c478bd9Sstevel@tonic-gate yybegin(YYS_CLAUSE); 21367c478bd9Sstevel@tonic-gate return (dnp); 21377c478bd9Sstevel@tonic-gate } 21387c478bd9Sstevel@tonic-gate 21397c478bd9Sstevel@tonic-gate dt_node_t * 21407c478bd9Sstevel@tonic-gate dt_node_inline(dt_node_t *expr) 21417c478bd9Sstevel@tonic-gate { 21427c478bd9Sstevel@tonic-gate dtrace_hdl_t *dtp = yypcb->pcb_hdl; 21437c478bd9Sstevel@tonic-gate dt_scope_t *dsp = &yypcb->pcb_dstack; 21447c478bd9Sstevel@tonic-gate dt_decl_t *ddp = dt_decl_top(); 21457c478bd9Sstevel@tonic-gate 21467c478bd9Sstevel@tonic-gate char n[DT_TYPE_NAMELEN]; 21477c478bd9Sstevel@tonic-gate dtrace_typeinfo_t dtt; 21487c478bd9Sstevel@tonic-gate 21497c478bd9Sstevel@tonic-gate dt_ident_t *idp, *rdp; 21507c478bd9Sstevel@tonic-gate dt_idnode_t *inp; 21517c478bd9Sstevel@tonic-gate dt_node_t *dnp; 21527c478bd9Sstevel@tonic-gate 21537c478bd9Sstevel@tonic-gate if (dt_decl_type(ddp, &dtt) != 0) 21547c478bd9Sstevel@tonic-gate longjmp(yypcb->pcb_jmpbuf, EDT_COMPILER); 21557c478bd9Sstevel@tonic-gate 21567c478bd9Sstevel@tonic-gate if (dsp->ds_class != DT_DC_DEFAULT) { 21577c478bd9Sstevel@tonic-gate xyerror(D_DECL_BADCLASS, "specified storage class not " 21587c478bd9Sstevel@tonic-gate "appropriate for inline declaration\n"); 21597c478bd9Sstevel@tonic-gate } 21607c478bd9Sstevel@tonic-gate 21617c478bd9Sstevel@tonic-gate if (dsp->ds_ident == NULL) 21627c478bd9Sstevel@tonic-gate xyerror(D_DECL_USELESS, "inline declaration requires a name\n"); 21637c478bd9Sstevel@tonic-gate 21647c478bd9Sstevel@tonic-gate if ((idp = dt_idstack_lookup( 21657c478bd9Sstevel@tonic-gate &yypcb->pcb_globals, dsp->ds_ident)) != NULL) { 21667c478bd9Sstevel@tonic-gate xyerror(D_DECL_IDRED, "identifier redefined: %s\n\t current: " 21677c478bd9Sstevel@tonic-gate "inline definition\n\tprevious: %s %s\n", 21687c478bd9Sstevel@tonic-gate idp->di_name, dt_idkind_name(idp->di_kind), 21697c478bd9Sstevel@tonic-gate (idp->di_flags & DT_IDFLG_INLINE) ? "inline" : ""); 21707c478bd9Sstevel@tonic-gate } 21717c478bd9Sstevel@tonic-gate 21727c478bd9Sstevel@tonic-gate /* 21737c478bd9Sstevel@tonic-gate * If we are declaring an inlined array, verify that we have a tuple 21747c478bd9Sstevel@tonic-gate * signature, and then recompute 'dtt' as the array's value type. 21757c478bd9Sstevel@tonic-gate */ 21767c478bd9Sstevel@tonic-gate if (ddp->dd_kind == CTF_K_ARRAY) { 21777c478bd9Sstevel@tonic-gate if (ddp->dd_node == NULL) { 21787c478bd9Sstevel@tonic-gate xyerror(D_DECL_ARRNULL, "inline declaration requires " 21797c478bd9Sstevel@tonic-gate "array tuple signature: %s\n", dsp->ds_ident); 21807c478bd9Sstevel@tonic-gate } 21817c478bd9Sstevel@tonic-gate 21827c478bd9Sstevel@tonic-gate if (ddp->dd_node->dn_kind != DT_NODE_TYPE) { 21837c478bd9Sstevel@tonic-gate xyerror(D_DECL_ARRNULL, "inline declaration cannot be " 21847c478bd9Sstevel@tonic-gate "of scalar array type: %s\n", dsp->ds_ident); 21857c478bd9Sstevel@tonic-gate } 21867c478bd9Sstevel@tonic-gate 21877c478bd9Sstevel@tonic-gate if (dt_decl_type(ddp->dd_next, &dtt) != 0) 21887c478bd9Sstevel@tonic-gate longjmp(yypcb->pcb_jmpbuf, EDT_COMPILER); 21897c478bd9Sstevel@tonic-gate } 21907c478bd9Sstevel@tonic-gate 21917c478bd9Sstevel@tonic-gate /* 21927c478bd9Sstevel@tonic-gate * If the inline identifier is not defined, then create it with the 21937c478bd9Sstevel@tonic-gate * orphan flag set. We do not insert the identifier into dt_globals 21947c478bd9Sstevel@tonic-gate * until we have successfully cooked the right-hand expression, below. 21957c478bd9Sstevel@tonic-gate */ 21967c478bd9Sstevel@tonic-gate dnp = dt_node_alloc(DT_NODE_INLINE); 21977c478bd9Sstevel@tonic-gate dt_node_type_assign(dnp, dtt.dtt_ctfp, dtt.dtt_type); 21987c478bd9Sstevel@tonic-gate dt_node_attr_assign(dnp, _dtrace_defattr); 21997c478bd9Sstevel@tonic-gate 22007c478bd9Sstevel@tonic-gate if (dt_node_is_void(dnp)) { 22017c478bd9Sstevel@tonic-gate xyerror(D_DECL_VOIDOBJ, 22027c478bd9Sstevel@tonic-gate "cannot declare void inline: %s\n", dsp->ds_ident); 22037c478bd9Sstevel@tonic-gate } 22047c478bd9Sstevel@tonic-gate 22057c478bd9Sstevel@tonic-gate if (ctf_type_kind(dnp->dn_ctfp, ctf_type_resolve( 22067c478bd9Sstevel@tonic-gate dnp->dn_ctfp, dnp->dn_type)) == CTF_K_FORWARD) { 22077c478bd9Sstevel@tonic-gate xyerror(D_DECL_INCOMPLETE, 22087c478bd9Sstevel@tonic-gate "incomplete struct/union/enum %s: %s\n", 22097c478bd9Sstevel@tonic-gate dt_node_type_name(dnp, n, sizeof (n)), dsp->ds_ident); 22107c478bd9Sstevel@tonic-gate } 22117c478bd9Sstevel@tonic-gate 22127c478bd9Sstevel@tonic-gate if ((inp = malloc(sizeof (dt_idnode_t))) == NULL) 22137c478bd9Sstevel@tonic-gate longjmp(yypcb->pcb_jmpbuf, EDT_NOMEM); 22147c478bd9Sstevel@tonic-gate 22157c478bd9Sstevel@tonic-gate bzero(inp, sizeof (dt_idnode_t)); 22167c478bd9Sstevel@tonic-gate 22177c478bd9Sstevel@tonic-gate idp = dnp->dn_ident = dt_ident_create(dsp->ds_ident, 22187c478bd9Sstevel@tonic-gate ddp->dd_kind == CTF_K_ARRAY ? DT_IDENT_ARRAY : DT_IDENT_SCALAR, 22197c478bd9Sstevel@tonic-gate DT_IDFLG_INLINE | DT_IDFLG_REF | DT_IDFLG_DECL | DT_IDFLG_ORPHAN, 0, 22207c478bd9Sstevel@tonic-gate _dtrace_defattr, 0, &dt_idops_inline, inp, dtp->dt_gen); 22217c478bd9Sstevel@tonic-gate 22227c478bd9Sstevel@tonic-gate if (idp == NULL) { 22237c478bd9Sstevel@tonic-gate free(inp); 22247c478bd9Sstevel@tonic-gate longjmp(yypcb->pcb_jmpbuf, EDT_NOMEM); 22257c478bd9Sstevel@tonic-gate } 22267c478bd9Sstevel@tonic-gate 22277c478bd9Sstevel@tonic-gate /* 22287c478bd9Sstevel@tonic-gate * If we're inlining an associative array, create a private identifier 22297c478bd9Sstevel@tonic-gate * hash containing the named parameters and store it in inp->din_hash. 22307c478bd9Sstevel@tonic-gate * We then push this hash on to the top of the pcb_globals stack. 22317c478bd9Sstevel@tonic-gate */ 22327c478bd9Sstevel@tonic-gate if (ddp->dd_kind == CTF_K_ARRAY) { 22337c478bd9Sstevel@tonic-gate dt_idnode_t *pinp; 22347c478bd9Sstevel@tonic-gate dt_ident_t *pidp; 22357c478bd9Sstevel@tonic-gate dt_node_t *pnp; 22367c478bd9Sstevel@tonic-gate uint_t i = 0; 22377c478bd9Sstevel@tonic-gate 22387c478bd9Sstevel@tonic-gate for (pnp = ddp->dd_node; pnp != NULL; pnp = pnp->dn_list) 22397c478bd9Sstevel@tonic-gate i++; /* count up parameters for din_argv[] */ 22407c478bd9Sstevel@tonic-gate 22417c478bd9Sstevel@tonic-gate inp->din_hash = dt_idhash_create("inline args", NULL, 0, 0); 22427c478bd9Sstevel@tonic-gate inp->din_argv = calloc(i, sizeof (dt_ident_t *)); 22437c478bd9Sstevel@tonic-gate 22447c478bd9Sstevel@tonic-gate if (inp->din_hash == NULL || inp->din_argv == NULL) 22457c478bd9Sstevel@tonic-gate longjmp(yypcb->pcb_jmpbuf, EDT_NOMEM); 22467c478bd9Sstevel@tonic-gate 22477c478bd9Sstevel@tonic-gate /* 22487c478bd9Sstevel@tonic-gate * Create an identifier for each parameter as a scalar inline, 22497c478bd9Sstevel@tonic-gate * and store it in din_hash and in position in din_argv[]. The 22507c478bd9Sstevel@tonic-gate * parameter identifiers also use dt_idops_inline, but we leave 22517c478bd9Sstevel@tonic-gate * the dt_idnode_t argument 'pinp' zeroed. This will be filled 22527c478bd9Sstevel@tonic-gate * in by the code generation pass with references to the args. 22537c478bd9Sstevel@tonic-gate */ 22547c478bd9Sstevel@tonic-gate for (i = 0, pnp = ddp->dd_node; 22557c478bd9Sstevel@tonic-gate pnp != NULL; pnp = pnp->dn_list, i++) { 22567c478bd9Sstevel@tonic-gate 22577c478bd9Sstevel@tonic-gate if (pnp->dn_string == NULL) 22587c478bd9Sstevel@tonic-gate continue; /* ignore anonymous parameters */ 22597c478bd9Sstevel@tonic-gate 22607c478bd9Sstevel@tonic-gate if ((pinp = malloc(sizeof (dt_idnode_t))) == NULL) 22617c478bd9Sstevel@tonic-gate longjmp(yypcb->pcb_jmpbuf, EDT_NOMEM); 22627c478bd9Sstevel@tonic-gate 22637c478bd9Sstevel@tonic-gate pidp = dt_idhash_insert(inp->din_hash, pnp->dn_string, 22647c478bd9Sstevel@tonic-gate DT_IDENT_SCALAR, DT_IDFLG_DECL | DT_IDFLG_INLINE, 0, 22657c478bd9Sstevel@tonic-gate _dtrace_defattr, 0, &dt_idops_inline, 22667c478bd9Sstevel@tonic-gate pinp, dtp->dt_gen); 22677c478bd9Sstevel@tonic-gate 22687c478bd9Sstevel@tonic-gate if (pidp == NULL) { 22697c478bd9Sstevel@tonic-gate free(pinp); 22707c478bd9Sstevel@tonic-gate longjmp(yypcb->pcb_jmpbuf, EDT_NOMEM); 22717c478bd9Sstevel@tonic-gate } 22727c478bd9Sstevel@tonic-gate 22737c478bd9Sstevel@tonic-gate inp->din_argv[i] = pidp; 22747c478bd9Sstevel@tonic-gate bzero(pinp, sizeof (dt_idnode_t)); 22757c478bd9Sstevel@tonic-gate dt_ident_type_assign(pidp, pnp->dn_ctfp, pnp->dn_type); 22767c478bd9Sstevel@tonic-gate } 22777c478bd9Sstevel@tonic-gate 22787c478bd9Sstevel@tonic-gate dt_idstack_push(&yypcb->pcb_globals, inp->din_hash); 22797c478bd9Sstevel@tonic-gate } 22807c478bd9Sstevel@tonic-gate 22817c478bd9Sstevel@tonic-gate /* 22827c478bd9Sstevel@tonic-gate * Unlike most constructors, we need to explicitly cook the right-hand 22837c478bd9Sstevel@tonic-gate * side of the inline definition immediately to prevent recursion. If 22847c478bd9Sstevel@tonic-gate * the right-hand side uses the inline itself, the cook will fail. 22857c478bd9Sstevel@tonic-gate */ 22867c478bd9Sstevel@tonic-gate expr = dt_node_cook(expr, DT_IDFLG_REF); 22877c478bd9Sstevel@tonic-gate 22887c478bd9Sstevel@tonic-gate if (ddp->dd_kind == CTF_K_ARRAY) 22897c478bd9Sstevel@tonic-gate dt_idstack_pop(&yypcb->pcb_globals, inp->din_hash); 22907c478bd9Sstevel@tonic-gate 22917c478bd9Sstevel@tonic-gate /* 22927c478bd9Sstevel@tonic-gate * Set the type, attributes, and flags for the inline. If the right- 22937c478bd9Sstevel@tonic-gate * hand expression has an identifier, propagate its flags. Then cook 22947c478bd9Sstevel@tonic-gate * the identifier to fully initialize it: if we're declaring an inline 22957c478bd9Sstevel@tonic-gate * associative array this will construct a type signature from 'ddp'. 22967c478bd9Sstevel@tonic-gate */ 22977c478bd9Sstevel@tonic-gate if (dt_node_is_dynamic(expr)) 22987c478bd9Sstevel@tonic-gate rdp = dt_ident_resolve(expr->dn_ident); 22997c478bd9Sstevel@tonic-gate else if (expr->dn_kind == DT_NODE_VAR || expr->dn_kind == DT_NODE_SYM) 23007c478bd9Sstevel@tonic-gate rdp = expr->dn_ident; 23017c478bd9Sstevel@tonic-gate else 23027c478bd9Sstevel@tonic-gate rdp = NULL; 23037c478bd9Sstevel@tonic-gate 23047c478bd9Sstevel@tonic-gate if (rdp != NULL) { 23057c478bd9Sstevel@tonic-gate idp->di_flags |= (rdp->di_flags & 23067c478bd9Sstevel@tonic-gate (DT_IDFLG_WRITE | DT_IDFLG_USER | DT_IDFLG_PRIM)); 23077c478bd9Sstevel@tonic-gate } 23087c478bd9Sstevel@tonic-gate 23097c478bd9Sstevel@tonic-gate idp->di_attr = dt_attr_min(_dtrace_defattr, expr->dn_attr); 23107c478bd9Sstevel@tonic-gate dt_ident_type_assign(idp, dtt.dtt_ctfp, dtt.dtt_type); 23117c478bd9Sstevel@tonic-gate (void) dt_ident_cook(dnp, idp, &ddp->dd_node); 23127c478bd9Sstevel@tonic-gate 23137c478bd9Sstevel@tonic-gate /* 23147c478bd9Sstevel@tonic-gate * Store the parse tree nodes for 'expr' inside of idp->di_data ('inp') 23157c478bd9Sstevel@tonic-gate * so that they will be preserved with this identifier. Then pop the 23167c478bd9Sstevel@tonic-gate * inline declaration from the declaration stack and restore the lexer. 23177c478bd9Sstevel@tonic-gate */ 23187c478bd9Sstevel@tonic-gate inp->din_list = yypcb->pcb_list; 23197c478bd9Sstevel@tonic-gate inp->din_root = expr; 23207c478bd9Sstevel@tonic-gate 23217c478bd9Sstevel@tonic-gate dt_decl_free(dt_decl_pop()); 23227c478bd9Sstevel@tonic-gate yybegin(YYS_CLAUSE); 23237c478bd9Sstevel@tonic-gate 23247c478bd9Sstevel@tonic-gate /* 23257c478bd9Sstevel@tonic-gate * Finally, insert the inline identifier into dt_globals to make it 23267c478bd9Sstevel@tonic-gate * visible, and then cook 'dnp' to check its type against 'expr'. 23277c478bd9Sstevel@tonic-gate */ 23287c478bd9Sstevel@tonic-gate dt_idhash_xinsert(dtp->dt_globals, idp); 23297c478bd9Sstevel@tonic-gate return (dt_node_cook(dnp, DT_IDFLG_REF)); 23307c478bd9Sstevel@tonic-gate } 23317c478bd9Sstevel@tonic-gate 23327c478bd9Sstevel@tonic-gate dt_node_t * 23337c478bd9Sstevel@tonic-gate dt_node_member(dt_decl_t *ddp, char *name, dt_node_t *expr) 23347c478bd9Sstevel@tonic-gate { 23357c478bd9Sstevel@tonic-gate dtrace_typeinfo_t dtt; 23367c478bd9Sstevel@tonic-gate dt_node_t *dnp; 23377c478bd9Sstevel@tonic-gate int err; 23387c478bd9Sstevel@tonic-gate 23397c478bd9Sstevel@tonic-gate if (ddp != NULL) { 23407c478bd9Sstevel@tonic-gate err = dt_decl_type(ddp, &dtt); 23417c478bd9Sstevel@tonic-gate dt_decl_free(ddp); 23427c478bd9Sstevel@tonic-gate 23437c478bd9Sstevel@tonic-gate if (err != 0) 23447c478bd9Sstevel@tonic-gate longjmp(yypcb->pcb_jmpbuf, EDT_COMPILER); 23457c478bd9Sstevel@tonic-gate } 23467c478bd9Sstevel@tonic-gate 23477c478bd9Sstevel@tonic-gate dnp = dt_node_alloc(DT_NODE_MEMBER); 23487c478bd9Sstevel@tonic-gate dnp->dn_membname = name; 23497c478bd9Sstevel@tonic-gate dnp->dn_membexpr = expr; 23507c478bd9Sstevel@tonic-gate 23517c478bd9Sstevel@tonic-gate if (ddp != NULL) 23527c478bd9Sstevel@tonic-gate dt_node_type_assign(dnp, dtt.dtt_ctfp, dtt.dtt_type); 23537c478bd9Sstevel@tonic-gate 23547c478bd9Sstevel@tonic-gate return (dnp); 23557c478bd9Sstevel@tonic-gate } 23567c478bd9Sstevel@tonic-gate 23577c478bd9Sstevel@tonic-gate dt_node_t * 23587c478bd9Sstevel@tonic-gate dt_node_xlator(dt_decl_t *ddp, dt_decl_t *sdp, char *name, dt_node_t *members) 23597c478bd9Sstevel@tonic-gate { 23607c478bd9Sstevel@tonic-gate dtrace_hdl_t *dtp = yypcb->pcb_hdl; 23617c478bd9Sstevel@tonic-gate dtrace_typeinfo_t src, dst; 23627c478bd9Sstevel@tonic-gate dt_node_t sn, dn; 23637c478bd9Sstevel@tonic-gate dt_xlator_t *dxp; 23647c478bd9Sstevel@tonic-gate dt_node_t *dnp; 23657c478bd9Sstevel@tonic-gate int edst, esrc; 23661a7c1b72Smws uint_t kind; 23677c478bd9Sstevel@tonic-gate 23687c478bd9Sstevel@tonic-gate char n1[DT_TYPE_NAMELEN]; 23697c478bd9Sstevel@tonic-gate char n2[DT_TYPE_NAMELEN]; 23707c478bd9Sstevel@tonic-gate 23717c478bd9Sstevel@tonic-gate edst = dt_decl_type(ddp, &dst); 23727c478bd9Sstevel@tonic-gate dt_decl_free(ddp); 23737c478bd9Sstevel@tonic-gate 23747c478bd9Sstevel@tonic-gate esrc = dt_decl_type(sdp, &src); 23757c478bd9Sstevel@tonic-gate dt_decl_free(sdp); 23767c478bd9Sstevel@tonic-gate 23777c478bd9Sstevel@tonic-gate if (edst != 0 || esrc != 0) { 23787c478bd9Sstevel@tonic-gate free(name); 23797c478bd9Sstevel@tonic-gate longjmp(yypcb->pcb_jmpbuf, EDT_COMPILER); 23807c478bd9Sstevel@tonic-gate } 23817c478bd9Sstevel@tonic-gate 23827c478bd9Sstevel@tonic-gate bzero(&sn, sizeof (sn)); 23837c478bd9Sstevel@tonic-gate dt_node_type_assign(&sn, src.dtt_ctfp, src.dtt_type); 23847c478bd9Sstevel@tonic-gate 23857c478bd9Sstevel@tonic-gate bzero(&dn, sizeof (dn)); 23867c478bd9Sstevel@tonic-gate dt_node_type_assign(&dn, dst.dtt_ctfp, dst.dtt_type); 23877c478bd9Sstevel@tonic-gate 23887c478bd9Sstevel@tonic-gate if (dt_xlator_lookup(dtp, &sn, &dn, DT_XLATE_EXACT) != NULL) { 23897c478bd9Sstevel@tonic-gate xyerror(D_XLATE_REDECL, 23907c478bd9Sstevel@tonic-gate "translator from %s to %s has already been declared\n", 23917c478bd9Sstevel@tonic-gate dt_node_type_name(&sn, n1, sizeof (n1)), 23927c478bd9Sstevel@tonic-gate dt_node_type_name(&dn, n2, sizeof (n2))); 23937c478bd9Sstevel@tonic-gate } 23947c478bd9Sstevel@tonic-gate 23951a7c1b72Smws kind = ctf_type_kind(dst.dtt_ctfp, 23961a7c1b72Smws ctf_type_resolve(dst.dtt_ctfp, dst.dtt_type)); 23971a7c1b72Smws 23981a7c1b72Smws if (kind == CTF_K_FORWARD) { 23991a7c1b72Smws xyerror(D_XLATE_SOU, "incomplete struct/union/enum %s\n", 24001a7c1b72Smws dt_type_name(dst.dtt_ctfp, dst.dtt_type, n1, sizeof (n1))); 24011a7c1b72Smws } 24021a7c1b72Smws 24031a7c1b72Smws if (kind != CTF_K_STRUCT && kind != CTF_K_UNION) { 24041a7c1b72Smws xyerror(D_XLATE_SOU, 24051a7c1b72Smws "translator output type must be a struct or union\n"); 24061a7c1b72Smws } 24071a7c1b72Smws 24087c478bd9Sstevel@tonic-gate dxp = dt_xlator_create(dtp, &src, &dst, name, members, yypcb->pcb_list); 24097c478bd9Sstevel@tonic-gate yybegin(YYS_CLAUSE); 24107c478bd9Sstevel@tonic-gate free(name); 24117c478bd9Sstevel@tonic-gate 24127c478bd9Sstevel@tonic-gate if (dxp == NULL) 24137c478bd9Sstevel@tonic-gate longjmp(yypcb->pcb_jmpbuf, EDT_NOMEM); 24147c478bd9Sstevel@tonic-gate 24157c478bd9Sstevel@tonic-gate dnp = dt_node_alloc(DT_NODE_XLATOR); 24167c478bd9Sstevel@tonic-gate dnp->dn_xlator = dxp; 24177c478bd9Sstevel@tonic-gate dnp->dn_members = members; 24187c478bd9Sstevel@tonic-gate 24197c478bd9Sstevel@tonic-gate return (dt_node_cook(dnp, DT_IDFLG_REF)); 24207c478bd9Sstevel@tonic-gate } 24217c478bd9Sstevel@tonic-gate 24227c478bd9Sstevel@tonic-gate dt_node_t * 24231a7c1b72Smws dt_node_probe(char *s, int protoc, dt_node_t *nargs, dt_node_t *xargs) 24247c478bd9Sstevel@tonic-gate { 24257c478bd9Sstevel@tonic-gate dtrace_hdl_t *dtp = yypcb->pcb_hdl; 24267c478bd9Sstevel@tonic-gate int nargc, xargc; 24277c478bd9Sstevel@tonic-gate dt_node_t *dnp; 24287c478bd9Sstevel@tonic-gate 24297c478bd9Sstevel@tonic-gate size_t len = strlen(s) + 3; /* +3 for :: and \0 */ 24307c478bd9Sstevel@tonic-gate char *name = alloca(len); 24317c478bd9Sstevel@tonic-gate 24327c478bd9Sstevel@tonic-gate (void) snprintf(name, len, "::%s", s); 24337c478bd9Sstevel@tonic-gate (void) strhyphenate(name); 24347c478bd9Sstevel@tonic-gate free(s); 24357c478bd9Sstevel@tonic-gate 24367c478bd9Sstevel@tonic-gate if (strchr(name, '`') != NULL) { 24377c478bd9Sstevel@tonic-gate xyerror(D_PROV_BADNAME, "probe name may not " 24387c478bd9Sstevel@tonic-gate "contain scoping operator: %s\n", name); 24397c478bd9Sstevel@tonic-gate } 24407c478bd9Sstevel@tonic-gate 24417c478bd9Sstevel@tonic-gate if (strlen(name) - 2 >= DTRACE_NAMELEN) { 24427c478bd9Sstevel@tonic-gate xyerror(D_PROV_BADNAME, "probe name may not exceed %d " 24437c478bd9Sstevel@tonic-gate "characters: %s\n", DTRACE_NAMELEN - 1, name); 24447c478bd9Sstevel@tonic-gate } 24457c478bd9Sstevel@tonic-gate 24467c478bd9Sstevel@tonic-gate dnp = dt_node_alloc(DT_NODE_PROBE); 24477c478bd9Sstevel@tonic-gate 24487c478bd9Sstevel@tonic-gate dnp->dn_ident = dt_ident_create(name, DT_IDENT_PROBE, 24497c478bd9Sstevel@tonic-gate DT_IDFLG_ORPHAN, DTRACE_IDNONE, _dtrace_defattr, 0, 24507c478bd9Sstevel@tonic-gate &dt_idops_probe, NULL, dtp->dt_gen); 24517c478bd9Sstevel@tonic-gate 24527c478bd9Sstevel@tonic-gate nargc = dt_decl_prototype(nargs, nargs, 24537c478bd9Sstevel@tonic-gate "probe input", DT_DP_VOID | DT_DP_ANON); 24547c478bd9Sstevel@tonic-gate 24557c478bd9Sstevel@tonic-gate xargc = dt_decl_prototype(xargs, nargs, 24567c478bd9Sstevel@tonic-gate "probe output", DT_DP_VOID); 24577c478bd9Sstevel@tonic-gate 24587c478bd9Sstevel@tonic-gate if (nargc > UINT8_MAX) { 24597c478bd9Sstevel@tonic-gate xyerror(D_PROV_PRARGLEN, "probe %s input prototype exceeds %u " 24607c478bd9Sstevel@tonic-gate "parameters: %d params used\n", name, UINT8_MAX, nargc); 24617c478bd9Sstevel@tonic-gate } 24627c478bd9Sstevel@tonic-gate 24637c478bd9Sstevel@tonic-gate if (xargc > UINT8_MAX) { 24647c478bd9Sstevel@tonic-gate xyerror(D_PROV_PRARGLEN, "probe %s output prototype exceeds %u " 24657c478bd9Sstevel@tonic-gate "parameters: %d params used\n", name, UINT8_MAX, xargc); 24667c478bd9Sstevel@tonic-gate } 24677c478bd9Sstevel@tonic-gate 24687c478bd9Sstevel@tonic-gate if (dnp->dn_ident == NULL || dt_probe_create(dtp, 24691a7c1b72Smws dnp->dn_ident, protoc, nargs, nargc, xargs, xargc) == NULL) 24707c478bd9Sstevel@tonic-gate longjmp(yypcb->pcb_jmpbuf, EDT_NOMEM); 24717c478bd9Sstevel@tonic-gate 24727c478bd9Sstevel@tonic-gate return (dnp); 24737c478bd9Sstevel@tonic-gate } 24747c478bd9Sstevel@tonic-gate 24757c478bd9Sstevel@tonic-gate dt_node_t * 24767c478bd9Sstevel@tonic-gate dt_node_provider(char *name, dt_node_t *probes) 24777c478bd9Sstevel@tonic-gate { 24787c478bd9Sstevel@tonic-gate dtrace_hdl_t *dtp = yypcb->pcb_hdl; 24797c478bd9Sstevel@tonic-gate dt_node_t *dnp = dt_node_alloc(DT_NODE_PROVIDER); 24801a7c1b72Smws dt_node_t *lnp; 24817c478bd9Sstevel@tonic-gate 24827c478bd9Sstevel@tonic-gate dnp->dn_provname = name; 24837c478bd9Sstevel@tonic-gate dnp->dn_probes = probes; 24847c478bd9Sstevel@tonic-gate 24857c478bd9Sstevel@tonic-gate if (strchr(name, '`') != NULL) { 24867c478bd9Sstevel@tonic-gate dnerror(dnp, D_PROV_BADNAME, "provider name may not " 24877c478bd9Sstevel@tonic-gate "contain scoping operator: %s\n", name); 24887c478bd9Sstevel@tonic-gate } 24897c478bd9Sstevel@tonic-gate 24907c478bd9Sstevel@tonic-gate if (strlen(name) >= DTRACE_PROVNAMELEN) { 24917c478bd9Sstevel@tonic-gate dnerror(dnp, D_PROV_BADNAME, "provider name may not exceed %d " 24927c478bd9Sstevel@tonic-gate "characters: %s\n", DTRACE_PROVNAMELEN - 1, name); 24937c478bd9Sstevel@tonic-gate } 24947c478bd9Sstevel@tonic-gate 24957c478bd9Sstevel@tonic-gate /* 24967c478bd9Sstevel@tonic-gate * Check to see if the provider is already defined or visible through 24977c478bd9Sstevel@tonic-gate * dtrace(7D). If so, set dn_provred to treat it as a re-declaration. 24987c478bd9Sstevel@tonic-gate * If not, create a new provider and set its interface-only flag. This 24997c478bd9Sstevel@tonic-gate * flag may be cleared later by calls made to dt_probe_declare(). 25007c478bd9Sstevel@tonic-gate */ 25017c478bd9Sstevel@tonic-gate if ((dnp->dn_provider = dt_provider_lookup(dtp, name)) != NULL) 25027c478bd9Sstevel@tonic-gate dnp->dn_provred = B_TRUE; 25037c478bd9Sstevel@tonic-gate else if ((dnp->dn_provider = dt_provider_create(dtp, name)) == NULL) 25047c478bd9Sstevel@tonic-gate longjmp(yypcb->pcb_jmpbuf, EDT_NOMEM); 25057c478bd9Sstevel@tonic-gate else 25067c478bd9Sstevel@tonic-gate dnp->dn_provider->pv_flags |= DT_PROVIDER_INTF; 25077c478bd9Sstevel@tonic-gate 25087c478bd9Sstevel@tonic-gate /* 25091a7c1b72Smws * Store all parse nodes created since we consumed the DT_KEY_PROVIDER 25107c478bd9Sstevel@tonic-gate * token with the provider and then restore our lexing state to CLAUSE. 25111a7c1b72Smws * Note that if dnp->dn_provred is true, we may end up storing dups of 25121a7c1b72Smws * a provider's interface and implementation: we eat this space because 25131a7c1b72Smws * the implementation will likely need to redeclare probe members, and 25141a7c1b72Smws * therefore may result in those member nodes becoming persistent. 25157c478bd9Sstevel@tonic-gate */ 25161a7c1b72Smws for (lnp = yypcb->pcb_list; lnp->dn_link != NULL; lnp = lnp->dn_link) 25171a7c1b72Smws continue; /* skip to end of allocation list */ 25181a7c1b72Smws 25191a7c1b72Smws lnp->dn_link = dnp->dn_provider->pv_nodes; 25201a7c1b72Smws dnp->dn_provider->pv_nodes = yypcb->pcb_list; 25217c478bd9Sstevel@tonic-gate 25227c478bd9Sstevel@tonic-gate yybegin(YYS_CLAUSE); 25237c478bd9Sstevel@tonic-gate return (dnp); 25247c478bd9Sstevel@tonic-gate } 25257c478bd9Sstevel@tonic-gate 25267c478bd9Sstevel@tonic-gate dt_node_t * 25277c478bd9Sstevel@tonic-gate dt_node_program(dt_node_t *lnp) 25287c478bd9Sstevel@tonic-gate { 25297c478bd9Sstevel@tonic-gate dt_node_t *dnp = dt_node_alloc(DT_NODE_PROG); 25307c478bd9Sstevel@tonic-gate dnp->dn_list = lnp; 25317c478bd9Sstevel@tonic-gate return (dnp); 25327c478bd9Sstevel@tonic-gate } 25337c478bd9Sstevel@tonic-gate 25347c478bd9Sstevel@tonic-gate /* 25357c478bd9Sstevel@tonic-gate * This function provides the underlying implementation of cooking an 25367c478bd9Sstevel@tonic-gate * identifier given its node, a hash of dynamic identifiers, an identifier 25377c478bd9Sstevel@tonic-gate * kind, and a boolean flag indicating whether we are allowed to instantiate 25387c478bd9Sstevel@tonic-gate * a new identifier if the string is not found. This function is either 25397c478bd9Sstevel@tonic-gate * called from dt_cook_ident(), below, or directly by the various cooking 25407c478bd9Sstevel@tonic-gate * routines that are allowed to instantiate identifiers (e.g. op2 TOK_ASGN). 25417c478bd9Sstevel@tonic-gate */ 25427c478bd9Sstevel@tonic-gate static void 25437c478bd9Sstevel@tonic-gate dt_xcook_ident(dt_node_t *dnp, dt_idhash_t *dhp, uint_t idkind, int create) 25447c478bd9Sstevel@tonic-gate { 25457c478bd9Sstevel@tonic-gate dtrace_hdl_t *dtp = yypcb->pcb_hdl; 25467c478bd9Sstevel@tonic-gate const char *sname = dt_idhash_name(dhp); 25477c478bd9Sstevel@tonic-gate int uref = 0; 25487c478bd9Sstevel@tonic-gate 25497c478bd9Sstevel@tonic-gate dtrace_attribute_t attr = _dtrace_defattr; 25507c478bd9Sstevel@tonic-gate dt_ident_t *idp; 25517c478bd9Sstevel@tonic-gate dtrace_syminfo_t dts; 25527c478bd9Sstevel@tonic-gate GElf_Sym sym; 25537c478bd9Sstevel@tonic-gate 25547c478bd9Sstevel@tonic-gate const char *scope, *mark; 25557c478bd9Sstevel@tonic-gate uchar_t dnkind; 25567c478bd9Sstevel@tonic-gate char *name; 25577c478bd9Sstevel@tonic-gate 25587c478bd9Sstevel@tonic-gate /* 25597c478bd9Sstevel@tonic-gate * Look for scoping marks in the identifier. If one is found, set our 25607c478bd9Sstevel@tonic-gate * scope to either DTRACE_OBJ_KMODS or UMODS or to the first part of 25617c478bd9Sstevel@tonic-gate * the string that specifies the scope using an explicit module name. 25627c478bd9Sstevel@tonic-gate * If two marks in a row are found, set 'uref' (user symbol reference). 25637c478bd9Sstevel@tonic-gate * Otherwise we set scope to DTRACE_OBJ_EXEC, indicating that normal 25647c478bd9Sstevel@tonic-gate * scope is desired and we should search the specified idhash. 25657c478bd9Sstevel@tonic-gate */ 25667c478bd9Sstevel@tonic-gate if ((name = strrchr(dnp->dn_string, '`')) != NULL) { 25677c478bd9Sstevel@tonic-gate if (name > dnp->dn_string && name[-1] == '`') { 25687c478bd9Sstevel@tonic-gate uref++; 25697c478bd9Sstevel@tonic-gate name[-1] = '\0'; 25707c478bd9Sstevel@tonic-gate } 25717c478bd9Sstevel@tonic-gate 25727c478bd9Sstevel@tonic-gate if (name == dnp->dn_string + uref) 25737c478bd9Sstevel@tonic-gate scope = uref ? DTRACE_OBJ_UMODS : DTRACE_OBJ_KMODS; 25747c478bd9Sstevel@tonic-gate else 25757c478bd9Sstevel@tonic-gate scope = dnp->dn_string; 25767c478bd9Sstevel@tonic-gate 25777c478bd9Sstevel@tonic-gate *name++ = '\0'; /* leave name pointing after scoping mark */ 25787c478bd9Sstevel@tonic-gate dnkind = DT_NODE_VAR; 25797c478bd9Sstevel@tonic-gate 25807c478bd9Sstevel@tonic-gate } else if (idkind == DT_IDENT_AGG) { 25817c478bd9Sstevel@tonic-gate scope = DTRACE_OBJ_EXEC; 25827c478bd9Sstevel@tonic-gate name = dnp->dn_string + 1; 25837c478bd9Sstevel@tonic-gate dnkind = DT_NODE_AGG; 25847c478bd9Sstevel@tonic-gate } else { 25857c478bd9Sstevel@tonic-gate scope = DTRACE_OBJ_EXEC; 25867c478bd9Sstevel@tonic-gate name = dnp->dn_string; 25877c478bd9Sstevel@tonic-gate dnkind = DT_NODE_VAR; 25887c478bd9Sstevel@tonic-gate } 25897c478bd9Sstevel@tonic-gate 25907c478bd9Sstevel@tonic-gate /* 25917c478bd9Sstevel@tonic-gate * If create is set to false, and we fail our idhash lookup, preset 25927c478bd9Sstevel@tonic-gate * the errno code to EDT_NOVAR for our final error message below. 25937c478bd9Sstevel@tonic-gate * If we end up calling dtrace_lookup_by_name(), it will reset the 25947c478bd9Sstevel@tonic-gate * errno appropriately and that error will be reported instead. 25957c478bd9Sstevel@tonic-gate */ 25967c478bd9Sstevel@tonic-gate (void) dt_set_errno(dtp, EDT_NOVAR); 25977c478bd9Sstevel@tonic-gate mark = uref ? "``" : "`"; 25987c478bd9Sstevel@tonic-gate 25997c478bd9Sstevel@tonic-gate if (scope == DTRACE_OBJ_EXEC && ( 26007c478bd9Sstevel@tonic-gate (dhp != dtp->dt_globals && 26017c478bd9Sstevel@tonic-gate (idp = dt_idhash_lookup(dhp, name)) != NULL) || 26027c478bd9Sstevel@tonic-gate (dhp == dtp->dt_globals && 26037c478bd9Sstevel@tonic-gate (idp = dt_idstack_lookup(&yypcb->pcb_globals, name)) != NULL))) { 26047c478bd9Sstevel@tonic-gate /* 26057c478bd9Sstevel@tonic-gate * Check that we are referencing the ident in the manner that 26067c478bd9Sstevel@tonic-gate * matches its type if this is a global lookup. In the TLS or 26077c478bd9Sstevel@tonic-gate * local case, we don't know how the ident will be used until 26087c478bd9Sstevel@tonic-gate * the time operator -> is seen; more parsing is needed. 26097c478bd9Sstevel@tonic-gate */ 26107c478bd9Sstevel@tonic-gate if (idp->di_kind != idkind && dhp == dtp->dt_globals) { 26117c478bd9Sstevel@tonic-gate xyerror(D_IDENT_BADREF, "%s '%s' may not be referenced " 26127c478bd9Sstevel@tonic-gate "as %s\n", dt_idkind_name(idp->di_kind), 26137c478bd9Sstevel@tonic-gate idp->di_name, dt_idkind_name(idkind)); 26147c478bd9Sstevel@tonic-gate } 26157c478bd9Sstevel@tonic-gate 26167c478bd9Sstevel@tonic-gate /* 26177c478bd9Sstevel@tonic-gate * Arrays and aggregations are not cooked individually. They 26187c478bd9Sstevel@tonic-gate * have dynamic types and must be referenced using operator []. 26197c478bd9Sstevel@tonic-gate * This is handled explicitly by the code for DT_TOK_LBRAC. 26207c478bd9Sstevel@tonic-gate */ 26217c478bd9Sstevel@tonic-gate if (idp->di_kind != DT_IDENT_ARRAY && 26227c478bd9Sstevel@tonic-gate idp->di_kind != DT_IDENT_AGG) 26237c478bd9Sstevel@tonic-gate attr = dt_ident_cook(dnp, idp, NULL); 26247c478bd9Sstevel@tonic-gate else { 26257c478bd9Sstevel@tonic-gate dt_node_type_assign(dnp, 26267c478bd9Sstevel@tonic-gate DT_DYN_CTFP(dtp), DT_DYN_TYPE(dtp)); 26277c478bd9Sstevel@tonic-gate attr = idp->di_attr; 26287c478bd9Sstevel@tonic-gate } 26297c478bd9Sstevel@tonic-gate 26307c478bd9Sstevel@tonic-gate free(dnp->dn_string); 26317c478bd9Sstevel@tonic-gate dnp->dn_string = NULL; 26327c478bd9Sstevel@tonic-gate dnp->dn_kind = dnkind; 26337c478bd9Sstevel@tonic-gate dnp->dn_ident = idp; 26347c478bd9Sstevel@tonic-gate dnp->dn_flags |= DT_NF_LVALUE; 26357c478bd9Sstevel@tonic-gate 26367c478bd9Sstevel@tonic-gate if (idp->di_flags & DT_IDFLG_WRITE) 26377c478bd9Sstevel@tonic-gate dnp->dn_flags |= DT_NF_WRITABLE; 26387c478bd9Sstevel@tonic-gate 26397c478bd9Sstevel@tonic-gate dt_node_attr_assign(dnp, attr); 26407c478bd9Sstevel@tonic-gate 26417c478bd9Sstevel@tonic-gate } else if (dhp == dtp->dt_globals && scope != DTRACE_OBJ_EXEC && 26427c478bd9Sstevel@tonic-gate dtrace_lookup_by_name(dtp, scope, name, &sym, &dts) == 0) { 26437c478bd9Sstevel@tonic-gate 26447c478bd9Sstevel@tonic-gate dt_module_t *mp = dt_module_lookup_by_name(dtp, dts.dts_object); 26457c478bd9Sstevel@tonic-gate int umod = (mp->dm_flags & DT_DM_KERNEL) == 0; 26467c478bd9Sstevel@tonic-gate static const char *const kunames[] = { "kernel", "user" }; 26477c478bd9Sstevel@tonic-gate 26487c478bd9Sstevel@tonic-gate dtrace_typeinfo_t dtt; 26497c478bd9Sstevel@tonic-gate dtrace_syminfo_t *sip; 26507c478bd9Sstevel@tonic-gate 26517c478bd9Sstevel@tonic-gate if (uref ^ umod) { 26527c478bd9Sstevel@tonic-gate xyerror(D_SYM_BADREF, "%s module '%s' symbol '%s' may " 26537c478bd9Sstevel@tonic-gate "not be referenced as a %s symbol\n", kunames[umod], 26547c478bd9Sstevel@tonic-gate dts.dts_object, dts.dts_name, kunames[uref]); 26557c478bd9Sstevel@tonic-gate } 26567c478bd9Sstevel@tonic-gate 26577c478bd9Sstevel@tonic-gate if (dtrace_symbol_type(dtp, &sym, &dts, &dtt) != 0) { 26587c478bd9Sstevel@tonic-gate /* 26597c478bd9Sstevel@tonic-gate * For now, we special-case EDT_DATAMODEL to clarify 26607c478bd9Sstevel@tonic-gate * that mixed data models are not currently supported. 26617c478bd9Sstevel@tonic-gate */ 26627c478bd9Sstevel@tonic-gate if (dtp->dt_errno == EDT_DATAMODEL) { 26637c478bd9Sstevel@tonic-gate xyerror(D_SYM_MODEL, "cannot use %s symbol " 26647c478bd9Sstevel@tonic-gate "%s%s%s in a %s D program\n", 26657c478bd9Sstevel@tonic-gate dt_module_modelname(mp), 26667c478bd9Sstevel@tonic-gate dts.dts_object, mark, dts.dts_name, 26677c478bd9Sstevel@tonic-gate dt_module_modelname(dtp->dt_ddefs)); 26687c478bd9Sstevel@tonic-gate } 26697c478bd9Sstevel@tonic-gate 26707c478bd9Sstevel@tonic-gate xyerror(D_SYM_NOTYPES, 26717c478bd9Sstevel@tonic-gate "no symbolic type information is available for " 26727c478bd9Sstevel@tonic-gate "%s%s%s: %s\n", dts.dts_object, mark, dts.dts_name, 26737c478bd9Sstevel@tonic-gate dtrace_errmsg(dtp, dtrace_errno(dtp))); 26747c478bd9Sstevel@tonic-gate } 26757c478bd9Sstevel@tonic-gate 26767c478bd9Sstevel@tonic-gate idp = dt_ident_create(name, DT_IDENT_SYMBOL, 0, 0, 26777c478bd9Sstevel@tonic-gate _dtrace_symattr, 0, &dt_idops_thaw, NULL, dtp->dt_gen); 26787c478bd9Sstevel@tonic-gate 26797c478bd9Sstevel@tonic-gate if (idp == NULL) 26807c478bd9Sstevel@tonic-gate longjmp(yypcb->pcb_jmpbuf, EDT_NOMEM); 26817c478bd9Sstevel@tonic-gate 26827c478bd9Sstevel@tonic-gate if (mp->dm_flags & DT_DM_PRIMARY) 26837c478bd9Sstevel@tonic-gate idp->di_flags |= DT_IDFLG_PRIM; 26847c478bd9Sstevel@tonic-gate 26857c478bd9Sstevel@tonic-gate idp->di_next = dtp->dt_externs; 26867c478bd9Sstevel@tonic-gate dtp->dt_externs = idp; 26877c478bd9Sstevel@tonic-gate 26887c478bd9Sstevel@tonic-gate if ((sip = malloc(sizeof (dtrace_syminfo_t))) == NULL) 26897c478bd9Sstevel@tonic-gate longjmp(yypcb->pcb_jmpbuf, EDT_NOMEM); 26907c478bd9Sstevel@tonic-gate 26917c478bd9Sstevel@tonic-gate bcopy(&dts, sip, sizeof (dtrace_syminfo_t)); 26927c478bd9Sstevel@tonic-gate idp->di_data = sip; 26937c478bd9Sstevel@tonic-gate idp->di_ctfp = dtt.dtt_ctfp; 26947c478bd9Sstevel@tonic-gate idp->di_type = dtt.dtt_type; 26957c478bd9Sstevel@tonic-gate 26967c478bd9Sstevel@tonic-gate free(dnp->dn_string); 26977c478bd9Sstevel@tonic-gate dnp->dn_string = NULL; 26987c478bd9Sstevel@tonic-gate dnp->dn_kind = DT_NODE_SYM; 26997c478bd9Sstevel@tonic-gate dnp->dn_ident = idp; 27007c478bd9Sstevel@tonic-gate dnp->dn_flags |= DT_NF_LVALUE; 27017c478bd9Sstevel@tonic-gate 27027c478bd9Sstevel@tonic-gate dt_node_type_assign(dnp, dtt.dtt_ctfp, dtt.dtt_type); 27037c478bd9Sstevel@tonic-gate dt_node_attr_assign(dnp, _dtrace_symattr); 27047c478bd9Sstevel@tonic-gate 27057c478bd9Sstevel@tonic-gate if (uref) { 27067c478bd9Sstevel@tonic-gate idp->di_flags |= DT_IDFLG_USER; 27077c478bd9Sstevel@tonic-gate dnp->dn_flags |= DT_NF_USERLAND; 27087c478bd9Sstevel@tonic-gate } 27097c478bd9Sstevel@tonic-gate 27107c478bd9Sstevel@tonic-gate } else if (scope == DTRACE_OBJ_EXEC && create == B_TRUE) { 27117c478bd9Sstevel@tonic-gate uint_t flags = DT_IDFLG_WRITE; 27127c478bd9Sstevel@tonic-gate uint_t id; 27137c478bd9Sstevel@tonic-gate 27147c478bd9Sstevel@tonic-gate if (dt_idhash_nextid(dhp, &id) == -1) { 27157c478bd9Sstevel@tonic-gate xyerror(D_ID_OFLOW, "cannot create %s: limit on number " 27167c478bd9Sstevel@tonic-gate "of %s variables exceeded\n", name, sname); 27177c478bd9Sstevel@tonic-gate } 27187c478bd9Sstevel@tonic-gate 27197c478bd9Sstevel@tonic-gate if (dhp == yypcb->pcb_locals) 27207c478bd9Sstevel@tonic-gate flags |= DT_IDFLG_LOCAL; 27217c478bd9Sstevel@tonic-gate else if (dhp == dtp->dt_tls) 27227c478bd9Sstevel@tonic-gate flags |= DT_IDFLG_TLS; 27237c478bd9Sstevel@tonic-gate 27247c478bd9Sstevel@tonic-gate dt_dprintf("create %s %s variable %s, id=%u\n", 27257c478bd9Sstevel@tonic-gate sname, dt_idkind_name(idkind), name, id); 27267c478bd9Sstevel@tonic-gate 27277c478bd9Sstevel@tonic-gate if (idkind == DT_IDENT_ARRAY || idkind == DT_IDENT_AGG) { 27287c478bd9Sstevel@tonic-gate idp = dt_idhash_insert(dhp, name, 27297c478bd9Sstevel@tonic-gate idkind, flags, id, _dtrace_defattr, 0, 27307c478bd9Sstevel@tonic-gate &dt_idops_assc, NULL, dtp->dt_gen); 27317c478bd9Sstevel@tonic-gate } else { 27327c478bd9Sstevel@tonic-gate idp = dt_idhash_insert(dhp, name, 27337c478bd9Sstevel@tonic-gate idkind, flags, id, _dtrace_defattr, 0, 27347c478bd9Sstevel@tonic-gate &dt_idops_thaw, NULL, dtp->dt_gen); 27357c478bd9Sstevel@tonic-gate } 27367c478bd9Sstevel@tonic-gate 27377c478bd9Sstevel@tonic-gate if (idp == NULL) 27387c478bd9Sstevel@tonic-gate longjmp(yypcb->pcb_jmpbuf, EDT_NOMEM); 27397c478bd9Sstevel@tonic-gate 27407c478bd9Sstevel@tonic-gate /* 27417c478bd9Sstevel@tonic-gate * Arrays and aggregations are not cooked individually. They 27427c478bd9Sstevel@tonic-gate * have dynamic types and must be referenced using operator []. 27437c478bd9Sstevel@tonic-gate * This is handled explicitly by the code for DT_TOK_LBRAC. 27447c478bd9Sstevel@tonic-gate */ 27457c478bd9Sstevel@tonic-gate if (idp->di_kind != DT_IDENT_ARRAY && 27467c478bd9Sstevel@tonic-gate idp->di_kind != DT_IDENT_AGG) 27477c478bd9Sstevel@tonic-gate attr = dt_ident_cook(dnp, idp, NULL); 27487c478bd9Sstevel@tonic-gate else { 27497c478bd9Sstevel@tonic-gate dt_node_type_assign(dnp, 27507c478bd9Sstevel@tonic-gate DT_DYN_CTFP(dtp), DT_DYN_TYPE(dtp)); 27517c478bd9Sstevel@tonic-gate attr = idp->di_attr; 27527c478bd9Sstevel@tonic-gate } 27537c478bd9Sstevel@tonic-gate 27547c478bd9Sstevel@tonic-gate free(dnp->dn_string); 27557c478bd9Sstevel@tonic-gate dnp->dn_string = NULL; 27567c478bd9Sstevel@tonic-gate dnp->dn_kind = dnkind; 27577c478bd9Sstevel@tonic-gate dnp->dn_ident = idp; 27587c478bd9Sstevel@tonic-gate dnp->dn_flags |= DT_NF_LVALUE | DT_NF_WRITABLE; 27597c478bd9Sstevel@tonic-gate 27607c478bd9Sstevel@tonic-gate dt_node_attr_assign(dnp, attr); 27617c478bd9Sstevel@tonic-gate 27627c478bd9Sstevel@tonic-gate } else if (scope != DTRACE_OBJ_EXEC) { 27637c478bd9Sstevel@tonic-gate xyerror(D_IDENT_UNDEF, "failed to resolve %s%s%s: %s\n", 27647c478bd9Sstevel@tonic-gate dnp->dn_string, mark, name, 27657c478bd9Sstevel@tonic-gate dtrace_errmsg(dtp, dtrace_errno(dtp))); 27667c478bd9Sstevel@tonic-gate } else { 27677c478bd9Sstevel@tonic-gate xyerror(D_IDENT_UNDEF, "failed to resolve %s: %s\n", 27687c478bd9Sstevel@tonic-gate dnp->dn_string, dtrace_errmsg(dtp, dtrace_errno(dtp))); 27697c478bd9Sstevel@tonic-gate } 27707c478bd9Sstevel@tonic-gate } 27717c478bd9Sstevel@tonic-gate 27727c478bd9Sstevel@tonic-gate static dt_node_t * 27737c478bd9Sstevel@tonic-gate dt_cook_ident(dt_node_t *dnp, uint_t idflags) 27747c478bd9Sstevel@tonic-gate { 27757c478bd9Sstevel@tonic-gate dtrace_hdl_t *dtp = yypcb->pcb_hdl; 27767c478bd9Sstevel@tonic-gate 27777c478bd9Sstevel@tonic-gate if (dnp->dn_op == DT_TOK_AGG) 27787c478bd9Sstevel@tonic-gate dt_xcook_ident(dnp, dtp->dt_aggs, DT_IDENT_AGG, B_FALSE); 27797c478bd9Sstevel@tonic-gate else 27807c478bd9Sstevel@tonic-gate dt_xcook_ident(dnp, dtp->dt_globals, DT_IDENT_SCALAR, B_FALSE); 27817c478bd9Sstevel@tonic-gate 27827c478bd9Sstevel@tonic-gate return (dt_node_cook(dnp, idflags)); 27837c478bd9Sstevel@tonic-gate } 27847c478bd9Sstevel@tonic-gate 27857c478bd9Sstevel@tonic-gate /* 27867c478bd9Sstevel@tonic-gate * Since operators [ and -> can instantiate new variables before we know 27877c478bd9Sstevel@tonic-gate * whether the reference is for a read or a write, we need to check read 27887c478bd9Sstevel@tonic-gate * references to determine if the identifier is currently dt_ident_unref(). 27897c478bd9Sstevel@tonic-gate * If so, we report that this first access was to an undefined variable. 27907c478bd9Sstevel@tonic-gate */ 27917c478bd9Sstevel@tonic-gate static dt_node_t * 27927c478bd9Sstevel@tonic-gate dt_cook_var(dt_node_t *dnp, uint_t idflags) 27937c478bd9Sstevel@tonic-gate { 27947c478bd9Sstevel@tonic-gate dt_ident_t *idp = dnp->dn_ident; 27957c478bd9Sstevel@tonic-gate 27967c478bd9Sstevel@tonic-gate if ((idflags & DT_IDFLG_REF) && dt_ident_unref(idp)) { 27977c478bd9Sstevel@tonic-gate dnerror(dnp, D_VAR_UNDEF, 27987c478bd9Sstevel@tonic-gate "%s%s has not yet been declared or assigned\n", 27997c478bd9Sstevel@tonic-gate (idp->di_flags & DT_IDFLG_LOCAL) ? "this->" : 28007c478bd9Sstevel@tonic-gate (idp->di_flags & DT_IDFLG_TLS) ? "self->" : "", 28017c478bd9Sstevel@tonic-gate idp->di_name); 28027c478bd9Sstevel@tonic-gate } 28037c478bd9Sstevel@tonic-gate 28047c478bd9Sstevel@tonic-gate dt_node_attr_assign(dnp, dt_ident_cook(dnp, idp, &dnp->dn_args)); 28057c478bd9Sstevel@tonic-gate return (dnp); 28067c478bd9Sstevel@tonic-gate } 28077c478bd9Sstevel@tonic-gate 28087c478bd9Sstevel@tonic-gate /*ARGSUSED*/ 28097c478bd9Sstevel@tonic-gate static dt_node_t * 28107c478bd9Sstevel@tonic-gate dt_cook_func(dt_node_t *dnp, uint_t idflags) 28117c478bd9Sstevel@tonic-gate { 28127c478bd9Sstevel@tonic-gate dt_node_attr_assign(dnp, 28137c478bd9Sstevel@tonic-gate dt_ident_cook(dnp, dnp->dn_ident, &dnp->dn_args)); 28147c478bd9Sstevel@tonic-gate 28157c478bd9Sstevel@tonic-gate return (dnp); 28167c478bd9Sstevel@tonic-gate } 28177c478bd9Sstevel@tonic-gate 28187c478bd9Sstevel@tonic-gate static dt_node_t * 28197c478bd9Sstevel@tonic-gate dt_cook_op1(dt_node_t *dnp, uint_t idflags) 28207c478bd9Sstevel@tonic-gate { 28217c478bd9Sstevel@tonic-gate dtrace_hdl_t *dtp = yypcb->pcb_hdl; 28227c478bd9Sstevel@tonic-gate dt_node_t *cp = dnp->dn_child; 28237c478bd9Sstevel@tonic-gate 28247c478bd9Sstevel@tonic-gate char n[DT_TYPE_NAMELEN]; 28257c478bd9Sstevel@tonic-gate dtrace_typeinfo_t dtt; 28267c478bd9Sstevel@tonic-gate dt_ident_t *idp; 28277c478bd9Sstevel@tonic-gate 28287c478bd9Sstevel@tonic-gate ctf_encoding_t e; 28297c478bd9Sstevel@tonic-gate ctf_arinfo_t r; 28307c478bd9Sstevel@tonic-gate ctf_id_t type, base; 28317c478bd9Sstevel@tonic-gate uint_t kind; 28327c478bd9Sstevel@tonic-gate 28337c478bd9Sstevel@tonic-gate if (dnp->dn_op == DT_TOK_PREINC || dnp->dn_op == DT_TOK_POSTINC || 28347c478bd9Sstevel@tonic-gate dnp->dn_op == DT_TOK_PREDEC || dnp->dn_op == DT_TOK_POSTDEC) 28357c478bd9Sstevel@tonic-gate idflags = DT_IDFLG_REF | DT_IDFLG_MOD; 28367c478bd9Sstevel@tonic-gate else 28377c478bd9Sstevel@tonic-gate idflags = DT_IDFLG_REF; 28387c478bd9Sstevel@tonic-gate 28397c478bd9Sstevel@tonic-gate /* 28407c478bd9Sstevel@tonic-gate * We allow the unary ++ and -- operators to instantiate new scalar 28417c478bd9Sstevel@tonic-gate * variables if applied to an identifier; otherwise just cook as usual. 28427c478bd9Sstevel@tonic-gate */ 28437c478bd9Sstevel@tonic-gate if (cp->dn_kind == DT_NODE_IDENT && (idflags & DT_IDFLG_MOD)) 28447c478bd9Sstevel@tonic-gate dt_xcook_ident(cp, dtp->dt_globals, DT_IDENT_SCALAR, B_TRUE); 28457c478bd9Sstevel@tonic-gate 28467c478bd9Sstevel@tonic-gate cp = dnp->dn_child = dt_node_cook(cp, 0); /* don't set idflags yet */ 28477c478bd9Sstevel@tonic-gate 28487c478bd9Sstevel@tonic-gate if (cp->dn_kind == DT_NODE_VAR && dt_ident_unref(cp->dn_ident)) { 28497c478bd9Sstevel@tonic-gate if (dt_type_lookup("int64_t", &dtt) != 0) 28507c478bd9Sstevel@tonic-gate xyerror(D_TYPE_ERR, "failed to lookup int64_t\n"); 28517c478bd9Sstevel@tonic-gate 28527c478bd9Sstevel@tonic-gate dt_ident_type_assign(cp->dn_ident, dtt.dtt_ctfp, dtt.dtt_type); 28537c478bd9Sstevel@tonic-gate dt_node_type_assign(cp, dtt.dtt_ctfp, dtt.dtt_type); 28547c478bd9Sstevel@tonic-gate } 28557c478bd9Sstevel@tonic-gate 28567c478bd9Sstevel@tonic-gate if (cp->dn_kind == DT_NODE_VAR) 28577c478bd9Sstevel@tonic-gate cp->dn_ident->di_flags |= idflags; 28587c478bd9Sstevel@tonic-gate 28597c478bd9Sstevel@tonic-gate switch (dnp->dn_op) { 28607c478bd9Sstevel@tonic-gate case DT_TOK_DEREF: 28617c478bd9Sstevel@tonic-gate /* 28627c478bd9Sstevel@tonic-gate * If the deref operator is applied to a translated pointer, 28637c478bd9Sstevel@tonic-gate * we can just set our output type to the base translation. 28647c478bd9Sstevel@tonic-gate */ 28657c478bd9Sstevel@tonic-gate if ((idp = dt_node_resolve(cp, DT_IDENT_XLPTR)) != NULL) { 28667c478bd9Sstevel@tonic-gate dt_xlator_t *dxp = idp->di_data; 28677c478bd9Sstevel@tonic-gate 28687c478bd9Sstevel@tonic-gate dnp->dn_ident = &dxp->dx_souid; 28697c478bd9Sstevel@tonic-gate dt_node_type_assign(dnp, 28707c478bd9Sstevel@tonic-gate DT_DYN_CTFP(dtp), DT_DYN_TYPE(dtp)); 28717c478bd9Sstevel@tonic-gate break; 28727c478bd9Sstevel@tonic-gate } 28737c478bd9Sstevel@tonic-gate 28747c478bd9Sstevel@tonic-gate type = ctf_type_resolve(cp->dn_ctfp, cp->dn_type); 28757c478bd9Sstevel@tonic-gate kind = ctf_type_kind(cp->dn_ctfp, type); 28767c478bd9Sstevel@tonic-gate 28777c478bd9Sstevel@tonic-gate if (kind == CTF_K_ARRAY) { 28787c478bd9Sstevel@tonic-gate if (ctf_array_info(cp->dn_ctfp, type, &r) != 0) { 28797c478bd9Sstevel@tonic-gate dtp->dt_ctferr = ctf_errno(cp->dn_ctfp); 28807c478bd9Sstevel@tonic-gate longjmp(yypcb->pcb_jmpbuf, EDT_CTF); 28817c478bd9Sstevel@tonic-gate } else 28827c478bd9Sstevel@tonic-gate type = r.ctr_contents; 28837c478bd9Sstevel@tonic-gate } else if (kind == CTF_K_POINTER) { 28847c478bd9Sstevel@tonic-gate type = ctf_type_reference(cp->dn_ctfp, type); 28857c478bd9Sstevel@tonic-gate } else { 28867c478bd9Sstevel@tonic-gate xyerror(D_DEREF_NONPTR, 28877c478bd9Sstevel@tonic-gate "cannot dereference non-pointer type\n"); 28887c478bd9Sstevel@tonic-gate } 28897c478bd9Sstevel@tonic-gate 28907c478bd9Sstevel@tonic-gate dt_node_type_assign(dnp, cp->dn_ctfp, type); 28917c478bd9Sstevel@tonic-gate base = ctf_type_resolve(cp->dn_ctfp, type); 28927c478bd9Sstevel@tonic-gate kind = ctf_type_kind(cp->dn_ctfp, base); 28937c478bd9Sstevel@tonic-gate 28947c478bd9Sstevel@tonic-gate if (kind == CTF_K_INTEGER && ctf_type_encoding(cp->dn_ctfp, 28957c478bd9Sstevel@tonic-gate base, &e) == 0 && IS_VOID(e)) { 28967c478bd9Sstevel@tonic-gate xyerror(D_DEREF_VOID, 28977c478bd9Sstevel@tonic-gate "cannot dereference pointer to void\n"); 28987c478bd9Sstevel@tonic-gate } 28997c478bd9Sstevel@tonic-gate 29007c478bd9Sstevel@tonic-gate if (kind == CTF_K_FUNCTION) { 29017c478bd9Sstevel@tonic-gate xyerror(D_DEREF_FUNC, 29027c478bd9Sstevel@tonic-gate "cannot dereference pointer to function\n"); 29037c478bd9Sstevel@tonic-gate } 29047c478bd9Sstevel@tonic-gate 29057c478bd9Sstevel@tonic-gate if (kind != CTF_K_ARRAY || dt_node_is_string(dnp)) 29067c478bd9Sstevel@tonic-gate dnp->dn_flags |= DT_NF_LVALUE; /* see K&R[A7.4.3] */ 29077c478bd9Sstevel@tonic-gate 29087c478bd9Sstevel@tonic-gate /* 29097c478bd9Sstevel@tonic-gate * If we propagated the l-value bit and the child operand was 29107c478bd9Sstevel@tonic-gate * a writable D variable or a binary operation of the form 29117c478bd9Sstevel@tonic-gate * a + b where a is writable, then propagate the writable bit. 29127c478bd9Sstevel@tonic-gate * This is necessary to permit assignments to scalar arrays, 29137c478bd9Sstevel@tonic-gate * which are converted to expressions of the form *(a + i). 29147c478bd9Sstevel@tonic-gate */ 29157c478bd9Sstevel@tonic-gate if ((cp->dn_flags & DT_NF_WRITABLE) || 29167c478bd9Sstevel@tonic-gate (cp->dn_kind == DT_NODE_OP2 && cp->dn_op == DT_TOK_ADD && 29177c478bd9Sstevel@tonic-gate (cp->dn_left->dn_flags & DT_NF_WRITABLE))) 29187c478bd9Sstevel@tonic-gate dnp->dn_flags |= DT_NF_WRITABLE; 29197c478bd9Sstevel@tonic-gate 29207c478bd9Sstevel@tonic-gate if ((cp->dn_flags & DT_NF_USERLAND) && 29217c478bd9Sstevel@tonic-gate (kind == CTF_K_POINTER || (dnp->dn_flags & DT_NF_REF))) 29227c478bd9Sstevel@tonic-gate dnp->dn_flags |= DT_NF_USERLAND; 29237c478bd9Sstevel@tonic-gate break; 29247c478bd9Sstevel@tonic-gate 29257c478bd9Sstevel@tonic-gate case DT_TOK_IPOS: 29267c478bd9Sstevel@tonic-gate case DT_TOK_INEG: 29277c478bd9Sstevel@tonic-gate if (!dt_node_is_arith(cp)) { 29287c478bd9Sstevel@tonic-gate xyerror(D_OP_ARITH, "operator %s requires an operand " 29297c478bd9Sstevel@tonic-gate "of arithmetic type\n", opstr(dnp->dn_op)); 29307c478bd9Sstevel@tonic-gate } 29317c478bd9Sstevel@tonic-gate dt_node_type_propagate(cp, dnp); /* see K&R[A7.4.4-6] */ 29327c478bd9Sstevel@tonic-gate break; 29337c478bd9Sstevel@tonic-gate 29347c478bd9Sstevel@tonic-gate case DT_TOK_BNEG: 29357c478bd9Sstevel@tonic-gate if (!dt_node_is_integer(cp)) { 29367c478bd9Sstevel@tonic-gate xyerror(D_OP_INT, "operator %s requires an operand of " 29377c478bd9Sstevel@tonic-gate "integral type\n", opstr(dnp->dn_op)); 29387c478bd9Sstevel@tonic-gate } 29397c478bd9Sstevel@tonic-gate dt_node_type_propagate(cp, dnp); /* see K&R[A7.4.4-6] */ 29407c478bd9Sstevel@tonic-gate break; 29417c478bd9Sstevel@tonic-gate 29427c478bd9Sstevel@tonic-gate case DT_TOK_LNEG: 29437c478bd9Sstevel@tonic-gate if (!dt_node_is_scalar(cp)) { 29447c478bd9Sstevel@tonic-gate xyerror(D_OP_SCALAR, "operator %s requires an operand " 29457c478bd9Sstevel@tonic-gate "of scalar type\n", opstr(dnp->dn_op)); 29467c478bd9Sstevel@tonic-gate } 29477c478bd9Sstevel@tonic-gate dt_node_type_assign(dnp, DT_INT_CTFP(dtp), DT_INT_TYPE(dtp)); 29487c478bd9Sstevel@tonic-gate break; 29497c478bd9Sstevel@tonic-gate 29507c478bd9Sstevel@tonic-gate case DT_TOK_ADDROF: 29517c478bd9Sstevel@tonic-gate if (cp->dn_kind == DT_NODE_VAR || cp->dn_kind == DT_NODE_AGG) { 29527c478bd9Sstevel@tonic-gate xyerror(D_ADDROF_VAR, 29537c478bd9Sstevel@tonic-gate "cannot take address of dynamic variable\n"); 29547c478bd9Sstevel@tonic-gate } 29557c478bd9Sstevel@tonic-gate 29567c478bd9Sstevel@tonic-gate if (dt_node_is_dynamic(cp)) { 29577c478bd9Sstevel@tonic-gate xyerror(D_ADDROF_VAR, 29587c478bd9Sstevel@tonic-gate "cannot take address of dynamic object\n"); 29597c478bd9Sstevel@tonic-gate } 29607c478bd9Sstevel@tonic-gate 29617c478bd9Sstevel@tonic-gate if (!(cp->dn_flags & DT_NF_LVALUE)) { 29627c478bd9Sstevel@tonic-gate xyerror(D_ADDROF_LVAL, /* see K&R[A7.4.2] */ 29637c478bd9Sstevel@tonic-gate "unacceptable operand for unary & operator\n"); 29647c478bd9Sstevel@tonic-gate } 29657c478bd9Sstevel@tonic-gate 29667c478bd9Sstevel@tonic-gate if (cp->dn_flags & DT_NF_BITFIELD) { 29677c478bd9Sstevel@tonic-gate xyerror(D_ADDROF_BITFIELD, 29687c478bd9Sstevel@tonic-gate "cannot take address of bit-field\n"); 29697c478bd9Sstevel@tonic-gate } 29707c478bd9Sstevel@tonic-gate 29717c478bd9Sstevel@tonic-gate dtt.dtt_object = NULL; 29727c478bd9Sstevel@tonic-gate dtt.dtt_ctfp = cp->dn_ctfp; 29737c478bd9Sstevel@tonic-gate dtt.dtt_type = cp->dn_type; 29747c478bd9Sstevel@tonic-gate 29757c478bd9Sstevel@tonic-gate if (dt_type_pointer(&dtt) == -1) { 29767c478bd9Sstevel@tonic-gate xyerror(D_TYPE_ERR, "cannot find type for \"&\": %s*\n", 29777c478bd9Sstevel@tonic-gate dt_node_type_name(cp, n, sizeof (n))); 29787c478bd9Sstevel@tonic-gate } 29797c478bd9Sstevel@tonic-gate 29807c478bd9Sstevel@tonic-gate dt_node_type_assign(dnp, dtt.dtt_ctfp, dtt.dtt_type); 29817c478bd9Sstevel@tonic-gate 29827c478bd9Sstevel@tonic-gate if (cp->dn_flags & DT_NF_USERLAND) 29837c478bd9Sstevel@tonic-gate dnp->dn_flags |= DT_NF_USERLAND; 29847c478bd9Sstevel@tonic-gate break; 29857c478bd9Sstevel@tonic-gate 29867c478bd9Sstevel@tonic-gate case DT_TOK_SIZEOF: 29877c478bd9Sstevel@tonic-gate if (cp->dn_flags & DT_NF_BITFIELD) { 29887c478bd9Sstevel@tonic-gate xyerror(D_SIZEOF_BITFIELD, 29897c478bd9Sstevel@tonic-gate "cannot apply sizeof to a bit-field\n"); 29907c478bd9Sstevel@tonic-gate } 29917c478bd9Sstevel@tonic-gate 29927c478bd9Sstevel@tonic-gate if (dt_node_sizeof(cp) == 0) { 29937c478bd9Sstevel@tonic-gate xyerror(D_SIZEOF_TYPE, "cannot apply sizeof to an " 29947c478bd9Sstevel@tonic-gate "operand of unknown size\n"); 29957c478bd9Sstevel@tonic-gate } 29967c478bd9Sstevel@tonic-gate 29977c478bd9Sstevel@tonic-gate dt_node_type_assign(dnp, dtp->dt_ddefs->dm_ctfp, 29987c478bd9Sstevel@tonic-gate ctf_lookup_by_name(dtp->dt_ddefs->dm_ctfp, "size_t")); 29997c478bd9Sstevel@tonic-gate break; 30007c478bd9Sstevel@tonic-gate 30017c478bd9Sstevel@tonic-gate case DT_TOK_STRINGOF: 30027c478bd9Sstevel@tonic-gate if (!dt_node_is_scalar(cp) && !dt_node_is_pointer(cp) && 30037c478bd9Sstevel@tonic-gate !dt_node_is_strcompat(cp)) { 30047c478bd9Sstevel@tonic-gate xyerror(D_STRINGOF_TYPE, 30057c478bd9Sstevel@tonic-gate "cannot apply stringof to a value of type %s\n", 30067c478bd9Sstevel@tonic-gate dt_node_type_name(cp, n, sizeof (n))); 30077c478bd9Sstevel@tonic-gate } 30087c478bd9Sstevel@tonic-gate dt_node_type_assign(dnp, DT_STR_CTFP(dtp), DT_STR_TYPE(dtp)); 30097c478bd9Sstevel@tonic-gate break; 30107c478bd9Sstevel@tonic-gate 30117c478bd9Sstevel@tonic-gate case DT_TOK_PREINC: 30127c478bd9Sstevel@tonic-gate case DT_TOK_POSTINC: 30137c478bd9Sstevel@tonic-gate case DT_TOK_PREDEC: 30147c478bd9Sstevel@tonic-gate case DT_TOK_POSTDEC: 30157c478bd9Sstevel@tonic-gate if (dt_node_is_scalar(cp) == 0) { 30167c478bd9Sstevel@tonic-gate xyerror(D_OP_SCALAR, "operator %s requires operand of " 30177c478bd9Sstevel@tonic-gate "scalar type\n", opstr(dnp->dn_op)); 30187c478bd9Sstevel@tonic-gate } 30197c478bd9Sstevel@tonic-gate 30207c478bd9Sstevel@tonic-gate if (dt_node_is_vfptr(cp)) { 30217c478bd9Sstevel@tonic-gate xyerror(D_OP_VFPTR, "operator %s requires an operand " 30227c478bd9Sstevel@tonic-gate "of known size\n", opstr(dnp->dn_op)); 30237c478bd9Sstevel@tonic-gate } 30247c478bd9Sstevel@tonic-gate 30257c478bd9Sstevel@tonic-gate if (!(cp->dn_flags & DT_NF_LVALUE)) { 30267c478bd9Sstevel@tonic-gate xyerror(D_OP_LVAL, "operator %s requires modifiable " 30277c478bd9Sstevel@tonic-gate "lvalue as an operand\n", opstr(dnp->dn_op)); 30287c478bd9Sstevel@tonic-gate } 30297c478bd9Sstevel@tonic-gate 30307c478bd9Sstevel@tonic-gate if (!(cp->dn_flags & DT_NF_WRITABLE)) { 30317c478bd9Sstevel@tonic-gate xyerror(D_OP_WRITE, "operator %s can only be applied " 30327c478bd9Sstevel@tonic-gate "to a writable variable\n", opstr(dnp->dn_op)); 30337c478bd9Sstevel@tonic-gate } 30347c478bd9Sstevel@tonic-gate 30357c478bd9Sstevel@tonic-gate dt_node_type_propagate(cp, dnp); /* see K&R[A7.4.1] */ 30367c478bd9Sstevel@tonic-gate break; 30377c478bd9Sstevel@tonic-gate 30387c478bd9Sstevel@tonic-gate default: 30397c478bd9Sstevel@tonic-gate xyerror(D_UNKNOWN, "invalid unary op %s\n", opstr(dnp->dn_op)); 30407c478bd9Sstevel@tonic-gate } 30417c478bd9Sstevel@tonic-gate 30427c478bd9Sstevel@tonic-gate dt_node_attr_assign(dnp, cp->dn_attr); 30437c478bd9Sstevel@tonic-gate return (dnp); 30447c478bd9Sstevel@tonic-gate } 30457c478bd9Sstevel@tonic-gate 30467c478bd9Sstevel@tonic-gate static dt_node_t * 30477c478bd9Sstevel@tonic-gate dt_cook_op2(dt_node_t *dnp, uint_t idflags) 30487c478bd9Sstevel@tonic-gate { 30497c478bd9Sstevel@tonic-gate dtrace_hdl_t *dtp = yypcb->pcb_hdl; 30507c478bd9Sstevel@tonic-gate dt_node_t *lp = dnp->dn_left; 30517c478bd9Sstevel@tonic-gate dt_node_t *rp = dnp->dn_right; 30527c478bd9Sstevel@tonic-gate int op = dnp->dn_op; 30537c478bd9Sstevel@tonic-gate 30547c478bd9Sstevel@tonic-gate ctf_membinfo_t m; 30557c478bd9Sstevel@tonic-gate ctf_file_t *ctfp; 30567c478bd9Sstevel@tonic-gate ctf_id_t type; 30577c478bd9Sstevel@tonic-gate int kind, val, uref; 30587c478bd9Sstevel@tonic-gate dt_ident_t *idp; 30597c478bd9Sstevel@tonic-gate 30607c478bd9Sstevel@tonic-gate char n1[DT_TYPE_NAMELEN]; 30617c478bd9Sstevel@tonic-gate char n2[DT_TYPE_NAMELEN]; 30627c478bd9Sstevel@tonic-gate 30637c478bd9Sstevel@tonic-gate /* 30647c478bd9Sstevel@tonic-gate * The expression E1[E2] is identical by definition to *((E1)+(E2)) so 30657c478bd9Sstevel@tonic-gate * we convert "[" to "+" and glue on "*" at the end (see K&R[A7.3.1]) 30667c478bd9Sstevel@tonic-gate * unless the left-hand side is an untyped D scalar, associative array, 30677c478bd9Sstevel@tonic-gate * or aggregation. In these cases, we proceed to case DT_TOK_LBRAC and 30687c478bd9Sstevel@tonic-gate * handle associative array and aggregation references there. 30697c478bd9Sstevel@tonic-gate */ 30707c478bd9Sstevel@tonic-gate if (op == DT_TOK_LBRAC) { 30717c478bd9Sstevel@tonic-gate if (lp->dn_kind == DT_NODE_IDENT) { 30727c478bd9Sstevel@tonic-gate dt_idhash_t *dhp; 30737c478bd9Sstevel@tonic-gate uint_t idkind; 30747c478bd9Sstevel@tonic-gate 30757c478bd9Sstevel@tonic-gate if (lp->dn_op == DT_TOK_AGG) { 30767c478bd9Sstevel@tonic-gate dhp = dtp->dt_aggs; 30777c478bd9Sstevel@tonic-gate idp = dt_idhash_lookup(dhp, lp->dn_string + 1); 30787c478bd9Sstevel@tonic-gate idkind = DT_IDENT_AGG; 30797c478bd9Sstevel@tonic-gate } else { 30807c478bd9Sstevel@tonic-gate dhp = dtp->dt_globals; 30817c478bd9Sstevel@tonic-gate idp = dt_idstack_lookup( 30827c478bd9Sstevel@tonic-gate &yypcb->pcb_globals, lp->dn_string); 30837c478bd9Sstevel@tonic-gate idkind = DT_IDENT_ARRAY; 30847c478bd9Sstevel@tonic-gate } 30857c478bd9Sstevel@tonic-gate 30867c478bd9Sstevel@tonic-gate if (idp == NULL || dt_ident_unref(idp)) 30877c478bd9Sstevel@tonic-gate dt_xcook_ident(lp, dhp, idkind, B_TRUE); 30887c478bd9Sstevel@tonic-gate else 30897c478bd9Sstevel@tonic-gate dt_xcook_ident(lp, dhp, idp->di_kind, B_FALSE); 30907c478bd9Sstevel@tonic-gate } else 30917c478bd9Sstevel@tonic-gate lp = dnp->dn_left = dt_node_cook(lp, 0); 30927c478bd9Sstevel@tonic-gate 30937c478bd9Sstevel@tonic-gate /* 30947c478bd9Sstevel@tonic-gate * Switch op to '+' for *(E1 + E2) array mode in these cases: 30957c478bd9Sstevel@tonic-gate * (a) lp is a DT_IDENT_ARRAY variable that has already been 30967c478bd9Sstevel@tonic-gate * referenced using [] notation (dn_args != NULL). 30977c478bd9Sstevel@tonic-gate * (b) lp is a non-ARRAY variable that has already been given 30987c478bd9Sstevel@tonic-gate * a type by assignment or declaration (!dt_ident_unref()) 30997c478bd9Sstevel@tonic-gate * (c) lp is neither a variable nor an aggregation 31007c478bd9Sstevel@tonic-gate */ 31017c478bd9Sstevel@tonic-gate if (lp->dn_kind == DT_NODE_VAR) { 31027c478bd9Sstevel@tonic-gate if (lp->dn_ident->di_kind == DT_IDENT_ARRAY) { 31037c478bd9Sstevel@tonic-gate if (lp->dn_args != NULL) 31047c478bd9Sstevel@tonic-gate op = DT_TOK_ADD; 31057c478bd9Sstevel@tonic-gate } else if (!dt_ident_unref(lp->dn_ident)) 31067c478bd9Sstevel@tonic-gate op = DT_TOK_ADD; 31077c478bd9Sstevel@tonic-gate } else if (lp->dn_kind != DT_NODE_AGG) 31087c478bd9Sstevel@tonic-gate op = DT_TOK_ADD; 31097c478bd9Sstevel@tonic-gate } 31107c478bd9Sstevel@tonic-gate 31117c478bd9Sstevel@tonic-gate switch (op) { 31127c478bd9Sstevel@tonic-gate case DT_TOK_BAND: 31137c478bd9Sstevel@tonic-gate case DT_TOK_XOR: 31147c478bd9Sstevel@tonic-gate case DT_TOK_BOR: 31157c478bd9Sstevel@tonic-gate lp = dnp->dn_left = dt_node_cook(lp, DT_IDFLG_REF); 31167c478bd9Sstevel@tonic-gate rp = dnp->dn_right = dt_node_cook(rp, DT_IDFLG_REF); 31177c478bd9Sstevel@tonic-gate 31187c478bd9Sstevel@tonic-gate if (!dt_node_is_integer(lp) || !dt_node_is_integer(rp)) { 31197c478bd9Sstevel@tonic-gate xyerror(D_OP_INT, "operator %s requires operands of " 31207c478bd9Sstevel@tonic-gate "integral type\n", opstr(op)); 31217c478bd9Sstevel@tonic-gate } 31227c478bd9Sstevel@tonic-gate 31237c478bd9Sstevel@tonic-gate dt_node_promote(lp, rp, dnp); /* see K&R[A7.11-13] */ 31247c478bd9Sstevel@tonic-gate break; 31257c478bd9Sstevel@tonic-gate 31267c478bd9Sstevel@tonic-gate case DT_TOK_LSH: 31277c478bd9Sstevel@tonic-gate case DT_TOK_RSH: 31287c478bd9Sstevel@tonic-gate lp = dnp->dn_left = dt_node_cook(lp, DT_IDFLG_REF); 31297c478bd9Sstevel@tonic-gate rp = dnp->dn_right = dt_node_cook(rp, DT_IDFLG_REF); 31307c478bd9Sstevel@tonic-gate 31317c478bd9Sstevel@tonic-gate if (!dt_node_is_integer(lp) || !dt_node_is_integer(rp)) { 31327c478bd9Sstevel@tonic-gate xyerror(D_OP_INT, "operator %s requires operands of " 31337c478bd9Sstevel@tonic-gate "integral type\n", opstr(op)); 31347c478bd9Sstevel@tonic-gate } 31357c478bd9Sstevel@tonic-gate 31367c478bd9Sstevel@tonic-gate dt_node_type_propagate(lp, dnp); /* see K&R[A7.8] */ 31377c478bd9Sstevel@tonic-gate dt_node_attr_assign(dnp, dt_attr_min(lp->dn_attr, rp->dn_attr)); 31387c478bd9Sstevel@tonic-gate break; 31397c478bd9Sstevel@tonic-gate 31407c478bd9Sstevel@tonic-gate case DT_TOK_MOD: 31417c478bd9Sstevel@tonic-gate lp = dnp->dn_left = dt_node_cook(lp, DT_IDFLG_REF); 31427c478bd9Sstevel@tonic-gate rp = dnp->dn_right = dt_node_cook(rp, DT_IDFLG_REF); 31437c478bd9Sstevel@tonic-gate 31447c478bd9Sstevel@tonic-gate if (!dt_node_is_integer(lp) || !dt_node_is_integer(rp)) { 31457c478bd9Sstevel@tonic-gate xyerror(D_OP_INT, "operator %s requires operands of " 31467c478bd9Sstevel@tonic-gate "integral type\n", opstr(op)); 31477c478bd9Sstevel@tonic-gate } 31487c478bd9Sstevel@tonic-gate 31497c478bd9Sstevel@tonic-gate dt_node_promote(lp, rp, dnp); /* see K&R[A7.6] */ 31507c478bd9Sstevel@tonic-gate break; 31517c478bd9Sstevel@tonic-gate 31527c478bd9Sstevel@tonic-gate case DT_TOK_MUL: 31537c478bd9Sstevel@tonic-gate case DT_TOK_DIV: 31547c478bd9Sstevel@tonic-gate lp = dnp->dn_left = dt_node_cook(lp, DT_IDFLG_REF); 31557c478bd9Sstevel@tonic-gate rp = dnp->dn_right = dt_node_cook(rp, DT_IDFLG_REF); 31567c478bd9Sstevel@tonic-gate 31577c478bd9Sstevel@tonic-gate if (!dt_node_is_arith(lp) || !dt_node_is_arith(rp)) { 31587c478bd9Sstevel@tonic-gate xyerror(D_OP_ARITH, "operator %s requires operands of " 31597c478bd9Sstevel@tonic-gate "arithmetic type\n", opstr(op)); 31607c478bd9Sstevel@tonic-gate } 31617c478bd9Sstevel@tonic-gate 31627c478bd9Sstevel@tonic-gate dt_node_promote(lp, rp, dnp); /* see K&R[A7.6] */ 31637c478bd9Sstevel@tonic-gate break; 31647c478bd9Sstevel@tonic-gate 31657c478bd9Sstevel@tonic-gate case DT_TOK_LAND: 31667c478bd9Sstevel@tonic-gate case DT_TOK_LXOR: 31677c478bd9Sstevel@tonic-gate case DT_TOK_LOR: 31687c478bd9Sstevel@tonic-gate lp = dnp->dn_left = dt_node_cook(lp, DT_IDFLG_REF); 31697c478bd9Sstevel@tonic-gate rp = dnp->dn_right = dt_node_cook(rp, DT_IDFLG_REF); 31707c478bd9Sstevel@tonic-gate 31717c478bd9Sstevel@tonic-gate if (!dt_node_is_scalar(lp) || !dt_node_is_scalar(rp)) { 31727c478bd9Sstevel@tonic-gate xyerror(D_OP_SCALAR, "operator %s requires operands " 31737c478bd9Sstevel@tonic-gate "of scalar type\n", opstr(op)); 31747c478bd9Sstevel@tonic-gate } 31757c478bd9Sstevel@tonic-gate 31767c478bd9Sstevel@tonic-gate dt_node_type_assign(dnp, DT_INT_CTFP(dtp), DT_INT_TYPE(dtp)); 31777c478bd9Sstevel@tonic-gate dt_node_attr_assign(dnp, dt_attr_min(lp->dn_attr, rp->dn_attr)); 31787c478bd9Sstevel@tonic-gate break; 31797c478bd9Sstevel@tonic-gate 31807c478bd9Sstevel@tonic-gate case DT_TOK_LT: 31817c478bd9Sstevel@tonic-gate case DT_TOK_LE: 31827c478bd9Sstevel@tonic-gate case DT_TOK_GT: 31837c478bd9Sstevel@tonic-gate case DT_TOK_GE: 31847c478bd9Sstevel@tonic-gate case DT_TOK_EQU: 31857c478bd9Sstevel@tonic-gate case DT_TOK_NEQ: 31867c478bd9Sstevel@tonic-gate /* 31877c478bd9Sstevel@tonic-gate * The D comparison operators provide the ability to transform 31887c478bd9Sstevel@tonic-gate * a right-hand identifier into a corresponding enum tag value 31897c478bd9Sstevel@tonic-gate * if the left-hand side is an enum type. To do this, we cook 31907c478bd9Sstevel@tonic-gate * the left-hand side, and then see if the right-hand side is 31917c478bd9Sstevel@tonic-gate * an unscoped identifier defined in the enum. If so, we 31927c478bd9Sstevel@tonic-gate * convert into an integer constant node with the tag's value. 31937c478bd9Sstevel@tonic-gate */ 31947c478bd9Sstevel@tonic-gate lp = dnp->dn_left = dt_node_cook(lp, DT_IDFLG_REF); 31957c478bd9Sstevel@tonic-gate 31967c478bd9Sstevel@tonic-gate kind = ctf_type_kind(lp->dn_ctfp, 31977c478bd9Sstevel@tonic-gate ctf_type_resolve(lp->dn_ctfp, lp->dn_type)); 31987c478bd9Sstevel@tonic-gate 31997c478bd9Sstevel@tonic-gate if (kind == CTF_K_ENUM && rp->dn_kind == DT_NODE_IDENT && 32007c478bd9Sstevel@tonic-gate strchr(rp->dn_string, '`') == NULL && ctf_enum_value( 32017c478bd9Sstevel@tonic-gate lp->dn_ctfp, lp->dn_type, rp->dn_string, &val) == 0) { 32027c478bd9Sstevel@tonic-gate 32037c478bd9Sstevel@tonic-gate if ((idp = dt_idstack_lookup(&yypcb->pcb_globals, 32047c478bd9Sstevel@tonic-gate rp->dn_string)) != NULL) { 32057c478bd9Sstevel@tonic-gate xyerror(D_IDENT_AMBIG, 32067c478bd9Sstevel@tonic-gate "ambiguous use of operator %s: %s is " 32077c478bd9Sstevel@tonic-gate "both a %s enum tag and a global %s\n", 32087c478bd9Sstevel@tonic-gate opstr(op), rp->dn_string, 32097c478bd9Sstevel@tonic-gate dt_node_type_name(lp, n1, sizeof (n1)), 32107c478bd9Sstevel@tonic-gate dt_idkind_name(idp->di_kind)); 32117c478bd9Sstevel@tonic-gate } 32127c478bd9Sstevel@tonic-gate 32137c478bd9Sstevel@tonic-gate free(rp->dn_string); 32147c478bd9Sstevel@tonic-gate rp->dn_string = NULL; 32157c478bd9Sstevel@tonic-gate rp->dn_kind = DT_NODE_INT; 32167c478bd9Sstevel@tonic-gate rp->dn_flags |= DT_NF_COOKED; 32177c478bd9Sstevel@tonic-gate rp->dn_op = DT_TOK_INT; 32187c478bd9Sstevel@tonic-gate rp->dn_value = (intmax_t)val; 32197c478bd9Sstevel@tonic-gate 32207c478bd9Sstevel@tonic-gate dt_node_type_assign(rp, lp->dn_ctfp, lp->dn_type); 32217c478bd9Sstevel@tonic-gate dt_node_attr_assign(rp, _dtrace_symattr); 32227c478bd9Sstevel@tonic-gate } 32237c478bd9Sstevel@tonic-gate 32247c478bd9Sstevel@tonic-gate rp = dnp->dn_right = dt_node_cook(rp, DT_IDFLG_REF); 32257c478bd9Sstevel@tonic-gate 32267c478bd9Sstevel@tonic-gate /* 32277c478bd9Sstevel@tonic-gate * The rules for type checking for the relational operators are 32287c478bd9Sstevel@tonic-gate * described in the ANSI-C spec (see K&R[A7.9-10]). We perform 32297c478bd9Sstevel@tonic-gate * the various tests in order from least to most expensive. We 32307c478bd9Sstevel@tonic-gate * also allow derived strings to be compared as a first-class 32317c478bd9Sstevel@tonic-gate * type (resulting in a strcmp(3C)-style comparison), and we 32327c478bd9Sstevel@tonic-gate * slightly relax the A7.9 rules to permit void pointer 32337c478bd9Sstevel@tonic-gate * comparisons as in A7.10. Our users won't be confused by 32347c478bd9Sstevel@tonic-gate * this since they understand pointers are just numbers, and 32357c478bd9Sstevel@tonic-gate * relaxing this constraint simplifies the implementation. 32367c478bd9Sstevel@tonic-gate */ 32377c478bd9Sstevel@tonic-gate if (ctf_type_compat(lp->dn_ctfp, lp->dn_type, 32387c478bd9Sstevel@tonic-gate rp->dn_ctfp, rp->dn_type)) 32397c478bd9Sstevel@tonic-gate /*EMPTY*/; 32407c478bd9Sstevel@tonic-gate else if (dt_node_is_integer(lp) && dt_node_is_integer(rp)) 32417c478bd9Sstevel@tonic-gate /*EMPTY*/; 32427c478bd9Sstevel@tonic-gate else if (dt_node_is_strcompat(lp) && dt_node_is_strcompat(rp) && 32437c478bd9Sstevel@tonic-gate (dt_node_is_string(lp) || dt_node_is_string(rp))) 32447c478bd9Sstevel@tonic-gate /*EMPTY*/; 32457c478bd9Sstevel@tonic-gate else if (dt_node_is_ptrcompat(lp, rp, NULL, NULL) == 0) { 32467c478bd9Sstevel@tonic-gate xyerror(D_OP_INCOMPAT, "operands have " 32477c478bd9Sstevel@tonic-gate "incompatible types: \"%s\" %s \"%s\"\n", 32487c478bd9Sstevel@tonic-gate dt_node_type_name(lp, n1, sizeof (n1)), opstr(op), 32497c478bd9Sstevel@tonic-gate dt_node_type_name(rp, n2, sizeof (n2))); 32507c478bd9Sstevel@tonic-gate } 32517c478bd9Sstevel@tonic-gate 32527c478bd9Sstevel@tonic-gate dt_node_type_assign(dnp, DT_INT_CTFP(dtp), DT_INT_TYPE(dtp)); 32537c478bd9Sstevel@tonic-gate dt_node_attr_assign(dnp, dt_attr_min(lp->dn_attr, rp->dn_attr)); 32547c478bd9Sstevel@tonic-gate break; 32557c478bd9Sstevel@tonic-gate 32567c478bd9Sstevel@tonic-gate case DT_TOK_ADD: 32577c478bd9Sstevel@tonic-gate case DT_TOK_SUB: { 32587c478bd9Sstevel@tonic-gate /* 32597c478bd9Sstevel@tonic-gate * The rules for type checking for the additive operators are 32607c478bd9Sstevel@tonic-gate * described in the ANSI-C spec (see K&R[A7.7]). Pointers and 32617c478bd9Sstevel@tonic-gate * integers may be manipulated according to specific rules. 32627c478bd9Sstevel@tonic-gate */ 32637c478bd9Sstevel@tonic-gate int lp_is_ptr, lp_is_int, rp_is_ptr, rp_is_int; 32647c478bd9Sstevel@tonic-gate 32657c478bd9Sstevel@tonic-gate lp = dnp->dn_left = dt_node_cook(lp, DT_IDFLG_REF); 32667c478bd9Sstevel@tonic-gate rp = dnp->dn_right = dt_node_cook(rp, DT_IDFLG_REF); 32677c478bd9Sstevel@tonic-gate 32687c478bd9Sstevel@tonic-gate lp_is_ptr = dt_node_is_pointer(lp) && !dt_node_is_vfptr(lp); 32697c478bd9Sstevel@tonic-gate lp_is_int = dt_node_is_integer(lp); 32707c478bd9Sstevel@tonic-gate 32717c478bd9Sstevel@tonic-gate rp_is_ptr = dt_node_is_pointer(rp) && !dt_node_is_vfptr(rp); 32727c478bd9Sstevel@tonic-gate rp_is_int = dt_node_is_integer(rp); 32737c478bd9Sstevel@tonic-gate 32747c478bd9Sstevel@tonic-gate if (lp_is_int && rp_is_int) { 32757c478bd9Sstevel@tonic-gate dt_type_promote(lp, rp, &ctfp, &type); 32767c478bd9Sstevel@tonic-gate uref = 0; 32777c478bd9Sstevel@tonic-gate } else if (lp_is_ptr && rp_is_int) { 32787c478bd9Sstevel@tonic-gate ctfp = lp->dn_ctfp; 32797c478bd9Sstevel@tonic-gate type = lp->dn_type; 32807c478bd9Sstevel@tonic-gate uref = lp->dn_flags & DT_NF_USERLAND; 32817c478bd9Sstevel@tonic-gate } else if (lp_is_int && rp_is_ptr && op == DT_TOK_ADD) { 32827c478bd9Sstevel@tonic-gate ctfp = rp->dn_ctfp; 32837c478bd9Sstevel@tonic-gate type = rp->dn_type; 32847c478bd9Sstevel@tonic-gate uref = rp->dn_flags & DT_NF_USERLAND; 32857c478bd9Sstevel@tonic-gate } else if (lp_is_ptr && rp_is_ptr && op == DT_TOK_SUB && 32867c478bd9Sstevel@tonic-gate dt_node_is_ptrcompat(lp, rp, NULL, NULL)) { 32877c478bd9Sstevel@tonic-gate ctfp = dtp->dt_ddefs->dm_ctfp; 32887c478bd9Sstevel@tonic-gate type = ctf_lookup_by_name(ctfp, "ptrdiff_t"); 32897c478bd9Sstevel@tonic-gate uref = 0; 32907c478bd9Sstevel@tonic-gate } else { 32917c478bd9Sstevel@tonic-gate xyerror(D_OP_INCOMPAT, "operands have incompatible " 32927c478bd9Sstevel@tonic-gate "types: \"%s\" %s \"%s\"\n", 32937c478bd9Sstevel@tonic-gate dt_node_type_name(lp, n1, sizeof (n1)), opstr(op), 32947c478bd9Sstevel@tonic-gate dt_node_type_name(rp, n2, sizeof (n2))); 32957c478bd9Sstevel@tonic-gate } 32967c478bd9Sstevel@tonic-gate 32977c478bd9Sstevel@tonic-gate dt_node_type_assign(dnp, ctfp, type); 32987c478bd9Sstevel@tonic-gate dt_node_attr_assign(dnp, dt_attr_min(lp->dn_attr, rp->dn_attr)); 32997c478bd9Sstevel@tonic-gate 33007c478bd9Sstevel@tonic-gate if (uref) 33017c478bd9Sstevel@tonic-gate dnp->dn_flags |= DT_NF_USERLAND; 33027c478bd9Sstevel@tonic-gate break; 33037c478bd9Sstevel@tonic-gate } 33047c478bd9Sstevel@tonic-gate 33057c478bd9Sstevel@tonic-gate case DT_TOK_OR_EQ: 33067c478bd9Sstevel@tonic-gate case DT_TOK_XOR_EQ: 33077c478bd9Sstevel@tonic-gate case DT_TOK_AND_EQ: 33087c478bd9Sstevel@tonic-gate case DT_TOK_LSH_EQ: 33097c478bd9Sstevel@tonic-gate case DT_TOK_RSH_EQ: 33107c478bd9Sstevel@tonic-gate case DT_TOK_MOD_EQ: 33117c478bd9Sstevel@tonic-gate if (lp->dn_kind == DT_NODE_IDENT) { 33127c478bd9Sstevel@tonic-gate dt_xcook_ident(lp, dtp->dt_globals, 33137c478bd9Sstevel@tonic-gate DT_IDENT_SCALAR, B_TRUE); 33147c478bd9Sstevel@tonic-gate } 33157c478bd9Sstevel@tonic-gate 33167c478bd9Sstevel@tonic-gate lp = dnp->dn_left = 33177c478bd9Sstevel@tonic-gate dt_node_cook(lp, DT_IDFLG_REF | DT_IDFLG_MOD); 33187c478bd9Sstevel@tonic-gate 33197c478bd9Sstevel@tonic-gate rp = dnp->dn_right = 33207c478bd9Sstevel@tonic-gate dt_node_cook(rp, DT_IDFLG_REF | DT_IDFLG_MOD); 33217c478bd9Sstevel@tonic-gate 33227c478bd9Sstevel@tonic-gate if (!dt_node_is_integer(lp) || !dt_node_is_integer(rp)) { 33237c478bd9Sstevel@tonic-gate xyerror(D_OP_INT, "operator %s requires operands of " 33247c478bd9Sstevel@tonic-gate "integral type\n", opstr(op)); 33257c478bd9Sstevel@tonic-gate } 33267c478bd9Sstevel@tonic-gate goto asgn_common; 33277c478bd9Sstevel@tonic-gate 33287c478bd9Sstevel@tonic-gate case DT_TOK_MUL_EQ: 33297c478bd9Sstevel@tonic-gate case DT_TOK_DIV_EQ: 33307c478bd9Sstevel@tonic-gate if (lp->dn_kind == DT_NODE_IDENT) { 33317c478bd9Sstevel@tonic-gate dt_xcook_ident(lp, dtp->dt_globals, 33327c478bd9Sstevel@tonic-gate DT_IDENT_SCALAR, B_TRUE); 33337c478bd9Sstevel@tonic-gate } 33347c478bd9Sstevel@tonic-gate 33357c478bd9Sstevel@tonic-gate lp = dnp->dn_left = 33367c478bd9Sstevel@tonic-gate dt_node_cook(lp, DT_IDFLG_REF | DT_IDFLG_MOD); 33377c478bd9Sstevel@tonic-gate 33387c478bd9Sstevel@tonic-gate rp = dnp->dn_right = 33397c478bd9Sstevel@tonic-gate dt_node_cook(rp, DT_IDFLG_REF | DT_IDFLG_MOD); 33407c478bd9Sstevel@tonic-gate 33417c478bd9Sstevel@tonic-gate if (!dt_node_is_arith(lp) || !dt_node_is_arith(rp)) { 33427c478bd9Sstevel@tonic-gate xyerror(D_OP_ARITH, "operator %s requires operands of " 33437c478bd9Sstevel@tonic-gate "arithmetic type\n", opstr(op)); 33447c478bd9Sstevel@tonic-gate } 33457c478bd9Sstevel@tonic-gate goto asgn_common; 33467c478bd9Sstevel@tonic-gate 33477c478bd9Sstevel@tonic-gate case DT_TOK_ASGN: 33487c478bd9Sstevel@tonic-gate /* 33497c478bd9Sstevel@tonic-gate * If the left-hand side is an identifier, attempt to resolve 33507c478bd9Sstevel@tonic-gate * it as either an aggregation or scalar variable. We pass 33517c478bd9Sstevel@tonic-gate * B_TRUE to dt_xcook_ident to indicate that a new variable can 33527c478bd9Sstevel@tonic-gate * be created if no matching variable exists in the namespace. 33537c478bd9Sstevel@tonic-gate */ 33547c478bd9Sstevel@tonic-gate if (lp->dn_kind == DT_NODE_IDENT) { 33557c478bd9Sstevel@tonic-gate if (lp->dn_op == DT_TOK_AGG) { 33567c478bd9Sstevel@tonic-gate dt_xcook_ident(lp, dtp->dt_aggs, 33577c478bd9Sstevel@tonic-gate DT_IDENT_AGG, B_TRUE); 33587c478bd9Sstevel@tonic-gate } else { 33597c478bd9Sstevel@tonic-gate dt_xcook_ident(lp, dtp->dt_globals, 33607c478bd9Sstevel@tonic-gate DT_IDENT_SCALAR, B_TRUE); 33617c478bd9Sstevel@tonic-gate } 33627c478bd9Sstevel@tonic-gate } 33637c478bd9Sstevel@tonic-gate 33647c478bd9Sstevel@tonic-gate lp = dnp->dn_left = dt_node_cook(lp, 0); /* don't set mod yet */ 33657c478bd9Sstevel@tonic-gate rp = dnp->dn_right = dt_node_cook(rp, DT_IDFLG_REF); 33667c478bd9Sstevel@tonic-gate 33677c478bd9Sstevel@tonic-gate /* 33687c478bd9Sstevel@tonic-gate * If the left-hand side is an aggregation, verify that we are 33697c478bd9Sstevel@tonic-gate * assigning it the result of an aggregating function. Once 33707c478bd9Sstevel@tonic-gate * we've done so, hide the func node in the aggregation and 33717c478bd9Sstevel@tonic-gate * return the aggregation itself up to the parse tree parent. 33727c478bd9Sstevel@tonic-gate * This transformation is legal since the assigned function 33737c478bd9Sstevel@tonic-gate * cannot change identity across disjoint cooking passes and 33747c478bd9Sstevel@tonic-gate * the argument list subtree is retained for later cooking. 33757c478bd9Sstevel@tonic-gate */ 33767c478bd9Sstevel@tonic-gate if (lp->dn_kind == DT_NODE_AGG) { 33777c478bd9Sstevel@tonic-gate const char *aname = lp->dn_ident->di_name; 33787c478bd9Sstevel@tonic-gate dt_ident_t *oid = lp->dn_ident->di_iarg; 33797c478bd9Sstevel@tonic-gate 33807c478bd9Sstevel@tonic-gate if (rp->dn_kind != DT_NODE_FUNC || 33817c478bd9Sstevel@tonic-gate rp->dn_ident->di_kind != DT_IDENT_AGGFUNC) { 33827c478bd9Sstevel@tonic-gate xyerror(D_AGG_FUNC, 33837c478bd9Sstevel@tonic-gate "@%s must be assigned the result of " 33847c478bd9Sstevel@tonic-gate "an aggregating function\n", aname); 33857c478bd9Sstevel@tonic-gate } 33867c478bd9Sstevel@tonic-gate 33877c478bd9Sstevel@tonic-gate if (oid != NULL && oid != rp->dn_ident) { 33887c478bd9Sstevel@tonic-gate xyerror(D_AGG_REDEF, 33897c478bd9Sstevel@tonic-gate "aggregation redefined: @%s\n\t " 33907c478bd9Sstevel@tonic-gate "current: @%s = %s( )\n\tprevious: @%s = " 33917c478bd9Sstevel@tonic-gate "%s( ) : line %d\n", aname, aname, 33927c478bd9Sstevel@tonic-gate rp->dn_ident->di_name, aname, oid->di_name, 33937c478bd9Sstevel@tonic-gate lp->dn_ident->di_lineno); 33947c478bd9Sstevel@tonic-gate } else if (oid == NULL) 33957c478bd9Sstevel@tonic-gate lp->dn_ident->di_iarg = rp->dn_ident; 33967c478bd9Sstevel@tonic-gate 33977c478bd9Sstevel@tonic-gate /* 33987c478bd9Sstevel@tonic-gate * Do not allow multiple aggregation assignments in a 33997c478bd9Sstevel@tonic-gate * single statement, e.g. (@a = count()) = count(); 34007c478bd9Sstevel@tonic-gate * We produce a message as if the result of aggregating 34017c478bd9Sstevel@tonic-gate * function does not propagate DT_NF_LVALUE. 34027c478bd9Sstevel@tonic-gate */ 34037c478bd9Sstevel@tonic-gate if (lp->dn_aggfun != NULL) { 34047c478bd9Sstevel@tonic-gate xyerror(D_OP_LVAL, "operator = requires " 34057c478bd9Sstevel@tonic-gate "modifiable lvalue as an operand\n"); 34067c478bd9Sstevel@tonic-gate } 34077c478bd9Sstevel@tonic-gate 34087c478bd9Sstevel@tonic-gate lp->dn_aggfun = rp; 34097c478bd9Sstevel@tonic-gate lp = dt_node_cook(lp, DT_IDFLG_MOD); 34107c478bd9Sstevel@tonic-gate 34117c478bd9Sstevel@tonic-gate dnp->dn_left = dnp->dn_right = NULL; 34127c478bd9Sstevel@tonic-gate dt_node_free(dnp); 34137c478bd9Sstevel@tonic-gate 34147c478bd9Sstevel@tonic-gate return (lp); 34157c478bd9Sstevel@tonic-gate } 34167c478bd9Sstevel@tonic-gate 34177c478bd9Sstevel@tonic-gate /* 34187c478bd9Sstevel@tonic-gate * If the right-hand side is a dynamic variable that is the 34197c478bd9Sstevel@tonic-gate * output of a translator, our result is the translated type. 34207c478bd9Sstevel@tonic-gate */ 34217c478bd9Sstevel@tonic-gate if ((idp = dt_node_resolve(rp, DT_IDENT_XLSOU)) != NULL) { 34227c478bd9Sstevel@tonic-gate ctfp = idp->di_ctfp; 34237c478bd9Sstevel@tonic-gate type = idp->di_type; 34247c478bd9Sstevel@tonic-gate uref = idp->di_flags & DT_IDFLG_USER; 34257c478bd9Sstevel@tonic-gate } else { 34267c478bd9Sstevel@tonic-gate ctfp = rp->dn_ctfp; 34277c478bd9Sstevel@tonic-gate type = rp->dn_type; 34287c478bd9Sstevel@tonic-gate uref = rp->dn_flags & DT_NF_USERLAND; 34297c478bd9Sstevel@tonic-gate } 34307c478bd9Sstevel@tonic-gate 34317c478bd9Sstevel@tonic-gate /* 34327c478bd9Sstevel@tonic-gate * If the left-hand side of an assignment statement is a virgin 34337c478bd9Sstevel@tonic-gate * variable created by this compilation pass, reset the type of 34347c478bd9Sstevel@tonic-gate * this variable to the type of the right-hand side. 34357c478bd9Sstevel@tonic-gate */ 34367c478bd9Sstevel@tonic-gate if (lp->dn_kind == DT_NODE_VAR && 34377c478bd9Sstevel@tonic-gate dt_ident_unref(lp->dn_ident)) { 34387c478bd9Sstevel@tonic-gate dt_node_type_assign(lp, ctfp, type); 34397c478bd9Sstevel@tonic-gate dt_ident_type_assign(lp->dn_ident, ctfp, type); 34407c478bd9Sstevel@tonic-gate 34417c478bd9Sstevel@tonic-gate if (uref) { 34427c478bd9Sstevel@tonic-gate lp->dn_flags |= DT_NF_USERLAND; 34437c478bd9Sstevel@tonic-gate lp->dn_ident->di_flags |= DT_IDFLG_USER; 34447c478bd9Sstevel@tonic-gate } 34457c478bd9Sstevel@tonic-gate } 34467c478bd9Sstevel@tonic-gate 34477c478bd9Sstevel@tonic-gate if (lp->dn_kind == DT_NODE_VAR) 34487c478bd9Sstevel@tonic-gate lp->dn_ident->di_flags |= DT_IDFLG_MOD; 34497c478bd9Sstevel@tonic-gate 34507c478bd9Sstevel@tonic-gate /* 34517c478bd9Sstevel@tonic-gate * The rules for type checking for the assignment operators are 34527c478bd9Sstevel@tonic-gate * described in the ANSI-C spec (see K&R[A7.17]). We share 34537c478bd9Sstevel@tonic-gate * most of this code with the argument list checking code. 34547c478bd9Sstevel@tonic-gate */ 34557c478bd9Sstevel@tonic-gate if (!dt_node_is_string(lp)) { 34567c478bd9Sstevel@tonic-gate kind = ctf_type_kind(lp->dn_ctfp, 34577c478bd9Sstevel@tonic-gate ctf_type_resolve(lp->dn_ctfp, lp->dn_type)); 34587c478bd9Sstevel@tonic-gate 34597c478bd9Sstevel@tonic-gate if (kind == CTF_K_ARRAY || kind == CTF_K_FUNCTION) { 34607c478bd9Sstevel@tonic-gate xyerror(D_OP_ARRFUN, "operator %s may not be " 34617c478bd9Sstevel@tonic-gate "applied to operand of type \"%s\"\n", 34627c478bd9Sstevel@tonic-gate opstr(op), 34637c478bd9Sstevel@tonic-gate dt_node_type_name(lp, n1, sizeof (n1))); 34647c478bd9Sstevel@tonic-gate } 34657c478bd9Sstevel@tonic-gate } 34667c478bd9Sstevel@tonic-gate 34677c478bd9Sstevel@tonic-gate if (idp != NULL && idp->di_kind == DT_IDENT_XLSOU && 34687c478bd9Sstevel@tonic-gate ctf_type_compat(lp->dn_ctfp, lp->dn_type, ctfp, type)) 34697c478bd9Sstevel@tonic-gate goto asgn_common; 34707c478bd9Sstevel@tonic-gate 34717c478bd9Sstevel@tonic-gate if (dt_node_is_argcompat(lp, rp)) 34727c478bd9Sstevel@tonic-gate goto asgn_common; 34737c478bd9Sstevel@tonic-gate 34747c478bd9Sstevel@tonic-gate xyerror(D_OP_INCOMPAT, 34757c478bd9Sstevel@tonic-gate "operands have incompatible types: \"%s\" %s \"%s\"\n", 34767c478bd9Sstevel@tonic-gate dt_node_type_name(lp, n1, sizeof (n1)), opstr(op), 34777c478bd9Sstevel@tonic-gate dt_node_type_name(rp, n2, sizeof (n2))); 34787c478bd9Sstevel@tonic-gate /*NOTREACHED*/ 34797c478bd9Sstevel@tonic-gate 34807c478bd9Sstevel@tonic-gate case DT_TOK_ADD_EQ: 34817c478bd9Sstevel@tonic-gate case DT_TOK_SUB_EQ: 34827c478bd9Sstevel@tonic-gate if (lp->dn_kind == DT_NODE_IDENT) { 34837c478bd9Sstevel@tonic-gate dt_xcook_ident(lp, dtp->dt_globals, 34847c478bd9Sstevel@tonic-gate DT_IDENT_SCALAR, B_TRUE); 34857c478bd9Sstevel@tonic-gate } 34867c478bd9Sstevel@tonic-gate 34877c478bd9Sstevel@tonic-gate lp = dnp->dn_left = 34887c478bd9Sstevel@tonic-gate dt_node_cook(lp, DT_IDFLG_REF | DT_IDFLG_MOD); 34897c478bd9Sstevel@tonic-gate 34907c478bd9Sstevel@tonic-gate rp = dnp->dn_right = 34917c478bd9Sstevel@tonic-gate dt_node_cook(rp, DT_IDFLG_REF | DT_IDFLG_MOD); 34927c478bd9Sstevel@tonic-gate 34937c478bd9Sstevel@tonic-gate if (dt_node_is_string(lp) || dt_node_is_string(rp)) { 34947c478bd9Sstevel@tonic-gate xyerror(D_OP_INCOMPAT, "operands have " 34957c478bd9Sstevel@tonic-gate "incompatible types: \"%s\" %s \"%s\"\n", 34967c478bd9Sstevel@tonic-gate dt_node_type_name(lp, n1, sizeof (n1)), opstr(op), 34977c478bd9Sstevel@tonic-gate dt_node_type_name(rp, n2, sizeof (n2))); 34987c478bd9Sstevel@tonic-gate } 34997c478bd9Sstevel@tonic-gate 35007c478bd9Sstevel@tonic-gate /* 35017c478bd9Sstevel@tonic-gate * The rules for type checking for the assignment operators are 35027c478bd9Sstevel@tonic-gate * described in the ANSI-C spec (see K&R[A7.17]). To these 35037c478bd9Sstevel@tonic-gate * rules we add that only writable D nodes can be modified. 35047c478bd9Sstevel@tonic-gate */ 35057c478bd9Sstevel@tonic-gate if (dt_node_is_integer(lp) == 0 || 35067c478bd9Sstevel@tonic-gate dt_node_is_integer(rp) == 0) { 35077c478bd9Sstevel@tonic-gate if (!dt_node_is_pointer(lp) || dt_node_is_vfptr(lp)) { 35087c478bd9Sstevel@tonic-gate xyerror(D_OP_VFPTR, 35097c478bd9Sstevel@tonic-gate "operator %s requires left-hand scalar " 35107c478bd9Sstevel@tonic-gate "operand of known size\n", opstr(op)); 35117c478bd9Sstevel@tonic-gate } else if (dt_node_is_integer(rp) == 0 && 35127c478bd9Sstevel@tonic-gate dt_node_is_ptrcompat(lp, rp, NULL, NULL) == 0) { 35137c478bd9Sstevel@tonic-gate xyerror(D_OP_INCOMPAT, "operands have " 35147c478bd9Sstevel@tonic-gate "incompatible types: \"%s\" %s \"%s\"\n", 35157c478bd9Sstevel@tonic-gate dt_node_type_name(lp, n1, sizeof (n1)), 35167c478bd9Sstevel@tonic-gate opstr(op), 35177c478bd9Sstevel@tonic-gate dt_node_type_name(rp, n2, sizeof (n2))); 35187c478bd9Sstevel@tonic-gate } 35197c478bd9Sstevel@tonic-gate } 35207c478bd9Sstevel@tonic-gate asgn_common: 35217c478bd9Sstevel@tonic-gate if (!(lp->dn_flags & DT_NF_LVALUE)) { 35227c478bd9Sstevel@tonic-gate xyerror(D_OP_LVAL, "operator %s requires modifiable " 35237c478bd9Sstevel@tonic-gate "lvalue as an operand\n", opstr(op)); 35247c478bd9Sstevel@tonic-gate /* see K&R[A7.17] */ 35257c478bd9Sstevel@tonic-gate } 35267c478bd9Sstevel@tonic-gate 35277c478bd9Sstevel@tonic-gate if (!(lp->dn_flags & DT_NF_WRITABLE)) { 35287c478bd9Sstevel@tonic-gate xyerror(D_OP_WRITE, "operator %s can only be applied " 35297c478bd9Sstevel@tonic-gate "to a writable variable\n", opstr(op)); 35307c478bd9Sstevel@tonic-gate } 35317c478bd9Sstevel@tonic-gate 35327c478bd9Sstevel@tonic-gate dt_node_type_propagate(lp, dnp); /* see K&R[A7.17] */ 35337c478bd9Sstevel@tonic-gate dt_node_attr_assign(dnp, dt_attr_min(lp->dn_attr, rp->dn_attr)); 35347c478bd9Sstevel@tonic-gate break; 35357c478bd9Sstevel@tonic-gate 35367c478bd9Sstevel@tonic-gate case DT_TOK_PTR: 35377c478bd9Sstevel@tonic-gate /* 35387c478bd9Sstevel@tonic-gate * If the left-hand side of operator -> is the name "self", 35397c478bd9Sstevel@tonic-gate * then we permit a TLS variable to be created or referenced. 35407c478bd9Sstevel@tonic-gate */ 35417c478bd9Sstevel@tonic-gate if (lp->dn_kind == DT_NODE_IDENT && 35427c478bd9Sstevel@tonic-gate strcmp(lp->dn_string, "self") == 0) { 35437c478bd9Sstevel@tonic-gate if (rp->dn_kind != DT_NODE_VAR) { 35447c478bd9Sstevel@tonic-gate dt_xcook_ident(rp, dtp->dt_tls, 35457c478bd9Sstevel@tonic-gate DT_IDENT_SCALAR, B_TRUE); 35467c478bd9Sstevel@tonic-gate } 35477c478bd9Sstevel@tonic-gate 35487c478bd9Sstevel@tonic-gate if (idflags != 0) 35497c478bd9Sstevel@tonic-gate rp = dt_node_cook(rp, idflags); 35507c478bd9Sstevel@tonic-gate 35517c478bd9Sstevel@tonic-gate dnp->dn_right = dnp->dn_left; /* avoid freeing rp */ 35527c478bd9Sstevel@tonic-gate dt_node_free(dnp); 35537c478bd9Sstevel@tonic-gate return (rp); 35547c478bd9Sstevel@tonic-gate } 35557c478bd9Sstevel@tonic-gate 35567c478bd9Sstevel@tonic-gate /* 35577c478bd9Sstevel@tonic-gate * If the left-hand side of operator -> is the name "this", 35587c478bd9Sstevel@tonic-gate * then we permit a local variable to be created or referenced. 35597c478bd9Sstevel@tonic-gate */ 35607c478bd9Sstevel@tonic-gate if (lp->dn_kind == DT_NODE_IDENT && 35617c478bd9Sstevel@tonic-gate strcmp(lp->dn_string, "this") == 0) { 35627c478bd9Sstevel@tonic-gate if (rp->dn_kind != DT_NODE_VAR) { 35637c478bd9Sstevel@tonic-gate dt_xcook_ident(rp, yypcb->pcb_locals, 35647c478bd9Sstevel@tonic-gate DT_IDENT_SCALAR, B_TRUE); 35657c478bd9Sstevel@tonic-gate } 35667c478bd9Sstevel@tonic-gate 35677c478bd9Sstevel@tonic-gate if (idflags != 0) 35687c478bd9Sstevel@tonic-gate rp = dt_node_cook(rp, idflags); 35697c478bd9Sstevel@tonic-gate 35707c478bd9Sstevel@tonic-gate dnp->dn_right = dnp->dn_left; /* avoid freeing rp */ 35717c478bd9Sstevel@tonic-gate dt_node_free(dnp); 35727c478bd9Sstevel@tonic-gate return (rp); 35737c478bd9Sstevel@tonic-gate } 35747c478bd9Sstevel@tonic-gate 35757c478bd9Sstevel@tonic-gate /*FALLTHRU*/ 35767c478bd9Sstevel@tonic-gate 35777c478bd9Sstevel@tonic-gate case DT_TOK_DOT: 35787c478bd9Sstevel@tonic-gate lp = dnp->dn_left = dt_node_cook(lp, DT_IDFLG_REF); 35797c478bd9Sstevel@tonic-gate 35807c478bd9Sstevel@tonic-gate if (rp->dn_kind != DT_NODE_IDENT) { 35817c478bd9Sstevel@tonic-gate xyerror(D_OP_IDENT, "operator %s must be followed by " 35827c478bd9Sstevel@tonic-gate "an identifier\n", opstr(op)); 35837c478bd9Sstevel@tonic-gate } 35847c478bd9Sstevel@tonic-gate 35857c478bd9Sstevel@tonic-gate if ((idp = dt_node_resolve(lp, DT_IDENT_XLSOU)) != NULL || 35867c478bd9Sstevel@tonic-gate (idp = dt_node_resolve(lp, DT_IDENT_XLPTR)) != NULL) { 35877c478bd9Sstevel@tonic-gate /* 35887c478bd9Sstevel@tonic-gate * If the left-hand side is a translated struct or ptr, 35897c478bd9Sstevel@tonic-gate * the type of the left is the translation output type. 35907c478bd9Sstevel@tonic-gate */ 35917c478bd9Sstevel@tonic-gate dt_xlator_t *dxp = idp->di_data; 35927c478bd9Sstevel@tonic-gate 35937c478bd9Sstevel@tonic-gate if (dt_xlator_member(dxp, rp->dn_string) == NULL) { 35947c478bd9Sstevel@tonic-gate xyerror(D_XLATE_NOCONV, 35957c478bd9Sstevel@tonic-gate "translator does not define conversion " 35967c478bd9Sstevel@tonic-gate "for member: %s\n", rp->dn_string); 35977c478bd9Sstevel@tonic-gate } 35987c478bd9Sstevel@tonic-gate 35997c478bd9Sstevel@tonic-gate ctfp = idp->di_ctfp; 36007c478bd9Sstevel@tonic-gate type = ctf_type_resolve(ctfp, idp->di_type); 36017c478bd9Sstevel@tonic-gate uref = idp->di_flags & DT_IDFLG_USER; 36027c478bd9Sstevel@tonic-gate } else { 36037c478bd9Sstevel@tonic-gate ctfp = lp->dn_ctfp; 36047c478bd9Sstevel@tonic-gate type = ctf_type_resolve(ctfp, lp->dn_type); 36057c478bd9Sstevel@tonic-gate uref = lp->dn_flags & DT_NF_USERLAND; 36067c478bd9Sstevel@tonic-gate } 36077c478bd9Sstevel@tonic-gate 36087c478bd9Sstevel@tonic-gate kind = ctf_type_kind(ctfp, type); 36097c478bd9Sstevel@tonic-gate 36107c478bd9Sstevel@tonic-gate if (op == DT_TOK_PTR) { 36117c478bd9Sstevel@tonic-gate if (kind != CTF_K_POINTER) { 36127c478bd9Sstevel@tonic-gate xyerror(D_OP_PTR, "operator %s must be " 36137c478bd9Sstevel@tonic-gate "applied to a pointer\n", opstr(op)); 36147c478bd9Sstevel@tonic-gate } 36157c478bd9Sstevel@tonic-gate type = ctf_type_reference(ctfp, type); 36167c478bd9Sstevel@tonic-gate type = ctf_type_resolve(ctfp, type); 36177c478bd9Sstevel@tonic-gate kind = ctf_type_kind(ctfp, type); 36187c478bd9Sstevel@tonic-gate } 36197c478bd9Sstevel@tonic-gate 36207c478bd9Sstevel@tonic-gate /* 36217c478bd9Sstevel@tonic-gate * If we follow a reference to a forward declaration tag, 36227c478bd9Sstevel@tonic-gate * search the entire type space for the actual definition. 36237c478bd9Sstevel@tonic-gate */ 36247c478bd9Sstevel@tonic-gate while (kind == CTF_K_FORWARD) { 36257c478bd9Sstevel@tonic-gate char *tag = ctf_type_name(ctfp, type, n1, sizeof (n1)); 36267c478bd9Sstevel@tonic-gate dtrace_typeinfo_t dtt; 36277c478bd9Sstevel@tonic-gate 36287c478bd9Sstevel@tonic-gate if (tag != NULL && dt_type_lookup(tag, &dtt) == 0 && 36297c478bd9Sstevel@tonic-gate (dtt.dtt_ctfp != ctfp || dtt.dtt_type != type)) { 36307c478bd9Sstevel@tonic-gate ctfp = dtt.dtt_ctfp; 36317c478bd9Sstevel@tonic-gate type = ctf_type_resolve(ctfp, dtt.dtt_type); 36327c478bd9Sstevel@tonic-gate kind = ctf_type_kind(ctfp, type); 36337c478bd9Sstevel@tonic-gate } else { 36347c478bd9Sstevel@tonic-gate xyerror(D_OP_INCOMPLETE, 36357c478bd9Sstevel@tonic-gate "operator %s cannot be applied to a " 36367c478bd9Sstevel@tonic-gate "forward declaration: no %s definition " 36377c478bd9Sstevel@tonic-gate "is available\n", opstr(op), tag); 36387c478bd9Sstevel@tonic-gate } 36397c478bd9Sstevel@tonic-gate } 36407c478bd9Sstevel@tonic-gate 36417c478bd9Sstevel@tonic-gate if (kind != CTF_K_STRUCT && kind != CTF_K_UNION) { 36427c478bd9Sstevel@tonic-gate if (op == DT_TOK_PTR) { 36437c478bd9Sstevel@tonic-gate xyerror(D_OP_SOU, "operator -> cannot be " 36447c478bd9Sstevel@tonic-gate "applied to pointer to type \"%s\"; must " 36457c478bd9Sstevel@tonic-gate "be applied to a struct or union pointer\n", 36467c478bd9Sstevel@tonic-gate ctf_type_name(ctfp, type, n1, sizeof (n1))); 36477c478bd9Sstevel@tonic-gate } else { 36487c478bd9Sstevel@tonic-gate xyerror(D_OP_SOU, "operator %s cannot be " 36497c478bd9Sstevel@tonic-gate "applied to type \"%s\"; must be applied " 36507c478bd9Sstevel@tonic-gate "to a struct or union\n", opstr(op), 36517c478bd9Sstevel@tonic-gate ctf_type_name(ctfp, type, n1, sizeof (n1))); 36527c478bd9Sstevel@tonic-gate } 36537c478bd9Sstevel@tonic-gate } 36547c478bd9Sstevel@tonic-gate 36557c478bd9Sstevel@tonic-gate if (ctf_member_info(ctfp, type, rp->dn_string, &m) == CTF_ERR) { 36567c478bd9Sstevel@tonic-gate xyerror(D_TYPE_MEMBER, 36577c478bd9Sstevel@tonic-gate "%s is not a member of %s\n", rp->dn_string, 36587c478bd9Sstevel@tonic-gate ctf_type_name(ctfp, type, n1, sizeof (n1))); 36597c478bd9Sstevel@tonic-gate } 36607c478bd9Sstevel@tonic-gate 36617c478bd9Sstevel@tonic-gate type = ctf_type_resolve(ctfp, m.ctm_type); 36627c478bd9Sstevel@tonic-gate kind = ctf_type_kind(ctfp, type); 36637c478bd9Sstevel@tonic-gate 36647c478bd9Sstevel@tonic-gate dt_node_type_assign(dnp, ctfp, m.ctm_type); 36657c478bd9Sstevel@tonic-gate dt_node_attr_assign(dnp, lp->dn_attr); 36667c478bd9Sstevel@tonic-gate 36677c478bd9Sstevel@tonic-gate if (op == DT_TOK_PTR && (kind != CTF_K_ARRAY || 36687c478bd9Sstevel@tonic-gate dt_node_is_string(dnp))) 36697c478bd9Sstevel@tonic-gate dnp->dn_flags |= DT_NF_LVALUE; /* see K&R[A7.3.3] */ 36707c478bd9Sstevel@tonic-gate 36717c478bd9Sstevel@tonic-gate if (op == DT_TOK_DOT && (lp->dn_flags & DT_NF_LVALUE) && 36727c478bd9Sstevel@tonic-gate (kind != CTF_K_ARRAY || dt_node_is_string(dnp))) 36737c478bd9Sstevel@tonic-gate dnp->dn_flags |= DT_NF_LVALUE; /* see K&R[A7.3.3] */ 36747c478bd9Sstevel@tonic-gate 36757c478bd9Sstevel@tonic-gate if (lp->dn_flags & DT_NF_WRITABLE) 36767c478bd9Sstevel@tonic-gate dnp->dn_flags |= DT_NF_WRITABLE; 36777c478bd9Sstevel@tonic-gate 36787c478bd9Sstevel@tonic-gate if (uref && (kind == CTF_K_POINTER || 36797c478bd9Sstevel@tonic-gate (dnp->dn_flags & DT_NF_REF))) 36807c478bd9Sstevel@tonic-gate dnp->dn_flags |= DT_NF_USERLAND; 36817c478bd9Sstevel@tonic-gate break; 36827c478bd9Sstevel@tonic-gate 36837c478bd9Sstevel@tonic-gate case DT_TOK_LBRAC: { 36847c478bd9Sstevel@tonic-gate /* 36857c478bd9Sstevel@tonic-gate * If op is DT_TOK_LBRAC, we know from the special-case code at 36867c478bd9Sstevel@tonic-gate * the top that lp is either a D variable or an aggregation. 36877c478bd9Sstevel@tonic-gate */ 36887c478bd9Sstevel@tonic-gate dt_node_t *lnp; 36897c478bd9Sstevel@tonic-gate 36907c478bd9Sstevel@tonic-gate /* 36917c478bd9Sstevel@tonic-gate * If the left-hand side is an aggregation, just set dn_aggtup 36927c478bd9Sstevel@tonic-gate * to the right-hand side and return the cooked aggregation. 36937c478bd9Sstevel@tonic-gate * This transformation is legal since we are just collapsing 36947c478bd9Sstevel@tonic-gate * nodes to simplify later processing, and the entire aggtup 36957c478bd9Sstevel@tonic-gate * parse subtree is retained for subsequent cooking passes. 36967c478bd9Sstevel@tonic-gate */ 36977c478bd9Sstevel@tonic-gate if (lp->dn_kind == DT_NODE_AGG) { 36987c478bd9Sstevel@tonic-gate if (lp->dn_aggtup != NULL) { 36997c478bd9Sstevel@tonic-gate xyerror(D_AGG_MDIM, "improper attempt to " 37007c478bd9Sstevel@tonic-gate "reference @%s as a multi-dimensional " 37017c478bd9Sstevel@tonic-gate "array\n", lp->dn_ident->di_name); 37027c478bd9Sstevel@tonic-gate } 37037c478bd9Sstevel@tonic-gate 37047c478bd9Sstevel@tonic-gate lp->dn_aggtup = rp; 37057c478bd9Sstevel@tonic-gate lp = dt_node_cook(lp, 0); 37067c478bd9Sstevel@tonic-gate 37077c478bd9Sstevel@tonic-gate dnp->dn_left = dnp->dn_right = NULL; 37087c478bd9Sstevel@tonic-gate dt_node_free(dnp); 37097c478bd9Sstevel@tonic-gate 37107c478bd9Sstevel@tonic-gate return (lp); 37117c478bd9Sstevel@tonic-gate } 37127c478bd9Sstevel@tonic-gate 37137c478bd9Sstevel@tonic-gate assert(lp->dn_kind == DT_NODE_VAR); 37147c478bd9Sstevel@tonic-gate idp = lp->dn_ident; 37157c478bd9Sstevel@tonic-gate 37167c478bd9Sstevel@tonic-gate /* 37177c478bd9Sstevel@tonic-gate * If the left-hand side is a non-global scalar that hasn't yet 37187c478bd9Sstevel@tonic-gate * been referenced or modified, it was just created by self-> 37197c478bd9Sstevel@tonic-gate * or this-> and we can convert it from scalar to assoc array. 37207c478bd9Sstevel@tonic-gate */ 37217c478bd9Sstevel@tonic-gate if (idp->di_kind == DT_IDENT_SCALAR && dt_ident_unref(idp) && 37227c478bd9Sstevel@tonic-gate (idp->di_flags & (DT_IDFLG_LOCAL | DT_IDFLG_TLS)) != 0) { 37237c478bd9Sstevel@tonic-gate 37247c478bd9Sstevel@tonic-gate if (idp->di_flags & DT_IDFLG_LOCAL) { 37257c478bd9Sstevel@tonic-gate xyerror(D_ARR_LOCAL, 37267c478bd9Sstevel@tonic-gate "local variables may not be used as " 37277c478bd9Sstevel@tonic-gate "associative arrays: %s\n", idp->di_name); 37287c478bd9Sstevel@tonic-gate } 37297c478bd9Sstevel@tonic-gate 37307c478bd9Sstevel@tonic-gate dt_dprintf("morph variable %s (id %u) from scalar to " 37317c478bd9Sstevel@tonic-gate "array\n", idp->di_name, idp->di_id); 37327c478bd9Sstevel@tonic-gate 37337c478bd9Sstevel@tonic-gate dt_ident_morph(idp, DT_IDENT_ARRAY, 37347c478bd9Sstevel@tonic-gate &dt_idops_assc, NULL); 37357c478bd9Sstevel@tonic-gate } 37367c478bd9Sstevel@tonic-gate 37377c478bd9Sstevel@tonic-gate if (idp->di_kind != DT_IDENT_ARRAY) { 37387c478bd9Sstevel@tonic-gate xyerror(D_IDENT_BADREF, "%s '%s' may not be referenced " 37397c478bd9Sstevel@tonic-gate "as %s\n", dt_idkind_name(idp->di_kind), 37407c478bd9Sstevel@tonic-gate idp->di_name, dt_idkind_name(DT_IDENT_ARRAY)); 37417c478bd9Sstevel@tonic-gate } 37427c478bd9Sstevel@tonic-gate 37437c478bd9Sstevel@tonic-gate /* 37447c478bd9Sstevel@tonic-gate * Now that we've confirmed our left-hand side is a DT_NODE_VAR 37457c478bd9Sstevel@tonic-gate * of idkind DT_IDENT_ARRAY, we need to splice the [ node from 37467c478bd9Sstevel@tonic-gate * the parse tree and leave a cooked DT_NODE_VAR in its place 37477c478bd9Sstevel@tonic-gate * where dn_args for the VAR node is the right-hand 'rp' tree, 37487c478bd9Sstevel@tonic-gate * as shown in the parse tree diagram below: 37497c478bd9Sstevel@tonic-gate * 37507c478bd9Sstevel@tonic-gate * / / 37517c478bd9Sstevel@tonic-gate * [ OP2 "[" ]=dnp [ VAR ]=dnp 37527c478bd9Sstevel@tonic-gate * / \ => | 37537c478bd9Sstevel@tonic-gate * / \ +- dn_args -> [ ??? ]=rp 37547c478bd9Sstevel@tonic-gate * [ VAR ]=lp [ ??? ]=rp 37557c478bd9Sstevel@tonic-gate * 37567c478bd9Sstevel@tonic-gate * Since the final dt_node_cook(dnp) can fail using longjmp we 37577c478bd9Sstevel@tonic-gate * must perform the transformations as a group first by over- 37587c478bd9Sstevel@tonic-gate * writing 'dnp' to become the VAR node, so that the parse tree 37597c478bd9Sstevel@tonic-gate * is guaranteed to be in a consistent state if the cook fails. 37607c478bd9Sstevel@tonic-gate */ 37617c478bd9Sstevel@tonic-gate assert(lp->dn_kind == DT_NODE_VAR); 37627c478bd9Sstevel@tonic-gate assert(lp->dn_args == NULL); 37637c478bd9Sstevel@tonic-gate 37647c478bd9Sstevel@tonic-gate lnp = dnp->dn_link; 37657c478bd9Sstevel@tonic-gate bcopy(lp, dnp, sizeof (dt_node_t)); 37667c478bd9Sstevel@tonic-gate dnp->dn_link = lnp; 37677c478bd9Sstevel@tonic-gate 37687c478bd9Sstevel@tonic-gate dnp->dn_args = rp; 37697c478bd9Sstevel@tonic-gate dnp->dn_list = NULL; 37707c478bd9Sstevel@tonic-gate 37717c478bd9Sstevel@tonic-gate dt_node_free(lp); 37727c478bd9Sstevel@tonic-gate return (dt_node_cook(dnp, idflags)); 37737c478bd9Sstevel@tonic-gate } 37747c478bd9Sstevel@tonic-gate 37757c478bd9Sstevel@tonic-gate case DT_TOK_XLATE: { 37767c478bd9Sstevel@tonic-gate dt_xlator_t *dxp; 37777c478bd9Sstevel@tonic-gate 37787c478bd9Sstevel@tonic-gate assert(lp->dn_kind == DT_NODE_TYPE); 37797c478bd9Sstevel@tonic-gate rp = dnp->dn_right = dt_node_cook(rp, DT_IDFLG_REF); 37807c478bd9Sstevel@tonic-gate dxp = dt_xlator_lookup(dtp, rp, lp, DT_XLATE_FUZZY); 37817c478bd9Sstevel@tonic-gate 37827c478bd9Sstevel@tonic-gate if (dxp == NULL) { 37837c478bd9Sstevel@tonic-gate xyerror(D_XLATE_NONE, 37847c478bd9Sstevel@tonic-gate "cannot translate from \"%s\" to \"%s\"\n", 37857c478bd9Sstevel@tonic-gate dt_node_type_name(rp, n1, sizeof (n1)), 37867c478bd9Sstevel@tonic-gate dt_node_type_name(lp, n2, sizeof (n2))); 37877c478bd9Sstevel@tonic-gate } 37887c478bd9Sstevel@tonic-gate 37897c478bd9Sstevel@tonic-gate dnp->dn_ident = dt_xlator_ident(dxp, lp->dn_ctfp, lp->dn_type); 37907c478bd9Sstevel@tonic-gate dt_node_type_assign(dnp, DT_DYN_CTFP(dtp), DT_DYN_TYPE(dtp)); 37917c478bd9Sstevel@tonic-gate dt_node_attr_assign(dnp, 37927c478bd9Sstevel@tonic-gate dt_attr_min(rp->dn_attr, dnp->dn_ident->di_attr)); 37937c478bd9Sstevel@tonic-gate break; 37947c478bd9Sstevel@tonic-gate } 37957c478bd9Sstevel@tonic-gate 37967c478bd9Sstevel@tonic-gate case DT_TOK_LPAR: { 37977c478bd9Sstevel@tonic-gate ctf_id_t ltype, rtype; 37987c478bd9Sstevel@tonic-gate uint_t lkind, rkind; 37997c478bd9Sstevel@tonic-gate 38007c478bd9Sstevel@tonic-gate assert(lp->dn_kind == DT_NODE_TYPE); 38017c478bd9Sstevel@tonic-gate rp = dnp->dn_right = dt_node_cook(rp, DT_IDFLG_REF); 38027c478bd9Sstevel@tonic-gate 38037c478bd9Sstevel@tonic-gate ltype = ctf_type_resolve(lp->dn_ctfp, lp->dn_type); 38047c478bd9Sstevel@tonic-gate lkind = ctf_type_kind(lp->dn_ctfp, ltype); 38057c478bd9Sstevel@tonic-gate 38067c478bd9Sstevel@tonic-gate rtype = ctf_type_resolve(rp->dn_ctfp, rp->dn_type); 38077c478bd9Sstevel@tonic-gate rkind = ctf_type_kind(rp->dn_ctfp, rtype); 38087c478bd9Sstevel@tonic-gate 38097c478bd9Sstevel@tonic-gate /* 38107c478bd9Sstevel@tonic-gate * The rules for casting are loosely explained in K&R[A7.5] 38117c478bd9Sstevel@tonic-gate * and K&R[A6]. Basically, we can cast to the same type or 38127c478bd9Sstevel@tonic-gate * same base type, between any kind of scalar values, from 38137c478bd9Sstevel@tonic-gate * arrays to pointers, and we can cast anything to void. 38147c478bd9Sstevel@tonic-gate * To these rules D adds casts from scalars to strings. 38157c478bd9Sstevel@tonic-gate */ 38167c478bd9Sstevel@tonic-gate if (ctf_type_compat(lp->dn_ctfp, lp->dn_type, 38177c478bd9Sstevel@tonic-gate rp->dn_ctfp, rp->dn_type)) 38187c478bd9Sstevel@tonic-gate /*EMPTY*/; 38197c478bd9Sstevel@tonic-gate else if (dt_node_is_scalar(lp) && 38207c478bd9Sstevel@tonic-gate (dt_node_is_scalar(rp) || rkind == CTF_K_FUNCTION)) 38217c478bd9Sstevel@tonic-gate /*EMPTY*/; 38227c478bd9Sstevel@tonic-gate else if (dt_node_is_void(lp)) 38237c478bd9Sstevel@tonic-gate /*EMPTY*/; 38247c478bd9Sstevel@tonic-gate else if (lkind == CTF_K_POINTER && dt_node_is_pointer(rp)) 38257c478bd9Sstevel@tonic-gate /*EMPTY*/; 38267c478bd9Sstevel@tonic-gate else if (dt_node_is_string(lp) && (dt_node_is_scalar(rp) || 38277c478bd9Sstevel@tonic-gate dt_node_is_pointer(rp) || dt_node_is_strcompat(rp))) 38287c478bd9Sstevel@tonic-gate /*EMPTY*/; 38297c478bd9Sstevel@tonic-gate else { 38307c478bd9Sstevel@tonic-gate xyerror(D_CAST_INVAL, 38317c478bd9Sstevel@tonic-gate "invalid cast expression: \"%s\" to \"%s\"\n", 38327c478bd9Sstevel@tonic-gate dt_node_type_name(rp, n1, sizeof (n1)), 38337c478bd9Sstevel@tonic-gate dt_node_type_name(lp, n2, sizeof (n2))); 38347c478bd9Sstevel@tonic-gate } 38357c478bd9Sstevel@tonic-gate 38367c478bd9Sstevel@tonic-gate dt_node_type_propagate(lp, dnp); /* see K&R[A7.5] */ 38377c478bd9Sstevel@tonic-gate dt_node_attr_assign(dnp, dt_attr_min(lp->dn_attr, rp->dn_attr)); 38387c478bd9Sstevel@tonic-gate break; 38397c478bd9Sstevel@tonic-gate } 38407c478bd9Sstevel@tonic-gate 38417c478bd9Sstevel@tonic-gate case DT_TOK_COMMA: 38427c478bd9Sstevel@tonic-gate lp = dnp->dn_left = dt_node_cook(lp, DT_IDFLG_REF); 38437c478bd9Sstevel@tonic-gate rp = dnp->dn_right = dt_node_cook(rp, DT_IDFLG_REF); 38447c478bd9Sstevel@tonic-gate 38457c478bd9Sstevel@tonic-gate if (dt_node_is_dynamic(lp) || dt_node_is_dynamic(rp)) { 38467c478bd9Sstevel@tonic-gate xyerror(D_OP_DYN, "operator %s operands " 38477c478bd9Sstevel@tonic-gate "cannot be of dynamic type\n", opstr(op)); 38487c478bd9Sstevel@tonic-gate } 38497c478bd9Sstevel@tonic-gate 38507c478bd9Sstevel@tonic-gate if (dt_node_is_actfunc(lp) || dt_node_is_actfunc(rp)) { 38517c478bd9Sstevel@tonic-gate xyerror(D_OP_ACT, "operator %s operands " 38527c478bd9Sstevel@tonic-gate "cannot be actions\n", opstr(op)); 38537c478bd9Sstevel@tonic-gate } 38547c478bd9Sstevel@tonic-gate 38557c478bd9Sstevel@tonic-gate dt_node_type_propagate(rp, dnp); /* see K&R[A7.18] */ 38567c478bd9Sstevel@tonic-gate dt_node_attr_assign(dnp, dt_attr_min(lp->dn_attr, rp->dn_attr)); 38577c478bd9Sstevel@tonic-gate break; 38587c478bd9Sstevel@tonic-gate 38597c478bd9Sstevel@tonic-gate default: 38607c478bd9Sstevel@tonic-gate xyerror(D_UNKNOWN, "invalid binary op %s\n", opstr(op)); 38617c478bd9Sstevel@tonic-gate } 38627c478bd9Sstevel@tonic-gate 38637c478bd9Sstevel@tonic-gate /* 38647c478bd9Sstevel@tonic-gate * Complete the conversion of E1[E2] to *((E1)+(E2)) that we started 38657c478bd9Sstevel@tonic-gate * at the top of our switch() above (see K&R[A7.3.1]). Since E2 is 38667c478bd9Sstevel@tonic-gate * parsed as an argument_expression_list by dt_grammar.y, we can 38677c478bd9Sstevel@tonic-gate * end up with a comma-separated list inside of a non-associative 38687c478bd9Sstevel@tonic-gate * array reference. We check for this and report an appropriate error. 38697c478bd9Sstevel@tonic-gate */ 38707c478bd9Sstevel@tonic-gate if (dnp->dn_op == DT_TOK_LBRAC && op == DT_TOK_ADD) { 38717c478bd9Sstevel@tonic-gate dt_node_t *pnp; 38727c478bd9Sstevel@tonic-gate 38737c478bd9Sstevel@tonic-gate if (rp->dn_list != NULL) { 38747c478bd9Sstevel@tonic-gate xyerror(D_ARR_BADREF, 38757c478bd9Sstevel@tonic-gate "cannot access %s as an associative array\n", 38767c478bd9Sstevel@tonic-gate dt_node_name(lp, n1, sizeof (n1))); 38777c478bd9Sstevel@tonic-gate } 38787c478bd9Sstevel@tonic-gate 38797c478bd9Sstevel@tonic-gate dnp->dn_op = DT_TOK_ADD; 38807c478bd9Sstevel@tonic-gate pnp = dt_node_op1(DT_TOK_DEREF, dnp); 38817c478bd9Sstevel@tonic-gate 38827c478bd9Sstevel@tonic-gate /* 38837c478bd9Sstevel@tonic-gate * Cook callbacks are not typically permitted to allocate nodes. 38847c478bd9Sstevel@tonic-gate * When we do, we must insert them in the middle of an existing 38857c478bd9Sstevel@tonic-gate * allocation list rather than having them appended to the pcb 38867c478bd9Sstevel@tonic-gate * list because the sub-expression may be part of a definition. 38877c478bd9Sstevel@tonic-gate */ 38887c478bd9Sstevel@tonic-gate assert(yypcb->pcb_list == pnp); 38897c478bd9Sstevel@tonic-gate yypcb->pcb_list = pnp->dn_link; 38907c478bd9Sstevel@tonic-gate 38917c478bd9Sstevel@tonic-gate pnp->dn_link = dnp->dn_link; 38927c478bd9Sstevel@tonic-gate dnp->dn_link = pnp; 38937c478bd9Sstevel@tonic-gate 38947c478bd9Sstevel@tonic-gate return (dt_node_cook(pnp, DT_IDFLG_REF)); 38957c478bd9Sstevel@tonic-gate } 38967c478bd9Sstevel@tonic-gate 38977c478bd9Sstevel@tonic-gate return (dnp); 38987c478bd9Sstevel@tonic-gate } 38997c478bd9Sstevel@tonic-gate 39007c478bd9Sstevel@tonic-gate /*ARGSUSED*/ 39017c478bd9Sstevel@tonic-gate static dt_node_t * 39027c478bd9Sstevel@tonic-gate dt_cook_op3(dt_node_t *dnp, uint_t idflags) 39037c478bd9Sstevel@tonic-gate { 39047c478bd9Sstevel@tonic-gate dt_node_t *lp, *rp; 39057c478bd9Sstevel@tonic-gate ctf_file_t *ctfp; 39067c478bd9Sstevel@tonic-gate ctf_id_t type; 39077c478bd9Sstevel@tonic-gate 39087c478bd9Sstevel@tonic-gate dnp->dn_expr = dt_node_cook(dnp->dn_expr, DT_IDFLG_REF); 39097c478bd9Sstevel@tonic-gate lp = dnp->dn_left = dt_node_cook(dnp->dn_left, DT_IDFLG_REF); 39107c478bd9Sstevel@tonic-gate rp = dnp->dn_right = dt_node_cook(dnp->dn_right, DT_IDFLG_REF); 39117c478bd9Sstevel@tonic-gate 39127c478bd9Sstevel@tonic-gate if (!dt_node_is_scalar(dnp->dn_expr)) { 39137c478bd9Sstevel@tonic-gate xyerror(D_OP_SCALAR, 39147c478bd9Sstevel@tonic-gate "operator ?: expression must be of scalar type\n"); 39157c478bd9Sstevel@tonic-gate } 39167c478bd9Sstevel@tonic-gate 39177c478bd9Sstevel@tonic-gate if (dt_node_is_dynamic(lp) || dt_node_is_dynamic(rp)) { 39187c478bd9Sstevel@tonic-gate xyerror(D_OP_DYN, 39197c478bd9Sstevel@tonic-gate "operator ?: operands cannot be of dynamic type\n"); 39207c478bd9Sstevel@tonic-gate } 39217c478bd9Sstevel@tonic-gate 39227c478bd9Sstevel@tonic-gate /* 39237c478bd9Sstevel@tonic-gate * The rules for type checking for the ternary operator are complex and 39247c478bd9Sstevel@tonic-gate * are described in the ANSI-C spec (see K&R[A7.16]). We implement 39257c478bd9Sstevel@tonic-gate * the various tests in order from least to most expensive. 39267c478bd9Sstevel@tonic-gate */ 39277c478bd9Sstevel@tonic-gate if (ctf_type_compat(lp->dn_ctfp, lp->dn_type, 39287c478bd9Sstevel@tonic-gate rp->dn_ctfp, rp->dn_type)) { 39297c478bd9Sstevel@tonic-gate ctfp = lp->dn_ctfp; 39307c478bd9Sstevel@tonic-gate type = lp->dn_type; 39317c478bd9Sstevel@tonic-gate } else if (dt_node_is_integer(lp) && dt_node_is_integer(rp)) { 39327c478bd9Sstevel@tonic-gate dt_type_promote(lp, rp, &ctfp, &type); 39337c478bd9Sstevel@tonic-gate } else if (dt_node_is_strcompat(lp) && dt_node_is_strcompat(rp) && 39347c478bd9Sstevel@tonic-gate (dt_node_is_string(lp) || dt_node_is_string(rp))) { 39357c478bd9Sstevel@tonic-gate ctfp = DT_STR_CTFP(yypcb->pcb_hdl); 39367c478bd9Sstevel@tonic-gate type = DT_STR_TYPE(yypcb->pcb_hdl); 39377c478bd9Sstevel@tonic-gate } else if (dt_node_is_ptrcompat(lp, rp, &ctfp, &type) == 0) { 39387c478bd9Sstevel@tonic-gate xyerror(D_OP_INCOMPAT, 39397c478bd9Sstevel@tonic-gate "operator ?: operands must have compatible types\n"); 39407c478bd9Sstevel@tonic-gate } 39417c478bd9Sstevel@tonic-gate 39427c478bd9Sstevel@tonic-gate if (dt_node_is_actfunc(lp) || dt_node_is_actfunc(rp)) { 39437c478bd9Sstevel@tonic-gate xyerror(D_OP_ACT, "action cannot be " 39447c478bd9Sstevel@tonic-gate "used in a conditional context\n"); 39457c478bd9Sstevel@tonic-gate } 39467c478bd9Sstevel@tonic-gate 39477c478bd9Sstevel@tonic-gate dt_node_type_assign(dnp, ctfp, type); 39487c478bd9Sstevel@tonic-gate dt_node_attr_assign(dnp, dt_attr_min(dnp->dn_expr->dn_attr, 39497c478bd9Sstevel@tonic-gate dt_attr_min(lp->dn_attr, rp->dn_attr))); 39507c478bd9Sstevel@tonic-gate 39517c478bd9Sstevel@tonic-gate return (dnp); 39527c478bd9Sstevel@tonic-gate } 39537c478bd9Sstevel@tonic-gate 39547c478bd9Sstevel@tonic-gate static dt_node_t * 39557c478bd9Sstevel@tonic-gate dt_cook_statement(dt_node_t *dnp, uint_t idflags) 39567c478bd9Sstevel@tonic-gate { 39577c478bd9Sstevel@tonic-gate dnp->dn_expr = dt_node_cook(dnp->dn_expr, idflags); 39587c478bd9Sstevel@tonic-gate dt_node_attr_assign(dnp, dnp->dn_expr->dn_attr); 39597c478bd9Sstevel@tonic-gate 39607c478bd9Sstevel@tonic-gate return (dnp); 39617c478bd9Sstevel@tonic-gate } 39627c478bd9Sstevel@tonic-gate 39637c478bd9Sstevel@tonic-gate /* 39647c478bd9Sstevel@tonic-gate * If dn_aggfun is set, this node is a collapsed aggregation assignment (see 39657c478bd9Sstevel@tonic-gate * the special case code for DT_TOK_ASGN in dt_cook_op2() above), in which 39667c478bd9Sstevel@tonic-gate * case we cook both the tuple and the function call. If dn_aggfun is NULL, 39677c478bd9Sstevel@tonic-gate * this node is just a reference to the aggregation's type and attributes. 39687c478bd9Sstevel@tonic-gate */ 39697c478bd9Sstevel@tonic-gate /*ARGSUSED*/ 39707c478bd9Sstevel@tonic-gate static dt_node_t * 39717c478bd9Sstevel@tonic-gate dt_cook_aggregation(dt_node_t *dnp, uint_t idflags) 39727c478bd9Sstevel@tonic-gate { 39737c478bd9Sstevel@tonic-gate dtrace_hdl_t *dtp = yypcb->pcb_hdl; 39747c478bd9Sstevel@tonic-gate 39757c478bd9Sstevel@tonic-gate if (dnp->dn_aggfun != NULL) { 39767c478bd9Sstevel@tonic-gate dnp->dn_aggfun = dt_node_cook(dnp->dn_aggfun, DT_IDFLG_REF); 39777c478bd9Sstevel@tonic-gate dt_node_attr_assign(dnp, dt_ident_cook(dnp, 39787c478bd9Sstevel@tonic-gate dnp->dn_ident, &dnp->dn_aggtup)); 39797c478bd9Sstevel@tonic-gate } else { 39807c478bd9Sstevel@tonic-gate dt_node_type_assign(dnp, DT_DYN_CTFP(dtp), DT_DYN_TYPE(dtp)); 39817c478bd9Sstevel@tonic-gate dt_node_attr_assign(dnp, dnp->dn_ident->di_attr); 39827c478bd9Sstevel@tonic-gate } 39837c478bd9Sstevel@tonic-gate 39847c478bd9Sstevel@tonic-gate return (dnp); 39857c478bd9Sstevel@tonic-gate } 39867c478bd9Sstevel@tonic-gate 39877c478bd9Sstevel@tonic-gate /* 39887c478bd9Sstevel@tonic-gate * Since D permits new variable identifiers to be instantiated in any program 39897c478bd9Sstevel@tonic-gate * expression, we may need to cook a clause's predicate either before or after 39907c478bd9Sstevel@tonic-gate * the action list depending on the program code in question. Consider: 39917c478bd9Sstevel@tonic-gate * 39927c478bd9Sstevel@tonic-gate * probe-description-list probe-description-list 39937c478bd9Sstevel@tonic-gate * /x++/ /x == 0/ 39947c478bd9Sstevel@tonic-gate * { { 39957c478bd9Sstevel@tonic-gate * trace(x); trace(x++); 39967c478bd9Sstevel@tonic-gate * } } 39977c478bd9Sstevel@tonic-gate * 39987c478bd9Sstevel@tonic-gate * In the left-hand example, the predicate uses operator ++ to instantiate 'x' 39997c478bd9Sstevel@tonic-gate * as a variable of type int64_t. The predicate must be cooked first because 40007c478bd9Sstevel@tonic-gate * otherwise the statement trace(x) refers to an unknown identifier. In the 40017c478bd9Sstevel@tonic-gate * right-hand example, the action list uses ++ to instantiate 'x'; the action 40027c478bd9Sstevel@tonic-gate * list must be cooked first because otherwise the predicate x == 0 refers to 40037c478bd9Sstevel@tonic-gate * an unknown identifier. In order to simplify programming, we support both. 40047c478bd9Sstevel@tonic-gate * 40057c478bd9Sstevel@tonic-gate * When cooking a clause, we cook the action statements before the predicate by 40067c478bd9Sstevel@tonic-gate * default, since it seems more common to create or modify identifiers in the 40077c478bd9Sstevel@tonic-gate * action list. If cooking fails due to an unknown identifier, we attempt to 40087c478bd9Sstevel@tonic-gate * cook the predicate (i.e. do it first) and then go back and cook the actions. 40097c478bd9Sstevel@tonic-gate * If this, too, fails (or if we get an error other than D_IDENT_UNDEF) we give 40107c478bd9Sstevel@tonic-gate * up and report failure back to the user. There are five possible paths: 40117c478bd9Sstevel@tonic-gate * 40127c478bd9Sstevel@tonic-gate * cook actions = OK, cook predicate = OK -> OK 40137c478bd9Sstevel@tonic-gate * cook actions = OK, cook predicate = ERR -> ERR 40147c478bd9Sstevel@tonic-gate * cook actions = ERR, cook predicate = ERR -> ERR 40157c478bd9Sstevel@tonic-gate * cook actions = ERR, cook predicate = OK, cook actions = OK -> OK 40167c478bd9Sstevel@tonic-gate * cook actions = ERR, cook predicate = OK, cook actions = ERR -> ERR 40177c478bd9Sstevel@tonic-gate * 40187c478bd9Sstevel@tonic-gate * The programmer can still defeat our scheme by creating circular definition 40197c478bd9Sstevel@tonic-gate * dependencies between predicates and actions, as in this example clause: 40207c478bd9Sstevel@tonic-gate * 40217c478bd9Sstevel@tonic-gate * probe-description-list 40227c478bd9Sstevel@tonic-gate * /x++ && y == 0/ 40237c478bd9Sstevel@tonic-gate * { 40247c478bd9Sstevel@tonic-gate * trace(x + y++); 40257c478bd9Sstevel@tonic-gate * } 40267c478bd9Sstevel@tonic-gate * 40277c478bd9Sstevel@tonic-gate * but it doesn't seem worth the complexity to handle such rare cases. The 40287c478bd9Sstevel@tonic-gate * user can simply use the D variable declaration syntax to work around them. 40297c478bd9Sstevel@tonic-gate */ 40307c478bd9Sstevel@tonic-gate static dt_node_t * 40317c478bd9Sstevel@tonic-gate dt_cook_clause(dt_node_t *dnp, uint_t idflags) 40327c478bd9Sstevel@tonic-gate { 40337c478bd9Sstevel@tonic-gate volatile int err, tries; 40347c478bd9Sstevel@tonic-gate jmp_buf ojb; 40357c478bd9Sstevel@tonic-gate 40367c478bd9Sstevel@tonic-gate /* 40377c478bd9Sstevel@tonic-gate * Before assigning dn_ctxattr, temporarily assign the probe attribute 40387c478bd9Sstevel@tonic-gate * to 'dnp' itself to force an attribute check and minimum violation. 40397c478bd9Sstevel@tonic-gate */ 40407c478bd9Sstevel@tonic-gate dt_node_attr_assign(dnp, yypcb->pcb_pinfo.dtp_attr); 40417c478bd9Sstevel@tonic-gate dnp->dn_ctxattr = yypcb->pcb_pinfo.dtp_attr; 40427c478bd9Sstevel@tonic-gate 40437c478bd9Sstevel@tonic-gate bcopy(yypcb->pcb_jmpbuf, ojb, sizeof (jmp_buf)); 40447c478bd9Sstevel@tonic-gate tries = 0; 40457c478bd9Sstevel@tonic-gate 40467c478bd9Sstevel@tonic-gate if (dnp->dn_pred != NULL && (err = setjmp(yypcb->pcb_jmpbuf)) != 0) { 40477c478bd9Sstevel@tonic-gate bcopy(ojb, yypcb->pcb_jmpbuf, sizeof (jmp_buf)); 40487c478bd9Sstevel@tonic-gate if (tries++ != 0 || err != EDT_COMPILER || ( 40497c478bd9Sstevel@tonic-gate yypcb->pcb_hdl->dt_errtag != dt_errtag(D_IDENT_UNDEF) && 40507c478bd9Sstevel@tonic-gate yypcb->pcb_hdl->dt_errtag != dt_errtag(D_VAR_UNDEF))) 40517c478bd9Sstevel@tonic-gate longjmp(yypcb->pcb_jmpbuf, err); 40527c478bd9Sstevel@tonic-gate } 40537c478bd9Sstevel@tonic-gate 40547c478bd9Sstevel@tonic-gate if (tries == 0) { 40557c478bd9Sstevel@tonic-gate yylabel("action list"); 40567c478bd9Sstevel@tonic-gate 40577c478bd9Sstevel@tonic-gate dt_node_attr_assign(dnp, 40587c478bd9Sstevel@tonic-gate dt_node_list_cook(&dnp->dn_acts, idflags)); 40597c478bd9Sstevel@tonic-gate 40607c478bd9Sstevel@tonic-gate bcopy(ojb, yypcb->pcb_jmpbuf, sizeof (jmp_buf)); 40617c478bd9Sstevel@tonic-gate yylabel(NULL); 40627c478bd9Sstevel@tonic-gate } 40637c478bd9Sstevel@tonic-gate 40647c478bd9Sstevel@tonic-gate if (dnp->dn_pred != NULL) { 40657c478bd9Sstevel@tonic-gate yylabel("predicate"); 40667c478bd9Sstevel@tonic-gate 40677c478bd9Sstevel@tonic-gate dnp->dn_pred = dt_node_cook(dnp->dn_pred, idflags); 40687c478bd9Sstevel@tonic-gate dt_node_attr_assign(dnp, 40697c478bd9Sstevel@tonic-gate dt_attr_min(dnp->dn_attr, dnp->dn_pred->dn_attr)); 40707c478bd9Sstevel@tonic-gate 40717c478bd9Sstevel@tonic-gate if (!dt_node_is_scalar(dnp->dn_pred)) { 40727c478bd9Sstevel@tonic-gate xyerror(D_PRED_SCALAR, 40737c478bd9Sstevel@tonic-gate "predicate result must be of scalar type\n"); 40747c478bd9Sstevel@tonic-gate } 40757c478bd9Sstevel@tonic-gate 40767c478bd9Sstevel@tonic-gate yylabel(NULL); 40777c478bd9Sstevel@tonic-gate } 40787c478bd9Sstevel@tonic-gate 40797c478bd9Sstevel@tonic-gate if (tries != 0) { 40807c478bd9Sstevel@tonic-gate yylabel("action list"); 40817c478bd9Sstevel@tonic-gate 40827c478bd9Sstevel@tonic-gate dt_node_attr_assign(dnp, 40837c478bd9Sstevel@tonic-gate dt_node_list_cook(&dnp->dn_acts, idflags)); 40847c478bd9Sstevel@tonic-gate 40857c478bd9Sstevel@tonic-gate yylabel(NULL); 40867c478bd9Sstevel@tonic-gate } 40877c478bd9Sstevel@tonic-gate 40887c478bd9Sstevel@tonic-gate return (dnp); 40897c478bd9Sstevel@tonic-gate } 40907c478bd9Sstevel@tonic-gate 40917c478bd9Sstevel@tonic-gate /*ARGSUSED*/ 40927c478bd9Sstevel@tonic-gate static dt_node_t * 40937c478bd9Sstevel@tonic-gate dt_cook_inline(dt_node_t *dnp, uint_t idflags) 40947c478bd9Sstevel@tonic-gate { 40957c478bd9Sstevel@tonic-gate dt_idnode_t *inp = dnp->dn_ident->di_iarg; 40967c478bd9Sstevel@tonic-gate dt_ident_t *rdp; 40977c478bd9Sstevel@tonic-gate 40987c478bd9Sstevel@tonic-gate char n1[DT_TYPE_NAMELEN]; 40997c478bd9Sstevel@tonic-gate char n2[DT_TYPE_NAMELEN]; 41007c478bd9Sstevel@tonic-gate 41017c478bd9Sstevel@tonic-gate assert(dnp->dn_ident->di_flags & DT_IDFLG_INLINE); 41027c478bd9Sstevel@tonic-gate assert(inp->din_root->dn_flags & DT_NF_COOKED); 41037c478bd9Sstevel@tonic-gate 41047c478bd9Sstevel@tonic-gate /* 41057c478bd9Sstevel@tonic-gate * If we are inlining a translation, verify that the inline declaration 41067c478bd9Sstevel@tonic-gate * type exactly matches the type that is returned by the translation. 41077c478bd9Sstevel@tonic-gate * Otherwise just use dt_node_is_argcompat() to check the types. 41087c478bd9Sstevel@tonic-gate */ 41097c478bd9Sstevel@tonic-gate if ((rdp = dt_node_resolve(inp->din_root, DT_IDENT_XLSOU)) != NULL || 41107c478bd9Sstevel@tonic-gate (rdp = dt_node_resolve(inp->din_root, DT_IDENT_XLPTR)) != NULL) { 41117c478bd9Sstevel@tonic-gate 41127c478bd9Sstevel@tonic-gate ctf_file_t *lctfp = dnp->dn_ctfp; 41137c478bd9Sstevel@tonic-gate ctf_id_t ltype = ctf_type_resolve(lctfp, dnp->dn_type); 41147c478bd9Sstevel@tonic-gate 41157c478bd9Sstevel@tonic-gate dt_xlator_t *dxp = rdp->di_data; 41167c478bd9Sstevel@tonic-gate ctf_file_t *rctfp = dxp->dx_dst_ctfp; 41177c478bd9Sstevel@tonic-gate ctf_id_t rtype = dxp->dx_dst_base; 41187c478bd9Sstevel@tonic-gate 41197c478bd9Sstevel@tonic-gate if (ctf_type_kind(lctfp, ltype) == CTF_K_POINTER) { 41207c478bd9Sstevel@tonic-gate ltype = ctf_type_reference(lctfp, ltype); 41217c478bd9Sstevel@tonic-gate ltype = ctf_type_resolve(lctfp, ltype); 41227c478bd9Sstevel@tonic-gate } 41237c478bd9Sstevel@tonic-gate 41247c478bd9Sstevel@tonic-gate if (ctf_type_compat(lctfp, ltype, rctfp, rtype) == 0) { 41257c478bd9Sstevel@tonic-gate dnerror(dnp, D_OP_INCOMPAT, 41267c478bd9Sstevel@tonic-gate "inline %s definition uses incompatible types: " 41277c478bd9Sstevel@tonic-gate "\"%s\" = \"%s\"\n", dnp->dn_ident->di_name, 41287c478bd9Sstevel@tonic-gate dt_type_name(lctfp, ltype, n1, sizeof (n1)), 41297c478bd9Sstevel@tonic-gate dt_type_name(rctfp, rtype, n2, sizeof (n2))); 41307c478bd9Sstevel@tonic-gate } 41317c478bd9Sstevel@tonic-gate 41327c478bd9Sstevel@tonic-gate } else if (dt_node_is_argcompat(dnp, inp->din_root) == 0) { 41337c478bd9Sstevel@tonic-gate dnerror(dnp, D_OP_INCOMPAT, 41347c478bd9Sstevel@tonic-gate "inline %s definition uses incompatible types: " 41357c478bd9Sstevel@tonic-gate "\"%s\" = \"%s\"\n", dnp->dn_ident->di_name, 41367c478bd9Sstevel@tonic-gate dt_node_type_name(dnp, n1, sizeof (n1)), 41377c478bd9Sstevel@tonic-gate dt_node_type_name(inp->din_root, n2, sizeof (n2))); 41387c478bd9Sstevel@tonic-gate } 41397c478bd9Sstevel@tonic-gate 41407c478bd9Sstevel@tonic-gate return (dnp); 41417c478bd9Sstevel@tonic-gate } 41427c478bd9Sstevel@tonic-gate 41437c478bd9Sstevel@tonic-gate static dt_node_t * 41447c478bd9Sstevel@tonic-gate dt_cook_member(dt_node_t *dnp, uint_t idflags) 41457c478bd9Sstevel@tonic-gate { 41467c478bd9Sstevel@tonic-gate dnp->dn_membexpr = dt_node_cook(dnp->dn_membexpr, idflags); 41477c478bd9Sstevel@tonic-gate dt_node_attr_assign(dnp, dnp->dn_membexpr->dn_attr); 41487c478bd9Sstevel@tonic-gate return (dnp); 41497c478bd9Sstevel@tonic-gate } 41507c478bd9Sstevel@tonic-gate 41517c478bd9Sstevel@tonic-gate /*ARGSUSED*/ 41527c478bd9Sstevel@tonic-gate static dt_node_t * 41537c478bd9Sstevel@tonic-gate dt_cook_xlator(dt_node_t *dnp, uint_t idflags) 41547c478bd9Sstevel@tonic-gate { 41557c478bd9Sstevel@tonic-gate dtrace_hdl_t *dtp = yypcb->pcb_hdl; 41567c478bd9Sstevel@tonic-gate dt_xlator_t *dxp = dnp->dn_xlator; 41577c478bd9Sstevel@tonic-gate dt_node_t *mnp; 41587c478bd9Sstevel@tonic-gate 41597c478bd9Sstevel@tonic-gate char n1[DT_TYPE_NAMELEN]; 41607c478bd9Sstevel@tonic-gate char n2[DT_TYPE_NAMELEN]; 41617c478bd9Sstevel@tonic-gate 41627c478bd9Sstevel@tonic-gate dtrace_attribute_t attr = _dtrace_maxattr; 41637c478bd9Sstevel@tonic-gate ctf_membinfo_t ctm; 41647c478bd9Sstevel@tonic-gate 41657c478bd9Sstevel@tonic-gate /* 41667c478bd9Sstevel@tonic-gate * Before cooking each translator member, we push a reference to the 41677c478bd9Sstevel@tonic-gate * hash containing translator-local identifiers on to pcb_globals to 41687c478bd9Sstevel@tonic-gate * temporarily interpose these identifiers in front of other globals. 41697c478bd9Sstevel@tonic-gate */ 41707c478bd9Sstevel@tonic-gate dt_idstack_push(&yypcb->pcb_globals, dxp->dx_locals); 41717c478bd9Sstevel@tonic-gate 41727c478bd9Sstevel@tonic-gate for (mnp = dnp->dn_members; mnp != NULL; mnp = mnp->dn_list) { 41737c478bd9Sstevel@tonic-gate if (ctf_member_info(dxp->dx_dst_ctfp, dxp->dx_dst_type, 41747c478bd9Sstevel@tonic-gate mnp->dn_membname, &ctm) == CTF_ERR) { 41757c478bd9Sstevel@tonic-gate xyerror(D_XLATE_MEMB, 41767c478bd9Sstevel@tonic-gate "translator member %s is not a member of %s\n", 41777c478bd9Sstevel@tonic-gate mnp->dn_membname, ctf_type_name(dxp->dx_dst_ctfp, 41787c478bd9Sstevel@tonic-gate dxp->dx_dst_type, n1, sizeof (n1))); 41797c478bd9Sstevel@tonic-gate } 41807c478bd9Sstevel@tonic-gate 41817c478bd9Sstevel@tonic-gate (void) dt_node_cook(mnp, DT_IDFLG_REF); 41827c478bd9Sstevel@tonic-gate dt_node_type_assign(mnp, dxp->dx_dst_ctfp, ctm.ctm_type); 41837c478bd9Sstevel@tonic-gate attr = dt_attr_min(attr, mnp->dn_attr); 41847c478bd9Sstevel@tonic-gate 41857c478bd9Sstevel@tonic-gate if (dt_node_is_argcompat(mnp, mnp->dn_membexpr) == 0) { 41867c478bd9Sstevel@tonic-gate xyerror(D_XLATE_INCOMPAT, 41877c478bd9Sstevel@tonic-gate "translator member %s definition uses " 41887c478bd9Sstevel@tonic-gate "incompatible types: \"%s\" = \"%s\"\n", 41897c478bd9Sstevel@tonic-gate mnp->dn_membname, 41907c478bd9Sstevel@tonic-gate dt_node_type_name(mnp, n1, sizeof (n1)), 41917c478bd9Sstevel@tonic-gate dt_node_type_name(mnp->dn_membexpr, 41927c478bd9Sstevel@tonic-gate n2, sizeof (n2))); 41937c478bd9Sstevel@tonic-gate } 41947c478bd9Sstevel@tonic-gate } 41957c478bd9Sstevel@tonic-gate 41967c478bd9Sstevel@tonic-gate dt_idstack_pop(&yypcb->pcb_globals, dxp->dx_locals); 41977c478bd9Sstevel@tonic-gate 41987c478bd9Sstevel@tonic-gate dxp->dx_souid.di_attr = attr; 41997c478bd9Sstevel@tonic-gate dxp->dx_ptrid.di_attr = attr; 42007c478bd9Sstevel@tonic-gate 42017c478bd9Sstevel@tonic-gate dt_node_type_assign(dnp, DT_DYN_CTFP(dtp), DT_DYN_TYPE(dtp)); 42027c478bd9Sstevel@tonic-gate dt_node_attr_assign(dnp, _dtrace_defattr); 42037c478bd9Sstevel@tonic-gate 42047c478bd9Sstevel@tonic-gate return (dnp); 42057c478bd9Sstevel@tonic-gate } 42067c478bd9Sstevel@tonic-gate 42077c478bd9Sstevel@tonic-gate static void 42087c478bd9Sstevel@tonic-gate dt_node_provider_cmp_argv(dt_provider_t *pvp, dt_node_t *pnp, const char *kind, 42097c478bd9Sstevel@tonic-gate uint_t old_argc, dt_node_t *old_argv, uint_t new_argc, dt_node_t *new_argv) 42107c478bd9Sstevel@tonic-gate { 42117c478bd9Sstevel@tonic-gate dt_probe_t *prp = pnp->dn_ident->di_data; 42127c478bd9Sstevel@tonic-gate uint_t i; 42137c478bd9Sstevel@tonic-gate 42147c478bd9Sstevel@tonic-gate char n1[DT_TYPE_NAMELEN]; 42157c478bd9Sstevel@tonic-gate char n2[DT_TYPE_NAMELEN]; 42167c478bd9Sstevel@tonic-gate 42177c478bd9Sstevel@tonic-gate if (old_argc != new_argc) { 42187c478bd9Sstevel@tonic-gate dnerror(pnp, D_PROV_INCOMPAT, 42197c478bd9Sstevel@tonic-gate "probe %s:%s %s prototype mismatch:\n" 42207c478bd9Sstevel@tonic-gate "\t current: %u arg%s\n\tprevious: %u arg%s\n", 42217c478bd9Sstevel@tonic-gate pvp->pv_desc.dtvd_name, prp->pr_ident->di_name, kind, 42227c478bd9Sstevel@tonic-gate new_argc, new_argc != 1 ? "s" : "", 42237c478bd9Sstevel@tonic-gate old_argc, old_argc != 1 ? "s" : ""); 42247c478bd9Sstevel@tonic-gate } 42257c478bd9Sstevel@tonic-gate 42267c478bd9Sstevel@tonic-gate for (i = 0; i < old_argc; i++, 42277c478bd9Sstevel@tonic-gate old_argv = old_argv->dn_list, new_argv = new_argv->dn_list) { 42287c478bd9Sstevel@tonic-gate if (ctf_type_cmp(old_argv->dn_ctfp, old_argv->dn_type, 42297c478bd9Sstevel@tonic-gate new_argv->dn_ctfp, new_argv->dn_type) == 0) 42307c478bd9Sstevel@tonic-gate continue; 42317c478bd9Sstevel@tonic-gate 42327c478bd9Sstevel@tonic-gate dnerror(pnp, D_PROV_INCOMPAT, 42337c478bd9Sstevel@tonic-gate "probe %s:%s %s prototype argument #%u mismatch:\n" 42347c478bd9Sstevel@tonic-gate "\t current: %s\n\tprevious: %s\n", 42357c478bd9Sstevel@tonic-gate pvp->pv_desc.dtvd_name, prp->pr_ident->di_name, kind, i + 1, 42367c478bd9Sstevel@tonic-gate dt_node_type_name(new_argv, n1, sizeof (n1)), 42377c478bd9Sstevel@tonic-gate dt_node_type_name(old_argv, n2, sizeof (n2))); 42387c478bd9Sstevel@tonic-gate } 42397c478bd9Sstevel@tonic-gate } 42407c478bd9Sstevel@tonic-gate 42417c478bd9Sstevel@tonic-gate /* 42427c478bd9Sstevel@tonic-gate * Compare a new probe declaration with an existing probe definition (either 42431a7c1b72Smws * from a previous declaration or cached from the kernel). If the existing 42441a7c1b72Smws * definition and declaration both have an input and output parameter list, 42451a7c1b72Smws * compare both lists. Otherwise compare only the output parameter lists. 42467c478bd9Sstevel@tonic-gate */ 42477c478bd9Sstevel@tonic-gate static void 42487c478bd9Sstevel@tonic-gate dt_node_provider_cmp(dt_provider_t *pvp, dt_node_t *pnp, 42497c478bd9Sstevel@tonic-gate dt_probe_t *old, dt_probe_t *new) 42507c478bd9Sstevel@tonic-gate { 42517c478bd9Sstevel@tonic-gate dt_node_provider_cmp_argv(pvp, pnp, "output", 42527c478bd9Sstevel@tonic-gate old->pr_xargc, old->pr_xargs, new->pr_xargc, new->pr_xargs); 42537c478bd9Sstevel@tonic-gate 42541a7c1b72Smws if (old->pr_nargs != old->pr_xargs && new->pr_nargs != new->pr_xargs) { 42557c478bd9Sstevel@tonic-gate dt_node_provider_cmp_argv(pvp, pnp, "input", 42567c478bd9Sstevel@tonic-gate old->pr_nargc, old->pr_nargs, new->pr_nargc, new->pr_nargs); 42577c478bd9Sstevel@tonic-gate } 42581a7c1b72Smws 42591a7c1b72Smws if (old->pr_nargs == old->pr_xargs && new->pr_nargs != new->pr_xargs) { 42601a7c1b72Smws if (pvp->pv_flags & DT_PROVIDER_IMPL) { 42611a7c1b72Smws dnerror(pnp, D_PROV_INCOMPAT, 42621a7c1b72Smws "provider interface mismatch: %s\n" 42631a7c1b72Smws "\t current: probe %s:%s has an output prototype\n" 42641a7c1b72Smws "\tprevious: probe %s:%s has no output prototype\n", 42651a7c1b72Smws pvp->pv_desc.dtvd_name, pvp->pv_desc.dtvd_name, 42661a7c1b72Smws new->pr_ident->di_name, pvp->pv_desc.dtvd_name, 42671a7c1b72Smws old->pr_ident->di_name); 42681a7c1b72Smws } 42691a7c1b72Smws 42701a7c1b72Smws if (old->pr_ident->di_gen == yypcb->pcb_hdl->dt_gen) 42711a7c1b72Smws old->pr_ident->di_flags |= DT_IDFLG_ORPHAN; 42721a7c1b72Smws 42731a7c1b72Smws dt_idhash_delete(pvp->pv_probes, old->pr_ident); 42741a7c1b72Smws dt_probe_declare(pvp, new); 42751a7c1b72Smws } 42761a7c1b72Smws } 42771a7c1b72Smws 42781a7c1b72Smws static void 42791a7c1b72Smws dt_cook_probe(dt_node_t *dnp, dt_provider_t *pvp) 42801a7c1b72Smws { 42811a7c1b72Smws dtrace_hdl_t *dtp = yypcb->pcb_hdl; 42821a7c1b72Smws dt_probe_t *prp = dnp->dn_ident->di_data; 42831a7c1b72Smws 42841a7c1b72Smws dt_xlator_t *dxp; 42851a7c1b72Smws uint_t i; 42861a7c1b72Smws 42871a7c1b72Smws char n1[DT_TYPE_NAMELEN]; 42881a7c1b72Smws char n2[DT_TYPE_NAMELEN]; 42891a7c1b72Smws 42901a7c1b72Smws if (prp->pr_nargs == prp->pr_xargs) 42911a7c1b72Smws return; 42921a7c1b72Smws 42931a7c1b72Smws for (i = 0; i < prp->pr_xargc; i++) { 42941a7c1b72Smws dt_node_t *xnp = prp->pr_xargv[i]; 42951a7c1b72Smws dt_node_t *nnp = prp->pr_nargv[prp->pr_mapping[i]]; 42961a7c1b72Smws 42971a7c1b72Smws if ((dxp = dt_xlator_lookup(dtp, 42981a7c1b72Smws nnp, xnp, DT_XLATE_FUZZY)) != NULL) { 42991a7c1b72Smws if (dt_provider_xref(dtp, pvp, dxp->dx_id) != 0) 43001a7c1b72Smws longjmp(yypcb->pcb_jmpbuf, EDT_NOMEM); 43011a7c1b72Smws continue; 43021a7c1b72Smws } 43031a7c1b72Smws 43041a7c1b72Smws if (dt_node_is_argcompat(nnp, xnp)) 43051a7c1b72Smws continue; /* no translator defined and none required */ 43061a7c1b72Smws 43071a7c1b72Smws dnerror(dnp, D_PROV_PRXLATOR, "translator for %s:%s output " 43081a7c1b72Smws "argument #%u from %s to %s is not defined\n", 43091a7c1b72Smws pvp->pv_desc.dtvd_name, dnp->dn_ident->di_name, i + 1, 43101a7c1b72Smws dt_node_type_name(nnp, n1, sizeof (n1)), 43111a7c1b72Smws dt_node_type_name(xnp, n2, sizeof (n2))); 43121a7c1b72Smws } 43137c478bd9Sstevel@tonic-gate } 43147c478bd9Sstevel@tonic-gate 43157c478bd9Sstevel@tonic-gate /*ARGSUSED*/ 43167c478bd9Sstevel@tonic-gate static dt_node_t * 43177c478bd9Sstevel@tonic-gate dt_cook_provider(dt_node_t *dnp, uint_t idflags) 43187c478bd9Sstevel@tonic-gate { 43197c478bd9Sstevel@tonic-gate dt_provider_t *pvp = dnp->dn_provider; 43207c478bd9Sstevel@tonic-gate dt_node_t *pnp; 43217c478bd9Sstevel@tonic-gate 43227c478bd9Sstevel@tonic-gate /* 43237c478bd9Sstevel@tonic-gate * If we're declaring a provider for the first time and it is unknown 43247c478bd9Sstevel@tonic-gate * to dtrace(7D), insert the probe definitions into the provider's hash. 43257c478bd9Sstevel@tonic-gate * If we're redeclaring a known provider, verify the interface matches. 43267c478bd9Sstevel@tonic-gate */ 43277c478bd9Sstevel@tonic-gate for (pnp = dnp->dn_probes; pnp != NULL; pnp = pnp->dn_list) { 43287c478bd9Sstevel@tonic-gate const char *probename = pnp->dn_ident->di_name; 43297c478bd9Sstevel@tonic-gate dt_probe_t *prp = dt_probe_lookup(pvp, probename); 43307c478bd9Sstevel@tonic-gate 43317c478bd9Sstevel@tonic-gate assert(pnp->dn_kind == DT_NODE_PROBE); 43327c478bd9Sstevel@tonic-gate 43337c478bd9Sstevel@tonic-gate if (prp != NULL && dnp->dn_provred) { 43347c478bd9Sstevel@tonic-gate dt_node_provider_cmp(pvp, pnp, 43357c478bd9Sstevel@tonic-gate prp, pnp->dn_ident->di_data); 43367c478bd9Sstevel@tonic-gate } else if (prp == NULL && dnp->dn_provred) { 43377c478bd9Sstevel@tonic-gate dnerror(pnp, D_PROV_INCOMPAT, 43387c478bd9Sstevel@tonic-gate "provider interface mismatch: %s\n" 43397c478bd9Sstevel@tonic-gate "\t current: probe %s:%s defined\n" 43407c478bd9Sstevel@tonic-gate "\tprevious: probe %s:%s not defined\n", 43417c478bd9Sstevel@tonic-gate dnp->dn_provname, dnp->dn_provname, 43427c478bd9Sstevel@tonic-gate probename, dnp->dn_provname, probename); 43437c478bd9Sstevel@tonic-gate } else if (prp != NULL) { 43447c478bd9Sstevel@tonic-gate dnerror(pnp, D_PROV_PRDUP, "probe redeclared: %s:%s\n", 43457c478bd9Sstevel@tonic-gate dnp->dn_provname, probename); 43467c478bd9Sstevel@tonic-gate } else 43477c478bd9Sstevel@tonic-gate dt_probe_declare(pvp, pnp->dn_ident->di_data); 43481a7c1b72Smws 43491a7c1b72Smws dt_cook_probe(pnp, pvp); 43507c478bd9Sstevel@tonic-gate } 43517c478bd9Sstevel@tonic-gate 43527c478bd9Sstevel@tonic-gate return (dnp); 43537c478bd9Sstevel@tonic-gate } 43547c478bd9Sstevel@tonic-gate 43557c478bd9Sstevel@tonic-gate /*ARGSUSED*/ 43567c478bd9Sstevel@tonic-gate static dt_node_t * 43577c478bd9Sstevel@tonic-gate dt_cook_none(dt_node_t *dnp, uint_t idflags) 43587c478bd9Sstevel@tonic-gate { 43597c478bd9Sstevel@tonic-gate return (dnp); 43607c478bd9Sstevel@tonic-gate } 43617c478bd9Sstevel@tonic-gate 43627c478bd9Sstevel@tonic-gate static dt_node_t *(*dt_cook_funcs[])(dt_node_t *, uint_t) = { 43637c478bd9Sstevel@tonic-gate dt_cook_none, /* DT_NODE_FREE */ 43647c478bd9Sstevel@tonic-gate dt_cook_none, /* DT_NODE_INT */ 43657c478bd9Sstevel@tonic-gate dt_cook_none, /* DT_NODE_STRING */ 43667c478bd9Sstevel@tonic-gate dt_cook_ident, /* DT_NODE_IDENT */ 43677c478bd9Sstevel@tonic-gate dt_cook_var, /* DT_NODE_VAR */ 43687c478bd9Sstevel@tonic-gate dt_cook_none, /* DT_NODE_SYM */ 43697c478bd9Sstevel@tonic-gate dt_cook_none, /* DT_NODE_TYPE */ 43707c478bd9Sstevel@tonic-gate dt_cook_func, /* DT_NODE_FUNC */ 43717c478bd9Sstevel@tonic-gate dt_cook_op1, /* DT_NODE_OP1 */ 43727c478bd9Sstevel@tonic-gate dt_cook_op2, /* DT_NODE_OP2 */ 43737c478bd9Sstevel@tonic-gate dt_cook_op3, /* DT_NODE_OP3 */ 43747c478bd9Sstevel@tonic-gate dt_cook_statement, /* DT_NODE_DEXPR */ 43757c478bd9Sstevel@tonic-gate dt_cook_statement, /* DT_NODE_DFUNC */ 43767c478bd9Sstevel@tonic-gate dt_cook_aggregation, /* DT_NODE_AGG */ 43777c478bd9Sstevel@tonic-gate dt_cook_none, /* DT_NODE_PDESC */ 43787c478bd9Sstevel@tonic-gate dt_cook_clause, /* DT_NODE_CLAUSE */ 43797c478bd9Sstevel@tonic-gate dt_cook_inline, /* DT_NODE_INLINE */ 43807c478bd9Sstevel@tonic-gate dt_cook_member, /* DT_NODE_MEMBER */ 43817c478bd9Sstevel@tonic-gate dt_cook_xlator, /* DT_NODE_XLATOR */ 43827c478bd9Sstevel@tonic-gate dt_cook_none, /* DT_NODE_PROBE */ 43837c478bd9Sstevel@tonic-gate dt_cook_provider, /* DT_NODE_PROVIDER */ 43847c478bd9Sstevel@tonic-gate dt_cook_none /* DT_NODE_PROG */ 43857c478bd9Sstevel@tonic-gate }; 43867c478bd9Sstevel@tonic-gate 43877c478bd9Sstevel@tonic-gate /* 43887c478bd9Sstevel@tonic-gate * Recursively cook the parse tree starting at the specified node. The idflags 43897c478bd9Sstevel@tonic-gate * parameter is used to indicate the type of reference (r/w) and is applied to 43907c478bd9Sstevel@tonic-gate * the resulting identifier if it is a D variable or D aggregation. 43917c478bd9Sstevel@tonic-gate */ 43927c478bd9Sstevel@tonic-gate dt_node_t * 43937c478bd9Sstevel@tonic-gate dt_node_cook(dt_node_t *dnp, uint_t idflags) 43947c478bd9Sstevel@tonic-gate { 43957c478bd9Sstevel@tonic-gate int oldlineno = yylineno; 43967c478bd9Sstevel@tonic-gate 43977c478bd9Sstevel@tonic-gate yylineno = dnp->dn_line; 43987c478bd9Sstevel@tonic-gate 43997c478bd9Sstevel@tonic-gate dnp = dt_cook_funcs[dnp->dn_kind](dnp, idflags); 44007c478bd9Sstevel@tonic-gate dnp->dn_flags |= DT_NF_COOKED; 44017c478bd9Sstevel@tonic-gate 44027c478bd9Sstevel@tonic-gate if (dnp->dn_kind == DT_NODE_VAR || dnp->dn_kind == DT_NODE_AGG) 44037c478bd9Sstevel@tonic-gate dnp->dn_ident->di_flags |= idflags; 44047c478bd9Sstevel@tonic-gate 44057c478bd9Sstevel@tonic-gate yylineno = oldlineno; 44067c478bd9Sstevel@tonic-gate return (dnp); 44077c478bd9Sstevel@tonic-gate } 44087c478bd9Sstevel@tonic-gate 44097c478bd9Sstevel@tonic-gate dtrace_attribute_t 44107c478bd9Sstevel@tonic-gate dt_node_list_cook(dt_node_t **pnp, uint_t idflags) 44117c478bd9Sstevel@tonic-gate { 44127c478bd9Sstevel@tonic-gate dtrace_attribute_t attr = _dtrace_defattr; 44137c478bd9Sstevel@tonic-gate dt_node_t *dnp, *nnp; 44147c478bd9Sstevel@tonic-gate 44157c478bd9Sstevel@tonic-gate for (dnp = (pnp != NULL ? *pnp : NULL); dnp != NULL; dnp = nnp) { 44167c478bd9Sstevel@tonic-gate nnp = dnp->dn_list; 44177c478bd9Sstevel@tonic-gate dnp = *pnp = dt_node_cook(dnp, idflags); 44187c478bd9Sstevel@tonic-gate attr = dt_attr_min(attr, dnp->dn_attr); 44197c478bd9Sstevel@tonic-gate dnp->dn_list = nnp; 44207c478bd9Sstevel@tonic-gate pnp = &dnp->dn_list; 44217c478bd9Sstevel@tonic-gate } 44227c478bd9Sstevel@tonic-gate 44237c478bd9Sstevel@tonic-gate return (attr); 44247c478bd9Sstevel@tonic-gate } 44257c478bd9Sstevel@tonic-gate 44267c478bd9Sstevel@tonic-gate void 44277c478bd9Sstevel@tonic-gate dt_node_list_free(dt_node_t **pnp) 44287c478bd9Sstevel@tonic-gate { 44297c478bd9Sstevel@tonic-gate dt_node_t *dnp, *nnp; 44307c478bd9Sstevel@tonic-gate 44317c478bd9Sstevel@tonic-gate for (dnp = (pnp != NULL ? *pnp : NULL); dnp != NULL; dnp = nnp) { 44327c478bd9Sstevel@tonic-gate nnp = dnp->dn_list; 44337c478bd9Sstevel@tonic-gate dt_node_free(dnp); 44347c478bd9Sstevel@tonic-gate } 44357c478bd9Sstevel@tonic-gate 44367c478bd9Sstevel@tonic-gate if (pnp != NULL) 44377c478bd9Sstevel@tonic-gate *pnp = NULL; 44387c478bd9Sstevel@tonic-gate } 44397c478bd9Sstevel@tonic-gate 44407c478bd9Sstevel@tonic-gate void 44417c478bd9Sstevel@tonic-gate dt_node_link_free(dt_node_t **pnp) 44427c478bd9Sstevel@tonic-gate { 44437c478bd9Sstevel@tonic-gate dt_node_t *dnp, *nnp; 44447c478bd9Sstevel@tonic-gate 44457c478bd9Sstevel@tonic-gate for (dnp = (pnp != NULL ? *pnp : NULL); dnp != NULL; dnp = nnp) { 44467c478bd9Sstevel@tonic-gate nnp = dnp->dn_link; 44477c478bd9Sstevel@tonic-gate dt_node_free(dnp); 44487c478bd9Sstevel@tonic-gate } 44497c478bd9Sstevel@tonic-gate 44507c478bd9Sstevel@tonic-gate for (dnp = (pnp != NULL ? *pnp : NULL); dnp != NULL; dnp = nnp) { 44517c478bd9Sstevel@tonic-gate nnp = dnp->dn_link; 44527c478bd9Sstevel@tonic-gate free(dnp); 44537c478bd9Sstevel@tonic-gate } 44547c478bd9Sstevel@tonic-gate 44557c478bd9Sstevel@tonic-gate if (pnp != NULL) 44567c478bd9Sstevel@tonic-gate *pnp = NULL; 44577c478bd9Sstevel@tonic-gate } 44587c478bd9Sstevel@tonic-gate 44597c478bd9Sstevel@tonic-gate dt_node_t * 44607c478bd9Sstevel@tonic-gate dt_node_link(dt_node_t *lp, dt_node_t *rp) 44617c478bd9Sstevel@tonic-gate { 44627c478bd9Sstevel@tonic-gate dt_node_t *dnp; 44637c478bd9Sstevel@tonic-gate 44647c478bd9Sstevel@tonic-gate if (lp == NULL) 44657c478bd9Sstevel@tonic-gate return (rp); 44667c478bd9Sstevel@tonic-gate else if (rp == NULL) 44677c478bd9Sstevel@tonic-gate return (lp); 44687c478bd9Sstevel@tonic-gate 44697c478bd9Sstevel@tonic-gate for (dnp = lp; dnp->dn_list != NULL; dnp = dnp->dn_list) 44707c478bd9Sstevel@tonic-gate continue; 44717c478bd9Sstevel@tonic-gate 44727c478bd9Sstevel@tonic-gate dnp->dn_list = rp; 44737c478bd9Sstevel@tonic-gate return (lp); 44747c478bd9Sstevel@tonic-gate } 44757c478bd9Sstevel@tonic-gate 44761a7c1b72Smws /* 44771a7c1b72Smws * Compute the DOF dtrace_diftype_t representation of a node's type. This is 44781a7c1b72Smws * called from a variety of places in the library so it cannot assume yypcb 44791a7c1b72Smws * is valid: any references to handle-specific data must be made through 'dtp'. 44801a7c1b72Smws */ 44817c478bd9Sstevel@tonic-gate void 44821a7c1b72Smws dt_node_diftype(dtrace_hdl_t *dtp, const dt_node_t *dnp, dtrace_diftype_t *tp) 44837c478bd9Sstevel@tonic-gate { 44841a7c1b72Smws if (dnp->dn_ctfp == DT_STR_CTFP(dtp) && 44851a7c1b72Smws dnp->dn_type == DT_STR_TYPE(dtp)) { 44867c478bd9Sstevel@tonic-gate tp->dtdt_kind = DIF_TYPE_STRING; 44877c478bd9Sstevel@tonic-gate tp->dtdt_ckind = CTF_K_UNKNOWN; 44887c478bd9Sstevel@tonic-gate } else { 44897c478bd9Sstevel@tonic-gate tp->dtdt_kind = DIF_TYPE_CTF; 44907c478bd9Sstevel@tonic-gate tp->dtdt_ckind = ctf_type_kind(dnp->dn_ctfp, 44917c478bd9Sstevel@tonic-gate ctf_type_resolve(dnp->dn_ctfp, dnp->dn_type)); 44927c478bd9Sstevel@tonic-gate } 44937c478bd9Sstevel@tonic-gate 44947c478bd9Sstevel@tonic-gate tp->dtdt_flags = (dnp->dn_flags & DT_NF_REF) ? DIF_TF_BYREF : 0; 44957c478bd9Sstevel@tonic-gate tp->dtdt_pad = 0; 44967c478bd9Sstevel@tonic-gate tp->dtdt_size = ctf_type_size(dnp->dn_ctfp, dnp->dn_type); 44977c478bd9Sstevel@tonic-gate } 44987c478bd9Sstevel@tonic-gate 44997c478bd9Sstevel@tonic-gate void 45007c478bd9Sstevel@tonic-gate dt_node_printr(dt_node_t *dnp, FILE *fp, int depth) 45017c478bd9Sstevel@tonic-gate { 45027c478bd9Sstevel@tonic-gate char n[DT_TYPE_NAMELEN], buf[BUFSIZ], a[8]; 45037c478bd9Sstevel@tonic-gate const dtrace_syminfo_t *dts; 45047c478bd9Sstevel@tonic-gate const dt_idnode_t *inp; 45057c478bd9Sstevel@tonic-gate dt_node_t *arg; 45067c478bd9Sstevel@tonic-gate 45077c478bd9Sstevel@tonic-gate (void) fprintf(fp, "%*s", depth * 2, ""); 45087c478bd9Sstevel@tonic-gate (void) dt_attr_str(dnp->dn_attr, a, sizeof (a)); 45097c478bd9Sstevel@tonic-gate 45107c478bd9Sstevel@tonic-gate if (dnp->dn_ctfp != NULL && dnp->dn_type != CTF_ERR && 45117c478bd9Sstevel@tonic-gate ctf_type_name(dnp->dn_ctfp, dnp->dn_type, n, sizeof (n)) != NULL) { 45127c478bd9Sstevel@tonic-gate (void) snprintf(buf, BUFSIZ, "type=<%s> attr=%s flags=", n, a); 45137c478bd9Sstevel@tonic-gate } else { 45147c478bd9Sstevel@tonic-gate (void) snprintf(buf, BUFSIZ, "type=<%ld> attr=%s flags=", 45157c478bd9Sstevel@tonic-gate dnp->dn_type, a); 45167c478bd9Sstevel@tonic-gate } 45177c478bd9Sstevel@tonic-gate 45187c478bd9Sstevel@tonic-gate if (dnp->dn_flags != 0) { 45197c478bd9Sstevel@tonic-gate n[0] = '\0'; 45207c478bd9Sstevel@tonic-gate if (dnp->dn_flags & DT_NF_SIGNED) 45217c478bd9Sstevel@tonic-gate (void) strcat(n, ",SIGN"); 45227c478bd9Sstevel@tonic-gate if (dnp->dn_flags & DT_NF_COOKED) 45237c478bd9Sstevel@tonic-gate (void) strcat(n, ",COOK"); 45247c478bd9Sstevel@tonic-gate if (dnp->dn_flags & DT_NF_REF) 45257c478bd9Sstevel@tonic-gate (void) strcat(n, ",REF"); 45267c478bd9Sstevel@tonic-gate if (dnp->dn_flags & DT_NF_LVALUE) 45277c478bd9Sstevel@tonic-gate (void) strcat(n, ",LVAL"); 45287c478bd9Sstevel@tonic-gate if (dnp->dn_flags & DT_NF_WRITABLE) 45297c478bd9Sstevel@tonic-gate (void) strcat(n, ",WRITE"); 45307c478bd9Sstevel@tonic-gate if (dnp->dn_flags & DT_NF_BITFIELD) 45317c478bd9Sstevel@tonic-gate (void) strcat(n, ",BITF"); 45327c478bd9Sstevel@tonic-gate if (dnp->dn_flags & DT_NF_USERLAND) 45337c478bd9Sstevel@tonic-gate (void) strcat(n, ",USER"); 45347c478bd9Sstevel@tonic-gate (void) strcat(buf, n + 1); 45357c478bd9Sstevel@tonic-gate } else 45367c478bd9Sstevel@tonic-gate (void) strcat(buf, "0"); 45377c478bd9Sstevel@tonic-gate 45387c478bd9Sstevel@tonic-gate switch (dnp->dn_kind) { 45397c478bd9Sstevel@tonic-gate case DT_NODE_FREE: 45407c478bd9Sstevel@tonic-gate (void) fprintf(fp, "FREE <node %p>\n", (void *)dnp); 45417c478bd9Sstevel@tonic-gate break; 45427c478bd9Sstevel@tonic-gate 45437c478bd9Sstevel@tonic-gate case DT_NODE_INT: 45447c478bd9Sstevel@tonic-gate (void) fprintf(fp, "INT 0x%llx (%s)\n", 45457c478bd9Sstevel@tonic-gate (u_longlong_t)dnp->dn_value, buf); 45467c478bd9Sstevel@tonic-gate break; 45477c478bd9Sstevel@tonic-gate 45487c478bd9Sstevel@tonic-gate case DT_NODE_STRING: 45497c478bd9Sstevel@tonic-gate (void) fprintf(fp, "STRING \"%s\" (%s)\n", dnp->dn_string, buf); 45507c478bd9Sstevel@tonic-gate break; 45517c478bd9Sstevel@tonic-gate 45527c478bd9Sstevel@tonic-gate case DT_NODE_IDENT: 45537c478bd9Sstevel@tonic-gate (void) fprintf(fp, "IDENT %s (%s)\n", dnp->dn_string, buf); 45547c478bd9Sstevel@tonic-gate break; 45557c478bd9Sstevel@tonic-gate 45567c478bd9Sstevel@tonic-gate case DT_NODE_VAR: 45577c478bd9Sstevel@tonic-gate (void) fprintf(fp, "VARIABLE %s%s (%s)\n", 45587c478bd9Sstevel@tonic-gate (dnp->dn_ident->di_flags & DT_IDFLG_LOCAL) ? "this->" : 45597c478bd9Sstevel@tonic-gate (dnp->dn_ident->di_flags & DT_IDFLG_TLS) ? "self->" : "", 45607c478bd9Sstevel@tonic-gate dnp->dn_ident->di_name, buf); 45617c478bd9Sstevel@tonic-gate 45627c478bd9Sstevel@tonic-gate if (dnp->dn_args != NULL) 45637c478bd9Sstevel@tonic-gate (void) fprintf(fp, "%*s[\n", depth * 2, ""); 45647c478bd9Sstevel@tonic-gate 45657c478bd9Sstevel@tonic-gate for (arg = dnp->dn_args; arg != NULL; arg = arg->dn_list) { 45667c478bd9Sstevel@tonic-gate dt_node_printr(arg, fp, depth + 1); 45677c478bd9Sstevel@tonic-gate if (arg->dn_list != NULL) 45687c478bd9Sstevel@tonic-gate (void) fprintf(fp, "%*s,\n", depth * 2, ""); 45697c478bd9Sstevel@tonic-gate } 45707c478bd9Sstevel@tonic-gate 45717c478bd9Sstevel@tonic-gate if (dnp->dn_args != NULL) 45727c478bd9Sstevel@tonic-gate (void) fprintf(fp, "%*s]\n", depth * 2, ""); 45737c478bd9Sstevel@tonic-gate break; 45747c478bd9Sstevel@tonic-gate 45757c478bd9Sstevel@tonic-gate case DT_NODE_SYM: 45767c478bd9Sstevel@tonic-gate dts = dnp->dn_ident->di_data; 45777c478bd9Sstevel@tonic-gate (void) fprintf(fp, "SYMBOL %s`%s (%s)\n", 45787c478bd9Sstevel@tonic-gate dts->dts_object, dts->dts_name, buf); 45797c478bd9Sstevel@tonic-gate break; 45807c478bd9Sstevel@tonic-gate 45817c478bd9Sstevel@tonic-gate case DT_NODE_TYPE: 45827c478bd9Sstevel@tonic-gate if (dnp->dn_string != NULL) { 45837c478bd9Sstevel@tonic-gate (void) fprintf(fp, "TYPE (%s) %s\n", 45847c478bd9Sstevel@tonic-gate buf, dnp->dn_string); 45857c478bd9Sstevel@tonic-gate } else 45867c478bd9Sstevel@tonic-gate (void) fprintf(fp, "TYPE (%s)\n", buf); 45877c478bd9Sstevel@tonic-gate break; 45887c478bd9Sstevel@tonic-gate 45897c478bd9Sstevel@tonic-gate case DT_NODE_FUNC: 45907c478bd9Sstevel@tonic-gate (void) fprintf(fp, "FUNC %s (%s)\n", 45917c478bd9Sstevel@tonic-gate dnp->dn_ident->di_name, buf); 45927c478bd9Sstevel@tonic-gate 45937c478bd9Sstevel@tonic-gate for (arg = dnp->dn_args; arg != NULL; arg = arg->dn_list) { 45947c478bd9Sstevel@tonic-gate dt_node_printr(arg, fp, depth + 1); 45957c478bd9Sstevel@tonic-gate if (arg->dn_list != NULL) 45967c478bd9Sstevel@tonic-gate (void) fprintf(fp, "%*s,\n", depth * 2, ""); 45977c478bd9Sstevel@tonic-gate } 45987c478bd9Sstevel@tonic-gate break; 45997c478bd9Sstevel@tonic-gate 46007c478bd9Sstevel@tonic-gate case DT_NODE_OP1: 46017c478bd9Sstevel@tonic-gate (void) fprintf(fp, "OP1 %s (%s)\n", opstr(dnp->dn_op), buf); 46027c478bd9Sstevel@tonic-gate dt_node_printr(dnp->dn_child, fp, depth + 1); 46037c478bd9Sstevel@tonic-gate break; 46047c478bd9Sstevel@tonic-gate 46057c478bd9Sstevel@tonic-gate case DT_NODE_OP2: 46067c478bd9Sstevel@tonic-gate (void) fprintf(fp, "OP2 %s (%s)\n", opstr(dnp->dn_op), buf); 46077c478bd9Sstevel@tonic-gate dt_node_printr(dnp->dn_left, fp, depth + 1); 46087c478bd9Sstevel@tonic-gate dt_node_printr(dnp->dn_right, fp, depth + 1); 46097c478bd9Sstevel@tonic-gate break; 46107c478bd9Sstevel@tonic-gate 46117c478bd9Sstevel@tonic-gate case DT_NODE_OP3: 46127c478bd9Sstevel@tonic-gate (void) fprintf(fp, "OP3 (%s)\n", buf); 46137c478bd9Sstevel@tonic-gate dt_node_printr(dnp->dn_expr, fp, depth + 1); 46147c478bd9Sstevel@tonic-gate (void) fprintf(fp, "%*s?\n", depth * 2, ""); 46157c478bd9Sstevel@tonic-gate dt_node_printr(dnp->dn_left, fp, depth + 1); 46167c478bd9Sstevel@tonic-gate (void) fprintf(fp, "%*s:\n", depth * 2, ""); 46177c478bd9Sstevel@tonic-gate dt_node_printr(dnp->dn_right, fp, depth + 1); 46187c478bd9Sstevel@tonic-gate break; 46197c478bd9Sstevel@tonic-gate 46207c478bd9Sstevel@tonic-gate case DT_NODE_DEXPR: 46217c478bd9Sstevel@tonic-gate case DT_NODE_DFUNC: 46227c478bd9Sstevel@tonic-gate (void) fprintf(fp, "D EXPRESSION attr=%s\n", a); 46237c478bd9Sstevel@tonic-gate dt_node_printr(dnp->dn_expr, fp, depth + 1); 46247c478bd9Sstevel@tonic-gate break; 46257c478bd9Sstevel@tonic-gate 46267c478bd9Sstevel@tonic-gate case DT_NODE_AGG: 46277c478bd9Sstevel@tonic-gate (void) fprintf(fp, "AGGREGATE @%s attr=%s [\n", 46287c478bd9Sstevel@tonic-gate dnp->dn_ident->di_name, a); 46297c478bd9Sstevel@tonic-gate 46307c478bd9Sstevel@tonic-gate for (arg = dnp->dn_aggtup; arg != NULL; arg = arg->dn_list) { 46317c478bd9Sstevel@tonic-gate dt_node_printr(arg, fp, depth + 1); 46327c478bd9Sstevel@tonic-gate if (arg->dn_list != NULL) 46337c478bd9Sstevel@tonic-gate (void) fprintf(fp, "%*s,\n", depth * 2, ""); 46347c478bd9Sstevel@tonic-gate } 46357c478bd9Sstevel@tonic-gate 46367c478bd9Sstevel@tonic-gate if (dnp->dn_aggfun) { 46377c478bd9Sstevel@tonic-gate (void) fprintf(fp, "%*s] = ", depth * 2, ""); 46387c478bd9Sstevel@tonic-gate dt_node_printr(dnp->dn_aggfun, fp, depth + 1); 46397c478bd9Sstevel@tonic-gate } else 46407c478bd9Sstevel@tonic-gate (void) fprintf(fp, "%*s]\n", depth * 2, ""); 46417c478bd9Sstevel@tonic-gate 46427c478bd9Sstevel@tonic-gate if (dnp->dn_aggfun) 46437c478bd9Sstevel@tonic-gate (void) fprintf(fp, "%*s)\n", depth * 2, ""); 46447c478bd9Sstevel@tonic-gate break; 46457c478bd9Sstevel@tonic-gate 46467c478bd9Sstevel@tonic-gate case DT_NODE_PDESC: 46477c478bd9Sstevel@tonic-gate (void) fprintf(fp, "PDESC %s:%s:%s:%s [%u]\n", 46487c478bd9Sstevel@tonic-gate dnp->dn_desc->dtpd_provider, dnp->dn_desc->dtpd_mod, 46497c478bd9Sstevel@tonic-gate dnp->dn_desc->dtpd_func, dnp->dn_desc->dtpd_name, 46507c478bd9Sstevel@tonic-gate dnp->dn_desc->dtpd_id); 46517c478bd9Sstevel@tonic-gate break; 46527c478bd9Sstevel@tonic-gate 46537c478bd9Sstevel@tonic-gate case DT_NODE_CLAUSE: 46547c478bd9Sstevel@tonic-gate (void) fprintf(fp, "CLAUSE attr=%s\n", a); 46557c478bd9Sstevel@tonic-gate 46567c478bd9Sstevel@tonic-gate for (arg = dnp->dn_pdescs; arg != NULL; arg = arg->dn_list) 46577c478bd9Sstevel@tonic-gate dt_node_printr(arg, fp, depth + 1); 46587c478bd9Sstevel@tonic-gate 46597c478bd9Sstevel@tonic-gate (void) fprintf(fp, "%*sCTXATTR %s\n", depth * 2, "", 46607c478bd9Sstevel@tonic-gate dt_attr_str(dnp->dn_ctxattr, a, sizeof (a))); 46617c478bd9Sstevel@tonic-gate 46627c478bd9Sstevel@tonic-gate if (dnp->dn_pred != NULL) { 46637c478bd9Sstevel@tonic-gate (void) fprintf(fp, "%*sPREDICATE /\n", depth * 2, ""); 46647c478bd9Sstevel@tonic-gate dt_node_printr(dnp->dn_pred, fp, depth + 1); 46657c478bd9Sstevel@tonic-gate (void) fprintf(fp, "%*s/\n", depth * 2, ""); 46667c478bd9Sstevel@tonic-gate } 46677c478bd9Sstevel@tonic-gate 46687c478bd9Sstevel@tonic-gate for (arg = dnp->dn_acts; arg != NULL; arg = arg->dn_list) 46697c478bd9Sstevel@tonic-gate dt_node_printr(arg, fp, depth + 1); 46707c478bd9Sstevel@tonic-gate break; 46717c478bd9Sstevel@tonic-gate 46727c478bd9Sstevel@tonic-gate case DT_NODE_INLINE: 46737c478bd9Sstevel@tonic-gate inp = dnp->dn_ident->di_iarg; 46747c478bd9Sstevel@tonic-gate 46757c478bd9Sstevel@tonic-gate (void) fprintf(fp, "INLINE %s (%s)\n", 46767c478bd9Sstevel@tonic-gate dnp->dn_ident->di_name, buf); 46777c478bd9Sstevel@tonic-gate dt_node_printr(inp->din_root, fp, depth + 1); 46787c478bd9Sstevel@tonic-gate break; 46797c478bd9Sstevel@tonic-gate 46807c478bd9Sstevel@tonic-gate case DT_NODE_MEMBER: 46817c478bd9Sstevel@tonic-gate (void) fprintf(fp, "MEMBER %s (%s)\n", dnp->dn_membname, buf); 46827c478bd9Sstevel@tonic-gate if (dnp->dn_membexpr) 46837c478bd9Sstevel@tonic-gate dt_node_printr(dnp->dn_membexpr, fp, depth + 1); 46847c478bd9Sstevel@tonic-gate break; 46857c478bd9Sstevel@tonic-gate 46867c478bd9Sstevel@tonic-gate case DT_NODE_XLATOR: 46877c478bd9Sstevel@tonic-gate (void) fprintf(fp, "XLATOR (%s)", buf); 46887c478bd9Sstevel@tonic-gate 46897c478bd9Sstevel@tonic-gate if (ctf_type_name(dnp->dn_xlator->dx_src_ctfp, 46907c478bd9Sstevel@tonic-gate dnp->dn_xlator->dx_src_type, n, sizeof (n)) != NULL) 46917c478bd9Sstevel@tonic-gate (void) fprintf(fp, " from <%s>", n); 46927c478bd9Sstevel@tonic-gate 46937c478bd9Sstevel@tonic-gate if (ctf_type_name(dnp->dn_xlator->dx_dst_ctfp, 46947c478bd9Sstevel@tonic-gate dnp->dn_xlator->dx_dst_type, n, sizeof (n)) != NULL) 46957c478bd9Sstevel@tonic-gate (void) fprintf(fp, " to <%s>", n); 46967c478bd9Sstevel@tonic-gate 46977c478bd9Sstevel@tonic-gate (void) fprintf(fp, "\n"); 46987c478bd9Sstevel@tonic-gate 46997c478bd9Sstevel@tonic-gate for (arg = dnp->dn_members; arg != NULL; arg = arg->dn_list) 47007c478bd9Sstevel@tonic-gate dt_node_printr(arg, fp, depth + 1); 47017c478bd9Sstevel@tonic-gate break; 47027c478bd9Sstevel@tonic-gate 47037c478bd9Sstevel@tonic-gate case DT_NODE_PROBE: 47047c478bd9Sstevel@tonic-gate (void) fprintf(fp, "PROBE %s\n", dnp->dn_ident->di_name); 47057c478bd9Sstevel@tonic-gate break; 47067c478bd9Sstevel@tonic-gate 47077c478bd9Sstevel@tonic-gate case DT_NODE_PROVIDER: 47087c478bd9Sstevel@tonic-gate (void) fprintf(fp, "PROVIDER %s (%s)\n", 47097c478bd9Sstevel@tonic-gate dnp->dn_provname, dnp->dn_provred ? "redecl" : "decl"); 47107c478bd9Sstevel@tonic-gate for (arg = dnp->dn_probes; arg != NULL; arg = arg->dn_list) 47117c478bd9Sstevel@tonic-gate dt_node_printr(arg, fp, depth + 1); 47127c478bd9Sstevel@tonic-gate break; 47137c478bd9Sstevel@tonic-gate 47147c478bd9Sstevel@tonic-gate case DT_NODE_PROG: 47157c478bd9Sstevel@tonic-gate (void) fprintf(fp, "PROGRAM attr=%s\n", a); 47167c478bd9Sstevel@tonic-gate for (arg = dnp->dn_list; arg != NULL; arg = arg->dn_list) 47177c478bd9Sstevel@tonic-gate dt_node_printr(arg, fp, depth + 1); 47187c478bd9Sstevel@tonic-gate break; 47197c478bd9Sstevel@tonic-gate 47207c478bd9Sstevel@tonic-gate default: 47217c478bd9Sstevel@tonic-gate (void) fprintf(fp, "<bad node %p, kind %d>\n", 47227c478bd9Sstevel@tonic-gate (void *)dnp, dnp->dn_kind); 47237c478bd9Sstevel@tonic-gate } 47247c478bd9Sstevel@tonic-gate } 47257c478bd9Sstevel@tonic-gate 47267c478bd9Sstevel@tonic-gate int 47277c478bd9Sstevel@tonic-gate dt_node_root(dt_node_t *dnp) 47287c478bd9Sstevel@tonic-gate { 47297c478bd9Sstevel@tonic-gate yypcb->pcb_root = dnp; 47307c478bd9Sstevel@tonic-gate return (0); 47317c478bd9Sstevel@tonic-gate } 47327c478bd9Sstevel@tonic-gate 47337c478bd9Sstevel@tonic-gate /*PRINTFLIKE3*/ 47347c478bd9Sstevel@tonic-gate void 47357c478bd9Sstevel@tonic-gate dnerror(const dt_node_t *dnp, dt_errtag_t tag, const char *format, ...) 47367c478bd9Sstevel@tonic-gate { 47377c478bd9Sstevel@tonic-gate int oldlineno = yylineno; 47387c478bd9Sstevel@tonic-gate va_list ap; 47397c478bd9Sstevel@tonic-gate 47407c478bd9Sstevel@tonic-gate yylineno = dnp->dn_line; 47417c478bd9Sstevel@tonic-gate 47427c478bd9Sstevel@tonic-gate va_start(ap, format); 47437c478bd9Sstevel@tonic-gate xyvwarn(tag, format, ap); 47447c478bd9Sstevel@tonic-gate va_end(ap); 47457c478bd9Sstevel@tonic-gate 47467c478bd9Sstevel@tonic-gate yylineno = oldlineno; 47477c478bd9Sstevel@tonic-gate longjmp(yypcb->pcb_jmpbuf, EDT_COMPILER); 47487c478bd9Sstevel@tonic-gate } 47497c478bd9Sstevel@tonic-gate 47507c478bd9Sstevel@tonic-gate /*PRINTFLIKE3*/ 47517c478bd9Sstevel@tonic-gate void 47527c478bd9Sstevel@tonic-gate dnwarn(const dt_node_t *dnp, dt_errtag_t tag, const char *format, ...) 47537c478bd9Sstevel@tonic-gate { 47547c478bd9Sstevel@tonic-gate int oldlineno = yylineno; 47557c478bd9Sstevel@tonic-gate va_list ap; 47567c478bd9Sstevel@tonic-gate 47577c478bd9Sstevel@tonic-gate yylineno = dnp->dn_line; 47587c478bd9Sstevel@tonic-gate 47597c478bd9Sstevel@tonic-gate va_start(ap, format); 47607c478bd9Sstevel@tonic-gate xyvwarn(tag, format, ap); 47617c478bd9Sstevel@tonic-gate va_end(ap); 47627c478bd9Sstevel@tonic-gate 47637c478bd9Sstevel@tonic-gate yylineno = oldlineno; 47647c478bd9Sstevel@tonic-gate } 47657c478bd9Sstevel@tonic-gate 47667c478bd9Sstevel@tonic-gate /*PRINTFLIKE2*/ 47677c478bd9Sstevel@tonic-gate void 47687c478bd9Sstevel@tonic-gate xyerror(dt_errtag_t tag, const char *format, ...) 47697c478bd9Sstevel@tonic-gate { 47707c478bd9Sstevel@tonic-gate va_list ap; 47717c478bd9Sstevel@tonic-gate 47727c478bd9Sstevel@tonic-gate va_start(ap, format); 47737c478bd9Sstevel@tonic-gate xyvwarn(tag, format, ap); 47747c478bd9Sstevel@tonic-gate va_end(ap); 47757c478bd9Sstevel@tonic-gate 47767c478bd9Sstevel@tonic-gate longjmp(yypcb->pcb_jmpbuf, EDT_COMPILER); 47777c478bd9Sstevel@tonic-gate } 47787c478bd9Sstevel@tonic-gate 47797c478bd9Sstevel@tonic-gate /*PRINTFLIKE2*/ 47807c478bd9Sstevel@tonic-gate void 47817c478bd9Sstevel@tonic-gate xywarn(dt_errtag_t tag, const char *format, ...) 47827c478bd9Sstevel@tonic-gate { 47837c478bd9Sstevel@tonic-gate va_list ap; 47847c478bd9Sstevel@tonic-gate 47857c478bd9Sstevel@tonic-gate va_start(ap, format); 47867c478bd9Sstevel@tonic-gate xyvwarn(tag, format, ap); 47877c478bd9Sstevel@tonic-gate va_end(ap); 47887c478bd9Sstevel@tonic-gate } 47897c478bd9Sstevel@tonic-gate 47907c478bd9Sstevel@tonic-gate void 47917c478bd9Sstevel@tonic-gate xyvwarn(dt_errtag_t tag, const char *format, va_list ap) 47927c478bd9Sstevel@tonic-gate { 47937c478bd9Sstevel@tonic-gate if (yypcb == NULL) 47947c478bd9Sstevel@tonic-gate return; /* compiler is not currently active: act as a no-op */ 47957c478bd9Sstevel@tonic-gate 47967c478bd9Sstevel@tonic-gate dt_set_errmsg(yypcb->pcb_hdl, dt_errtag(tag), yypcb->pcb_region, 47977c478bd9Sstevel@tonic-gate yypcb->pcb_filetag, yypcb->pcb_fileptr ? yylineno : 0, format, ap); 47987c478bd9Sstevel@tonic-gate } 47997c478bd9Sstevel@tonic-gate 48007c478bd9Sstevel@tonic-gate /*PRINTFLIKE1*/ 48017c478bd9Sstevel@tonic-gate void 48027c478bd9Sstevel@tonic-gate yyerror(const char *format, ...) 48037c478bd9Sstevel@tonic-gate { 48047c478bd9Sstevel@tonic-gate va_list ap; 48057c478bd9Sstevel@tonic-gate 48067c478bd9Sstevel@tonic-gate va_start(ap, format); 48077c478bd9Sstevel@tonic-gate yyvwarn(format, ap); 48087c478bd9Sstevel@tonic-gate va_end(ap); 48097c478bd9Sstevel@tonic-gate 48107c478bd9Sstevel@tonic-gate longjmp(yypcb->pcb_jmpbuf, EDT_COMPILER); 48117c478bd9Sstevel@tonic-gate } 48127c478bd9Sstevel@tonic-gate 48137c478bd9Sstevel@tonic-gate /*PRINTFLIKE1*/ 48147c478bd9Sstevel@tonic-gate void 48157c478bd9Sstevel@tonic-gate yywarn(const char *format, ...) 48167c478bd9Sstevel@tonic-gate { 48177c478bd9Sstevel@tonic-gate va_list ap; 48187c478bd9Sstevel@tonic-gate 48197c478bd9Sstevel@tonic-gate va_start(ap, format); 48207c478bd9Sstevel@tonic-gate yyvwarn(format, ap); 48217c478bd9Sstevel@tonic-gate va_end(ap); 48227c478bd9Sstevel@tonic-gate } 48237c478bd9Sstevel@tonic-gate 48247c478bd9Sstevel@tonic-gate void 48257c478bd9Sstevel@tonic-gate yyvwarn(const char *format, va_list ap) 48267c478bd9Sstevel@tonic-gate { 48277c478bd9Sstevel@tonic-gate if (yypcb == NULL) 48287c478bd9Sstevel@tonic-gate return; /* compiler is not currently active: act as a no-op */ 48297c478bd9Sstevel@tonic-gate 48307c478bd9Sstevel@tonic-gate dt_set_errmsg(yypcb->pcb_hdl, dt_errtag(D_SYNTAX), yypcb->pcb_region, 48317c478bd9Sstevel@tonic-gate yypcb->pcb_filetag, yypcb->pcb_fileptr ? yylineno : 0, format, ap); 48327c478bd9Sstevel@tonic-gate 48337c478bd9Sstevel@tonic-gate if (strchr(format, '\n') == NULL) { 48347c478bd9Sstevel@tonic-gate dtrace_hdl_t *dtp = yypcb->pcb_hdl; 48357c478bd9Sstevel@tonic-gate size_t len = strlen(dtp->dt_errmsg); 48367c478bd9Sstevel@tonic-gate char *p, *s = dtp->dt_errmsg + len; 48377c478bd9Sstevel@tonic-gate size_t n = sizeof (dtp->dt_errmsg) - len; 48387c478bd9Sstevel@tonic-gate 48397c478bd9Sstevel@tonic-gate if (yytext[0] == '\0') 48407c478bd9Sstevel@tonic-gate (void) snprintf(s, n, " near end of input"); 48417c478bd9Sstevel@tonic-gate else if (yytext[0] == '\n') 48427c478bd9Sstevel@tonic-gate (void) snprintf(s, n, " near end of line"); 48437c478bd9Sstevel@tonic-gate else { 48447c478bd9Sstevel@tonic-gate if ((p = strchr(yytext, '\n')) != NULL) 48457c478bd9Sstevel@tonic-gate *p = '\0'; /* crop at newline */ 48467c478bd9Sstevel@tonic-gate (void) snprintf(s, n, " near \"%s\"", yytext); 48477c478bd9Sstevel@tonic-gate } 48487c478bd9Sstevel@tonic-gate } 48497c478bd9Sstevel@tonic-gate } 48507c478bd9Sstevel@tonic-gate 48517c478bd9Sstevel@tonic-gate void 48527c478bd9Sstevel@tonic-gate yylabel(const char *label) 48537c478bd9Sstevel@tonic-gate { 48547c478bd9Sstevel@tonic-gate dt_dprintf("set label to <%s>\n", label ? label : "NULL"); 48557c478bd9Sstevel@tonic-gate yypcb->pcb_region = label; 48567c478bd9Sstevel@tonic-gate } 48577c478bd9Sstevel@tonic-gate 48587c478bd9Sstevel@tonic-gate int 48597c478bd9Sstevel@tonic-gate yywrap(void) 48607c478bd9Sstevel@tonic-gate { 48617c478bd9Sstevel@tonic-gate return (1); /* indicate that lex should return a zero token for EOF */ 48627c478bd9Sstevel@tonic-gate } 4863