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