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