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 (the "License").
   6  * You may not use this file except in compliance with the License.
   7  *
   8  * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE
   9  * or http://www.opensolaris.org/os/licensing.
  10  * See the License for the specific language governing permissions
  11  * and limitations under the License.
  12  *
  13  * When distributing Covered Code, include this CDDL HEADER in each
  14  * file and include the License file at usr/src/OPENSOLARIS.LICENSE.
  15  * If applicable, add the following below this CDDL HEADER, with the
  16  * fields enclosed by brackets "[]" replaced with your own identifying
  17  * information: Portions Copyright [yyyy] [name of copyright owner]
  18  *
  19  * CDDL HEADER END
  20  */
  21 
  22 /*
  23  * Copyright (c) 2003, 2010, Oracle and/or its affiliates. All rights reserved.
  24  * Copyright (c) 2011, 2014 by Delphix. All rights reserved.
  25  * Copyright (c) 2013, Joyent Inc. All rights reserved.
  26  * Copyright 2015 Gary Mills
  27  */
  28 
  29 /*
  30  * DTrace D Language Compiler
  31  *
  32  * The code in this source file implements the main engine for the D language
  33  * compiler.  The driver routine for the compiler is dt_compile(), below.  The
  34  * compiler operates on either stdio FILEs or in-memory strings as its input
  35  * and can produce either dtrace_prog_t structures from a D program or a single
  36  * dtrace_difo_t structure from a D expression.  Multiple entry points are
  37  * provided as wrappers around dt_compile() for the various input/output pairs.
  38  * The compiler itself is implemented across the following source files:
  39  *
  40  * dt_lex.l - lex scanner
  41  * dt_grammar.y - yacc grammar
  42  * dt_parser.c - parse tree creation and semantic checking
  43  * dt_decl.c - declaration stack processing
  44  * dt_xlator.c - D translator lookup and creation
  45  * dt_ident.c - identifier and symbol table routines
  46  * dt_pragma.c - #pragma processing and D pragmas
  47  * dt_printf.c - D printf() and printa() argument checking and processing
  48  * dt_cc.c - compiler driver and dtrace_prog_t construction
  49  * dt_cg.c - DIF code generator
  50  * dt_as.c - DIF assembler
  51  * dt_dof.c - dtrace_prog_t -> DOF conversion
  52  *
  53  * Several other source files provide collections of utility routines used by
  54  * these major files.  The compiler itself is implemented in multiple passes:
  55  *
  56  * (1) The input program is scanned and parsed by dt_lex.l and dt_grammar.y
  57  *     and parse tree nodes are constructed using the routines in dt_parser.c.
  58  *     This node construction pass is described further in dt_parser.c.
  59  *
  60  * (2) The parse tree is "cooked" by assigning each clause a context (see the
  61  *     routine dt_setcontext(), below) based on its probe description and then
  62  *     recursively descending the tree performing semantic checking.  The cook
  63  *     routines are also implemented in dt_parser.c and described there.
  64  *
  65  * (3) For actions that are DIF expression statements, the DIF code generator
  66  *     and assembler are invoked to create a finished DIFO for the statement.
  67  *
  68  * (4) The dtrace_prog_t data structures for the program clauses and actions
  69  *     are built, containing pointers to any DIFOs created in step (3).
  70  *
  71  * (5) The caller invokes a routine in dt_dof.c to convert the finished program
  72  *     into DOF format for use in anonymous tracing or enabling in the kernel.
  73  *
  74  * In the implementation, steps 2-4 are intertwined in that they are performed
  75  * in order for each clause as part of a loop that executes over the clauses.
  76  *
  77  * The D compiler currently implements nearly no optimization.  The compiler
  78  * implements integer constant folding as part of pass (1), and a set of very
  79  * simple peephole optimizations as part of pass (3).  As with any C compiler,
  80  * a large number of optimizations are possible on both the intermediate data
  81  * structures and the generated DIF code.  These possibilities should be
  82  * investigated in the context of whether they will have any substantive effect
  83  * on the overall DTrace probe effect before they are undertaken.
  84  */
  85 
  86 #include <sys/types.h>
  87 #include <sys/wait.h>
  88 #include <sys/sysmacros.h>
  89 
  90 #include <assert.h>
  91 #include <strings.h>
  92 #include <signal.h>
  93 #include <unistd.h>
  94 #include <stdlib.h>
  95 #include <stdio.h>
  96 #include <errno.h>
  97 #include <ucontext.h>
  98 #include <limits.h>
  99 #include <ctype.h>
 100 #include <dirent.h>
 101 #include <dt_module.h>
 102 #include <dt_program.h>
 103 #include <dt_provider.h>
 104 #include <dt_printf.h>
 105 #include <dt_pid.h>
 106 #include <dt_grammar.h>
 107 #include <dt_ident.h>
 108 #include <dt_string.h>
 109 #include <dt_impl.h>
 110 
 111 static const dtrace_diftype_t dt_void_rtype = {
 112         DIF_TYPE_CTF, CTF_K_INTEGER, 0, 0, 0
 113 };
 114 
 115 static const dtrace_diftype_t dt_int_rtype = {
 116         DIF_TYPE_CTF, CTF_K_INTEGER, 0, 0, sizeof (uint64_t)
 117 };
 118 
 119 static void *dt_compile(dtrace_hdl_t *, int, dtrace_probespec_t, void *,
 120     uint_t, int, char *const[], FILE *, const char *);
 121 
 122 /*ARGSUSED*/
 123 static int
 124 dt_idreset(dt_idhash_t *dhp, dt_ident_t *idp, void *ignored)
 125 {
 126         idp->di_flags &= ~(DT_IDFLG_REF | DT_IDFLG_MOD |
 127             DT_IDFLG_DIFR | DT_IDFLG_DIFW);
 128         return (0);
 129 }
 130 
 131 /*ARGSUSED*/
 132 static int
 133 dt_idpragma(dt_idhash_t *dhp, dt_ident_t *idp, void *ignored)
 134 {
 135         yylineno = idp->di_lineno;
 136         xyerror(D_PRAGMA_UNUSED, "unused #pragma %s\n", (char *)idp->di_iarg);
 137         return (0);
 138 }
 139 
 140 static dtrace_stmtdesc_t *
 141 dt_stmt_create(dtrace_hdl_t *dtp, dtrace_ecbdesc_t *edp,
 142     dtrace_attribute_t descattr, dtrace_attribute_t stmtattr)
 143 {
 144         dtrace_stmtdesc_t *sdp = dtrace_stmt_create(dtp, edp);
 145 
 146         if (sdp == NULL)
 147                 longjmp(yypcb->pcb_jmpbuf, EDT_NOMEM);
 148 
 149         assert(yypcb->pcb_stmt == NULL);
 150         yypcb->pcb_stmt = sdp;
 151 
 152         sdp->dtsd_descattr = descattr;
 153         sdp->dtsd_stmtattr = stmtattr;
 154 
 155         return (sdp);
 156 }
 157 
 158 static dtrace_actdesc_t *
 159 dt_stmt_action(dtrace_hdl_t *dtp, dtrace_stmtdesc_t *sdp)
 160 {
 161         dtrace_actdesc_t *new;
 162 
 163         if ((new = dtrace_stmt_action(dtp, sdp)) == NULL)
 164                 longjmp(yypcb->pcb_jmpbuf, EDT_NOMEM);
 165 
 166         return (new);
 167 }
 168 
 169 /*
 170  * Utility function to determine if a given action description is destructive.
 171  * The dtdo_destructive bit is set for us by the DIF assembler (see dt_as.c).
 172  */
 173 static int
 174 dt_action_destructive(const dtrace_actdesc_t *ap)
 175 {
 176         return (DTRACEACT_ISDESTRUCTIVE(ap->dtad_kind) || (ap->dtad_kind ==
 177             DTRACEACT_DIFEXPR && ap->dtad_difo->dtdo_destructive));
 178 }
 179 
 180 static void
 181 dt_stmt_append(dtrace_stmtdesc_t *sdp, const dt_node_t *dnp)
 182 {
 183         dtrace_ecbdesc_t *edp = sdp->dtsd_ecbdesc;
 184         dtrace_actdesc_t *ap, *tap;
 185         int commit = 0;
 186         int speculate = 0;
 187         int datarec = 0;
 188 
 189         /*
 190          * Make sure that the new statement jibes with the rest of the ECB.
 191          */
 192         for (ap = edp->dted_action; ap != NULL; ap = ap->dtad_next) {
 193                 if (ap->dtad_kind == DTRACEACT_COMMIT) {
 194                         if (commit) {
 195                                 dnerror(dnp, D_COMM_COMM, "commit( ) may "
 196                                     "not follow commit( )\n");
 197                         }
 198 
 199                         if (datarec) {
 200                                 dnerror(dnp, D_COMM_DREC, "commit( ) may "
 201                                     "not follow data-recording action(s)\n");
 202                         }
 203 
 204                         for (tap = ap; tap != NULL; tap = tap->dtad_next) {
 205                                 if (!DTRACEACT_ISAGG(tap->dtad_kind))
 206                                         continue;
 207 
 208                                 dnerror(dnp, D_AGG_COMM, "aggregating actions "
 209                                     "may not follow commit( )\n");
 210                         }
 211 
 212                         commit = 1;
 213                         continue;
 214                 }
 215 
 216                 if (ap->dtad_kind == DTRACEACT_SPECULATE) {
 217                         if (speculate) {
 218                                 dnerror(dnp, D_SPEC_SPEC, "speculate( ) may "
 219                                     "not follow speculate( )\n");
 220                         }
 221 
 222                         if (commit) {
 223                                 dnerror(dnp, D_SPEC_COMM, "speculate( ) may "
 224                                     "not follow commit( )\n");
 225                         }
 226 
 227                         if (datarec) {
 228                                 dnerror(dnp, D_SPEC_DREC, "speculate( ) may "
 229                                     "not follow data-recording action(s)\n");
 230                         }
 231 
 232                         speculate = 1;
 233                         continue;
 234                 }
 235 
 236                 if (DTRACEACT_ISAGG(ap->dtad_kind)) {
 237                         if (speculate) {
 238                                 dnerror(dnp, D_AGG_SPEC, "aggregating actions "
 239                                     "may not follow speculate( )\n");
 240                         }
 241 
 242                         datarec = 1;
 243                         continue;
 244                 }
 245 
 246                 if (speculate) {
 247                         if (dt_action_destructive(ap)) {
 248                                 dnerror(dnp, D_ACT_SPEC, "destructive actions "
 249                                     "may not follow speculate( )\n");
 250                         }
 251 
 252                         if (ap->dtad_kind == DTRACEACT_EXIT) {
 253                                 dnerror(dnp, D_EXIT_SPEC, "exit( ) may not "
 254                                     "follow speculate( )\n");
 255                         }
 256                 }
 257 
 258                 /*
 259                  * Exclude all non data-recording actions.
 260                  */
 261                 if (dt_action_destructive(ap) ||
 262                     ap->dtad_kind == DTRACEACT_DISCARD)
 263                         continue;
 264 
 265                 if (ap->dtad_kind == DTRACEACT_DIFEXPR &&
 266                     ap->dtad_difo->dtdo_rtype.dtdt_kind == DIF_TYPE_CTF &&
 267                     ap->dtad_difo->dtdo_rtype.dtdt_size == 0)
 268                         continue;
 269 
 270                 if (commit) {
 271                         dnerror(dnp, D_DREC_COMM, "data-recording actions "
 272                             "may not follow commit( )\n");
 273                 }
 274 
 275                 if (!speculate)
 276                         datarec = 1;
 277         }
 278 
 279         if (dtrace_stmt_add(yypcb->pcb_hdl, yypcb->pcb_prog, sdp) != 0)
 280                 longjmp(yypcb->pcb_jmpbuf, dtrace_errno(yypcb->pcb_hdl));
 281 
 282         if (yypcb->pcb_stmt == sdp)
 283                 yypcb->pcb_stmt = NULL;
 284 }
 285 
 286 /*
 287  * For the first element of an aggregation tuple or for printa(), we create a
 288  * simple DIF program that simply returns the immediate value that is the ID
 289  * of the aggregation itself.  This could be optimized in the future by
 290  * creating a new in-kernel dtad_kind that just returns an integer.
 291  */
 292 static void
 293 dt_action_difconst(dtrace_actdesc_t *ap, uint_t id, dtrace_actkind_t kind)
 294 {
 295         dtrace_hdl_t *dtp = yypcb->pcb_hdl;
 296         dtrace_difo_t *dp = dt_zalloc(dtp, sizeof (dtrace_difo_t));
 297 
 298         if (dp == NULL)
 299                 longjmp(yypcb->pcb_jmpbuf, EDT_NOMEM);
 300 
 301         dp->dtdo_buf = dt_alloc(dtp, sizeof (dif_instr_t) * 2);
 302         dp->dtdo_inttab = dt_alloc(dtp, sizeof (uint64_t));
 303 
 304         if (dp->dtdo_buf == NULL || dp->dtdo_inttab == NULL) {
 305                 dt_difo_free(dtp, dp);
 306                 longjmp(yypcb->pcb_jmpbuf, EDT_NOMEM);
 307         }
 308 
 309         dp->dtdo_buf[0] = DIF_INSTR_SETX(0, 1); /* setx      DIF_INTEGER[0], %r1 */
 310         dp->dtdo_buf[1] = DIF_INSTR_RET(1);  /* ret  %r1 */
 311         dp->dtdo_len = 2;
 312         dp->dtdo_inttab[0] = id;
 313         dp->dtdo_intlen = 1;
 314         dp->dtdo_rtype = dt_int_rtype;
 315 
 316         ap->dtad_difo = dp;
 317         ap->dtad_kind = kind;
 318 }
 319 
 320 static void
 321 dt_action_clear(dtrace_hdl_t *dtp, dt_node_t *dnp, dtrace_stmtdesc_t *sdp)
 322 {
 323         dt_ident_t *aid;
 324         dtrace_actdesc_t *ap;
 325         dt_node_t *anp;
 326 
 327         char n[DT_TYPE_NAMELEN];
 328         int argc = 0;
 329 
 330         for (anp = dnp->dn_args; anp != NULL; anp = anp->dn_list)
 331                 argc++; /* count up arguments for error messages below */
 332 
 333         if (argc != 1) {
 334                 dnerror(dnp, D_CLEAR_PROTO,
 335                     "%s( ) prototype mismatch: %d args passed, 1 expected\n",
 336                     dnp->dn_ident->di_name, argc);
 337         }
 338 
 339         anp = dnp->dn_args;
 340         assert(anp != NULL);
 341 
 342         if (anp->dn_kind != DT_NODE_AGG) {
 343                 dnerror(dnp, D_CLEAR_AGGARG,
 344                     "%s( ) argument #1 is incompatible with prototype:\n"
 345                     "\tprototype: aggregation\n\t argument: %s\n",
 346                     dnp->dn_ident->di_name,
 347                     dt_node_type_name(anp, n, sizeof (n)));
 348         }
 349 
 350         aid = anp->dn_ident;
 351 
 352         if (aid->di_gen == dtp->dt_gen && !(aid->di_flags & DT_IDFLG_MOD)) {
 353                 dnerror(dnp, D_CLEAR_AGGBAD,
 354                     "undefined aggregation: @%s\n", aid->di_name);
 355         }
 356 
 357         ap = dt_stmt_action(dtp, sdp);
 358         dt_action_difconst(ap, anp->dn_ident->di_id, DTRACEACT_LIBACT);
 359         ap->dtad_arg = DT_ACT_CLEAR;
 360 }
 361 
 362 static void
 363 dt_action_normalize(dtrace_hdl_t *dtp, dt_node_t *dnp, dtrace_stmtdesc_t *sdp)
 364 {
 365         dt_ident_t *aid;
 366         dtrace_actdesc_t *ap;
 367         dt_node_t *anp, *normal;
 368         int denormal = (strcmp(dnp->dn_ident->di_name, "denormalize") == 0);
 369 
 370         char n[DT_TYPE_NAMELEN];
 371         int argc = 0;
 372 
 373         for (anp = dnp->dn_args; anp != NULL; anp = anp->dn_list)
 374                 argc++; /* count up arguments for error messages below */
 375 
 376         if ((denormal && argc != 1) || (!denormal && argc != 2)) {
 377                 dnerror(dnp, D_NORMALIZE_PROTO,
 378                     "%s( ) prototype mismatch: %d args passed, %d expected\n",
 379                     dnp->dn_ident->di_name, argc, denormal ? 1 : 2);
 380         }
 381 
 382         anp = dnp->dn_args;
 383         assert(anp != NULL);
 384 
 385         if (anp->dn_kind != DT_NODE_AGG) {
 386                 dnerror(dnp, D_NORMALIZE_AGGARG,
 387                     "%s( ) argument #1 is incompatible with prototype:\n"
 388                     "\tprototype: aggregation\n\t argument: %s\n",
 389                     dnp->dn_ident->di_name,
 390                     dt_node_type_name(anp, n, sizeof (n)));
 391         }
 392 
 393         if ((normal = anp->dn_list) != NULL && !dt_node_is_scalar(normal)) {
 394                 dnerror(dnp, D_NORMALIZE_SCALAR,
 395                     "%s( ) argument #2 must be of scalar type\n",
 396                     dnp->dn_ident->di_name);
 397         }
 398 
 399         aid = anp->dn_ident;
 400 
 401         if (aid->di_gen == dtp->dt_gen && !(aid->di_flags & DT_IDFLG_MOD)) {
 402                 dnerror(dnp, D_NORMALIZE_AGGBAD,
 403                     "undefined aggregation: @%s\n", aid->di_name);
 404         }
 405 
 406         ap = dt_stmt_action(dtp, sdp);
 407         dt_action_difconst(ap, anp->dn_ident->di_id, DTRACEACT_LIBACT);
 408 
 409         if (denormal) {
 410                 ap->dtad_arg = DT_ACT_DENORMALIZE;
 411                 return;
 412         }
 413 
 414         ap->dtad_arg = DT_ACT_NORMALIZE;
 415 
 416         assert(normal != NULL);
 417         ap = dt_stmt_action(dtp, sdp);
 418         dt_cg(yypcb, normal);
 419 
 420         ap->dtad_difo = dt_as(yypcb);
 421         ap->dtad_kind = DTRACEACT_LIBACT;
 422         ap->dtad_arg = DT_ACT_NORMALIZE;
 423 }
 424 
 425 static void
 426 dt_action_trunc(dtrace_hdl_t *dtp, dt_node_t *dnp, dtrace_stmtdesc_t *sdp)
 427 {
 428         dt_ident_t *aid;
 429         dtrace_actdesc_t *ap;
 430         dt_node_t *anp, *trunc;
 431 
 432         char n[DT_TYPE_NAMELEN];
 433         int argc = 0;
 434 
 435         for (anp = dnp->dn_args; anp != NULL; anp = anp->dn_list)
 436                 argc++; /* count up arguments for error messages below */
 437 
 438         if (argc > 2 || argc < 1) {
 439                 dnerror(dnp, D_TRUNC_PROTO,
 440                     "%s( ) prototype mismatch: %d args passed, %s expected\n",
 441                     dnp->dn_ident->di_name, argc,
 442                     argc < 1 ? "at least 1" : "no more than 2");
 443         }
 444 
 445         anp = dnp->dn_args;
 446         assert(anp != NULL);
 447         trunc = anp->dn_list;
 448 
 449         if (anp->dn_kind != DT_NODE_AGG) {
 450                 dnerror(dnp, D_TRUNC_AGGARG,
 451                     "%s( ) argument #1 is incompatible with prototype:\n"
 452                     "\tprototype: aggregation\n\t argument: %s\n",
 453                     dnp->dn_ident->di_name,
 454                     dt_node_type_name(anp, n, sizeof (n)));
 455         }
 456 
 457         if (argc == 2) {
 458                 assert(trunc != NULL);
 459                 if (!dt_node_is_scalar(trunc)) {
 460                         dnerror(dnp, D_TRUNC_SCALAR,
 461                             "%s( ) argument #2 must be of scalar type\n",
 462                             dnp->dn_ident->di_name);
 463                 }
 464         }
 465 
 466         aid = anp->dn_ident;
 467 
 468         if (aid->di_gen == dtp->dt_gen && !(aid->di_flags & DT_IDFLG_MOD)) {
 469                 dnerror(dnp, D_TRUNC_AGGBAD,
 470                     "undefined aggregation: @%s\n", aid->di_name);
 471         }
 472 
 473         ap = dt_stmt_action(dtp, sdp);
 474         dt_action_difconst(ap, anp->dn_ident->di_id, DTRACEACT_LIBACT);
 475         ap->dtad_arg = DT_ACT_TRUNC;
 476 
 477         ap = dt_stmt_action(dtp, sdp);
 478 
 479         if (argc == 1) {
 480                 dt_action_difconst(ap, 0, DTRACEACT_LIBACT);
 481         } else {
 482                 assert(trunc != NULL);
 483                 dt_cg(yypcb, trunc);
 484                 ap->dtad_difo = dt_as(yypcb);
 485                 ap->dtad_kind = DTRACEACT_LIBACT;
 486         }
 487 
 488         ap->dtad_arg = DT_ACT_TRUNC;
 489 }
 490 
 491 static void
 492 dt_action_printa(dtrace_hdl_t *dtp, dt_node_t *dnp, dtrace_stmtdesc_t *sdp)
 493 {
 494         dt_ident_t *aid, *fid;
 495         dtrace_actdesc_t *ap;
 496         const char *format;
 497         dt_node_t *anp, *proto = NULL;
 498 
 499         char n[DT_TYPE_NAMELEN];
 500         int argc = 0, argr = 0;
 501 
 502         for (anp = dnp->dn_args; anp != NULL; anp = anp->dn_list)
 503                 argc++; /* count up arguments for error messages below */
 504 
 505         switch (dnp->dn_args->dn_kind) {
 506         case DT_NODE_STRING:
 507                 format = dnp->dn_args->dn_string;
 508                 anp = dnp->dn_args->dn_list;
 509                 argr = 2;
 510                 break;
 511         case DT_NODE_AGG:
 512                 format = NULL;
 513                 anp = dnp->dn_args;
 514                 argr = 1;
 515                 break;
 516         default:
 517                 format = NULL;
 518                 anp = dnp->dn_args;
 519                 argr = 1;
 520         }
 521 
 522         if (argc < argr) {
 523                 dnerror(dnp, D_PRINTA_PROTO,
 524                     "%s( ) prototype mismatch: %d args passed, %d expected\n",
 525                     dnp->dn_ident->di_name, argc, argr);
 526         }
 527 
 528         assert(anp != NULL);
 529 
 530         while (anp != NULL) {
 531                 if (anp->dn_kind != DT_NODE_AGG) {
 532                         dnerror(dnp, D_PRINTA_AGGARG,
 533                             "%s( ) argument #%d is incompatible with "
 534                             "prototype:\n\tprototype: aggregation\n"
 535                             "\t argument: %s\n", dnp->dn_ident->di_name, argr,
 536                             dt_node_type_name(anp, n, sizeof (n)));
 537                 }
 538 
 539                 aid = anp->dn_ident;
 540                 fid = aid->di_iarg;
 541 
 542                 if (aid->di_gen == dtp->dt_gen &&
 543                     !(aid->di_flags & DT_IDFLG_MOD)) {
 544                         dnerror(dnp, D_PRINTA_AGGBAD,
 545                             "undefined aggregation: @%s\n", aid->di_name);
 546                 }
 547 
 548                 /*
 549                  * If we have multiple aggregations, we must be sure that
 550                  * their key signatures match.
 551                  */
 552                 if (proto != NULL) {
 553                         dt_printa_validate(proto, anp);
 554                 } else {
 555                         proto = anp;
 556                 }
 557 
 558                 if (format != NULL) {
 559                         yylineno = dnp->dn_line;
 560 
 561                         sdp->dtsd_fmtdata =
 562                             dt_printf_create(yypcb->pcb_hdl, format);
 563                         dt_printf_validate(sdp->dtsd_fmtdata,
 564                             DT_PRINTF_AGGREGATION, dnp->dn_ident, 1,
 565                             fid->di_id, ((dt_idsig_t *)aid->di_data)->dis_args);
 566                         format = NULL;
 567                 }
 568 
 569                 ap = dt_stmt_action(dtp, sdp);
 570                 dt_action_difconst(ap, anp->dn_ident->di_id, DTRACEACT_PRINTA);
 571 
 572                 anp = anp->dn_list;
 573                 argr++;
 574         }
 575 }
 576 
 577 static void
 578 dt_action_printflike(dtrace_hdl_t *dtp, dt_node_t *dnp, dtrace_stmtdesc_t *sdp,
 579     dtrace_actkind_t kind)
 580 {
 581         dt_node_t *anp, *arg1;
 582         dtrace_actdesc_t *ap = NULL;
 583         char n[DT_TYPE_NAMELEN], *str;
 584 
 585         assert(DTRACEACT_ISPRINTFLIKE(kind));
 586 
 587         if (dnp->dn_args->dn_kind != DT_NODE_STRING) {
 588                 dnerror(dnp, D_PRINTF_ARG_FMT,
 589                     "%s( ) argument #1 is incompatible with prototype:\n"
 590                     "\tprototype: string constant\n\t argument: %s\n",
 591                     dnp->dn_ident->di_name,
 592                     dt_node_type_name(dnp->dn_args, n, sizeof (n)));
 593         }
 594 
 595         arg1 = dnp->dn_args->dn_list;
 596         yylineno = dnp->dn_line;
 597         str = dnp->dn_args->dn_string;
 598 
 599 
 600         /*
 601          * If this is an freopen(), we use an empty string to denote that
 602          * stdout should be restored.  For other printf()-like actions, an
 603          * empty format string is illegal:  an empty format string would
 604          * result in malformed DOF, and the compiler thus flags an empty
 605          * format string as a compile-time error.  To avoid propagating the
 606          * freopen() special case throughout the system, we simply transpose
 607          * an empty string into a sentinel string (DT_FREOPEN_RESTORE) that
 608          * denotes that stdout should be restored.
 609          */
 610         if (kind == DTRACEACT_FREOPEN) {
 611                 if (strcmp(str, DT_FREOPEN_RESTORE) == 0) {
 612                         /*
 613                          * Our sentinel is always an invalid argument to
 614                          * freopen(), but if it's been manually specified, we
 615                          * must fail now instead of when the freopen() is
 616                          * actually evaluated.
 617                          */
 618                         dnerror(dnp, D_FREOPEN_INVALID,
 619                             "%s( ) argument #1 cannot be \"%s\"\n",
 620                             dnp->dn_ident->di_name, DT_FREOPEN_RESTORE);
 621                 }
 622 
 623                 if (str[0] == '\0')
 624                         str = DT_FREOPEN_RESTORE;
 625         }
 626 
 627         sdp->dtsd_fmtdata = dt_printf_create(dtp, str);
 628 
 629         dt_printf_validate(sdp->dtsd_fmtdata, DT_PRINTF_EXACTLEN,
 630             dnp->dn_ident, 1, DTRACEACT_AGGREGATION, arg1);
 631 
 632         if (arg1 == NULL) {
 633                 dif_instr_t *dbuf;
 634                 dtrace_difo_t *dp;
 635 
 636                 if ((dbuf = dt_alloc(dtp, sizeof (dif_instr_t))) == NULL ||
 637                     (dp = dt_zalloc(dtp, sizeof (dtrace_difo_t))) == NULL) {
 638                         dt_free(dtp, dbuf);
 639                         longjmp(yypcb->pcb_jmpbuf, EDT_NOMEM);
 640                 }
 641 
 642                 dbuf[0] = DIF_INSTR_RET(DIF_REG_R0); /* ret %r0 */
 643 
 644                 dp->dtdo_buf = dbuf;
 645                 dp->dtdo_len = 1;
 646                 dp->dtdo_rtype = dt_int_rtype;
 647 
 648                 ap = dt_stmt_action(dtp, sdp);
 649                 ap->dtad_difo = dp;
 650                 ap->dtad_kind = kind;
 651                 return;
 652         }
 653 
 654         for (anp = arg1; anp != NULL; anp = anp->dn_list) {
 655                 ap = dt_stmt_action(dtp, sdp);
 656                 dt_cg(yypcb, anp);
 657                 ap->dtad_difo = dt_as(yypcb);
 658                 ap->dtad_kind = kind;
 659         }
 660 }
 661 
 662 static void
 663 dt_action_trace(dtrace_hdl_t *dtp, dt_node_t *dnp, dtrace_stmtdesc_t *sdp)
 664 {
 665         int ctflib;
 666 
 667         dtrace_actdesc_t *ap = dt_stmt_action(dtp, sdp);
 668         boolean_t istrace = (dnp->dn_ident->di_id == DT_ACT_TRACE);
 669         const char *act = istrace ?  "trace" : "print";
 670 
 671         if (dt_node_is_void(dnp->dn_args)) {
 672                 dnerror(dnp->dn_args, istrace ? D_TRACE_VOID : D_PRINT_VOID,
 673                     "%s( ) may not be applied to a void expression\n", act);
 674         }
 675 
 676         if (dt_node_resolve(dnp->dn_args, DT_IDENT_XLPTR) != NULL) {
 677                 dnerror(dnp->dn_args, istrace ? D_TRACE_DYN : D_PRINT_DYN,
 678                     "%s( ) may not be applied to a translated pointer\n", act);
 679         }
 680 
 681         if (dnp->dn_args->dn_kind == DT_NODE_AGG) {
 682                 dnerror(dnp->dn_args, istrace ? D_TRACE_AGG : D_PRINT_AGG,
 683                     "%s( ) may not be applied to an aggregation%s\n", act,
 684                     istrace ? "" : " -- did you mean printa()?");
 685         }
 686 
 687         dt_cg(yypcb, dnp->dn_args);
 688 
 689         /*
 690          * The print() action behaves identically to trace(), except that it
 691          * stores the CTF type of the argument (if present) within the DOF for
 692          * the DIFEXPR action.  To do this, we set the 'dtsd_strdata' to point
 693          * to the fully-qualified CTF type ID for the result of the DIF
 694          * action.  We use the ID instead of the name to handles complex types
 695          * like arrays and function pointers that can't be resolved by
 696          * ctf_type_lookup().  This is later processed by dtrace_dof_create()
 697          * and turned into a reference into the string table so that we can
 698          * get the type information when we process the data after the fact.  In
 699          * the case where we are referring to userland CTF data, we also need to
 700          * to identify which ctf container in question we care about and encode
 701          * that within the name.
 702          */
 703         if (dnp->dn_ident->di_id == DT_ACT_PRINT) {
 704                 dt_node_t *dret;
 705                 size_t n;
 706                 dt_module_t *dmp;
 707 
 708                 dret = yypcb->pcb_dret;
 709                 dmp = dt_module_lookup_by_ctf(dtp, dret->dn_ctfp);
 710 
 711                 if (dmp->dm_pid != 0) {
 712                         ctflib = dt_module_getlibid(dtp, dmp, dret->dn_ctfp);
 713                         assert(ctflib >= 0);
 714                         n = snprintf(NULL, 0, "%s`%d`%d", dmp->dm_name,
 715                             ctflib, dret->dn_type) + 1;
 716                 } else {
 717                         n = snprintf(NULL, 0, "%s`%d", dmp->dm_name,
 718                             dret->dn_type) + 1;
 719                 }
 720                 sdp->dtsd_strdata = dt_alloc(dtp, n);
 721                 if (sdp->dtsd_strdata == NULL)
 722                         longjmp(yypcb->pcb_jmpbuf, EDT_NOMEM);
 723                 if (dmp->dm_pid != 0) {
 724                         (void) snprintf(sdp->dtsd_strdata, n, "%s`%d`%d",
 725                             dmp->dm_name, ctflib, dret->dn_type);
 726                 } else {
 727                         (void) snprintf(sdp->dtsd_strdata, n, "%s`%d",
 728                             dmp->dm_name, dret->dn_type);
 729                 }
 730         }
 731 
 732         ap->dtad_difo = dt_as(yypcb);
 733         ap->dtad_kind = DTRACEACT_DIFEXPR;
 734 }
 735 
 736 static void
 737 dt_action_tracemem(dtrace_hdl_t *dtp, dt_node_t *dnp, dtrace_stmtdesc_t *sdp)
 738 {
 739         dtrace_actdesc_t *ap = dt_stmt_action(dtp, sdp);
 740 
 741         dt_node_t *addr = dnp->dn_args;
 742         dt_node_t *max = dnp->dn_args->dn_list;
 743         dt_node_t *size;
 744 
 745         char n[DT_TYPE_NAMELEN];
 746 
 747         if (dt_node_is_integer(addr) == 0 && dt_node_is_pointer(addr) == 0) {
 748                 dnerror(addr, D_TRACEMEM_ADDR,
 749                     "tracemem( ) argument #1 is incompatible with "
 750                     "prototype:\n\tprototype: pointer or integer\n"
 751                     "\t argument: %s\n",
 752                     dt_node_type_name(addr, n, sizeof (n)));
 753         }
 754 
 755         if (dt_node_is_posconst(max) == 0) {
 756                 dnerror(max, D_TRACEMEM_SIZE, "tracemem( ) argument #2 must "
 757                     "be a non-zero positive integral constant expression\n");
 758         }
 759 
 760         if ((size = max->dn_list) != NULL) {
 761                 if (size->dn_list != NULL) {
 762                         dnerror(size, D_TRACEMEM_ARGS, "tracemem ( ) prototype "
 763                             "mismatch: expected at most 3 args\n");
 764                 }
 765 
 766                 if (!dt_node_is_scalar(size)) {
 767                         dnerror(size, D_TRACEMEM_DYNSIZE, "tracemem ( ) "
 768                             "dynamic size (argument #3) must be of "
 769                             "scalar type\n");
 770                 }
 771 
 772                 dt_cg(yypcb, size);
 773                 ap->dtad_difo = dt_as(yypcb);
 774                 ap->dtad_difo->dtdo_rtype = dt_int_rtype;
 775                 ap->dtad_kind = DTRACEACT_TRACEMEM_DYNSIZE;
 776 
 777                 ap = dt_stmt_action(dtp, sdp);
 778         }
 779 
 780         dt_cg(yypcb, addr);
 781         ap->dtad_difo = dt_as(yypcb);
 782         ap->dtad_kind = DTRACEACT_TRACEMEM;
 783 
 784         ap->dtad_difo->dtdo_rtype.dtdt_flags |= DIF_TF_BYREF;
 785         ap->dtad_difo->dtdo_rtype.dtdt_size = max->dn_value;
 786 }
 787 
 788 static void
 789 dt_action_stack_args(dtrace_hdl_t *dtp, dtrace_actdesc_t *ap, dt_node_t *arg0)
 790 {
 791         ap->dtad_kind = DTRACEACT_STACK;
 792 
 793         if (dtp->dt_options[DTRACEOPT_STACKFRAMES] != DTRACEOPT_UNSET) {
 794                 ap->dtad_arg = dtp->dt_options[DTRACEOPT_STACKFRAMES];
 795         } else {
 796                 ap->dtad_arg = 0;
 797         }
 798 
 799         if (arg0 != NULL) {
 800                 if (arg0->dn_list != NULL) {
 801                         dnerror(arg0, D_STACK_PROTO, "stack( ) prototype "
 802                             "mismatch: too many arguments\n");
 803                 }
 804 
 805                 if (dt_node_is_posconst(arg0) == 0) {
 806                         dnerror(arg0, D_STACK_SIZE, "stack( ) size must be a "
 807                             "non-zero positive integral constant expression\n");
 808                 }
 809 
 810                 ap->dtad_arg = arg0->dn_value;
 811         }
 812 }
 813 
 814 static void
 815 dt_action_stack(dtrace_hdl_t *dtp, dt_node_t *dnp, dtrace_stmtdesc_t *sdp)
 816 {
 817         dtrace_actdesc_t *ap = dt_stmt_action(dtp, sdp);
 818         dt_action_stack_args(dtp, ap, dnp->dn_args);
 819 }
 820 
 821 static void
 822 dt_action_ustack_args(dtrace_hdl_t *dtp, dtrace_actdesc_t *ap, dt_node_t *dnp)
 823 {
 824         uint32_t nframes = 0;
 825         uint32_t strsize = 0;   /* default string table size */
 826         dt_node_t *arg0 = dnp->dn_args;
 827         dt_node_t *arg1 = arg0 != NULL ? arg0->dn_list : NULL;
 828 
 829         assert(dnp->dn_ident->di_id == DT_ACT_JSTACK ||
 830             dnp->dn_ident->di_id == DT_ACT_USTACK);
 831 
 832         if (dnp->dn_ident->di_id == DT_ACT_JSTACK) {
 833                 if (dtp->dt_options[DTRACEOPT_JSTACKFRAMES] != DTRACEOPT_UNSET)
 834                         nframes = dtp->dt_options[DTRACEOPT_JSTACKFRAMES];
 835 
 836                 if (dtp->dt_options[DTRACEOPT_JSTACKSTRSIZE] != DTRACEOPT_UNSET)
 837                         strsize = dtp->dt_options[DTRACEOPT_JSTACKSTRSIZE];
 838 
 839                 ap->dtad_kind = DTRACEACT_JSTACK;
 840         } else {
 841                 assert(dnp->dn_ident->di_id == DT_ACT_USTACK);
 842 
 843                 if (dtp->dt_options[DTRACEOPT_USTACKFRAMES] != DTRACEOPT_UNSET)
 844                         nframes = dtp->dt_options[DTRACEOPT_USTACKFRAMES];
 845 
 846                 ap->dtad_kind = DTRACEACT_USTACK;
 847         }
 848 
 849         if (arg0 != NULL) {
 850                 if (!dt_node_is_posconst(arg0)) {
 851                         dnerror(arg0, D_USTACK_FRAMES, "ustack( ) argument #1 "
 852                             "must be a non-zero positive integer constant\n");
 853                 }
 854                 nframes = (uint32_t)arg0->dn_value;
 855         }
 856 
 857         if (arg1 != NULL) {
 858                 if (arg1->dn_kind != DT_NODE_INT ||
 859                     ((arg1->dn_flags & DT_NF_SIGNED) &&
 860                     (int64_t)arg1->dn_value < 0)) {
 861                         dnerror(arg1, D_USTACK_STRSIZE, "ustack( ) argument #2 "
 862                             "must be a positive integer constant\n");
 863                 }
 864 
 865                 if (arg1->dn_list != NULL) {
 866                         dnerror(arg1, D_USTACK_PROTO, "ustack( ) prototype "
 867                             "mismatch: too many arguments\n");
 868                 }
 869 
 870                 strsize = (uint32_t)arg1->dn_value;
 871         }
 872 
 873         ap->dtad_arg = DTRACE_USTACK_ARG(nframes, strsize);
 874 }
 875 
 876 static void
 877 dt_action_ustack(dtrace_hdl_t *dtp, dt_node_t *dnp, dtrace_stmtdesc_t *sdp)
 878 {
 879         dtrace_actdesc_t *ap = dt_stmt_action(dtp, sdp);
 880         dt_action_ustack_args(dtp, ap, dnp);
 881 }
 882 
 883 static void
 884 dt_action_setopt(dtrace_hdl_t *dtp, dt_node_t *dnp, dtrace_stmtdesc_t *sdp)
 885 {
 886         dtrace_actdesc_t *ap;
 887         dt_node_t *arg0, *arg1;
 888 
 889         /*
 890          * The prototype guarantees that we are called with either one or
 891          * two arguments, and that any arguments that are present are strings.
 892          */
 893         arg0 = dnp->dn_args;
 894         arg1 = arg0->dn_list;
 895 
 896         ap = dt_stmt_action(dtp, sdp);
 897         dt_cg(yypcb, arg0);
 898         ap->dtad_difo = dt_as(yypcb);
 899         ap->dtad_kind = DTRACEACT_LIBACT;
 900         ap->dtad_arg = DT_ACT_SETOPT;
 901 
 902         ap = dt_stmt_action(dtp, sdp);
 903 
 904         if (arg1 == NULL) {
 905                 dt_action_difconst(ap, 0, DTRACEACT_LIBACT);
 906         } else {
 907                 dt_cg(yypcb, arg1);
 908                 ap->dtad_difo = dt_as(yypcb);
 909                 ap->dtad_kind = DTRACEACT_LIBACT;
 910         }
 911 
 912         ap->dtad_arg = DT_ACT_SETOPT;
 913 }
 914 
 915 /*ARGSUSED*/
 916 static void
 917 dt_action_symmod_args(dtrace_hdl_t *dtp, dtrace_actdesc_t *ap,
 918     dt_node_t *dnp, dtrace_actkind_t kind)
 919 {
 920         assert(kind == DTRACEACT_SYM || kind == DTRACEACT_MOD ||
 921             kind == DTRACEACT_USYM || kind == DTRACEACT_UMOD ||
 922             kind == DTRACEACT_UADDR);
 923 
 924         dt_cg(yypcb, dnp);
 925         ap->dtad_difo = dt_as(yypcb);
 926         ap->dtad_kind = kind;
 927         ap->dtad_difo->dtdo_rtype.dtdt_size = sizeof (uint64_t);
 928 }
 929 
 930 static void
 931 dt_action_symmod(dtrace_hdl_t *dtp, dt_node_t *dnp, dtrace_stmtdesc_t *sdp,
 932     dtrace_actkind_t kind)
 933 {
 934         dtrace_actdesc_t *ap = dt_stmt_action(dtp, sdp);
 935         dt_action_symmod_args(dtp, ap, dnp->dn_args, kind);
 936 }
 937 
 938 /*ARGSUSED*/
 939 static void
 940 dt_action_ftruncate(dtrace_hdl_t *dtp, dt_node_t *dnp, dtrace_stmtdesc_t *sdp)
 941 {
 942         dtrace_actdesc_t *ap = dt_stmt_action(dtp, sdp);
 943 
 944         /*
 945          * Library actions need a DIFO that serves as an argument.  As
 946          * ftruncate() doesn't take an argument, we generate the constant 0
 947          * in a DIFO; this constant will be ignored when the ftruncate() is
 948          * processed.
 949          */
 950         dt_action_difconst(ap, 0, DTRACEACT_LIBACT);
 951         ap->dtad_arg = DT_ACT_FTRUNCATE;
 952 }
 953 
 954 /*ARGSUSED*/
 955 static void
 956 dt_action_stop(dtrace_hdl_t *dtp, dt_node_t *dnp, dtrace_stmtdesc_t *sdp)
 957 {
 958         dtrace_actdesc_t *ap = dt_stmt_action(dtp, sdp);
 959 
 960         ap->dtad_kind = DTRACEACT_STOP;
 961         ap->dtad_arg = 0;
 962 }
 963 
 964 /*ARGSUSED*/
 965 static void
 966 dt_action_breakpoint(dtrace_hdl_t *dtp, dt_node_t *dnp, dtrace_stmtdesc_t *sdp)
 967 {
 968         dtrace_actdesc_t *ap = dt_stmt_action(dtp, sdp);
 969 
 970         ap->dtad_kind = DTRACEACT_BREAKPOINT;
 971         ap->dtad_arg = 0;
 972 }
 973 
 974 /*ARGSUSED*/
 975 static void
 976 dt_action_panic(dtrace_hdl_t *dtp, dt_node_t *dnp, dtrace_stmtdesc_t *sdp)
 977 {
 978         dtrace_actdesc_t *ap = dt_stmt_action(dtp, sdp);
 979 
 980         ap->dtad_kind = DTRACEACT_PANIC;
 981         ap->dtad_arg = 0;
 982 }
 983 
 984 static void
 985 dt_action_chill(dtrace_hdl_t *dtp, dt_node_t *dnp, dtrace_stmtdesc_t *sdp)
 986 {
 987         dtrace_actdesc_t *ap = dt_stmt_action(dtp, sdp);
 988 
 989         dt_cg(yypcb, dnp->dn_args);
 990         ap->dtad_difo = dt_as(yypcb);
 991         ap->dtad_kind = DTRACEACT_CHILL;
 992 }
 993 
 994 static void
 995 dt_action_raise(dtrace_hdl_t *dtp, dt_node_t *dnp, dtrace_stmtdesc_t *sdp)
 996 {
 997         dtrace_actdesc_t *ap = dt_stmt_action(dtp, sdp);
 998 
 999         dt_cg(yypcb, dnp->dn_args);
1000         ap->dtad_difo = dt_as(yypcb);
1001         ap->dtad_kind = DTRACEACT_RAISE;
1002 }
1003 
1004 static void
1005 dt_action_exit(dtrace_hdl_t *dtp, dt_node_t *dnp, dtrace_stmtdesc_t *sdp)
1006 {
1007         dtrace_actdesc_t *ap = dt_stmt_action(dtp, sdp);
1008 
1009         dt_cg(yypcb, dnp->dn_args);
1010         ap->dtad_difo = dt_as(yypcb);
1011         ap->dtad_kind = DTRACEACT_EXIT;
1012         ap->dtad_difo->dtdo_rtype.dtdt_size = sizeof (int);
1013 }
1014 
1015 static void
1016 dt_action_speculate(dtrace_hdl_t *dtp, dt_node_t *dnp, dtrace_stmtdesc_t *sdp)
1017 {
1018         dtrace_actdesc_t *ap = dt_stmt_action(dtp, sdp);
1019 
1020         dt_cg(yypcb, dnp->dn_args);
1021         ap->dtad_difo = dt_as(yypcb);
1022         ap->dtad_kind = DTRACEACT_SPECULATE;
1023 }
1024 
1025 static void
1026 dt_action_commit(dtrace_hdl_t *dtp, dt_node_t *dnp, dtrace_stmtdesc_t *sdp)
1027 {
1028         dtrace_actdesc_t *ap = dt_stmt_action(dtp, sdp);
1029 
1030         dt_cg(yypcb, dnp->dn_args);
1031         ap->dtad_difo = dt_as(yypcb);
1032         ap->dtad_kind = DTRACEACT_COMMIT;
1033 }
1034 
1035 static void
1036 dt_action_discard(dtrace_hdl_t *dtp, dt_node_t *dnp, dtrace_stmtdesc_t *sdp)
1037 {
1038         dtrace_actdesc_t *ap = dt_stmt_action(dtp, sdp);
1039 
1040         dt_cg(yypcb, dnp->dn_args);
1041         ap->dtad_difo = dt_as(yypcb);
1042         ap->dtad_kind = DTRACEACT_DISCARD;
1043 }
1044 
1045 static void
1046 dt_compile_fun(dtrace_hdl_t *dtp, dt_node_t *dnp, dtrace_stmtdesc_t *sdp)
1047 {
1048         switch (dnp->dn_expr->dn_ident->di_id) {
1049         case DT_ACT_BREAKPOINT:
1050                 dt_action_breakpoint(dtp, dnp->dn_expr, sdp);
1051                 break;
1052         case DT_ACT_CHILL:
1053                 dt_action_chill(dtp, dnp->dn_expr, sdp);
1054                 break;
1055         case DT_ACT_CLEAR:
1056                 dt_action_clear(dtp, dnp->dn_expr, sdp);
1057                 break;
1058         case DT_ACT_COMMIT:
1059                 dt_action_commit(dtp, dnp->dn_expr, sdp);
1060                 break;
1061         case DT_ACT_DENORMALIZE:
1062                 dt_action_normalize(dtp, dnp->dn_expr, sdp);
1063                 break;
1064         case DT_ACT_DISCARD:
1065                 dt_action_discard(dtp, dnp->dn_expr, sdp);
1066                 break;
1067         case DT_ACT_EXIT:
1068                 dt_action_exit(dtp, dnp->dn_expr, sdp);
1069                 break;
1070         case DT_ACT_FREOPEN:
1071                 dt_action_printflike(dtp, dnp->dn_expr, sdp, DTRACEACT_FREOPEN);
1072                 break;
1073         case DT_ACT_FTRUNCATE:
1074                 dt_action_ftruncate(dtp, dnp->dn_expr, sdp);
1075                 break;
1076         case DT_ACT_MOD:
1077                 dt_action_symmod(dtp, dnp->dn_expr, sdp, DTRACEACT_MOD);
1078                 break;
1079         case DT_ACT_NORMALIZE:
1080                 dt_action_normalize(dtp, dnp->dn_expr, sdp);
1081                 break;
1082         case DT_ACT_PANIC:
1083                 dt_action_panic(dtp, dnp->dn_expr, sdp);
1084                 break;
1085         case DT_ACT_PRINT:
1086                 dt_action_trace(dtp, dnp->dn_expr, sdp);
1087                 break;
1088         case DT_ACT_PRINTA:
1089                 dt_action_printa(dtp, dnp->dn_expr, sdp);
1090                 break;
1091         case DT_ACT_PRINTF:
1092                 dt_action_printflike(dtp, dnp->dn_expr, sdp, DTRACEACT_PRINTF);
1093                 break;
1094         case DT_ACT_RAISE:
1095                 dt_action_raise(dtp, dnp->dn_expr, sdp);
1096                 break;
1097         case DT_ACT_SETOPT:
1098                 dt_action_setopt(dtp, dnp->dn_expr, sdp);
1099                 break;
1100         case DT_ACT_SPECULATE:
1101                 dt_action_speculate(dtp, dnp->dn_expr, sdp);
1102                 break;
1103         case DT_ACT_STACK:
1104                 dt_action_stack(dtp, dnp->dn_expr, sdp);
1105                 break;
1106         case DT_ACT_STOP:
1107                 dt_action_stop(dtp, dnp->dn_expr, sdp);
1108                 break;
1109         case DT_ACT_SYM:
1110                 dt_action_symmod(dtp, dnp->dn_expr, sdp, DTRACEACT_SYM);
1111                 break;
1112         case DT_ACT_SYSTEM:
1113                 dt_action_printflike(dtp, dnp->dn_expr, sdp, DTRACEACT_SYSTEM);
1114                 break;
1115         case DT_ACT_TRACE:
1116                 dt_action_trace(dtp, dnp->dn_expr, sdp);
1117                 break;
1118         case DT_ACT_TRACEMEM:
1119                 dt_action_tracemem(dtp, dnp->dn_expr, sdp);
1120                 break;
1121         case DT_ACT_TRUNC:
1122                 dt_action_trunc(dtp, dnp->dn_expr, sdp);
1123                 break;
1124         case DT_ACT_UADDR:
1125                 dt_action_symmod(dtp, dnp->dn_expr, sdp, DTRACEACT_UADDR);
1126                 break;
1127         case DT_ACT_UMOD:
1128                 dt_action_symmod(dtp, dnp->dn_expr, sdp, DTRACEACT_UMOD);
1129                 break;
1130         case DT_ACT_USYM:
1131                 dt_action_symmod(dtp, dnp->dn_expr, sdp, DTRACEACT_USYM);
1132                 break;
1133         case DT_ACT_USTACK:
1134         case DT_ACT_JSTACK:
1135                 dt_action_ustack(dtp, dnp->dn_expr, sdp);
1136                 break;
1137         default:
1138                 dnerror(dnp->dn_expr, D_UNKNOWN, "tracing function %s( ) is "
1139                     "not yet supported\n", dnp->dn_expr->dn_ident->di_name);
1140         }
1141 }
1142 
1143 static void
1144 dt_compile_exp(dtrace_hdl_t *dtp, dt_node_t *dnp, dtrace_stmtdesc_t *sdp)
1145 {
1146         dtrace_actdesc_t *ap = dt_stmt_action(dtp, sdp);
1147 
1148         dt_cg(yypcb, dnp->dn_expr);
1149         ap->dtad_difo = dt_as(yypcb);
1150         ap->dtad_difo->dtdo_rtype = dt_void_rtype;
1151         ap->dtad_kind = DTRACEACT_DIFEXPR;
1152 }
1153 
1154 static void
1155 dt_compile_agg(dtrace_hdl_t *dtp, dt_node_t *dnp, dtrace_stmtdesc_t *sdp)
1156 {
1157         dt_ident_t *aid, *fid;
1158         dt_node_t *anp, *incr = NULL;
1159         dtrace_actdesc_t *ap;
1160         uint_t n = 1, argmax;
1161         uint64_t arg = 0;
1162 
1163         /*
1164          * If the aggregation has no aggregating function applied to it, then
1165          * this statement has no effect.  Flag this as a programming error.
1166          */
1167         if (dnp->dn_aggfun == NULL) {
1168                 dnerror(dnp, D_AGG_NULL, "expression has null effect: @%s\n",
1169                     dnp->dn_ident->di_name);
1170         }
1171 
1172         aid = dnp->dn_ident;
1173         fid = dnp->dn_aggfun->dn_ident;
1174 
1175         if (dnp->dn_aggfun->dn_args != NULL &&
1176             dt_node_is_scalar(dnp->dn_aggfun->dn_args) == 0) {
1177                 dnerror(dnp->dn_aggfun, D_AGG_SCALAR, "%s( ) argument #1 must "
1178                     "be of scalar type\n", fid->di_name);
1179         }
1180 
1181         /*
1182          * The ID of the aggregation itself is implicitly recorded as the first
1183          * member of each aggregation tuple so we can distinguish them later.
1184          */
1185         ap = dt_stmt_action(dtp, sdp);
1186         dt_action_difconst(ap, aid->di_id, DTRACEACT_DIFEXPR);
1187 
1188         for (anp = dnp->dn_aggtup; anp != NULL; anp = anp->dn_list) {
1189                 ap = dt_stmt_action(dtp, sdp);
1190                 n++;
1191 
1192                 if (anp->dn_kind == DT_NODE_FUNC) {
1193                         if (anp->dn_ident->di_id == DT_ACT_STACK) {
1194                                 dt_action_stack_args(dtp, ap, anp->dn_args);
1195                                 continue;
1196                         }
1197 
1198                         if (anp->dn_ident->di_id == DT_ACT_USTACK ||
1199                             anp->dn_ident->di_id == DT_ACT_JSTACK) {
1200                                 dt_action_ustack_args(dtp, ap, anp);
1201                                 continue;
1202                         }
1203 
1204                         switch (anp->dn_ident->di_id) {
1205                         case DT_ACT_UADDR:
1206                                 dt_action_symmod_args(dtp, ap,
1207                                     anp->dn_args, DTRACEACT_UADDR);
1208                                 continue;
1209 
1210                         case DT_ACT_USYM:
1211                                 dt_action_symmod_args(dtp, ap,
1212                                     anp->dn_args, DTRACEACT_USYM);
1213                                 continue;
1214 
1215                         case DT_ACT_UMOD:
1216                                 dt_action_symmod_args(dtp, ap,
1217                                     anp->dn_args, DTRACEACT_UMOD);
1218                                 continue;
1219 
1220                         case DT_ACT_SYM:
1221                                 dt_action_symmod_args(dtp, ap,
1222                                     anp->dn_args, DTRACEACT_SYM);
1223                                 continue;
1224 
1225                         case DT_ACT_MOD:
1226                                 dt_action_symmod_args(dtp, ap,
1227                                     anp->dn_args, DTRACEACT_MOD);
1228                                 continue;
1229 
1230                         default:
1231                                 break;
1232                         }
1233                 }
1234 
1235                 dt_cg(yypcb, anp);
1236                 ap->dtad_difo = dt_as(yypcb);
1237                 ap->dtad_kind = DTRACEACT_DIFEXPR;
1238         }
1239 
1240         if (fid->di_id == DTRACEAGG_LQUANTIZE) {
1241                 /*
1242                  * For linear quantization, we have between two and four
1243                  * arguments in addition to the expression:
1244                  *
1245                  *    arg1 => Base value
1246                  *    arg2 => Limit value
1247                  *    arg3 => Quantization level step size (defaults to 1)
1248                  *    arg4 => Quantization increment value (defaults to 1)
1249                  */
1250                 dt_node_t *arg1 = dnp->dn_aggfun->dn_args->dn_list;
1251                 dt_node_t *arg2 = arg1->dn_list;
1252                 dt_node_t *arg3 = arg2->dn_list;
1253                 dt_idsig_t *isp;
1254                 uint64_t nlevels, step = 1, oarg;
1255                 int64_t baseval, limitval;
1256 
1257                 if (arg1->dn_kind != DT_NODE_INT) {
1258                         dnerror(arg1, D_LQUANT_BASETYPE, "lquantize( ) "
1259                             "argument #1 must be an integer constant\n");
1260                 }
1261 
1262                 baseval = (int64_t)arg1->dn_value;
1263 
1264                 if (baseval < INT32_MIN || baseval > INT32_MAX) {
1265                         dnerror(arg1, D_LQUANT_BASEVAL, "lquantize( ) "
1266                             "argument #1 must be a 32-bit quantity\n");
1267                 }
1268 
1269                 if (arg2->dn_kind != DT_NODE_INT) {
1270                         dnerror(arg2, D_LQUANT_LIMTYPE, "lquantize( ) "
1271                             "argument #2 must be an integer constant\n");
1272                 }
1273 
1274                 limitval = (int64_t)arg2->dn_value;
1275 
1276                 if (limitval < INT32_MIN || limitval > INT32_MAX) {
1277                         dnerror(arg2, D_LQUANT_LIMVAL, "lquantize( ) "
1278                             "argument #2 must be a 32-bit quantity\n");
1279                 }
1280 
1281                 if (limitval < baseval) {
1282                         dnerror(dnp, D_LQUANT_MISMATCH,
1283                             "lquantize( ) base (argument #1) must be less "
1284                             "than limit (argument #2)\n");
1285                 }
1286 
1287                 if (arg3 != NULL) {
1288                         if (!dt_node_is_posconst(arg3)) {
1289                                 dnerror(arg3, D_LQUANT_STEPTYPE, "lquantize( ) "
1290                                     "argument #3 must be a non-zero positive "
1291                                     "integer constant\n");
1292                         }
1293 
1294                         if ((step = arg3->dn_value) > UINT16_MAX) {
1295                                 dnerror(arg3, D_LQUANT_STEPVAL, "lquantize( ) "
1296                                     "argument #3 must be a 16-bit quantity\n");
1297                         }
1298                 }
1299 
1300                 nlevels = (limitval - baseval) / step;
1301 
1302                 if (nlevels == 0) {
1303                         dnerror(dnp, D_LQUANT_STEPLARGE,
1304                             "lquantize( ) step (argument #3) too large: must "
1305                             "have at least one quantization level\n");
1306                 }
1307 
1308                 if (nlevels > UINT16_MAX) {
1309                         dnerror(dnp, D_LQUANT_STEPSMALL, "lquantize( ) step "
1310                             "(argument #3) too small: number of quantization "
1311                             "levels must be a 16-bit quantity\n");
1312                 }
1313 
1314                 arg = (step << DTRACE_LQUANTIZE_STEPSHIFT) |
1315                     (nlevels << DTRACE_LQUANTIZE_LEVELSHIFT) |
1316                     ((baseval << DTRACE_LQUANTIZE_BASESHIFT) &
1317                     DTRACE_LQUANTIZE_BASEMASK);
1318 
1319                 assert(arg != 0);
1320 
1321                 isp = (dt_idsig_t *)aid->di_data;
1322 
1323                 if (isp->dis_auxinfo == 0) {
1324                         /*
1325                          * This is the first time we've seen an lquantize()
1326                          * for this aggregation; we'll store our argument
1327                          * as the auxiliary signature information.
1328                          */
1329                         isp->dis_auxinfo = arg;
1330                 } else if ((oarg = isp->dis_auxinfo) != arg) {
1331                         /*
1332                          * If we have seen this lquantize() before and the
1333                          * argument doesn't match the original argument, pick
1334                          * the original argument apart to concisely report the
1335                          * mismatch.
1336                          */
1337                         int obaseval = DTRACE_LQUANTIZE_BASE(oarg);
1338                         int onlevels = DTRACE_LQUANTIZE_LEVELS(oarg);
1339                         int ostep = DTRACE_LQUANTIZE_STEP(oarg);
1340 
1341                         if (obaseval != baseval) {
1342                                 dnerror(dnp, D_LQUANT_MATCHBASE, "lquantize( ) "
1343                                     "base (argument #1) doesn't match previous "
1344                                     "declaration: expected %d, found %d\n",
1345                                     obaseval, (int)baseval);
1346                         }
1347 
1348                         if (onlevels * ostep != nlevels * step) {
1349                                 dnerror(dnp, D_LQUANT_MATCHLIM, "lquantize( ) "
1350                                     "limit (argument #2) doesn't match previous"
1351                                     " declaration: expected %d, found %d\n",
1352                                     obaseval + onlevels * ostep,
1353                                     (int)baseval + (int)nlevels * (int)step);
1354                         }
1355 
1356                         if (ostep != step) {
1357                                 dnerror(dnp, D_LQUANT_MATCHSTEP, "lquantize( ) "
1358                                     "step (argument #3) doesn't match previous "
1359                                     "declaration: expected %d, found %d\n",
1360                                     ostep, (int)step);
1361                         }
1362 
1363                         /*
1364                          * We shouldn't be able to get here -- one of the
1365                          * parameters must be mismatched if the arguments
1366                          * didn't match.
1367                          */
1368                         assert(0);
1369                 }
1370 
1371                 incr = arg3 != NULL ? arg3->dn_list : NULL;
1372                 argmax = 5;
1373         }
1374 
1375         if (fid->di_id == DTRACEAGG_LLQUANTIZE) {
1376                 /*
1377                  * For log/linear quantizations, we have between one and five
1378                  * arguments in addition to the expression:
1379                  *
1380                  *    arg1 => Factor
1381                  *    arg2 => Low magnitude
1382                  *    arg3 => High magnitude
1383                  *    arg4 => Number of steps per magnitude
1384                  *    arg5 => Quantization increment value (defaults to 1)
1385                  */
1386                 dt_node_t *llarg = dnp->dn_aggfun->dn_args->dn_list;
1387                 uint64_t oarg, order, v;
1388                 dt_idsig_t *isp;
1389                 int i;
1390 
1391                 struct {
1392                         char *str;              /* string identifier */
1393                         int badtype;            /* error on bad type */
1394                         int badval;             /* error on bad value */
1395                         int mismatch;           /* error on bad match */
1396                         int shift;              /* shift value */
1397                         uint16_t value;         /* value itself */
1398                 } args[] = {
1399                         { "factor", D_LLQUANT_FACTORTYPE,
1400                             D_LLQUANT_FACTORVAL, D_LLQUANT_FACTORMATCH,
1401                             DTRACE_LLQUANTIZE_FACTORSHIFT },
1402                         { "low magnitude", D_LLQUANT_LOWTYPE,
1403                             D_LLQUANT_LOWVAL, D_LLQUANT_LOWMATCH,
1404                             DTRACE_LLQUANTIZE_LOWSHIFT },
1405                         { "high magnitude", D_LLQUANT_HIGHTYPE,
1406                             D_LLQUANT_HIGHVAL, D_LLQUANT_HIGHMATCH,
1407                             DTRACE_LLQUANTIZE_HIGHSHIFT },
1408                         { "linear steps per magnitude", D_LLQUANT_NSTEPTYPE,
1409                             D_LLQUANT_NSTEPVAL, D_LLQUANT_NSTEPMATCH,
1410                             DTRACE_LLQUANTIZE_NSTEPSHIFT },
1411                         { NULL }
1412                 };
1413 
1414                 assert(arg == 0);
1415 
1416                 for (i = 0; args[i].str != NULL; i++) {
1417                         if (llarg->dn_kind != DT_NODE_INT) {
1418                                 dnerror(llarg, args[i].badtype, "llquantize( ) "
1419                                     "argument #%d (%s) must be an "
1420                                     "integer constant\n", i + 1, args[i].str);
1421                         }
1422 
1423                         if ((uint64_t)llarg->dn_value > UINT16_MAX) {
1424                                 dnerror(llarg, args[i].badval, "llquantize( ) "
1425                                     "argument #%d (%s) must be an unsigned "
1426                                     "16-bit quantity\n", i + 1, args[i].str);
1427                         }
1428 
1429                         args[i].value = (uint16_t)llarg->dn_value;
1430 
1431                         assert(!(arg & (UINT16_MAX << args[i].shift)));
1432                         arg |= ((uint64_t)args[i].value << args[i].shift);
1433                         llarg = llarg->dn_list;
1434                 }
1435 
1436                 assert(arg != 0);
1437 
1438                 if (args[0].value < 2) {
1439                         dnerror(dnp, D_LLQUANT_FACTORSMALL, "llquantize( ) "
1440                             "factor (argument #1) must be two or more\n");
1441                 }
1442 
1443                 if (args[1].value >= args[2].value) {
1444                         dnerror(dnp, D_LLQUANT_MAGRANGE, "llquantize( ) "
1445                             "high magnitude (argument #3) must be greater "
1446                             "than low magnitude (argument #2)\n");
1447                 }
1448 
1449                 if (args[3].value < args[0].value) {
1450                         dnerror(dnp, D_LLQUANT_FACTORNSTEPS, "llquantize( ) "
1451                             "factor (argument #1) must be less than or "
1452                             "equal to the number of linear steps per "
1453                             "magnitude (argument #4)\n");
1454                 }
1455 
1456                 for (v = args[0].value; v < args[3].value; v *= args[0].value)
1457                         continue;
1458 
1459                 if ((args[3].value % args[0].value) || (v % args[3].value)) {
1460                         dnerror(dnp, D_LLQUANT_FACTOREVEN, "llquantize( ) "
1461                             "factor (argument #1) must evenly divide the "
1462                             "number of steps per magnitude (argument #4), "
1463                             "and the number of steps per magnitude must evenly "
1464                             "divide a power of the factor\n");
1465                 }
1466 
1467                 for (i = 0, order = 1; i < args[2].value; i++) {
1468                         if (order * args[0].value > order) {
1469                                 order *= args[0].value;
1470                                 continue;
1471                         }
1472 
1473                         dnerror(dnp, D_LLQUANT_MAGTOOBIG, "llquantize( ) "
1474                             "factor (%d) raised to power of high magnitude "
1475                             "(%d) overflows 64-bits\n", args[0].value,
1476                             args[2].value);
1477                 }
1478 
1479                 isp = (dt_idsig_t *)aid->di_data;
1480 
1481                 if (isp->dis_auxinfo == 0) {
1482                         /*
1483                          * This is the first time we've seen an llquantize()
1484                          * for this aggregation; we'll store our argument
1485                          * as the auxiliary signature information.
1486                          */
1487                         isp->dis_auxinfo = arg;
1488                 } else if ((oarg = isp->dis_auxinfo) != arg) {
1489                         /*
1490                          * If we have seen this llquantize() before and the
1491                          * argument doesn't match the original argument, pick
1492                          * the original argument apart to concisely report the
1493                          * mismatch.
1494                          */
1495                         int expected = 0, found = 0;
1496 
1497                         for (i = 0; expected == found; i++) {
1498                                 assert(args[i].str != NULL);
1499 
1500                                 expected = (oarg >> args[i].shift) & UINT16_MAX;
1501                                 found = (arg >> args[i].shift) & UINT16_MAX;
1502                         }
1503 
1504                         dnerror(dnp, args[i - 1].mismatch, "llquantize( ) "
1505                             "%s (argument #%d) doesn't match previous "
1506                             "declaration: expected %d, found %d\n",
1507                             args[i - 1].str, i, expected, found);
1508                 }
1509 
1510                 incr = llarg;
1511                 argmax = 6;
1512         }
1513 
1514         if (fid->di_id == DTRACEAGG_QUANTIZE) {
1515                 incr = dnp->dn_aggfun->dn_args->dn_list;
1516                 argmax = 2;
1517         }
1518 
1519         if (incr != NULL) {
1520                 if (!dt_node_is_scalar(incr)) {
1521                         dnerror(dnp, D_PROTO_ARG, "%s( ) increment value "
1522                             "(argument #%d) must be of scalar type\n",
1523                             fid->di_name, argmax);
1524                 }
1525 
1526                 if ((anp = incr->dn_list) != NULL) {
1527                         int argc = argmax;
1528 
1529                         for (; anp != NULL; anp = anp->dn_list)
1530                                 argc++;
1531 
1532                         dnerror(incr, D_PROTO_LEN, "%s( ) prototype "
1533                             "mismatch: %d args passed, at most %d expected",
1534                             fid->di_name, argc, argmax);
1535                 }
1536 
1537                 ap = dt_stmt_action(dtp, sdp);
1538                 n++;
1539 
1540                 dt_cg(yypcb, incr);
1541                 ap->dtad_difo = dt_as(yypcb);
1542                 ap->dtad_difo->dtdo_rtype = dt_void_rtype;
1543                 ap->dtad_kind = DTRACEACT_DIFEXPR;
1544         }
1545 
1546         assert(sdp->dtsd_aggdata == NULL);
1547         sdp->dtsd_aggdata = aid;
1548 
1549         ap = dt_stmt_action(dtp, sdp);
1550         assert(fid->di_kind == DT_IDENT_AGGFUNC);
1551         assert(DTRACEACT_ISAGG(fid->di_id));
1552         ap->dtad_kind = fid->di_id;
1553         ap->dtad_ntuple = n;
1554         ap->dtad_arg = arg;
1555 
1556         if (dnp->dn_aggfun->dn_args != NULL) {
1557                 dt_cg(yypcb, dnp->dn_aggfun->dn_args);
1558                 ap->dtad_difo = dt_as(yypcb);
1559         }
1560 }
1561 
1562 static void
1563 dt_compile_one_clause(dtrace_hdl_t *dtp, dt_node_t *cnp, dt_node_t *pnp)
1564 {
1565         dtrace_ecbdesc_t *edp;
1566         dtrace_stmtdesc_t *sdp;
1567         dt_node_t *dnp;
1568 
1569         yylineno = pnp->dn_line;
1570         dt_setcontext(dtp, pnp->dn_desc);
1571         (void) dt_node_cook(cnp, DT_IDFLG_REF);
1572 
1573         if (DT_TREEDUMP_PASS(dtp, 2))
1574                 dt_node_printr(cnp, stderr, 0);
1575 
1576         if ((edp = dt_ecbdesc_create(dtp, pnp->dn_desc)) == NULL)
1577                 longjmp(yypcb->pcb_jmpbuf, EDT_NOMEM);
1578 
1579         assert(yypcb->pcb_ecbdesc == NULL);
1580         yypcb->pcb_ecbdesc = edp;
1581 
1582         if (cnp->dn_pred != NULL) {
1583                 dt_cg(yypcb, cnp->dn_pred);
1584                 edp->dted_pred.dtpdd_difo = dt_as(yypcb);
1585         }
1586 
1587         if (cnp->dn_acts == NULL) {
1588                 dt_stmt_append(dt_stmt_create(dtp, edp,
1589                     cnp->dn_ctxattr, _dtrace_defattr), cnp);
1590         }
1591 
1592         for (dnp = cnp->dn_acts; dnp != NULL; dnp = dnp->dn_list) {
1593                 assert(yypcb->pcb_stmt == NULL);
1594                 sdp = dt_stmt_create(dtp, edp, cnp->dn_ctxattr, cnp->dn_attr);
1595 
1596                 switch (dnp->dn_kind) {
1597                 case DT_NODE_DEXPR:
1598                         if (dnp->dn_expr->dn_kind == DT_NODE_AGG)
1599                                 dt_compile_agg(dtp, dnp->dn_expr, sdp);
1600                         else
1601                                 dt_compile_exp(dtp, dnp, sdp);
1602                         break;
1603                 case DT_NODE_DFUNC:
1604                         dt_compile_fun(dtp, dnp, sdp);
1605                         break;
1606                 case DT_NODE_AGG:
1607                         dt_compile_agg(dtp, dnp, sdp);
1608                         break;
1609                 default:
1610                         dnerror(dnp, D_UNKNOWN, "internal error -- node kind "
1611                             "%u is not a valid statement\n", dnp->dn_kind);
1612                 }
1613 
1614                 assert(yypcb->pcb_stmt == sdp);
1615                 dt_stmt_append(sdp, dnp);
1616         }
1617 
1618         assert(yypcb->pcb_ecbdesc == edp);
1619         dt_ecbdesc_release(dtp, edp);
1620         dt_endcontext(dtp);
1621         yypcb->pcb_ecbdesc = NULL;
1622 }
1623 
1624 static void
1625 dt_compile_clause(dtrace_hdl_t *dtp, dt_node_t *cnp)
1626 {
1627         dt_node_t *pnp;
1628 
1629         for (pnp = cnp->dn_pdescs; pnp != NULL; pnp = pnp->dn_list)
1630                 dt_compile_one_clause(dtp, cnp, pnp);
1631 }
1632 
1633 static void
1634 dt_compile_xlator(dt_node_t *dnp)
1635 {
1636         dt_xlator_t *dxp = dnp->dn_xlator;
1637         dt_node_t *mnp;
1638 
1639         for (mnp = dnp->dn_members; mnp != NULL; mnp = mnp->dn_list) {
1640                 assert(dxp->dx_membdif[mnp->dn_membid] == NULL);
1641                 dt_cg(yypcb, mnp);
1642                 dxp->dx_membdif[mnp->dn_membid] = dt_as(yypcb);
1643         }
1644 }
1645 
1646 void
1647 dt_setcontext(dtrace_hdl_t *dtp, dtrace_probedesc_t *pdp)
1648 {
1649         const dtrace_pattr_t *pap;
1650         dt_probe_t *prp;
1651         dt_provider_t *pvp;
1652         dt_ident_t *idp;
1653         char attrstr[8];
1654         int err;
1655 
1656         /*
1657          * Both kernel and pid based providers are allowed to have names
1658          * ending with what could be interpreted as a number. We assume it's
1659          * a pid and that we may need to dynamically create probes for
1660          * that process if:
1661          *
1662          * (1) The provider doesn't exist, or,
1663          * (2) The provider exists and has DTRACE_PRIV_PROC privilege.
1664          *
1665          * On an error, dt_pid_create_probes() will set the error message
1666          * and tag -- we just have to longjmp() out of here.
1667          */
1668         if (isdigit(pdp->dtpd_provider[strlen(pdp->dtpd_provider) - 1]) &&
1669             ((pvp = dt_provider_lookup(dtp, pdp->dtpd_provider)) == NULL ||
1670             pvp->pv_desc.dtvd_priv.dtpp_flags & DTRACE_PRIV_PROC) &&
1671             dt_pid_create_probes(pdp, dtp, yypcb) != 0) {
1672                 longjmp(yypcb->pcb_jmpbuf, EDT_COMPILER);
1673         }
1674 
1675         /*
1676          * Call dt_probe_info() to get the probe arguments and attributes.  If
1677          * a representative probe is found, set 'pap' to the probe provider's
1678          * attributes.  Otherwise set 'pap' to default Unstable attributes.
1679          */
1680         if ((prp = dt_probe_info(dtp, pdp, &yypcb->pcb_pinfo)) == NULL) {
1681                 pap = &_dtrace_prvdesc;
1682                 err = dtrace_errno(dtp);
1683                 bzero(&yypcb->pcb_pinfo, sizeof (dtrace_probeinfo_t));
1684                 yypcb->pcb_pinfo.dtp_attr = pap->dtpa_provider;
1685                 yypcb->pcb_pinfo.dtp_arga = pap->dtpa_args;
1686         } else {
1687                 pap = &prp->pr_pvp->pv_desc.dtvd_attr;
1688                 err = 0;
1689         }
1690 
1691         if (err == EDT_NOPROBE && !(yypcb->pcb_cflags & DTRACE_C_ZDEFS)) {
1692                 xyerror(D_PDESC_ZERO, "probe description %s:%s:%s:%s does not "
1693                     "match any probes\n", pdp->dtpd_provider, pdp->dtpd_mod,
1694                     pdp->dtpd_func, pdp->dtpd_name);
1695         }
1696 
1697         if (err != EDT_NOPROBE && err != EDT_UNSTABLE && err != 0)
1698                 xyerror(D_PDESC_INVAL, "%s\n", dtrace_errmsg(dtp, err));
1699 
1700         dt_dprintf("set context to %s:%s:%s:%s [%u] prp=%p attr=%s argc=%d\n",
1701             pdp->dtpd_provider, pdp->dtpd_mod, pdp->dtpd_func, pdp->dtpd_name,
1702             pdp->dtpd_id, (void *)prp, dt_attr_str(yypcb->pcb_pinfo.dtp_attr,
1703             attrstr, sizeof (attrstr)), yypcb->pcb_pinfo.dtp_argc);
1704 
1705         /*
1706          * Reset the stability attributes of D global variables that vary
1707          * based on the attributes of the provider and context itself.
1708          */
1709         if ((idp = dt_idhash_lookup(dtp->dt_globals, "probeprov")) != NULL)
1710                 idp->di_attr = pap->dtpa_provider;
1711         if ((idp = dt_idhash_lookup(dtp->dt_globals, "probemod")) != NULL)
1712                 idp->di_attr = pap->dtpa_mod;
1713         if ((idp = dt_idhash_lookup(dtp->dt_globals, "probefunc")) != NULL)
1714                 idp->di_attr = pap->dtpa_func;
1715         if ((idp = dt_idhash_lookup(dtp->dt_globals, "probename")) != NULL)
1716                 idp->di_attr = pap->dtpa_name;
1717         if ((idp = dt_idhash_lookup(dtp->dt_globals, "args")) != NULL)
1718                 idp->di_attr = pap->dtpa_args;
1719 
1720         yypcb->pcb_pdesc = pdp;
1721         yypcb->pcb_probe = prp;
1722 }
1723 
1724 /*
1725  * Reset context-dependent variables and state at the end of cooking a D probe
1726  * definition clause.  This ensures that external declarations between clauses
1727  * do not reference any stale context-dependent data from the previous clause.
1728  */
1729 void
1730 dt_endcontext(dtrace_hdl_t *dtp)
1731 {
1732         static const char *const cvars[] = {
1733                 "probeprov", "probemod", "probefunc", "probename", "args", NULL
1734         };
1735 
1736         dt_ident_t *idp;
1737         int i;
1738 
1739         for (i = 0; cvars[i] != NULL; i++) {
1740                 if ((idp = dt_idhash_lookup(dtp->dt_globals, cvars[i])) != NULL)
1741                         idp->di_attr = _dtrace_defattr;
1742         }
1743 
1744         yypcb->pcb_pdesc = NULL;
1745         yypcb->pcb_probe = NULL;
1746 }
1747 
1748 static int
1749 dt_reduceid(dt_idhash_t *dhp, dt_ident_t *idp, dtrace_hdl_t *dtp)
1750 {
1751         if (idp->di_vers != 0 && idp->di_vers > dtp->dt_vmax)
1752                 dt_idhash_delete(dhp, idp);
1753 
1754         return (0);
1755 }
1756 
1757 /*
1758  * When dtrace_setopt() is called for "version", it calls dt_reduce() to remove
1759  * any identifiers or translators that have been previously defined as bound to
1760  * a version greater than the specified version.  Therefore, in our current
1761  * version implementation, establishing a binding is a one-way transformation.
1762  * In addition, no versioning is currently provided for types as our .d library
1763  * files do not define any types and we reserve prefixes DTRACE_ and dtrace_
1764  * for our exclusive use.  If required, type versioning will require more work.
1765  */
1766 int
1767 dt_reduce(dtrace_hdl_t *dtp, dt_version_t v)
1768 {
1769         char s[DT_VERSION_STRMAX];
1770         dt_xlator_t *dxp, *nxp;
1771 
1772         if (v > dtp->dt_vmax)
1773                 return (dt_set_errno(dtp, EDT_VERSREDUCED));
1774         else if (v == dtp->dt_vmax)
1775                 return (0); /* no reduction necessary */
1776 
1777         dt_dprintf("reducing api version to %s\n",
1778             dt_version_num2str(v, s, sizeof (s)));
1779 
1780         dtp->dt_vmax = v;
1781 
1782         for (dxp = dt_list_next(&dtp->dt_xlators); dxp != NULL; dxp = nxp) {
1783                 nxp = dt_list_next(dxp);
1784                 if ((dxp->dx_souid.di_vers != 0 && dxp->dx_souid.di_vers > v) ||
1785                     (dxp->dx_ptrid.di_vers != 0 && dxp->dx_ptrid.di_vers > v))
1786                         dt_list_delete(&dtp->dt_xlators, dxp);
1787         }
1788 
1789         (void) dt_idhash_iter(dtp->dt_macros, (dt_idhash_f *)dt_reduceid, dtp);
1790         (void) dt_idhash_iter(dtp->dt_aggs, (dt_idhash_f *)dt_reduceid, dtp);
1791         (void) dt_idhash_iter(dtp->dt_globals, (dt_idhash_f *)dt_reduceid, dtp);
1792         (void) dt_idhash_iter(dtp->dt_tls, (dt_idhash_f *)dt_reduceid, dtp);
1793 
1794         return (0);
1795 }
1796 
1797 /*
1798  * Fork and exec the cpp(1) preprocessor to run over the specified input file,
1799  * and return a FILE handle for the cpp output.  We use the /dev/fd filesystem
1800  * here to simplify the code by leveraging file descriptor inheritance.
1801  */
1802 static FILE *
1803 dt_preproc(dtrace_hdl_t *dtp, FILE *ifp)
1804 {
1805         int argc = dtp->dt_cpp_argc;
1806         char **argv = malloc(sizeof (char *) * (argc + 5));
1807         FILE *ofp = tmpfile();
1808 
1809         char ipath[20], opath[20]; /* big enough for /dev/fd/ + INT_MAX + \0 */
1810         char verdef[32]; /* big enough for -D__SUNW_D_VERSION=0x%08x + \0 */
1811 
1812         struct sigaction act, oact;
1813         sigset_t mask, omask;
1814 
1815         int wstat, estat;
1816         pid_t pid;
1817         off64_t off;
1818         int c;
1819 
1820         if (argv == NULL || ofp == NULL) {
1821                 (void) dt_set_errno(dtp, errno);
1822                 goto err;
1823         }
1824 
1825         /*
1826          * If the input is a seekable file, see if it is an interpreter file.
1827          * If we see #!, seek past the first line because cpp will choke on it.
1828          * We start cpp just prior to the \n at the end of this line so that
1829          * it still sees the newline, ensuring that #line values are correct.
1830          */
1831         if (isatty(fileno(ifp)) == 0 && (off = ftello64(ifp)) != -1) {
1832                 if ((c = fgetc(ifp)) == '#' && (c = fgetc(ifp)) == '!') {
1833                         for (off += 2; c != '\n'; off++) {
1834                                 if ((c = fgetc(ifp)) == EOF)
1835                                         break;
1836                         }
1837                         if (c == '\n')
1838                                 off--; /* start cpp just prior to \n */
1839                 }
1840                 (void) fflush(ifp);
1841                 (void) fseeko64(ifp, off, SEEK_SET);
1842         }
1843 
1844         (void) snprintf(ipath, sizeof (ipath), "/dev/fd/%d", fileno(ifp));
1845         (void) snprintf(opath, sizeof (opath), "/dev/fd/%d", fileno(ofp));
1846 
1847         bcopy(dtp->dt_cpp_argv, argv, sizeof (char *) * argc);
1848 
1849         (void) snprintf(verdef, sizeof (verdef),
1850             "-D__SUNW_D_VERSION=0x%08x", dtp->dt_vmax);
1851         argv[argc++] = verdef;
1852 
1853         switch (dtp->dt_stdcmode) {
1854         case DT_STDC_XA:
1855         case DT_STDC_XT:
1856                 argv[argc++] = "-D__STDC__=0";
1857                 break;
1858         case DT_STDC_XC:
1859                 argv[argc++] = "-D__STDC__=1";
1860                 break;
1861         }
1862 
1863         argv[argc++] = ipath;
1864         argv[argc++] = opath;
1865         argv[argc] = NULL;
1866 
1867         /*
1868          * libdtrace must be able to be embedded in other programs that may
1869          * include application-specific signal handlers.  Therefore, if we
1870          * need to fork to run cpp(1), we must avoid generating a SIGCHLD
1871          * that could confuse the containing application.  To do this,
1872          * we block SIGCHLD and reset its disposition to SIG_DFL.
1873          * We restore our signal state once we are done.
1874          */
1875         (void) sigemptyset(&mask);
1876         (void) sigaddset(&mask, SIGCHLD);
1877         (void) sigprocmask(SIG_BLOCK, &mask, &omask);
1878 
1879         bzero(&act, sizeof (act));
1880         act.sa_handler = SIG_DFL;
1881         (void) sigaction(SIGCHLD, &act, &oact);
1882 
1883         if ((pid = fork1()) == -1) {
1884                 (void) sigaction(SIGCHLD, &oact, NULL);
1885                 (void) sigprocmask(SIG_SETMASK, &omask, NULL);
1886                 (void) dt_set_errno(dtp, EDT_CPPFORK);
1887                 goto err;
1888         }
1889 
1890         if (pid == 0) {
1891                 (void) execvp(dtp->dt_cpp_path, argv);
1892                 _exit(errno == ENOENT ? 127 : 126);
1893         }
1894 
1895         do {
1896                 dt_dprintf("waiting for %s (PID %d)\n", dtp->dt_cpp_path,
1897                     (int)pid);
1898         } while (waitpid(pid, &wstat, 0) == -1 && errno == EINTR);
1899 
1900         (void) sigaction(SIGCHLD, &oact, NULL);
1901         (void) sigprocmask(SIG_SETMASK, &omask, NULL);
1902 
1903         dt_dprintf("%s returned exit status 0x%x\n", dtp->dt_cpp_path, wstat);
1904         estat = WIFEXITED(wstat) ? WEXITSTATUS(wstat) : -1;
1905 
1906         if (estat != 0) {
1907                 switch (estat) {
1908                 case 126:
1909                         (void) dt_set_errno(dtp, EDT_CPPEXEC);
1910                         break;
1911                 case 127:
1912                         (void) dt_set_errno(dtp, EDT_CPPENT);
1913                         break;
1914                 default:
1915                         (void) dt_set_errno(dtp, EDT_CPPERR);
1916                 }
1917                 goto err;
1918         }
1919 
1920         free(argv);
1921         (void) fflush(ofp);
1922         (void) fseek(ofp, 0, SEEK_SET);
1923         return (ofp);
1924 
1925 err:
1926         free(argv);
1927         (void) fclose(ofp);
1928         return (NULL);
1929 }
1930 
1931 static void
1932 dt_lib_depend_error(dtrace_hdl_t *dtp, const char *format, ...)
1933 {
1934         va_list ap;
1935 
1936         va_start(ap, format);
1937         dt_set_errmsg(dtp, NULL, NULL, NULL, 0, format, ap);
1938         va_end(ap);
1939 }
1940 
1941 int
1942 dt_lib_depend_add(dtrace_hdl_t *dtp, dt_list_t *dlp, const char *arg)
1943 {
1944         dt_lib_depend_t *dld;
1945         const char *end;
1946 
1947         assert(arg != NULL);
1948 
1949         if ((end = strrchr(arg, '/')) == NULL)
1950                 return (dt_set_errno(dtp, EINVAL));
1951 
1952         if ((dld = dt_zalloc(dtp, sizeof (dt_lib_depend_t))) == NULL)
1953                 return (-1);
1954 
1955         if ((dld->dtld_libpath = dt_alloc(dtp, MAXPATHLEN)) == NULL) {
1956                 dt_free(dtp, dld);
1957                 return (-1);
1958         }
1959 
1960         (void) strlcpy(dld->dtld_libpath, arg, end - arg + 2);
1961         if ((dld->dtld_library = strdup(arg)) == NULL) {
1962                 dt_free(dtp, dld->dtld_libpath);
1963                 dt_free(dtp, dld);
1964                 return (dt_set_errno(dtp, EDT_NOMEM));
1965         }
1966 
1967         dt_list_append(dlp, dld);
1968         return (0);
1969 }
1970 
1971 dt_lib_depend_t *
1972 dt_lib_depend_lookup(dt_list_t *dld, const char *arg)
1973 {
1974         dt_lib_depend_t *dldn;
1975 
1976         for (dldn = dt_list_next(dld); dldn != NULL;
1977             dldn = dt_list_next(dldn)) {
1978                 if (strcmp(dldn->dtld_library, arg) == 0)
1979                         return (dldn);
1980         }
1981 
1982         return (NULL);
1983 }
1984 
1985 /*
1986  * Go through all the library files, and, if any library dependencies exist for
1987  * that file, add it to that node's list of dependents. The result of this
1988  * will be a graph which can then be topologically sorted to produce a
1989  * compilation order.
1990  */
1991 static int
1992 dt_lib_build_graph(dtrace_hdl_t *dtp)
1993 {
1994         dt_lib_depend_t *dld, *dpld;
1995 
1996         for (dld = dt_list_next(&dtp->dt_lib_dep); dld != NULL;
1997             dld = dt_list_next(dld)) {
1998                 char *library = dld->dtld_library;
1999 
2000                 for (dpld = dt_list_next(&dld->dtld_dependencies); dpld != NULL;
2001                     dpld = dt_list_next(dpld)) {
2002                         dt_lib_depend_t *dlda;
2003 
2004                         if ((dlda = dt_lib_depend_lookup(&dtp->dt_lib_dep,
2005                             dpld->dtld_library)) == NULL) {
2006                                 dt_lib_depend_error(dtp,
2007                                     "Invalid library dependency in %s: %s\n",
2008                                     dld->dtld_library, dpld->dtld_library);
2009 
2010                                 return (dt_set_errno(dtp, EDT_COMPILER));
2011                         }
2012 
2013                         if ((dt_lib_depend_add(dtp, &dlda->dtld_dependents,
2014                             library)) != 0) {
2015                                 return (-1); /* preserve dt_errno */
2016                         }
2017                 }
2018         }
2019         return (0);
2020 }
2021 
2022 static int
2023 dt_topo_sort(dtrace_hdl_t *dtp, dt_lib_depend_t *dld, int *count)
2024 {
2025         dt_lib_depend_t *dpld, *dlda, *new;
2026 
2027         dld->dtld_start = ++(*count);
2028 
2029         for (dpld = dt_list_next(&dld->dtld_dependents); dpld != NULL;
2030             dpld = dt_list_next(dpld)) {
2031                 dlda = dt_lib_depend_lookup(&dtp->dt_lib_dep,
2032                     dpld->dtld_library);
2033                 assert(dlda != NULL);
2034 
2035                 if (dlda->dtld_start == 0 &&
2036                     dt_topo_sort(dtp, dlda, count) == -1)
2037                         return (-1);
2038         }
2039 
2040         if ((new = dt_zalloc(dtp, sizeof (dt_lib_depend_t))) == NULL)
2041                 return (-1);
2042 
2043         if ((new->dtld_library = strdup(dld->dtld_library)) == NULL) {
2044                 dt_free(dtp, new);
2045                 return (dt_set_errno(dtp, EDT_NOMEM));
2046         }
2047 
2048         new->dtld_start = dld->dtld_start;
2049         new->dtld_finish = dld->dtld_finish = ++(*count);
2050         dt_list_prepend(&dtp->dt_lib_dep_sorted, new);
2051 
2052         dt_dprintf("library %s sorted (%d/%d)\n", new->dtld_library,
2053             new->dtld_start, new->dtld_finish);
2054 
2055         return (0);
2056 }
2057 
2058 static int
2059 dt_lib_depend_sort(dtrace_hdl_t *dtp)
2060 {
2061         dt_lib_depend_t *dld, *dpld, *dlda;
2062         int count = 0;
2063 
2064         if (dt_lib_build_graph(dtp) == -1)
2065                 return (-1); /* preserve dt_errno */
2066 
2067         /*
2068          * Perform a topological sort of the graph that hangs off
2069          * dtp->dt_lib_dep. The result of this process will be a
2070          * dependency ordered list located at dtp->dt_lib_dep_sorted.
2071          */
2072         for (dld = dt_list_next(&dtp->dt_lib_dep); dld != NULL;
2073             dld = dt_list_next(dld)) {
2074                 if (dld->dtld_start == 0 &&
2075                     dt_topo_sort(dtp, dld, &count) == -1)
2076                         return (-1); /* preserve dt_errno */;
2077         }
2078 
2079         /*
2080          * Check the graph for cycles. If an ancestor's finishing time is
2081          * less than any of its dependent's finishing times then a back edge
2082          * exists in the graph and this is a cycle.
2083          */
2084         for (dld = dt_list_next(&dtp->dt_lib_dep); dld != NULL;
2085             dld = dt_list_next(dld)) {
2086                 for (dpld = dt_list_next(&dld->dtld_dependents); dpld != NULL;
2087                     dpld = dt_list_next(dpld)) {
2088                         dlda = dt_lib_depend_lookup(&dtp->dt_lib_dep_sorted,
2089                             dpld->dtld_library);
2090                         assert(dlda != NULL);
2091 
2092                         if (dlda->dtld_finish > dld->dtld_finish) {
2093                                 dt_lib_depend_error(dtp,
2094                                     "Cyclic dependency detected: %s => %s\n",
2095                                     dld->dtld_library, dpld->dtld_library);
2096 
2097                                 return (dt_set_errno(dtp, EDT_COMPILER));
2098                         }
2099                 }
2100         }
2101 
2102         return (0);
2103 }
2104 
2105 static void
2106 dt_lib_depend_free(dtrace_hdl_t *dtp)
2107 {
2108         dt_lib_depend_t *dld, *dlda;
2109 
2110         while ((dld = dt_list_next(&dtp->dt_lib_dep)) != NULL) {
2111                 while ((dlda = dt_list_next(&dld->dtld_dependencies)) != NULL) {
2112                         dt_list_delete(&dld->dtld_dependencies, dlda);
2113                         dt_free(dtp, dlda->dtld_library);
2114                         dt_free(dtp, dlda->dtld_libpath);
2115                         dt_free(dtp, dlda);
2116                 }
2117                 while ((dlda = dt_list_next(&dld->dtld_dependents)) != NULL) {
2118                         dt_list_delete(&dld->dtld_dependents, dlda);
2119                         dt_free(dtp, dlda->dtld_library);
2120                         dt_free(dtp, dlda->dtld_libpath);
2121                         dt_free(dtp, dlda);
2122                 }
2123                 dt_list_delete(&dtp->dt_lib_dep, dld);
2124                 dt_free(dtp, dld->dtld_library);
2125                 dt_free(dtp, dld->dtld_libpath);
2126                 dt_free(dtp, dld);
2127         }
2128 
2129         while ((dld = dt_list_next(&dtp->dt_lib_dep_sorted)) != NULL) {
2130                 dt_list_delete(&dtp->dt_lib_dep_sorted, dld);
2131                 dt_free(dtp, dld->dtld_library);
2132                 dt_free(dtp, dld);
2133         }
2134 }
2135 
2136 /*
2137  * Open all the .d library files found in the specified directory and
2138  * compile each one of them.  We silently ignore any missing directories and
2139  * other files found therein.  We only fail (and thereby fail dt_load_libs()) if
2140  * we fail to compile a library and the error is something other than #pragma D
2141  * depends_on.  Dependency errors are silently ignored to permit a library
2142  * directory to contain libraries which may not be accessible depending on our
2143  * privileges.
2144  */
2145 static int
2146 dt_load_libs_dir(dtrace_hdl_t *dtp, const char *path)
2147 {
2148         struct dirent *dp;
2149         const char *p, *end;
2150         DIR *dirp;
2151 
2152         char fname[PATH_MAX];
2153         FILE *fp;
2154         void *rv;
2155         dt_lib_depend_t *dld;
2156 
2157         if ((dirp = opendir(path)) == NULL) {
2158                 dt_dprintf("skipping lib dir %s: %s\n", path, strerror(errno));
2159                 return (0);
2160         }
2161 
2162         /* First, parse each file for library dependencies. */
2163         while ((dp = readdir(dirp)) != NULL) {
2164                 if ((p = strrchr(dp->d_name, '.')) == NULL || strcmp(p, ".d"))
2165                         continue; /* skip any filename not ending in .d */
2166 
2167                 (void) snprintf(fname, sizeof (fname),
2168                     "%s/%s", path, dp->d_name);
2169 
2170                 if ((fp = fopen(fname, "rF")) == NULL) {
2171                         dt_dprintf("skipping library %s: %s\n",
2172                             fname, strerror(errno));
2173                         continue;
2174                 }
2175 
2176                 /*
2177                  * Skip files whose name match an already processed library
2178                  */
2179                 for (dld = dt_list_next(&dtp->dt_lib_dep); dld != NULL;
2180                     dld = dt_list_next(dld)) {
2181                         end = strrchr(dld->dtld_library, '/');
2182                         /* dt_lib_depend_add ensures this */
2183                         assert(end != NULL);
2184                         if (strcmp(end + 1, dp->d_name) == 0)
2185                                 break;
2186                 }
2187 
2188                 if (dld != NULL) {
2189                         dt_dprintf("skipping library %s, already processed "
2190                             "library with the same name: %s", dp->d_name,
2191                             dld->dtld_library);
2192                         (void) fclose(fp);
2193                         continue;
2194                 }
2195 
2196                 dtp->dt_filetag = fname;
2197                 if (dt_lib_depend_add(dtp, &dtp->dt_lib_dep, fname) != 0) {
2198                         (void) fclose(fp);
2199                         return (-1); /* preserve dt_errno */
2200                 }
2201 
2202                 rv = dt_compile(dtp, DT_CTX_DPROG,
2203                     DTRACE_PROBESPEC_NAME, NULL,
2204                     DTRACE_C_EMPTY | DTRACE_C_CTL, 0, NULL, fp, NULL);
2205 
2206                 if (rv != NULL && dtp->dt_errno &&
2207                     (dtp->dt_errno != EDT_COMPILER ||
2208                     dtp->dt_errtag != dt_errtag(D_PRAGMA_DEPEND))) {
2209                         (void) fclose(fp);
2210                         return (-1); /* preserve dt_errno */
2211                 }
2212 
2213                 if (dtp->dt_errno)
2214                         dt_dprintf("error parsing library %s: %s\n",
2215                             fname, dtrace_errmsg(dtp, dtrace_errno(dtp)));
2216 
2217                 (void) fclose(fp);
2218                 dtp->dt_filetag = NULL;
2219         }
2220 
2221         (void) closedir(dirp);
2222 
2223         return (0);
2224 }
2225 
2226 /*
2227  * Perform a topological sorting of all the libraries found across the entire
2228  * dt_lib_path.  Once sorted, compile each one in topological order to cache its
2229  * inlines and translators, etc.  We silently ignore any missing directories and
2230  * other files found therein. We only fail (and thereby fail dt_load_libs()) if
2231  * we fail to compile a library and the error is something other than #pragma D
2232  * depends_on.  Dependency errors are silently ignored to permit a library
2233  * directory to contain libraries which may not be accessible depending on our
2234  * privileges.
2235  */
2236 static int
2237 dt_load_libs_sort(dtrace_hdl_t *dtp)
2238 {
2239         dtrace_prog_t *pgp;
2240         FILE *fp;
2241         dt_lib_depend_t *dld;
2242 
2243         /*
2244          * Finish building the graph containing the library dependencies
2245          * and perform a topological sort to generate an ordered list
2246          * for compilation.
2247          */
2248         if (dt_lib_depend_sort(dtp) == -1)
2249                 goto err;
2250 
2251         for (dld = dt_list_next(&dtp->dt_lib_dep_sorted); dld != NULL;
2252             dld = dt_list_next(dld)) {
2253 
2254                 if ((fp = fopen(dld->dtld_library, "r")) == NULL) {
2255                         dt_dprintf("skipping library %s: %s\n",
2256                             dld->dtld_library, strerror(errno));
2257                         continue;
2258                 }
2259 
2260                 dtp->dt_filetag = dld->dtld_library;
2261                 pgp = dtrace_program_fcompile(dtp, fp, DTRACE_C_EMPTY, 0, NULL);
2262                 (void) fclose(fp);
2263                 dtp->dt_filetag = NULL;
2264 
2265                 if (pgp == NULL && (dtp->dt_errno != EDT_COMPILER ||
2266                     dtp->dt_errtag != dt_errtag(D_PRAGMA_DEPEND)))
2267                         goto err;
2268 
2269                 if (pgp == NULL) {
2270                         dt_dprintf("skipping library %s: %s\n",
2271                             dld->dtld_library,
2272                             dtrace_errmsg(dtp, dtrace_errno(dtp)));
2273                 } else {
2274                         dld->dtld_loaded = B_TRUE;
2275                         dt_program_destroy(dtp, pgp);
2276                 }
2277         }
2278 
2279         dt_lib_depend_free(dtp);
2280         return (0);
2281 
2282 err:
2283         dt_lib_depend_free(dtp);
2284         return (-1); /* preserve dt_errno */
2285 }
2286 
2287 /*
2288  * Load the contents of any appropriate DTrace .d library files.  These files
2289  * contain inlines and translators that will be cached by the compiler.  We
2290  * defer this activity until the first compile to permit libdtrace clients to
2291  * add their own library directories and so that we can properly report errors.
2292  */
2293 static int
2294 dt_load_libs(dtrace_hdl_t *dtp)
2295 {
2296         dt_dirpath_t *dirp;
2297 
2298         if (dtp->dt_cflags & DTRACE_C_NOLIBS)
2299                 return (0); /* libraries already processed */
2300 
2301         dtp->dt_cflags |= DTRACE_C_NOLIBS;
2302 
2303         /*
2304          * /usr/lib/dtrace is always at the head of the list. The rest of the
2305          * list is specified in the precedence order the user requested. Process
2306          * everything other than the head first. DTRACE_C_NOLIBS has already
2307          * been spcified so dt_vopen will ensure that there is always one entry
2308          * in dt_lib_path.
2309          */
2310         for (dirp = dt_list_next(dt_list_next(&dtp->dt_lib_path));
2311             dirp != NULL; dirp = dt_list_next(dirp)) {
2312                 if (dt_load_libs_dir(dtp, dirp->dir_path) != 0) {
2313                         dtp->dt_cflags &= ~DTRACE_C_NOLIBS;
2314                         return (-1); /* errno is set for us */
2315                 }
2316         }
2317 
2318         /* Handle /usr/lib/dtrace */
2319         dirp = dt_list_next(&dtp->dt_lib_path);
2320         if (dt_load_libs_dir(dtp, dirp->dir_path) != 0) {
2321                 dtp->dt_cflags &= ~DTRACE_C_NOLIBS;
2322                 return (-1); /* errno is set for us */
2323         }
2324 
2325         if (dt_load_libs_sort(dtp) < 0)
2326                 return (-1); /* errno is set for us */
2327 
2328         return (0);
2329 }
2330 
2331 static void *
2332 dt_compile(dtrace_hdl_t *dtp, int context, dtrace_probespec_t pspec, void *arg,
2333     uint_t cflags, int argc, char *const argv[], FILE *fp, const char *s)
2334 {
2335         dt_node_t *dnp;
2336         dt_decl_t *ddp;
2337         dt_pcb_t pcb;
2338         void *volatile rv;
2339         int err;
2340 
2341         if ((fp == NULL && s == NULL) || (cflags & ~DTRACE_C_MASK) != 0) {
2342                 (void) dt_set_errno(dtp, EINVAL);
2343                 return (NULL);
2344         }
2345 
2346         if (dt_list_next(&dtp->dt_lib_path) != NULL && dt_load_libs(dtp) != 0)
2347                 return (NULL); /* errno is set for us */
2348 
2349         if (dtp->dt_globals->dh_nelems != 0)
2350                 (void) dt_idhash_iter(dtp->dt_globals, dt_idreset, NULL);
2351 
2352         if (dtp->dt_tls->dh_nelems != 0)
2353                 (void) dt_idhash_iter(dtp->dt_tls, dt_idreset, NULL);
2354 
2355         if (fp && (cflags & DTRACE_C_CPP) && (fp = dt_preproc(dtp, fp)) == NULL)
2356                 return (NULL); /* errno is set for us */
2357 
2358         dt_pcb_push(dtp, &pcb);
2359 
2360         pcb.pcb_fileptr = fp;
2361         pcb.pcb_string = s;
2362         pcb.pcb_strptr = s;
2363         pcb.pcb_strlen = s ? strlen(s) : 0;
2364         pcb.pcb_sargc = argc;
2365         pcb.pcb_sargv = argv;
2366         pcb.pcb_sflagv = argc ? calloc(argc, sizeof (ushort_t)) : NULL;
2367         pcb.pcb_pspec = pspec;
2368         pcb.pcb_cflags = dtp->dt_cflags | cflags;
2369         pcb.pcb_amin = dtp->dt_amin;
2370         pcb.pcb_yystate = -1;
2371         pcb.pcb_context = context;
2372         pcb.pcb_token = context;
2373 
2374         if (context != DT_CTX_DPROG)
2375                 yybegin(YYS_EXPR);
2376         else if (cflags & DTRACE_C_CTL)
2377                 yybegin(YYS_CONTROL);
2378         else
2379                 yybegin(YYS_CLAUSE);
2380 
2381         if ((err = setjmp(yypcb->pcb_jmpbuf)) != 0)
2382                 goto out;
2383 
2384         if (yypcb->pcb_sargc != 0 && yypcb->pcb_sflagv == NULL)
2385                 longjmp(yypcb->pcb_jmpbuf, EDT_NOMEM);
2386 
2387         yypcb->pcb_idents = dt_idhash_create("ambiguous", NULL, 0, 0);
2388         yypcb->pcb_locals = dt_idhash_create("clause local", NULL,
2389             DIF_VAR_OTHER_UBASE, DIF_VAR_OTHER_MAX);
2390 
2391         if (yypcb->pcb_idents == NULL || yypcb->pcb_locals == NULL)
2392                 longjmp(yypcb->pcb_jmpbuf, EDT_NOMEM);
2393 
2394         /*
2395          * Invoke the parser to evaluate the D source code.  If any errors
2396          * occur during parsing, an error function will be called and we
2397          * will longjmp back to pcb_jmpbuf to abort.  If parsing succeeds,
2398          * we optionally display the parse tree if debugging is enabled.
2399          */
2400         if (yyparse() != 0 || yypcb->pcb_root == NULL)
2401                 xyerror(D_EMPTY, "empty D program translation unit\n");
2402 
2403         yybegin(YYS_DONE);
2404 
2405         if (cflags & DTRACE_C_CTL)
2406                 goto out;
2407 
2408         if (context != DT_CTX_DTYPE && DT_TREEDUMP_PASS(dtp, 1))
2409                 dt_node_printr(yypcb->pcb_root, stderr, 0);
2410 
2411         if (yypcb->pcb_pragmas != NULL)
2412                 (void) dt_idhash_iter(yypcb->pcb_pragmas, dt_idpragma, NULL);
2413 
2414         if (argc > 1 && !(yypcb->pcb_cflags & DTRACE_C_ARGREF) &&
2415             !(yypcb->pcb_sflagv[argc - 1] & DT_IDFLG_REF)) {
2416                 xyerror(D_MACRO_UNUSED, "extraneous argument '%s' ($%d is "
2417                     "not referenced)\n", yypcb->pcb_sargv[argc - 1], argc - 1);
2418         }
2419 
2420         /*
2421          * Perform sugar transformations (for "if" / "else") and replace the
2422          * existing clause chain with the new one.
2423          */
2424         if (context == DT_CTX_DPROG) {
2425                 dt_node_t *dnp, *next_dnp;
2426                 dt_node_t *new_list = NULL;
2427 
2428                 for (dnp = yypcb->pcb_root->dn_list;
2429                     dnp != NULL; dnp = next_dnp) {
2430                         /* remove this node from the list */
2431                         next_dnp = dnp->dn_list;
2432                         dnp->dn_list = NULL;
2433 
2434                         if (dnp->dn_kind == DT_NODE_CLAUSE)
2435                                 dnp = dt_compile_sugar(dtp, dnp);
2436                         /* append node to the new list */
2437                         new_list = dt_node_link(new_list, dnp);
2438                 }
2439                 yypcb->pcb_root->dn_list = new_list;
2440         }
2441 
2442         /*
2443          * If we have successfully created a parse tree for a D program, loop
2444          * over the clauses and actions and instantiate the corresponding
2445          * libdtrace program.  If we are parsing a D expression, then we
2446          * simply run the code generator and assembler on the resulting tree.
2447          */
2448         switch (context) {
2449         case DT_CTX_DPROG:
2450                 assert(yypcb->pcb_root->dn_kind == DT_NODE_PROG);
2451 
2452                 if ((dnp = yypcb->pcb_root->dn_list) == NULL &&
2453                     !(yypcb->pcb_cflags & DTRACE_C_EMPTY))
2454                         xyerror(D_EMPTY, "empty D program translation unit\n");
2455 
2456                 if ((yypcb->pcb_prog = dt_program_create(dtp)) == NULL)
2457                         longjmp(yypcb->pcb_jmpbuf, dtrace_errno(dtp));
2458 
2459                 for (; dnp != NULL; dnp = dnp->dn_list) {
2460                         switch (dnp->dn_kind) {
2461                         case DT_NODE_CLAUSE:
2462                                 if (DT_TREEDUMP_PASS(dtp, 4))
2463                                         dt_printd(dnp, stderr, 0);
2464                                 dt_compile_clause(dtp, dnp);
2465                                 break;
2466                         case DT_NODE_XLATOR:
2467                                 if (dtp->dt_xlatemode == DT_XL_DYNAMIC)
2468                                         dt_compile_xlator(dnp);
2469                                 break;
2470                         case DT_NODE_PROVIDER:
2471                                 (void) dt_node_cook(dnp, DT_IDFLG_REF);
2472                                 break;
2473                         }
2474                 }
2475 
2476                 yypcb->pcb_prog->dp_xrefs = yypcb->pcb_asxrefs;
2477                 yypcb->pcb_prog->dp_xrefslen = yypcb->pcb_asxreflen;
2478                 yypcb->pcb_asxrefs = NULL;
2479                 yypcb->pcb_asxreflen = 0;
2480 
2481                 rv = yypcb->pcb_prog;
2482                 break;
2483 
2484         case DT_CTX_DEXPR:
2485                 (void) dt_node_cook(yypcb->pcb_root, DT_IDFLG_REF);
2486                 dt_cg(yypcb, yypcb->pcb_root);
2487                 rv = dt_as(yypcb);
2488                 break;
2489 
2490         case DT_CTX_DTYPE:
2491                 ddp = (dt_decl_t *)yypcb->pcb_root; /* root is really a decl */
2492                 err = dt_decl_type(ddp, arg);
2493                 dt_decl_free(ddp);
2494 
2495                 if (err != 0)
2496                         longjmp(yypcb->pcb_jmpbuf, EDT_COMPILER);
2497 
2498                 rv = NULL;
2499                 break;
2500         }
2501 
2502 out:
2503         if (context != DT_CTX_DTYPE && yypcb->pcb_root != NULL &&
2504             DT_TREEDUMP_PASS(dtp, 3))
2505                 dt_node_printr(yypcb->pcb_root, stderr, 0);
2506 
2507         if (dtp->dt_cdefs_fd != -1 && (ftruncate64(dtp->dt_cdefs_fd, 0) == -1 ||
2508             lseek64(dtp->dt_cdefs_fd, 0, SEEK_SET) == -1 ||
2509             ctf_write(dtp->dt_cdefs->dm_ctfp, dtp->dt_cdefs_fd) == CTF_ERR))
2510                 dt_dprintf("failed to update CTF cache: %s\n", strerror(errno));
2511 
2512         if (dtp->dt_ddefs_fd != -1 && (ftruncate64(dtp->dt_ddefs_fd, 0) == -1 ||
2513             lseek64(dtp->dt_ddefs_fd, 0, SEEK_SET) == -1 ||
2514             ctf_write(dtp->dt_ddefs->dm_ctfp, dtp->dt_ddefs_fd) == CTF_ERR))
2515                 dt_dprintf("failed to update CTF cache: %s\n", strerror(errno));
2516 
2517         if (yypcb->pcb_fileptr && (cflags & DTRACE_C_CPP))
2518                 (void) fclose(yypcb->pcb_fileptr); /* close dt_preproc() file */
2519 
2520         dt_pcb_pop(dtp, err);
2521         (void) dt_set_errno(dtp, err);
2522         return (err ? NULL : rv);
2523 }
2524 
2525 dtrace_prog_t *
2526 dtrace_program_strcompile(dtrace_hdl_t *dtp, const char *s,
2527     dtrace_probespec_t spec, uint_t cflags, int argc, char *const argv[])
2528 {
2529         return (dt_compile(dtp, DT_CTX_DPROG,
2530             spec, NULL, cflags, argc, argv, NULL, s));
2531 }
2532 
2533 dtrace_prog_t *
2534 dtrace_program_fcompile(dtrace_hdl_t *dtp, FILE *fp,
2535     uint_t cflags, int argc, char *const argv[])
2536 {
2537         return (dt_compile(dtp, DT_CTX_DPROG,
2538             DTRACE_PROBESPEC_NAME, NULL, cflags, argc, argv, fp, NULL));
2539 }
2540 
2541 int
2542 dtrace_type_strcompile(dtrace_hdl_t *dtp, const char *s, dtrace_typeinfo_t *dtt)
2543 {
2544         (void) dt_compile(dtp, DT_CTX_DTYPE,
2545             DTRACE_PROBESPEC_NONE, dtt, 0, 0, NULL, NULL, s);
2546         return (dtp->dt_errno ? -1 : 0);
2547 }
2548 
2549 int
2550 dtrace_type_fcompile(dtrace_hdl_t *dtp, FILE *fp, dtrace_typeinfo_t *dtt)
2551 {
2552         (void) dt_compile(dtp, DT_CTX_DTYPE,
2553             DTRACE_PROBESPEC_NONE, dtt, 0, 0, NULL, fp, NULL);
2554         return (dtp->dt_errno ? -1 : 0);
2555 }