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