cddl/contrib/opensolaris/lib/libdtrace/common/dt_parser.c

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