17c478bd9Sstevel@tonic-gate /* 27c478bd9Sstevel@tonic-gate * CDDL HEADER START 37c478bd9Sstevel@tonic-gate * 47c478bd9Sstevel@tonic-gate * The contents of this file are subject to the terms of the 57c478bd9Sstevel@tonic-gate * Common Development and Distribution License, Version 1.0 only 67c478bd9Sstevel@tonic-gate * (the "License"). You may not use this file except in compliance 77c478bd9Sstevel@tonic-gate * with the License. 87c478bd9Sstevel@tonic-gate * 97c478bd9Sstevel@tonic-gate * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE 107c478bd9Sstevel@tonic-gate * or http://www.opensolaris.org/os/licensing. 117c478bd9Sstevel@tonic-gate * See the License for the specific language governing permissions 127c478bd9Sstevel@tonic-gate * and limitations under the License. 137c478bd9Sstevel@tonic-gate * 147c478bd9Sstevel@tonic-gate * When distributing Covered Code, include this CDDL HEADER in each 157c478bd9Sstevel@tonic-gate * file and include the License file at usr/src/OPENSOLARIS.LICENSE. 167c478bd9Sstevel@tonic-gate * If applicable, add the following below this CDDL HEADER, with the 177c478bd9Sstevel@tonic-gate * fields enclosed by brackets "[]" replaced with your own identifying 187c478bd9Sstevel@tonic-gate * information: Portions Copyright [yyyy] [name of copyright owner] 197c478bd9Sstevel@tonic-gate * 207c478bd9Sstevel@tonic-gate * CDDL HEADER END 217c478bd9Sstevel@tonic-gate */ 227c478bd9Sstevel@tonic-gate /* 237c478bd9Sstevel@tonic-gate * Copyright 2005 Sun Microsystems, Inc. All rights reserved. 247c478bd9Sstevel@tonic-gate * Use is subject to license terms. 257c478bd9Sstevel@tonic-gate */ 267c478bd9Sstevel@tonic-gate 277c478bd9Sstevel@tonic-gate #pragma ident "%Z%%M% %I% %E% SMI" 287c478bd9Sstevel@tonic-gate 297c478bd9Sstevel@tonic-gate /* 307c478bd9Sstevel@tonic-gate * DTrace D Language Compiler 317c478bd9Sstevel@tonic-gate * 327c478bd9Sstevel@tonic-gate * The code in this source file implements the main engine for the D language 337c478bd9Sstevel@tonic-gate * compiler. The driver routine for the compiler is dt_compile(), below. The 347c478bd9Sstevel@tonic-gate * compiler operates on either stdio FILEs or in-memory strings as its input 357c478bd9Sstevel@tonic-gate * and can produce either dtrace_prog_t structures from a D program or a single 367c478bd9Sstevel@tonic-gate * dtrace_difo_t structure from a D expression. Multiple entry points are 377c478bd9Sstevel@tonic-gate * provided as wrappers around dt_compile() for the various input/output pairs. 387c478bd9Sstevel@tonic-gate * The compiler itself is implemented across the following source files: 397c478bd9Sstevel@tonic-gate * 407c478bd9Sstevel@tonic-gate * dt_lex.l - lex scanner 417c478bd9Sstevel@tonic-gate * dt_grammar.y - yacc grammar 427c478bd9Sstevel@tonic-gate * dt_parser.c - parse tree creation and semantic checking 437c478bd9Sstevel@tonic-gate * dt_decl.c - declaration stack processing 447c478bd9Sstevel@tonic-gate * dt_xlator.c - D translator lookup and creation 457c478bd9Sstevel@tonic-gate * dt_ident.c - identifier and symbol table routines 467c478bd9Sstevel@tonic-gate * dt_pragma.c - #pragma processing and D pragmas 477c478bd9Sstevel@tonic-gate * dt_printf.c - D printf() and printa() argument checking and processing 487c478bd9Sstevel@tonic-gate * dt_cc.c - compiler driver and dtrace_prog_t construction 497c478bd9Sstevel@tonic-gate * dt_cg.c - DIF code generator 507c478bd9Sstevel@tonic-gate * dt_as.c - DIF assembler 517c478bd9Sstevel@tonic-gate * dt_dof.c - dtrace_prog_t -> DOF conversion 527c478bd9Sstevel@tonic-gate * 537c478bd9Sstevel@tonic-gate * Several other source files provide collections of utility routines used by 547c478bd9Sstevel@tonic-gate * these major files. The compiler itself is implemented in multiple passes: 557c478bd9Sstevel@tonic-gate * 567c478bd9Sstevel@tonic-gate * (1) The input program is scanned and parsed by dt_lex.l and dt_grammar.y 577c478bd9Sstevel@tonic-gate * and parse tree nodes are constructed using the routines in dt_parser.c. 587c478bd9Sstevel@tonic-gate * This node construction pass is described further in dt_parser.c. 597c478bd9Sstevel@tonic-gate * 607c478bd9Sstevel@tonic-gate * (2) The parse tree is "cooked" by assigning each clause a context (see the 617c478bd9Sstevel@tonic-gate * routine dt_setcontext(), below) based on its probe description and then 627c478bd9Sstevel@tonic-gate * recursively descending the tree performing semantic checking. The cook 637c478bd9Sstevel@tonic-gate * routines are also implemented in dt_parser.c and described there. 647c478bd9Sstevel@tonic-gate * 657c478bd9Sstevel@tonic-gate * (3) For actions that are DIF expression statements, the DIF code generator 667c478bd9Sstevel@tonic-gate * and assembler are invoked to create a finished DIFO for the statement. 677c478bd9Sstevel@tonic-gate * 687c478bd9Sstevel@tonic-gate * (4) The dtrace_prog_t data structures for the program clauses and actions 697c478bd9Sstevel@tonic-gate * are built, containing pointers to any DIFOs created in step (3). 707c478bd9Sstevel@tonic-gate * 717c478bd9Sstevel@tonic-gate * (5) The caller invokes a routine in dt_dof.c to convert the finished program 727c478bd9Sstevel@tonic-gate * into DOF format for use in anonymous tracing or enabling in the kernel. 737c478bd9Sstevel@tonic-gate * 747c478bd9Sstevel@tonic-gate * In the implementation, steps 2-4 are intertwined in that they are performed 757c478bd9Sstevel@tonic-gate * in order for each clause as part of a loop that executes over the clauses. 767c478bd9Sstevel@tonic-gate * 777c478bd9Sstevel@tonic-gate * The D compiler currently implements nearly no optimization. The compiler 787c478bd9Sstevel@tonic-gate * implements integer constant folding as part of pass (1), and a set of very 797c478bd9Sstevel@tonic-gate * simple peephole optimizations as part of pass (3). As with any C compiler, 807c478bd9Sstevel@tonic-gate * a large number of optimizations are possible on both the intermediate data 817c478bd9Sstevel@tonic-gate * structures and the generated DIF code. These possibilities should be 827c478bd9Sstevel@tonic-gate * investigated in the context of whether they will have any substantive effect 837c478bd9Sstevel@tonic-gate * on the overall DTrace probe effect before they are undertaken. 847c478bd9Sstevel@tonic-gate */ 857c478bd9Sstevel@tonic-gate 867c478bd9Sstevel@tonic-gate #include <sys/types.h> 877c478bd9Sstevel@tonic-gate #include <sys/wait.h> 887c478bd9Sstevel@tonic-gate 897c478bd9Sstevel@tonic-gate #include <assert.h> 907c478bd9Sstevel@tonic-gate #include <strings.h> 917c478bd9Sstevel@tonic-gate #include <signal.h> 927c478bd9Sstevel@tonic-gate #include <unistd.h> 937c478bd9Sstevel@tonic-gate #include <stdlib.h> 947c478bd9Sstevel@tonic-gate #include <stdio.h> 957c478bd9Sstevel@tonic-gate #include <errno.h> 967c478bd9Sstevel@tonic-gate #include <ucontext.h> 977c478bd9Sstevel@tonic-gate #include <limits.h> 987c478bd9Sstevel@tonic-gate #include <alloca.h> 997c478bd9Sstevel@tonic-gate #include <ctype.h> 1007c478bd9Sstevel@tonic-gate 1017c478bd9Sstevel@tonic-gate #define _POSIX_PTHREAD_SEMANTICS 1027c478bd9Sstevel@tonic-gate #include <dirent.h> 1037c478bd9Sstevel@tonic-gate #undef _POSIX_PTHREAD_SEMANTICS 1047c478bd9Sstevel@tonic-gate 1057c478bd9Sstevel@tonic-gate #include <dt_module.h> 1061a7c1b72Smws #include <dt_program.h> 1077c478bd9Sstevel@tonic-gate #include <dt_provider.h> 1087c478bd9Sstevel@tonic-gate #include <dt_printf.h> 1097c478bd9Sstevel@tonic-gate #include <dt_pid.h> 1107c478bd9Sstevel@tonic-gate #include <dt_grammar.h> 1117c478bd9Sstevel@tonic-gate #include <dt_ident.h> 1127c478bd9Sstevel@tonic-gate #include <dt_string.h> 1137c478bd9Sstevel@tonic-gate #include <dt_impl.h> 1147c478bd9Sstevel@tonic-gate 1157c478bd9Sstevel@tonic-gate static const dtrace_diftype_t dt_void_rtype = { 1167c478bd9Sstevel@tonic-gate DIF_TYPE_CTF, CTF_K_INTEGER, 0, 0, 0 1177c478bd9Sstevel@tonic-gate }; 1187c478bd9Sstevel@tonic-gate 1197c478bd9Sstevel@tonic-gate static const dtrace_diftype_t dt_int_rtype = { 1207c478bd9Sstevel@tonic-gate DIF_TYPE_CTF, CTF_K_INTEGER, 0, 0, sizeof (uint64_t) 1217c478bd9Sstevel@tonic-gate }; 1227c478bd9Sstevel@tonic-gate 1237c478bd9Sstevel@tonic-gate /*ARGSUSED*/ 1247c478bd9Sstevel@tonic-gate static int 1257c478bd9Sstevel@tonic-gate dt_idreset(dt_idhash_t *dhp, dt_ident_t *idp, void *ignored) 1267c478bd9Sstevel@tonic-gate { 1277c478bd9Sstevel@tonic-gate idp->di_flags &= ~(DT_IDFLG_REF | DT_IDFLG_MOD | 1287c478bd9Sstevel@tonic-gate DT_IDFLG_DIFR | DT_IDFLG_DIFW); 1297c478bd9Sstevel@tonic-gate return (0); 1307c478bd9Sstevel@tonic-gate } 1317c478bd9Sstevel@tonic-gate 1327c478bd9Sstevel@tonic-gate /*ARGSUSED*/ 1337c478bd9Sstevel@tonic-gate static int 1347c478bd9Sstevel@tonic-gate dt_idpragma(dt_idhash_t *dhp, dt_ident_t *idp, void *ignored) 1357c478bd9Sstevel@tonic-gate { 1367c478bd9Sstevel@tonic-gate yylineno = idp->di_lineno; 1377c478bd9Sstevel@tonic-gate xyerror(D_PRAGMA_UNUSED, "unused #pragma %s\n", (char *)idp->di_iarg); 1387c478bd9Sstevel@tonic-gate return (0); 1397c478bd9Sstevel@tonic-gate } 1407c478bd9Sstevel@tonic-gate 1417c478bd9Sstevel@tonic-gate static dtrace_stmtdesc_t * 1427c478bd9Sstevel@tonic-gate dt_stmt_create(dtrace_hdl_t *dtp, dtrace_ecbdesc_t *edp, 1437c478bd9Sstevel@tonic-gate dtrace_attribute_t descattr, dtrace_attribute_t stmtattr) 1447c478bd9Sstevel@tonic-gate { 1457c478bd9Sstevel@tonic-gate dtrace_stmtdesc_t *sdp = dtrace_stmt_create(dtp, edp); 1467c478bd9Sstevel@tonic-gate 1477c478bd9Sstevel@tonic-gate if (sdp == NULL) 1487c478bd9Sstevel@tonic-gate longjmp(yypcb->pcb_jmpbuf, EDT_NOMEM); 1497c478bd9Sstevel@tonic-gate 1507c478bd9Sstevel@tonic-gate assert(yypcb->pcb_stmt == NULL); 1517c478bd9Sstevel@tonic-gate yypcb->pcb_stmt = sdp; 1527c478bd9Sstevel@tonic-gate 1537c478bd9Sstevel@tonic-gate sdp->dtsd_descattr = descattr; 1547c478bd9Sstevel@tonic-gate sdp->dtsd_stmtattr = stmtattr; 1557c478bd9Sstevel@tonic-gate 1567c478bd9Sstevel@tonic-gate return (sdp); 1577c478bd9Sstevel@tonic-gate } 1587c478bd9Sstevel@tonic-gate 1597c478bd9Sstevel@tonic-gate static dtrace_actdesc_t * 1607c478bd9Sstevel@tonic-gate dt_stmt_action(dtrace_hdl_t *dtp, dtrace_stmtdesc_t *sdp) 1617c478bd9Sstevel@tonic-gate { 1627c478bd9Sstevel@tonic-gate dtrace_actdesc_t *new; 1637c478bd9Sstevel@tonic-gate 1647c478bd9Sstevel@tonic-gate if ((new = dtrace_stmt_action(dtp, sdp)) == NULL) 1657c478bd9Sstevel@tonic-gate longjmp(yypcb->pcb_jmpbuf, EDT_NOMEM); 1667c478bd9Sstevel@tonic-gate 1677c478bd9Sstevel@tonic-gate return (new); 1687c478bd9Sstevel@tonic-gate } 1697c478bd9Sstevel@tonic-gate 1707c478bd9Sstevel@tonic-gate /* 1717c478bd9Sstevel@tonic-gate * Utility function to determine if a given action description is destructive. 1727c478bd9Sstevel@tonic-gate * The dtdo_destructive bit is set for us by the DIF assembler (see dt_as.c). 1737c478bd9Sstevel@tonic-gate */ 1747c478bd9Sstevel@tonic-gate static int 1757c478bd9Sstevel@tonic-gate dt_action_destructive(const dtrace_actdesc_t *ap) 1767c478bd9Sstevel@tonic-gate { 1777c478bd9Sstevel@tonic-gate return (DTRACEACT_ISDESTRUCTIVE(ap->dtad_kind) || (ap->dtad_kind == 1787c478bd9Sstevel@tonic-gate DTRACEACT_DIFEXPR && ap->dtad_difo->dtdo_destructive)); 1797c478bd9Sstevel@tonic-gate } 1807c478bd9Sstevel@tonic-gate 1817c478bd9Sstevel@tonic-gate static void 1827c478bd9Sstevel@tonic-gate dt_stmt_append(dtrace_stmtdesc_t *sdp, const dt_node_t *dnp) 1837c478bd9Sstevel@tonic-gate { 1847c478bd9Sstevel@tonic-gate dtrace_ecbdesc_t *edp = sdp->dtsd_ecbdesc; 1857c478bd9Sstevel@tonic-gate dtrace_actdesc_t *ap, *tap; 1867c478bd9Sstevel@tonic-gate int commit = 0; 1877c478bd9Sstevel@tonic-gate int speculate = 0; 1887c478bd9Sstevel@tonic-gate int datarec = 0; 1897c478bd9Sstevel@tonic-gate 1907c478bd9Sstevel@tonic-gate /* 1917c478bd9Sstevel@tonic-gate * Make sure that the new statement jibes with the rest of the ECB. 1927c478bd9Sstevel@tonic-gate */ 1937c478bd9Sstevel@tonic-gate for (ap = edp->dted_action; ap != NULL; ap = ap->dtad_next) { 1947c478bd9Sstevel@tonic-gate if (ap->dtad_kind == DTRACEACT_COMMIT) { 1957c478bd9Sstevel@tonic-gate if (commit) { 1967c478bd9Sstevel@tonic-gate dnerror(dnp, D_COMM_COMM, "commit( ) may " 1977c478bd9Sstevel@tonic-gate "not follow commit( )\n"); 1987c478bd9Sstevel@tonic-gate } 1997c478bd9Sstevel@tonic-gate 2007c478bd9Sstevel@tonic-gate if (datarec) { 2017c478bd9Sstevel@tonic-gate dnerror(dnp, D_COMM_DREC, "commit( ) may " 2027c478bd9Sstevel@tonic-gate "not follow data-recording action(s)\n"); 2037c478bd9Sstevel@tonic-gate } 2047c478bd9Sstevel@tonic-gate 2057c478bd9Sstevel@tonic-gate for (tap = ap; tap != NULL; tap = tap->dtad_next) { 2067c478bd9Sstevel@tonic-gate if (!DTRACEACT_ISAGG(tap->dtad_kind)) 2077c478bd9Sstevel@tonic-gate continue; 2087c478bd9Sstevel@tonic-gate 2097c478bd9Sstevel@tonic-gate dnerror(dnp, D_AGG_COMM, "aggregating actions " 2107c478bd9Sstevel@tonic-gate "may not follow commit( )\n"); 2117c478bd9Sstevel@tonic-gate } 2127c478bd9Sstevel@tonic-gate 2137c478bd9Sstevel@tonic-gate commit = 1; 2147c478bd9Sstevel@tonic-gate continue; 2157c478bd9Sstevel@tonic-gate } 2167c478bd9Sstevel@tonic-gate 2177c478bd9Sstevel@tonic-gate if (ap->dtad_kind == DTRACEACT_SPECULATE) { 2187c478bd9Sstevel@tonic-gate if (speculate) { 2197c478bd9Sstevel@tonic-gate dnerror(dnp, D_SPEC_SPEC, "speculate( ) may " 2207c478bd9Sstevel@tonic-gate "not follow speculate( )\n"); 2217c478bd9Sstevel@tonic-gate } 2227c478bd9Sstevel@tonic-gate 2237c478bd9Sstevel@tonic-gate if (commit) { 2247c478bd9Sstevel@tonic-gate dnerror(dnp, D_SPEC_COMM, "speculate( ) may " 2257c478bd9Sstevel@tonic-gate "not follow commit( )\n"); 2267c478bd9Sstevel@tonic-gate } 2277c478bd9Sstevel@tonic-gate 2287c478bd9Sstevel@tonic-gate if (datarec) { 2297c478bd9Sstevel@tonic-gate dnerror(dnp, D_SPEC_DREC, "speculate( ) may " 2307c478bd9Sstevel@tonic-gate "not follow data-recording action(s)\n"); 2317c478bd9Sstevel@tonic-gate } 2327c478bd9Sstevel@tonic-gate 2337c478bd9Sstevel@tonic-gate speculate = 1; 2347c478bd9Sstevel@tonic-gate continue; 2357c478bd9Sstevel@tonic-gate } 2367c478bd9Sstevel@tonic-gate 2377c478bd9Sstevel@tonic-gate if (DTRACEACT_ISAGG(ap->dtad_kind)) { 2387c478bd9Sstevel@tonic-gate if (speculate) { 2397c478bd9Sstevel@tonic-gate dnerror(dnp, D_AGG_SPEC, "aggregating actions " 2407c478bd9Sstevel@tonic-gate "may not follow speculate( )\n"); 2417c478bd9Sstevel@tonic-gate } 2427c478bd9Sstevel@tonic-gate 2437c478bd9Sstevel@tonic-gate datarec = 1; 2447c478bd9Sstevel@tonic-gate continue; 2457c478bd9Sstevel@tonic-gate } 2467c478bd9Sstevel@tonic-gate 2477c478bd9Sstevel@tonic-gate if (speculate) { 2487c478bd9Sstevel@tonic-gate if (dt_action_destructive(ap)) { 2497c478bd9Sstevel@tonic-gate dnerror(dnp, D_ACT_SPEC, "destructive actions " 2507c478bd9Sstevel@tonic-gate "may not follow speculate( )\n"); 2517c478bd9Sstevel@tonic-gate } 2527c478bd9Sstevel@tonic-gate 2537c478bd9Sstevel@tonic-gate if (ap->dtad_kind == DTRACEACT_EXIT) { 2547c478bd9Sstevel@tonic-gate dnerror(dnp, D_EXIT_SPEC, "exit( ) may not " 2557c478bd9Sstevel@tonic-gate "follow speculate( )\n"); 2567c478bd9Sstevel@tonic-gate } 2577c478bd9Sstevel@tonic-gate } 2587c478bd9Sstevel@tonic-gate 2597c478bd9Sstevel@tonic-gate /* 2607c478bd9Sstevel@tonic-gate * Exclude all non data-recording actions. 2617c478bd9Sstevel@tonic-gate */ 2627c478bd9Sstevel@tonic-gate if (dt_action_destructive(ap) || 2637c478bd9Sstevel@tonic-gate ap->dtad_kind == DTRACEACT_DISCARD) 2647c478bd9Sstevel@tonic-gate continue; 2657c478bd9Sstevel@tonic-gate 2667c478bd9Sstevel@tonic-gate if (ap->dtad_kind == DTRACEACT_DIFEXPR && 2677c478bd9Sstevel@tonic-gate ap->dtad_difo->dtdo_rtype.dtdt_kind == DIF_TYPE_CTF && 2687c478bd9Sstevel@tonic-gate ap->dtad_difo->dtdo_rtype.dtdt_size == 0) 2697c478bd9Sstevel@tonic-gate continue; 2707c478bd9Sstevel@tonic-gate 2717c478bd9Sstevel@tonic-gate if (commit) { 2727c478bd9Sstevel@tonic-gate dnerror(dnp, D_DREC_COMM, "data-recording actions " 2737c478bd9Sstevel@tonic-gate "may not follow commit( )\n"); 2747c478bd9Sstevel@tonic-gate } 2757c478bd9Sstevel@tonic-gate 2767c478bd9Sstevel@tonic-gate if (!speculate) 2777c478bd9Sstevel@tonic-gate datarec = 1; 2787c478bd9Sstevel@tonic-gate } 2797c478bd9Sstevel@tonic-gate 2807c478bd9Sstevel@tonic-gate if (dtrace_stmt_add(yypcb->pcb_hdl, yypcb->pcb_prog, sdp) != 0) 2817c478bd9Sstevel@tonic-gate longjmp(yypcb->pcb_jmpbuf, dtrace_errno(yypcb->pcb_hdl)); 2827c478bd9Sstevel@tonic-gate 2837c478bd9Sstevel@tonic-gate if (yypcb->pcb_stmt == sdp) 2847c478bd9Sstevel@tonic-gate yypcb->pcb_stmt = NULL; 2857c478bd9Sstevel@tonic-gate } 2867c478bd9Sstevel@tonic-gate 2877c478bd9Sstevel@tonic-gate /* 2887c478bd9Sstevel@tonic-gate * For the first element of an aggregation tuple or for printa(), we create a 2897c478bd9Sstevel@tonic-gate * simple DIF program that simply returns the immediate value that is the ID 2907c478bd9Sstevel@tonic-gate * of the aggregation itself. This could be optimized in the future by 2917c478bd9Sstevel@tonic-gate * creating a new in-kernel dtad_kind that just returns an integer. 2927c478bd9Sstevel@tonic-gate */ 2937c478bd9Sstevel@tonic-gate static void 2947c478bd9Sstevel@tonic-gate dt_action_difconst(dtrace_actdesc_t *ap, uint_t id, dtrace_actkind_t kind) 2957c478bd9Sstevel@tonic-gate { 2961a7c1b72Smws dtrace_hdl_t *dtp = yypcb->pcb_hdl; 2971a7c1b72Smws dtrace_difo_t *dp = dt_zalloc(dtp, sizeof (dtrace_difo_t)); 2987c478bd9Sstevel@tonic-gate 2997c478bd9Sstevel@tonic-gate if (dp == NULL) 3007c478bd9Sstevel@tonic-gate longjmp(yypcb->pcb_jmpbuf, EDT_NOMEM); 3017c478bd9Sstevel@tonic-gate 3021a7c1b72Smws dp->dtdo_buf = dt_alloc(dtp, sizeof (dif_instr_t) * 2); 3031a7c1b72Smws dp->dtdo_inttab = dt_alloc(dtp, sizeof (uint64_t)); 3047c478bd9Sstevel@tonic-gate 3057c478bd9Sstevel@tonic-gate if (dp->dtdo_buf == NULL || dp->dtdo_inttab == NULL) { 3061a7c1b72Smws dt_difo_free(dtp, dp); 3077c478bd9Sstevel@tonic-gate longjmp(yypcb->pcb_jmpbuf, EDT_NOMEM); 3087c478bd9Sstevel@tonic-gate } 3097c478bd9Sstevel@tonic-gate 3107c478bd9Sstevel@tonic-gate dp->dtdo_buf[0] = DIF_INSTR_SETX(0, 1); /* setx DIF_INTEGER[0], %r1 */ 3117c478bd9Sstevel@tonic-gate dp->dtdo_buf[1] = DIF_INSTR_RET(1); /* ret %r1 */ 3127c478bd9Sstevel@tonic-gate dp->dtdo_len = 2; 3137c478bd9Sstevel@tonic-gate dp->dtdo_inttab[0] = id; 3147c478bd9Sstevel@tonic-gate dp->dtdo_intlen = 1; 3157c478bd9Sstevel@tonic-gate dp->dtdo_rtype = dt_int_rtype; 3167c478bd9Sstevel@tonic-gate 3177c478bd9Sstevel@tonic-gate ap->dtad_difo = dp; 3187c478bd9Sstevel@tonic-gate ap->dtad_kind = kind; 3197c478bd9Sstevel@tonic-gate } 3207c478bd9Sstevel@tonic-gate 3217c478bd9Sstevel@tonic-gate static void 3227c478bd9Sstevel@tonic-gate dt_action_clear(dtrace_hdl_t *dtp, dt_node_t *dnp, dtrace_stmtdesc_t *sdp) 3237c478bd9Sstevel@tonic-gate { 3247c478bd9Sstevel@tonic-gate dt_ident_t *aid; 3257c478bd9Sstevel@tonic-gate dtrace_actdesc_t *ap; 3267c478bd9Sstevel@tonic-gate dt_node_t *anp; 3277c478bd9Sstevel@tonic-gate 3287c478bd9Sstevel@tonic-gate char n[DT_TYPE_NAMELEN]; 3297c478bd9Sstevel@tonic-gate int argc = 0; 3307c478bd9Sstevel@tonic-gate 3317c478bd9Sstevel@tonic-gate for (anp = dnp->dn_args; anp != NULL; anp = anp->dn_list) 3327c478bd9Sstevel@tonic-gate argc++; /* count up arguments for error messages below */ 3337c478bd9Sstevel@tonic-gate 3347c478bd9Sstevel@tonic-gate if (argc != 1) { 3357c478bd9Sstevel@tonic-gate dnerror(dnp, D_CLEAR_PROTO, 3367c478bd9Sstevel@tonic-gate "%s( ) prototype mismatch: %d args passed, 1 expected\n", 3377c478bd9Sstevel@tonic-gate dnp->dn_ident->di_name, argc); 3387c478bd9Sstevel@tonic-gate } 3397c478bd9Sstevel@tonic-gate 3407c478bd9Sstevel@tonic-gate anp = dnp->dn_args; 3417c478bd9Sstevel@tonic-gate assert(anp != NULL); 3427c478bd9Sstevel@tonic-gate 3437c478bd9Sstevel@tonic-gate if (anp->dn_kind != DT_NODE_AGG) { 3447c478bd9Sstevel@tonic-gate dnerror(dnp, D_CLEAR_AGGARG, 3457c478bd9Sstevel@tonic-gate "%s( ) argument #1 is incompatible with prototype:\n" 3467c478bd9Sstevel@tonic-gate "\tprototype: aggregation\n\t argument: %s\n", 3477c478bd9Sstevel@tonic-gate dnp->dn_ident->di_name, 3487c478bd9Sstevel@tonic-gate dt_node_type_name(anp, n, sizeof (n))); 3497c478bd9Sstevel@tonic-gate } 3507c478bd9Sstevel@tonic-gate 3517c478bd9Sstevel@tonic-gate aid = anp->dn_ident; 3527c478bd9Sstevel@tonic-gate 3537c478bd9Sstevel@tonic-gate if (aid->di_gen == dtp->dt_gen && !(aid->di_flags & DT_IDFLG_MOD)) { 3547c478bd9Sstevel@tonic-gate dnerror(dnp, D_CLEAR_AGGBAD, 3557c478bd9Sstevel@tonic-gate "undefined aggregation: @%s\n", aid->di_name); 3567c478bd9Sstevel@tonic-gate } 3577c478bd9Sstevel@tonic-gate 3587c478bd9Sstevel@tonic-gate ap = dt_stmt_action(dtp, sdp); 3597c478bd9Sstevel@tonic-gate dt_action_difconst(ap, anp->dn_ident->di_id, DTRACEACT_LIBACT); 3607c478bd9Sstevel@tonic-gate ap->dtad_arg = DT_ACT_CLEAR; 3617c478bd9Sstevel@tonic-gate } 3627c478bd9Sstevel@tonic-gate 3637c478bd9Sstevel@tonic-gate static void 3647c478bd9Sstevel@tonic-gate dt_action_normalize(dtrace_hdl_t *dtp, dt_node_t *dnp, dtrace_stmtdesc_t *sdp) 3657c478bd9Sstevel@tonic-gate { 3667c478bd9Sstevel@tonic-gate dt_ident_t *aid; 3677c478bd9Sstevel@tonic-gate dtrace_actdesc_t *ap; 3687c478bd9Sstevel@tonic-gate dt_node_t *anp, *normal; 3697c478bd9Sstevel@tonic-gate int denormal = (strcmp(dnp->dn_ident->di_name, "denormalize") == 0); 3707c478bd9Sstevel@tonic-gate 3717c478bd9Sstevel@tonic-gate char n[DT_TYPE_NAMELEN]; 3727c478bd9Sstevel@tonic-gate int argc = 0; 3737c478bd9Sstevel@tonic-gate 3747c478bd9Sstevel@tonic-gate for (anp = dnp->dn_args; anp != NULL; anp = anp->dn_list) 3757c478bd9Sstevel@tonic-gate argc++; /* count up arguments for error messages below */ 3767c478bd9Sstevel@tonic-gate 3777c478bd9Sstevel@tonic-gate if ((denormal && argc != 1) || (!denormal && argc != 2)) { 3787c478bd9Sstevel@tonic-gate dnerror(dnp, D_NORMALIZE_PROTO, 3797c478bd9Sstevel@tonic-gate "%s( ) prototype mismatch: %d args passed, %d expected\n", 3807c478bd9Sstevel@tonic-gate dnp->dn_ident->di_name, argc, denormal ? 1 : 2); 3817c478bd9Sstevel@tonic-gate } 3827c478bd9Sstevel@tonic-gate 3837c478bd9Sstevel@tonic-gate anp = dnp->dn_args; 3847c478bd9Sstevel@tonic-gate assert(anp != NULL); 3857c478bd9Sstevel@tonic-gate 3867c478bd9Sstevel@tonic-gate if (anp->dn_kind != DT_NODE_AGG) { 3877c478bd9Sstevel@tonic-gate dnerror(dnp, D_NORMALIZE_AGGARG, 3887c478bd9Sstevel@tonic-gate "%s( ) argument #1 is incompatible with prototype:\n" 3897c478bd9Sstevel@tonic-gate "\tprototype: aggregation\n\t argument: %s\n", 3907c478bd9Sstevel@tonic-gate dnp->dn_ident->di_name, 3917c478bd9Sstevel@tonic-gate dt_node_type_name(anp, n, sizeof (n))); 3927c478bd9Sstevel@tonic-gate } 3937c478bd9Sstevel@tonic-gate 3947c478bd9Sstevel@tonic-gate if ((normal = anp->dn_list) != NULL && !dt_node_is_scalar(normal)) { 3957c478bd9Sstevel@tonic-gate dnerror(dnp, D_NORMALIZE_SCALAR, 3967c478bd9Sstevel@tonic-gate "%s( ) argument #2 must be of scalar type\n", 3977c478bd9Sstevel@tonic-gate dnp->dn_ident->di_name); 3987c478bd9Sstevel@tonic-gate } 3997c478bd9Sstevel@tonic-gate 4007c478bd9Sstevel@tonic-gate aid = anp->dn_ident; 4017c478bd9Sstevel@tonic-gate 4027c478bd9Sstevel@tonic-gate if (aid->di_gen == dtp->dt_gen && !(aid->di_flags & DT_IDFLG_MOD)) { 4037c478bd9Sstevel@tonic-gate dnerror(dnp, D_NORMALIZE_AGGBAD, 4047c478bd9Sstevel@tonic-gate "undefined aggregation: @%s\n", aid->di_name); 4057c478bd9Sstevel@tonic-gate } 4067c478bd9Sstevel@tonic-gate 4077c478bd9Sstevel@tonic-gate ap = dt_stmt_action(dtp, sdp); 4087c478bd9Sstevel@tonic-gate dt_action_difconst(ap, anp->dn_ident->di_id, DTRACEACT_LIBACT); 4097c478bd9Sstevel@tonic-gate 4107c478bd9Sstevel@tonic-gate if (denormal) { 4117c478bd9Sstevel@tonic-gate ap->dtad_arg = DT_ACT_DENORMALIZE; 4127c478bd9Sstevel@tonic-gate return; 4137c478bd9Sstevel@tonic-gate } 4147c478bd9Sstevel@tonic-gate 4157c478bd9Sstevel@tonic-gate ap->dtad_arg = DT_ACT_NORMALIZE; 4167c478bd9Sstevel@tonic-gate 4177c478bd9Sstevel@tonic-gate assert(normal != NULL); 4187c478bd9Sstevel@tonic-gate ap = dt_stmt_action(dtp, sdp); 4197c478bd9Sstevel@tonic-gate dt_cg(yypcb, normal); 4207c478bd9Sstevel@tonic-gate 4217c478bd9Sstevel@tonic-gate ap->dtad_difo = dt_as(yypcb); 4227c478bd9Sstevel@tonic-gate ap->dtad_kind = DTRACEACT_LIBACT; 4237c478bd9Sstevel@tonic-gate ap->dtad_arg = DT_ACT_NORMALIZE; 4247c478bd9Sstevel@tonic-gate } 4257c478bd9Sstevel@tonic-gate 4267c478bd9Sstevel@tonic-gate static void 4277c478bd9Sstevel@tonic-gate dt_action_trunc(dtrace_hdl_t *dtp, dt_node_t *dnp, dtrace_stmtdesc_t *sdp) 4287c478bd9Sstevel@tonic-gate { 4297c478bd9Sstevel@tonic-gate dt_ident_t *aid; 4307c478bd9Sstevel@tonic-gate dtrace_actdesc_t *ap; 4317c478bd9Sstevel@tonic-gate dt_node_t *anp, *trunc; 4327c478bd9Sstevel@tonic-gate 4337c478bd9Sstevel@tonic-gate char n[DT_TYPE_NAMELEN]; 4347c478bd9Sstevel@tonic-gate int argc = 0; 4357c478bd9Sstevel@tonic-gate 4367c478bd9Sstevel@tonic-gate for (anp = dnp->dn_args; anp != NULL; anp = anp->dn_list) 4377c478bd9Sstevel@tonic-gate argc++; /* count up arguments for error messages below */ 4387c478bd9Sstevel@tonic-gate 4397c478bd9Sstevel@tonic-gate if (argc > 2 || argc < 1) { 4407c478bd9Sstevel@tonic-gate dnerror(dnp, D_TRUNC_PROTO, 4417c478bd9Sstevel@tonic-gate "%s( ) prototype mismatch: %d args passed, %s expected\n", 4427c478bd9Sstevel@tonic-gate dnp->dn_ident->di_name, argc, 4437c478bd9Sstevel@tonic-gate argc < 1 ? "at least 1" : "no more than 2"); 4447c478bd9Sstevel@tonic-gate } 4457c478bd9Sstevel@tonic-gate 4467c478bd9Sstevel@tonic-gate anp = dnp->dn_args; 4477c478bd9Sstevel@tonic-gate assert(anp != NULL); 4487c478bd9Sstevel@tonic-gate trunc = anp->dn_list; 4497c478bd9Sstevel@tonic-gate 4507c478bd9Sstevel@tonic-gate if (anp->dn_kind != DT_NODE_AGG) { 4517c478bd9Sstevel@tonic-gate dnerror(dnp, D_TRUNC_AGGARG, 4527c478bd9Sstevel@tonic-gate "%s( ) argument #1 is incompatible with prototype:\n" 4537c478bd9Sstevel@tonic-gate "\tprototype: aggregation\n\t argument: %s\n", 4547c478bd9Sstevel@tonic-gate dnp->dn_ident->di_name, 4557c478bd9Sstevel@tonic-gate dt_node_type_name(anp, n, sizeof (n))); 4567c478bd9Sstevel@tonic-gate } 4577c478bd9Sstevel@tonic-gate 4587c478bd9Sstevel@tonic-gate if (argc == 2) { 4597c478bd9Sstevel@tonic-gate assert(trunc != NULL); 4607c478bd9Sstevel@tonic-gate if (!dt_node_is_scalar(trunc)) { 4617c478bd9Sstevel@tonic-gate dnerror(dnp, D_TRUNC_SCALAR, 4627c478bd9Sstevel@tonic-gate "%s( ) argument #2 must be of scalar type\n", 4637c478bd9Sstevel@tonic-gate dnp->dn_ident->di_name); 4647c478bd9Sstevel@tonic-gate } 4657c478bd9Sstevel@tonic-gate } 4667c478bd9Sstevel@tonic-gate 4677c478bd9Sstevel@tonic-gate aid = anp->dn_ident; 4687c478bd9Sstevel@tonic-gate 4697c478bd9Sstevel@tonic-gate if (aid->di_gen == dtp->dt_gen && !(aid->di_flags & DT_IDFLG_MOD)) { 4707c478bd9Sstevel@tonic-gate dnerror(dnp, D_TRUNC_AGGBAD, 4717c478bd9Sstevel@tonic-gate "undefined aggregation: @%s\n", aid->di_name); 4727c478bd9Sstevel@tonic-gate } 4737c478bd9Sstevel@tonic-gate 4747c478bd9Sstevel@tonic-gate ap = dt_stmt_action(dtp, sdp); 4757c478bd9Sstevel@tonic-gate dt_action_difconst(ap, anp->dn_ident->di_id, DTRACEACT_LIBACT); 4767c478bd9Sstevel@tonic-gate ap->dtad_arg = DT_ACT_TRUNC; 4777c478bd9Sstevel@tonic-gate 4787c478bd9Sstevel@tonic-gate ap = dt_stmt_action(dtp, sdp); 4797c478bd9Sstevel@tonic-gate 4807c478bd9Sstevel@tonic-gate if (argc == 1) { 4817c478bd9Sstevel@tonic-gate dt_action_difconst(ap, 0, DTRACEACT_LIBACT); 4827c478bd9Sstevel@tonic-gate } else { 4837c478bd9Sstevel@tonic-gate assert(trunc != NULL); 4847c478bd9Sstevel@tonic-gate dt_cg(yypcb, trunc); 4857c478bd9Sstevel@tonic-gate ap->dtad_difo = dt_as(yypcb); 4867c478bd9Sstevel@tonic-gate ap->dtad_kind = DTRACEACT_LIBACT; 4877c478bd9Sstevel@tonic-gate } 4887c478bd9Sstevel@tonic-gate 4897c478bd9Sstevel@tonic-gate ap->dtad_arg = DT_ACT_TRUNC; 4907c478bd9Sstevel@tonic-gate } 4917c478bd9Sstevel@tonic-gate 4927c478bd9Sstevel@tonic-gate static void 4937c478bd9Sstevel@tonic-gate dt_action_printa(dtrace_hdl_t *dtp, dt_node_t *dnp, dtrace_stmtdesc_t *sdp) 4947c478bd9Sstevel@tonic-gate { 4957c478bd9Sstevel@tonic-gate dt_ident_t *aid, *fid; 4967c478bd9Sstevel@tonic-gate dtrace_actdesc_t *ap; 4977c478bd9Sstevel@tonic-gate const char *format; 4987c478bd9Sstevel@tonic-gate dt_node_t *anp; 4997c478bd9Sstevel@tonic-gate 5007c478bd9Sstevel@tonic-gate char n[DT_TYPE_NAMELEN]; 5017c478bd9Sstevel@tonic-gate int argc = 0, argr = 0; 5027c478bd9Sstevel@tonic-gate 5037c478bd9Sstevel@tonic-gate for (anp = dnp->dn_args; anp != NULL; anp = anp->dn_list) 5047c478bd9Sstevel@tonic-gate argc++; /* count up arguments for error messages below */ 5057c478bd9Sstevel@tonic-gate 5067c478bd9Sstevel@tonic-gate switch (dnp->dn_args->dn_kind) { 5077c478bd9Sstevel@tonic-gate case DT_NODE_STRING: 5087c478bd9Sstevel@tonic-gate format = dnp->dn_args->dn_string; 5097c478bd9Sstevel@tonic-gate anp = dnp->dn_args->dn_list; 5107c478bd9Sstevel@tonic-gate argr = 2; 5117c478bd9Sstevel@tonic-gate break; 5127c478bd9Sstevel@tonic-gate case DT_NODE_AGG: 5137c478bd9Sstevel@tonic-gate format = NULL; 5147c478bd9Sstevel@tonic-gate anp = dnp->dn_args; 5157c478bd9Sstevel@tonic-gate argr = 1; 5167c478bd9Sstevel@tonic-gate break; 5177c478bd9Sstevel@tonic-gate default: 5187c478bd9Sstevel@tonic-gate format = NULL; 5197c478bd9Sstevel@tonic-gate anp = dnp->dn_args; 5207c478bd9Sstevel@tonic-gate argr = 1; 5217c478bd9Sstevel@tonic-gate } 5227c478bd9Sstevel@tonic-gate 5237c478bd9Sstevel@tonic-gate if (argc != argr) { 5247c478bd9Sstevel@tonic-gate dnerror(dnp, D_PRINTA_PROTO, 5257c478bd9Sstevel@tonic-gate "%s( ) prototype mismatch: %d args passed, %d expected\n", 5267c478bd9Sstevel@tonic-gate dnp->dn_ident->di_name, argc, argr); 5277c478bd9Sstevel@tonic-gate } 5287c478bd9Sstevel@tonic-gate 5297c478bd9Sstevel@tonic-gate if (anp->dn_kind != DT_NODE_AGG) { 5307c478bd9Sstevel@tonic-gate dnerror(dnp, D_PRINTA_AGGARG, 5317c478bd9Sstevel@tonic-gate "%s( ) argument #%d is incompatible with prototype:\n" 5327c478bd9Sstevel@tonic-gate "\tprototype: aggregation\n\t argument: %s\n", 5337c478bd9Sstevel@tonic-gate dnp->dn_ident->di_name, argr, 5347c478bd9Sstevel@tonic-gate dt_node_type_name(anp, n, sizeof (n))); 5357c478bd9Sstevel@tonic-gate } 5367c478bd9Sstevel@tonic-gate 5377c478bd9Sstevel@tonic-gate aid = anp->dn_ident; 5387c478bd9Sstevel@tonic-gate fid = aid->di_iarg; 5397c478bd9Sstevel@tonic-gate 5407c478bd9Sstevel@tonic-gate if (aid->di_gen == dtp->dt_gen && !(aid->di_flags & DT_IDFLG_MOD)) { 5417c478bd9Sstevel@tonic-gate dnerror(dnp, D_PRINTA_AGGBAD, 5427c478bd9Sstevel@tonic-gate "undefined aggregation: @%s\n", aid->di_name); 5437c478bd9Sstevel@tonic-gate } 5447c478bd9Sstevel@tonic-gate 5457c478bd9Sstevel@tonic-gate if (format != NULL) { 5467c478bd9Sstevel@tonic-gate yylineno = dnp->dn_line; 5477c478bd9Sstevel@tonic-gate 5487c478bd9Sstevel@tonic-gate sdp->dtsd_fmtdata = dt_printf_create(yypcb->pcb_hdl, format); 5497c478bd9Sstevel@tonic-gate dt_printf_validate(sdp->dtsd_fmtdata, 5507c478bd9Sstevel@tonic-gate DT_PRINTF_AGGREGATION, dnp->dn_ident, 1, 5517c478bd9Sstevel@tonic-gate fid->di_id, ((dt_idsig_t *)aid->di_data)->dis_args); 5527c478bd9Sstevel@tonic-gate } 5537c478bd9Sstevel@tonic-gate 5547c478bd9Sstevel@tonic-gate ap = dt_stmt_action(dtp, sdp); 5557c478bd9Sstevel@tonic-gate dt_action_difconst(ap, anp->dn_ident->di_id, DTRACEACT_PRINTA); 5567c478bd9Sstevel@tonic-gate } 5577c478bd9Sstevel@tonic-gate 5587c478bd9Sstevel@tonic-gate static void 5597c478bd9Sstevel@tonic-gate dt_action_printflike(dtrace_hdl_t *dtp, dt_node_t *dnp, dtrace_stmtdesc_t *sdp, 5607c478bd9Sstevel@tonic-gate dtrace_actkind_t kind) 5617c478bd9Sstevel@tonic-gate { 5627c478bd9Sstevel@tonic-gate dt_node_t *anp, *arg1; 5637c478bd9Sstevel@tonic-gate dtrace_actdesc_t *ap = NULL; 5647c478bd9Sstevel@tonic-gate char n[DT_TYPE_NAMELEN], *str; 5657c478bd9Sstevel@tonic-gate 5667c478bd9Sstevel@tonic-gate assert(DTRACEACT_ISPRINTFLIKE(kind)); 5677c478bd9Sstevel@tonic-gate 5687c478bd9Sstevel@tonic-gate if (dnp->dn_args->dn_kind != DT_NODE_STRING) { 5697c478bd9Sstevel@tonic-gate dnerror(dnp, D_PRINTF_ARG_FMT, 5707c478bd9Sstevel@tonic-gate "%s( ) argument #1 is incompatible with prototype:\n" 5717c478bd9Sstevel@tonic-gate "\tprototype: string constant\n\t argument: %s\n", 5727c478bd9Sstevel@tonic-gate dnp->dn_ident->di_name, 5737c478bd9Sstevel@tonic-gate dt_node_type_name(dnp->dn_args, n, sizeof (n))); 5747c478bd9Sstevel@tonic-gate } 5757c478bd9Sstevel@tonic-gate 5767c478bd9Sstevel@tonic-gate arg1 = dnp->dn_args->dn_list; 5777c478bd9Sstevel@tonic-gate yylineno = dnp->dn_line; 5787c478bd9Sstevel@tonic-gate str = dnp->dn_args->dn_string; 5797c478bd9Sstevel@tonic-gate 5807c478bd9Sstevel@tonic-gate 5817c478bd9Sstevel@tonic-gate /* 5827c478bd9Sstevel@tonic-gate * If this is an freopen(), we use an empty string to denote that 5837c478bd9Sstevel@tonic-gate * stdout should be restored. For other printf()-like actions, an 5847c478bd9Sstevel@tonic-gate * empty format string is illegal: an empty format string would 5857c478bd9Sstevel@tonic-gate * result in malformed DOF, and the compiler thus flags an empty 5867c478bd9Sstevel@tonic-gate * format string as a compile-time error. To avoid propagating the 5877c478bd9Sstevel@tonic-gate * freopen() special case throughout the system, we simply transpose 5887c478bd9Sstevel@tonic-gate * an empty string into a sentinel string (DT_FREOPEN_RESTORE) that 5897c478bd9Sstevel@tonic-gate * denotes that stdout should be restored. 5907c478bd9Sstevel@tonic-gate */ 5917c478bd9Sstevel@tonic-gate if (kind == DTRACEACT_FREOPEN) { 5927c478bd9Sstevel@tonic-gate if (strcmp(str, DT_FREOPEN_RESTORE) == 0) { 5937c478bd9Sstevel@tonic-gate /* 5947c478bd9Sstevel@tonic-gate * Our sentinel is always an invalid argument to 5957c478bd9Sstevel@tonic-gate * freopen(), but if it's been manually specified, we 5967c478bd9Sstevel@tonic-gate * must fail now instead of when the freopen() is 5977c478bd9Sstevel@tonic-gate * actually evaluated. 5987c478bd9Sstevel@tonic-gate */ 5997c478bd9Sstevel@tonic-gate dnerror(dnp, D_FREOPEN_INVALID, 6007c478bd9Sstevel@tonic-gate "%s( ) argument #1 cannot be \"%s\"\n", 6017c478bd9Sstevel@tonic-gate dnp->dn_ident->di_name, DT_FREOPEN_RESTORE); 6027c478bd9Sstevel@tonic-gate } 6037c478bd9Sstevel@tonic-gate 6047c478bd9Sstevel@tonic-gate if (str[0] == '\0') 6057c478bd9Sstevel@tonic-gate str = DT_FREOPEN_RESTORE; 6067c478bd9Sstevel@tonic-gate } 6077c478bd9Sstevel@tonic-gate 6081a7c1b72Smws sdp->dtsd_fmtdata = dt_printf_create(dtp, str); 6097c478bd9Sstevel@tonic-gate 6107c478bd9Sstevel@tonic-gate dt_printf_validate(sdp->dtsd_fmtdata, DT_PRINTF_EXACTLEN, 6117c478bd9Sstevel@tonic-gate dnp->dn_ident, 1, DTRACEACT_AGGREGATION, arg1); 6127c478bd9Sstevel@tonic-gate 6137c478bd9Sstevel@tonic-gate if (arg1 == NULL) { 6147c478bd9Sstevel@tonic-gate dif_instr_t *dbuf; 6157c478bd9Sstevel@tonic-gate dtrace_difo_t *dp; 6167c478bd9Sstevel@tonic-gate 6171a7c1b72Smws if ((dbuf = dt_alloc(dtp, sizeof (dif_instr_t))) == NULL || 6181a7c1b72Smws (dp = dt_zalloc(dtp, sizeof (dtrace_difo_t))) == NULL) { 6191a7c1b72Smws dt_free(dtp, dbuf); 6207c478bd9Sstevel@tonic-gate longjmp(yypcb->pcb_jmpbuf, EDT_NOMEM); 6217c478bd9Sstevel@tonic-gate } 6227c478bd9Sstevel@tonic-gate 6237c478bd9Sstevel@tonic-gate dbuf[0] = DIF_INSTR_RET(DIF_REG_R0); /* ret %r0 */ 6247c478bd9Sstevel@tonic-gate 6257c478bd9Sstevel@tonic-gate dp->dtdo_buf = dbuf; 6267c478bd9Sstevel@tonic-gate dp->dtdo_len = 1; 6277c478bd9Sstevel@tonic-gate dp->dtdo_rtype = dt_int_rtype; 6287c478bd9Sstevel@tonic-gate 6297c478bd9Sstevel@tonic-gate ap = dt_stmt_action(dtp, sdp); 6307c478bd9Sstevel@tonic-gate ap->dtad_difo = dp; 6317c478bd9Sstevel@tonic-gate ap->dtad_kind = kind; 6327c478bd9Sstevel@tonic-gate return; 6337c478bd9Sstevel@tonic-gate } 6347c478bd9Sstevel@tonic-gate 6357c478bd9Sstevel@tonic-gate for (anp = arg1; anp != NULL; anp = anp->dn_list) { 6367c478bd9Sstevel@tonic-gate ap = dt_stmt_action(dtp, sdp); 6377c478bd9Sstevel@tonic-gate dt_cg(yypcb, anp); 6387c478bd9Sstevel@tonic-gate ap->dtad_difo = dt_as(yypcb); 6397c478bd9Sstevel@tonic-gate ap->dtad_kind = kind; 6407c478bd9Sstevel@tonic-gate } 6417c478bd9Sstevel@tonic-gate } 6427c478bd9Sstevel@tonic-gate 6437c478bd9Sstevel@tonic-gate static void 6447c478bd9Sstevel@tonic-gate dt_action_trace(dtrace_hdl_t *dtp, dt_node_t *dnp, dtrace_stmtdesc_t *sdp) 6457c478bd9Sstevel@tonic-gate { 6467c478bd9Sstevel@tonic-gate dtrace_actdesc_t *ap = dt_stmt_action(dtp, sdp); 6477c478bd9Sstevel@tonic-gate 6487c478bd9Sstevel@tonic-gate if (dt_node_is_void(dnp->dn_args)) { 6497c478bd9Sstevel@tonic-gate dnerror(dnp->dn_args, D_TRACE_VOID, 6507c478bd9Sstevel@tonic-gate "trace( ) may not be applied to a void expression\n"); 6517c478bd9Sstevel@tonic-gate } 6527c478bd9Sstevel@tonic-gate 6537c478bd9Sstevel@tonic-gate if (dt_node_is_dynamic(dnp->dn_args)) { 6547c478bd9Sstevel@tonic-gate dnerror(dnp->dn_args, D_TRACE_DYN, 6557c478bd9Sstevel@tonic-gate "trace( ) may not be applied to a dynamic expression\n"); 6567c478bd9Sstevel@tonic-gate } 6577c478bd9Sstevel@tonic-gate 6587c478bd9Sstevel@tonic-gate dt_cg(yypcb, dnp->dn_args); 6597c478bd9Sstevel@tonic-gate ap->dtad_difo = dt_as(yypcb); 6607c478bd9Sstevel@tonic-gate ap->dtad_kind = DTRACEACT_DIFEXPR; 6617c478bd9Sstevel@tonic-gate } 6627c478bd9Sstevel@tonic-gate 6637c478bd9Sstevel@tonic-gate static void 6647c478bd9Sstevel@tonic-gate dt_action_tracemem(dtrace_hdl_t *dtp, dt_node_t *dnp, dtrace_stmtdesc_t *sdp) 6657c478bd9Sstevel@tonic-gate { 6667c478bd9Sstevel@tonic-gate dtrace_actdesc_t *ap = dt_stmt_action(dtp, sdp); 6677c478bd9Sstevel@tonic-gate 6687c478bd9Sstevel@tonic-gate dt_node_t *addr = dnp->dn_args; 6697c478bd9Sstevel@tonic-gate dt_node_t *size = dnp->dn_args->dn_list; 6707c478bd9Sstevel@tonic-gate 6717c478bd9Sstevel@tonic-gate char n[DT_TYPE_NAMELEN]; 6727c478bd9Sstevel@tonic-gate 6737c478bd9Sstevel@tonic-gate if (dt_node_is_integer(addr) == 0 && dt_node_is_pointer(addr) == 0) { 6747c478bd9Sstevel@tonic-gate dnerror(addr, D_TRACEMEM_ADDR, 6757c478bd9Sstevel@tonic-gate "tracemem( ) argument #1 is incompatible with " 6767c478bd9Sstevel@tonic-gate "prototype:\n\tprototype: pointer or integer\n" 6777c478bd9Sstevel@tonic-gate "\t argument: %s\n", 6787c478bd9Sstevel@tonic-gate dt_node_type_name(addr, n, sizeof (n))); 6797c478bd9Sstevel@tonic-gate } 6807c478bd9Sstevel@tonic-gate 6817c478bd9Sstevel@tonic-gate if (dt_node_is_posconst(size) == 0) { 6827c478bd9Sstevel@tonic-gate dnerror(size, D_TRACEMEM_SIZE, "tracemem( ) argument #2 must " 6837c478bd9Sstevel@tonic-gate "be a non-zero positive integral constant expression\n"); 6847c478bd9Sstevel@tonic-gate } 6857c478bd9Sstevel@tonic-gate 6867c478bd9Sstevel@tonic-gate dt_cg(yypcb, addr); 6877c478bd9Sstevel@tonic-gate ap->dtad_difo = dt_as(yypcb); 6887c478bd9Sstevel@tonic-gate ap->dtad_kind = DTRACEACT_DIFEXPR; 6897c478bd9Sstevel@tonic-gate 6907c478bd9Sstevel@tonic-gate ap->dtad_difo->dtdo_rtype.dtdt_flags |= DIF_TF_BYREF; 6917c478bd9Sstevel@tonic-gate ap->dtad_difo->dtdo_rtype.dtdt_size = size->dn_value; 6927c478bd9Sstevel@tonic-gate } 6937c478bd9Sstevel@tonic-gate 6947c478bd9Sstevel@tonic-gate static void 6957c478bd9Sstevel@tonic-gate dt_action_stack_args(dtrace_hdl_t *dtp, dtrace_actdesc_t *ap, dt_node_t *arg0) 6967c478bd9Sstevel@tonic-gate { 6977c478bd9Sstevel@tonic-gate ap->dtad_kind = DTRACEACT_STACK; 6987c478bd9Sstevel@tonic-gate 6997c478bd9Sstevel@tonic-gate if (dtp->dt_options[DTRACEOPT_STACKFRAMES] != DTRACEOPT_UNSET) { 7007c478bd9Sstevel@tonic-gate ap->dtad_arg = dtp->dt_options[DTRACEOPT_STACKFRAMES]; 7017c478bd9Sstevel@tonic-gate } else { 7027c478bd9Sstevel@tonic-gate ap->dtad_arg = 0; 7037c478bd9Sstevel@tonic-gate } 7047c478bd9Sstevel@tonic-gate 7057c478bd9Sstevel@tonic-gate if (arg0 != NULL) { 7067c478bd9Sstevel@tonic-gate if (arg0->dn_list != NULL) { 7077c478bd9Sstevel@tonic-gate dnerror(arg0, D_STACK_PROTO, "stack( ) prototype " 7087c478bd9Sstevel@tonic-gate "mismatch: too many arguments\n"); 7097c478bd9Sstevel@tonic-gate } 7107c478bd9Sstevel@tonic-gate 7117c478bd9Sstevel@tonic-gate if (dt_node_is_posconst(arg0) == 0) { 7127c478bd9Sstevel@tonic-gate dnerror(arg0, D_STACK_SIZE, "stack( ) size must be a " 7137c478bd9Sstevel@tonic-gate "non-zero positive integral constant expression\n"); 7147c478bd9Sstevel@tonic-gate } 7157c478bd9Sstevel@tonic-gate 7167c478bd9Sstevel@tonic-gate ap->dtad_arg = arg0->dn_value; 7177c478bd9Sstevel@tonic-gate } 7187c478bd9Sstevel@tonic-gate } 7197c478bd9Sstevel@tonic-gate 7207c478bd9Sstevel@tonic-gate static void 7217c478bd9Sstevel@tonic-gate dt_action_stack(dtrace_hdl_t *dtp, dt_node_t *dnp, dtrace_stmtdesc_t *sdp) 7227c478bd9Sstevel@tonic-gate { 7237c478bd9Sstevel@tonic-gate dtrace_actdesc_t *ap = dt_stmt_action(dtp, sdp); 7247c478bd9Sstevel@tonic-gate dt_action_stack_args(dtp, ap, dnp->dn_args); 7257c478bd9Sstevel@tonic-gate } 7267c478bd9Sstevel@tonic-gate 7277c478bd9Sstevel@tonic-gate static void 7287c478bd9Sstevel@tonic-gate dt_action_ustack_args(dtrace_hdl_t *dtp, dtrace_actdesc_t *ap, dt_node_t *dnp) 7297c478bd9Sstevel@tonic-gate { 7307c478bd9Sstevel@tonic-gate uint32_t nframes = 0; 7317c478bd9Sstevel@tonic-gate uint32_t strsize = 0; /* default string table size */ 7327c478bd9Sstevel@tonic-gate dt_node_t *arg0 = dnp->dn_args; 7337c478bd9Sstevel@tonic-gate dt_node_t *arg1 = arg0 != NULL ? arg0->dn_list : NULL; 7347c478bd9Sstevel@tonic-gate 7357c478bd9Sstevel@tonic-gate assert(dnp->dn_ident->di_id == DT_ACT_JSTACK || 7367c478bd9Sstevel@tonic-gate dnp->dn_ident->di_id == DT_ACT_USTACK); 7377c478bd9Sstevel@tonic-gate 7387c478bd9Sstevel@tonic-gate if (dnp->dn_ident->di_id == DT_ACT_JSTACK) { 7397c478bd9Sstevel@tonic-gate if (dtp->dt_options[DTRACEOPT_JSTACKFRAMES] != DTRACEOPT_UNSET) 7407c478bd9Sstevel@tonic-gate nframes = dtp->dt_options[DTRACEOPT_JSTACKFRAMES]; 7417c478bd9Sstevel@tonic-gate 7427c478bd9Sstevel@tonic-gate if (dtp->dt_options[DTRACEOPT_JSTACKSTRSIZE] != DTRACEOPT_UNSET) 7437c478bd9Sstevel@tonic-gate strsize = dtp->dt_options[DTRACEOPT_JSTACKSTRSIZE]; 7447c478bd9Sstevel@tonic-gate 7457c478bd9Sstevel@tonic-gate ap->dtad_kind = DTRACEACT_JSTACK; 7467c478bd9Sstevel@tonic-gate } else { 7477c478bd9Sstevel@tonic-gate assert(dnp->dn_ident->di_id == DT_ACT_USTACK); 7487c478bd9Sstevel@tonic-gate 7497c478bd9Sstevel@tonic-gate if (dtp->dt_options[DTRACEOPT_USTACKFRAMES] != DTRACEOPT_UNSET) 7507c478bd9Sstevel@tonic-gate nframes = dtp->dt_options[DTRACEOPT_USTACKFRAMES]; 7517c478bd9Sstevel@tonic-gate 7527c478bd9Sstevel@tonic-gate ap->dtad_kind = DTRACEACT_USTACK; 7537c478bd9Sstevel@tonic-gate } 7547c478bd9Sstevel@tonic-gate 7557c478bd9Sstevel@tonic-gate if (arg0 != NULL) { 7567c478bd9Sstevel@tonic-gate if (!dt_node_is_posconst(arg0)) { 7577c478bd9Sstevel@tonic-gate dnerror(arg0, D_USTACK_FRAMES, "ustack( ) argument #1 " 7587c478bd9Sstevel@tonic-gate "must be a non-zero positive integer constant\n"); 7597c478bd9Sstevel@tonic-gate } 7607c478bd9Sstevel@tonic-gate nframes = (uint32_t)arg0->dn_value; 7617c478bd9Sstevel@tonic-gate } 7627c478bd9Sstevel@tonic-gate 7637c478bd9Sstevel@tonic-gate if (arg1 != NULL) { 7647c478bd9Sstevel@tonic-gate if (arg1->dn_kind != DT_NODE_INT || 7657c478bd9Sstevel@tonic-gate ((arg1->dn_flags & DT_NF_SIGNED) && 7667c478bd9Sstevel@tonic-gate (int64_t)arg1->dn_value < 0)) { 7677c478bd9Sstevel@tonic-gate dnerror(arg1, D_USTACK_STRSIZE, "ustack( ) argument #2 " 7687c478bd9Sstevel@tonic-gate "must be a positive integer constant\n"); 7697c478bd9Sstevel@tonic-gate } 7707c478bd9Sstevel@tonic-gate 7717c478bd9Sstevel@tonic-gate if (arg1->dn_list != NULL) { 7727c478bd9Sstevel@tonic-gate dnerror(arg1, D_USTACK_PROTO, "ustack( ) prototype " 7737c478bd9Sstevel@tonic-gate "mismatch: too many arguments\n"); 7747c478bd9Sstevel@tonic-gate } 7757c478bd9Sstevel@tonic-gate 7767c478bd9Sstevel@tonic-gate strsize = (uint32_t)arg1->dn_value; 7777c478bd9Sstevel@tonic-gate } 7787c478bd9Sstevel@tonic-gate 7797c478bd9Sstevel@tonic-gate ap->dtad_arg = DTRACE_USTACK_ARG(nframes, strsize); 7807c478bd9Sstevel@tonic-gate } 7817c478bd9Sstevel@tonic-gate 7827c478bd9Sstevel@tonic-gate static void 7837c478bd9Sstevel@tonic-gate dt_action_ustack(dtrace_hdl_t *dtp, dt_node_t *dnp, dtrace_stmtdesc_t *sdp) 7847c478bd9Sstevel@tonic-gate { 7857c478bd9Sstevel@tonic-gate dtrace_actdesc_t *ap = dt_stmt_action(dtp, sdp); 7867c478bd9Sstevel@tonic-gate dt_action_ustack_args(dtp, ap, dnp); 7877c478bd9Sstevel@tonic-gate } 7887c478bd9Sstevel@tonic-gate 789*a1b5e537Sbmc static void 790*a1b5e537Sbmc dt_action_setopt(dtrace_hdl_t *dtp, dt_node_t *dnp, dtrace_stmtdesc_t *sdp) 791*a1b5e537Sbmc { 792*a1b5e537Sbmc dtrace_actdesc_t *ap; 793*a1b5e537Sbmc dt_node_t *arg0, *arg1; 794*a1b5e537Sbmc 795*a1b5e537Sbmc /* 796*a1b5e537Sbmc * The prototype guarantees that we are called with either one or 797*a1b5e537Sbmc * two arguments, and that any arguments that are present are strings. 798*a1b5e537Sbmc */ 799*a1b5e537Sbmc arg0 = dnp->dn_args; 800*a1b5e537Sbmc arg1 = arg0->dn_list; 801*a1b5e537Sbmc 802*a1b5e537Sbmc ap = dt_stmt_action(dtp, sdp); 803*a1b5e537Sbmc dt_cg(yypcb, arg0); 804*a1b5e537Sbmc ap->dtad_difo = dt_as(yypcb); 805*a1b5e537Sbmc ap->dtad_kind = DTRACEACT_LIBACT; 806*a1b5e537Sbmc ap->dtad_arg = DT_ACT_SETOPT; 807*a1b5e537Sbmc 808*a1b5e537Sbmc ap = dt_stmt_action(dtp, sdp); 809*a1b5e537Sbmc 810*a1b5e537Sbmc if (arg1 == NULL) { 811*a1b5e537Sbmc dt_action_difconst(ap, 0, DTRACEACT_LIBACT); 812*a1b5e537Sbmc } else { 813*a1b5e537Sbmc dt_cg(yypcb, arg1); 814*a1b5e537Sbmc ap->dtad_difo = dt_as(yypcb); 815*a1b5e537Sbmc ap->dtad_kind = DTRACEACT_LIBACT; 816*a1b5e537Sbmc } 817*a1b5e537Sbmc 818*a1b5e537Sbmc ap->dtad_arg = DT_ACT_SETOPT; 819*a1b5e537Sbmc } 820*a1b5e537Sbmc 821*a1b5e537Sbmc /*ARGSUSED*/ 822*a1b5e537Sbmc static void 823*a1b5e537Sbmc dt_action_symmod_args(dtrace_hdl_t *dtp, dtrace_actdesc_t *ap, 824*a1b5e537Sbmc dt_node_t *dnp, dtrace_actkind_t kind) 825*a1b5e537Sbmc { 826*a1b5e537Sbmc assert(kind == DTRACEACT_SYM || kind == DTRACEACT_MOD || 827*a1b5e537Sbmc kind == DTRACEACT_USYM || kind == DTRACEACT_UMOD || 828*a1b5e537Sbmc kind == DTRACEACT_UADDR); 829*a1b5e537Sbmc 830*a1b5e537Sbmc dt_cg(yypcb, dnp); 831*a1b5e537Sbmc ap->dtad_difo = dt_as(yypcb); 832*a1b5e537Sbmc ap->dtad_kind = kind; 833*a1b5e537Sbmc ap->dtad_difo->dtdo_rtype.dtdt_size = sizeof (uint64_t); 834*a1b5e537Sbmc } 835*a1b5e537Sbmc 836*a1b5e537Sbmc static void 837*a1b5e537Sbmc dt_action_symmod(dtrace_hdl_t *dtp, dt_node_t *dnp, dtrace_stmtdesc_t *sdp, 838*a1b5e537Sbmc dtrace_actkind_t kind) 839*a1b5e537Sbmc { 840*a1b5e537Sbmc dtrace_actdesc_t *ap = dt_stmt_action(dtp, sdp); 841*a1b5e537Sbmc dt_action_symmod_args(dtp, ap, dnp->dn_args, kind); 842*a1b5e537Sbmc } 843*a1b5e537Sbmc 8447c478bd9Sstevel@tonic-gate /*ARGSUSED*/ 8457c478bd9Sstevel@tonic-gate static void 8467c478bd9Sstevel@tonic-gate dt_action_ftruncate(dtrace_hdl_t *dtp, dt_node_t *dnp, dtrace_stmtdesc_t *sdp) 8477c478bd9Sstevel@tonic-gate { 8487c478bd9Sstevel@tonic-gate dtrace_actdesc_t *ap = dt_stmt_action(dtp, sdp); 8497c478bd9Sstevel@tonic-gate 8507c478bd9Sstevel@tonic-gate /* 8517c478bd9Sstevel@tonic-gate * Library actions need a DIFO that serves as an argument. As 8527c478bd9Sstevel@tonic-gate * ftruncate() doesn't take an argument, we generate the constant 0 8537c478bd9Sstevel@tonic-gate * in a DIFO; this constant will be ignored when the ftruncate() is 8547c478bd9Sstevel@tonic-gate * processed. 8557c478bd9Sstevel@tonic-gate */ 8567c478bd9Sstevel@tonic-gate dt_action_difconst(ap, 0, DTRACEACT_LIBACT); 8577c478bd9Sstevel@tonic-gate ap->dtad_arg = DT_ACT_FTRUNCATE; 8587c478bd9Sstevel@tonic-gate } 8597c478bd9Sstevel@tonic-gate 8607c478bd9Sstevel@tonic-gate /*ARGSUSED*/ 8617c478bd9Sstevel@tonic-gate static void 8627c478bd9Sstevel@tonic-gate dt_action_stop(dtrace_hdl_t *dtp, dt_node_t *dnp, dtrace_stmtdesc_t *sdp) 8637c478bd9Sstevel@tonic-gate { 8647c478bd9Sstevel@tonic-gate dtrace_actdesc_t *ap = dt_stmt_action(dtp, sdp); 8657c478bd9Sstevel@tonic-gate 8667c478bd9Sstevel@tonic-gate ap->dtad_kind = DTRACEACT_STOP; 8677c478bd9Sstevel@tonic-gate ap->dtad_arg = 0; 8687c478bd9Sstevel@tonic-gate } 8697c478bd9Sstevel@tonic-gate 8707c478bd9Sstevel@tonic-gate /*ARGSUSED*/ 8717c478bd9Sstevel@tonic-gate static void 8727c478bd9Sstevel@tonic-gate dt_action_breakpoint(dtrace_hdl_t *dtp, dt_node_t *dnp, dtrace_stmtdesc_t *sdp) 8737c478bd9Sstevel@tonic-gate { 8747c478bd9Sstevel@tonic-gate dtrace_actdesc_t *ap = dt_stmt_action(dtp, sdp); 8757c478bd9Sstevel@tonic-gate 8767c478bd9Sstevel@tonic-gate ap->dtad_kind = DTRACEACT_BREAKPOINT; 8777c478bd9Sstevel@tonic-gate ap->dtad_arg = 0; 8787c478bd9Sstevel@tonic-gate } 8797c478bd9Sstevel@tonic-gate 8807c478bd9Sstevel@tonic-gate /*ARGSUSED*/ 8817c478bd9Sstevel@tonic-gate static void 8827c478bd9Sstevel@tonic-gate dt_action_panic(dtrace_hdl_t *dtp, dt_node_t *dnp, dtrace_stmtdesc_t *sdp) 8837c478bd9Sstevel@tonic-gate { 8847c478bd9Sstevel@tonic-gate dtrace_actdesc_t *ap = dt_stmt_action(dtp, sdp); 8857c478bd9Sstevel@tonic-gate 8867c478bd9Sstevel@tonic-gate ap->dtad_kind = DTRACEACT_PANIC; 8877c478bd9Sstevel@tonic-gate ap->dtad_arg = 0; 8887c478bd9Sstevel@tonic-gate } 8897c478bd9Sstevel@tonic-gate 8907c478bd9Sstevel@tonic-gate static void 8917c478bd9Sstevel@tonic-gate dt_action_chill(dtrace_hdl_t *dtp, dt_node_t *dnp, dtrace_stmtdesc_t *sdp) 8927c478bd9Sstevel@tonic-gate { 8937c478bd9Sstevel@tonic-gate dtrace_actdesc_t *ap = dt_stmt_action(dtp, sdp); 8947c478bd9Sstevel@tonic-gate 8957c478bd9Sstevel@tonic-gate dt_cg(yypcb, dnp->dn_args); 8967c478bd9Sstevel@tonic-gate ap->dtad_difo = dt_as(yypcb); 8977c478bd9Sstevel@tonic-gate ap->dtad_kind = DTRACEACT_CHILL; 8987c478bd9Sstevel@tonic-gate } 8997c478bd9Sstevel@tonic-gate 9007c478bd9Sstevel@tonic-gate static void 9017c478bd9Sstevel@tonic-gate dt_action_raise(dtrace_hdl_t *dtp, dt_node_t *dnp, dtrace_stmtdesc_t *sdp) 9027c478bd9Sstevel@tonic-gate { 9037c478bd9Sstevel@tonic-gate dtrace_actdesc_t *ap = dt_stmt_action(dtp, sdp); 9047c478bd9Sstevel@tonic-gate 9057c478bd9Sstevel@tonic-gate dt_cg(yypcb, dnp->dn_args); 9067c478bd9Sstevel@tonic-gate ap->dtad_difo = dt_as(yypcb); 9077c478bd9Sstevel@tonic-gate ap->dtad_kind = DTRACEACT_RAISE; 9087c478bd9Sstevel@tonic-gate } 9097c478bd9Sstevel@tonic-gate 9107c478bd9Sstevel@tonic-gate static void 9117c478bd9Sstevel@tonic-gate dt_action_exit(dtrace_hdl_t *dtp, dt_node_t *dnp, dtrace_stmtdesc_t *sdp) 9127c478bd9Sstevel@tonic-gate { 9137c478bd9Sstevel@tonic-gate dtrace_actdesc_t *ap = dt_stmt_action(dtp, sdp); 9147c478bd9Sstevel@tonic-gate 9157c478bd9Sstevel@tonic-gate dt_cg(yypcb, dnp->dn_args); 9167c478bd9Sstevel@tonic-gate ap->dtad_difo = dt_as(yypcb); 9177c478bd9Sstevel@tonic-gate ap->dtad_kind = DTRACEACT_EXIT; 9187c478bd9Sstevel@tonic-gate ap->dtad_difo->dtdo_rtype.dtdt_size = sizeof (int); 9197c478bd9Sstevel@tonic-gate } 9207c478bd9Sstevel@tonic-gate 9217c478bd9Sstevel@tonic-gate static void 9227c478bd9Sstevel@tonic-gate dt_action_speculate(dtrace_hdl_t *dtp, dt_node_t *dnp, dtrace_stmtdesc_t *sdp) 9237c478bd9Sstevel@tonic-gate { 9247c478bd9Sstevel@tonic-gate dtrace_actdesc_t *ap = dt_stmt_action(dtp, sdp); 9257c478bd9Sstevel@tonic-gate 9267c478bd9Sstevel@tonic-gate dt_cg(yypcb, dnp->dn_args); 9277c478bd9Sstevel@tonic-gate ap->dtad_difo = dt_as(yypcb); 9287c478bd9Sstevel@tonic-gate ap->dtad_kind = DTRACEACT_SPECULATE; 9297c478bd9Sstevel@tonic-gate } 9307c478bd9Sstevel@tonic-gate 9317c478bd9Sstevel@tonic-gate static void 9327c478bd9Sstevel@tonic-gate dt_action_commit(dtrace_hdl_t *dtp, dt_node_t *dnp, dtrace_stmtdesc_t *sdp) 9337c478bd9Sstevel@tonic-gate { 9347c478bd9Sstevel@tonic-gate dtrace_actdesc_t *ap = dt_stmt_action(dtp, sdp); 9357c478bd9Sstevel@tonic-gate 9367c478bd9Sstevel@tonic-gate dt_cg(yypcb, dnp->dn_args); 9377c478bd9Sstevel@tonic-gate ap->dtad_difo = dt_as(yypcb); 9387c478bd9Sstevel@tonic-gate ap->dtad_kind = DTRACEACT_COMMIT; 9397c478bd9Sstevel@tonic-gate } 9407c478bd9Sstevel@tonic-gate 9417c478bd9Sstevel@tonic-gate static void 9427c478bd9Sstevel@tonic-gate dt_action_discard(dtrace_hdl_t *dtp, dt_node_t *dnp, dtrace_stmtdesc_t *sdp) 9437c478bd9Sstevel@tonic-gate { 9447c478bd9Sstevel@tonic-gate dtrace_actdesc_t *ap = dt_stmt_action(dtp, sdp); 9457c478bd9Sstevel@tonic-gate 9467c478bd9Sstevel@tonic-gate dt_cg(yypcb, dnp->dn_args); 9477c478bd9Sstevel@tonic-gate ap->dtad_difo = dt_as(yypcb); 9487c478bd9Sstevel@tonic-gate ap->dtad_kind = DTRACEACT_DISCARD; 9497c478bd9Sstevel@tonic-gate } 9507c478bd9Sstevel@tonic-gate 9517c478bd9Sstevel@tonic-gate static void 9527c478bd9Sstevel@tonic-gate dt_compile_fun(dtrace_hdl_t *dtp, dt_node_t *dnp, dtrace_stmtdesc_t *sdp) 9537c478bd9Sstevel@tonic-gate { 9547c478bd9Sstevel@tonic-gate switch (dnp->dn_expr->dn_ident->di_id) { 9557c478bd9Sstevel@tonic-gate case DT_ACT_BREAKPOINT: 9567c478bd9Sstevel@tonic-gate dt_action_breakpoint(dtp, dnp->dn_expr, sdp); 9577c478bd9Sstevel@tonic-gate break; 9587c478bd9Sstevel@tonic-gate case DT_ACT_CHILL: 9597c478bd9Sstevel@tonic-gate dt_action_chill(dtp, dnp->dn_expr, sdp); 9607c478bd9Sstevel@tonic-gate break; 9617c478bd9Sstevel@tonic-gate case DT_ACT_CLEAR: 9627c478bd9Sstevel@tonic-gate dt_action_clear(dtp, dnp->dn_expr, sdp); 9637c478bd9Sstevel@tonic-gate break; 9647c478bd9Sstevel@tonic-gate case DT_ACT_COMMIT: 9657c478bd9Sstevel@tonic-gate dt_action_commit(dtp, dnp->dn_expr, sdp); 9667c478bd9Sstevel@tonic-gate break; 9677c478bd9Sstevel@tonic-gate case DT_ACT_DENORMALIZE: 9687c478bd9Sstevel@tonic-gate dt_action_normalize(dtp, dnp->dn_expr, sdp); 9697c478bd9Sstevel@tonic-gate break; 9707c478bd9Sstevel@tonic-gate case DT_ACT_DISCARD: 9717c478bd9Sstevel@tonic-gate dt_action_discard(dtp, dnp->dn_expr, sdp); 9727c478bd9Sstevel@tonic-gate break; 9737c478bd9Sstevel@tonic-gate case DT_ACT_EXIT: 9747c478bd9Sstevel@tonic-gate dt_action_exit(dtp, dnp->dn_expr, sdp); 9757c478bd9Sstevel@tonic-gate break; 9767c478bd9Sstevel@tonic-gate case DT_ACT_FREOPEN: 9777c478bd9Sstevel@tonic-gate dt_action_printflike(dtp, dnp->dn_expr, sdp, DTRACEACT_FREOPEN); 9787c478bd9Sstevel@tonic-gate break; 9797c478bd9Sstevel@tonic-gate case DT_ACT_FTRUNCATE: 9807c478bd9Sstevel@tonic-gate dt_action_ftruncate(dtp, dnp->dn_expr, sdp); 9817c478bd9Sstevel@tonic-gate break; 982*a1b5e537Sbmc case DT_ACT_MOD: 983*a1b5e537Sbmc dt_action_symmod(dtp, dnp->dn_expr, sdp, DTRACEACT_MOD); 984*a1b5e537Sbmc break; 9857c478bd9Sstevel@tonic-gate case DT_ACT_NORMALIZE: 9867c478bd9Sstevel@tonic-gate dt_action_normalize(dtp, dnp->dn_expr, sdp); 9877c478bd9Sstevel@tonic-gate break; 9887c478bd9Sstevel@tonic-gate case DT_ACT_PANIC: 9897c478bd9Sstevel@tonic-gate dt_action_panic(dtp, dnp->dn_expr, sdp); 9907c478bd9Sstevel@tonic-gate break; 9917c478bd9Sstevel@tonic-gate case DT_ACT_PRINTA: 9927c478bd9Sstevel@tonic-gate dt_action_printa(dtp, dnp->dn_expr, sdp); 9937c478bd9Sstevel@tonic-gate break; 9947c478bd9Sstevel@tonic-gate case DT_ACT_PRINTF: 9957c478bd9Sstevel@tonic-gate dt_action_printflike(dtp, dnp->dn_expr, sdp, DTRACEACT_PRINTF); 9967c478bd9Sstevel@tonic-gate break; 9977c478bd9Sstevel@tonic-gate case DT_ACT_RAISE: 9987c478bd9Sstevel@tonic-gate dt_action_raise(dtp, dnp->dn_expr, sdp); 9997c478bd9Sstevel@tonic-gate break; 1000*a1b5e537Sbmc case DT_ACT_SETOPT: 1001*a1b5e537Sbmc dt_action_setopt(dtp, dnp->dn_expr, sdp); 1002*a1b5e537Sbmc break; 10037c478bd9Sstevel@tonic-gate case DT_ACT_SPECULATE: 10047c478bd9Sstevel@tonic-gate dt_action_speculate(dtp, dnp->dn_expr, sdp); 10057c478bd9Sstevel@tonic-gate break; 10067c478bd9Sstevel@tonic-gate case DT_ACT_STACK: 10077c478bd9Sstevel@tonic-gate dt_action_stack(dtp, dnp->dn_expr, sdp); 10087c478bd9Sstevel@tonic-gate break; 10097c478bd9Sstevel@tonic-gate case DT_ACT_STOP: 10107c478bd9Sstevel@tonic-gate dt_action_stop(dtp, dnp->dn_expr, sdp); 10117c478bd9Sstevel@tonic-gate break; 1012*a1b5e537Sbmc case DT_ACT_SYM: 1013*a1b5e537Sbmc dt_action_symmod(dtp, dnp->dn_expr, sdp, DTRACEACT_SYM); 1014*a1b5e537Sbmc break; 10157c478bd9Sstevel@tonic-gate case DT_ACT_SYSTEM: 10167c478bd9Sstevel@tonic-gate dt_action_printflike(dtp, dnp->dn_expr, sdp, DTRACEACT_SYSTEM); 10177c478bd9Sstevel@tonic-gate break; 10187c478bd9Sstevel@tonic-gate case DT_ACT_TRACE: 10197c478bd9Sstevel@tonic-gate dt_action_trace(dtp, dnp->dn_expr, sdp); 10207c478bd9Sstevel@tonic-gate break; 10217c478bd9Sstevel@tonic-gate case DT_ACT_TRACEMEM: 10227c478bd9Sstevel@tonic-gate dt_action_tracemem(dtp, dnp->dn_expr, sdp); 10237c478bd9Sstevel@tonic-gate break; 10247c478bd9Sstevel@tonic-gate case DT_ACT_TRUNC: 10257c478bd9Sstevel@tonic-gate dt_action_trunc(dtp, dnp->dn_expr, sdp); 10267c478bd9Sstevel@tonic-gate break; 1027*a1b5e537Sbmc case DT_ACT_UADDR: 1028*a1b5e537Sbmc dt_action_symmod(dtp, dnp->dn_expr, sdp, DTRACEACT_UADDR); 1029*a1b5e537Sbmc break; 1030*a1b5e537Sbmc case DT_ACT_UMOD: 1031*a1b5e537Sbmc dt_action_symmod(dtp, dnp->dn_expr, sdp, DTRACEACT_UMOD); 1032*a1b5e537Sbmc break; 1033*a1b5e537Sbmc case DT_ACT_USYM: 1034*a1b5e537Sbmc dt_action_symmod(dtp, dnp->dn_expr, sdp, DTRACEACT_USYM); 1035*a1b5e537Sbmc break; 10367c478bd9Sstevel@tonic-gate case DT_ACT_USTACK: 10377c478bd9Sstevel@tonic-gate case DT_ACT_JSTACK: 10387c478bd9Sstevel@tonic-gate dt_action_ustack(dtp, dnp->dn_expr, sdp); 10397c478bd9Sstevel@tonic-gate break; 10407c478bd9Sstevel@tonic-gate default: 10417c478bd9Sstevel@tonic-gate dnerror(dnp->dn_expr, D_UNKNOWN, "tracing function %s( ) is " 10427c478bd9Sstevel@tonic-gate "not yet supported\n", dnp->dn_expr->dn_ident->di_name); 10437c478bd9Sstevel@tonic-gate } 10447c478bd9Sstevel@tonic-gate } 10457c478bd9Sstevel@tonic-gate 10467c478bd9Sstevel@tonic-gate static void 10477c478bd9Sstevel@tonic-gate dt_compile_exp(dtrace_hdl_t *dtp, dt_node_t *dnp, dtrace_stmtdesc_t *sdp) 10487c478bd9Sstevel@tonic-gate { 10497c478bd9Sstevel@tonic-gate dtrace_actdesc_t *ap = dt_stmt_action(dtp, sdp); 10507c478bd9Sstevel@tonic-gate 10517c478bd9Sstevel@tonic-gate dt_cg(yypcb, dnp->dn_expr); 10527c478bd9Sstevel@tonic-gate ap->dtad_difo = dt_as(yypcb); 10537c478bd9Sstevel@tonic-gate ap->dtad_difo->dtdo_rtype = dt_void_rtype; 10547c478bd9Sstevel@tonic-gate ap->dtad_kind = DTRACEACT_DIFEXPR; 10557c478bd9Sstevel@tonic-gate } 10567c478bd9Sstevel@tonic-gate 10577c478bd9Sstevel@tonic-gate static void 10587c478bd9Sstevel@tonic-gate dt_compile_agg(dtrace_hdl_t *dtp, dt_node_t *dnp, dtrace_stmtdesc_t *sdp) 10597c478bd9Sstevel@tonic-gate { 10607c478bd9Sstevel@tonic-gate dt_ident_t *aid, *fid; 1061*a1b5e537Sbmc dt_node_t *anp, *incr = NULL; 10627c478bd9Sstevel@tonic-gate dtrace_actdesc_t *ap; 1063*a1b5e537Sbmc uint_t n = 1, argmax; 1064*a1b5e537Sbmc uint64_t arg = 0; 10657c478bd9Sstevel@tonic-gate 10667c478bd9Sstevel@tonic-gate /* 10677c478bd9Sstevel@tonic-gate * If the aggregation has no aggregating function applied to it, then 10687c478bd9Sstevel@tonic-gate * this statement has no effect. Flag this as a programming error. 10697c478bd9Sstevel@tonic-gate */ 10707c478bd9Sstevel@tonic-gate if (dnp->dn_aggfun == NULL) { 10717c478bd9Sstevel@tonic-gate dnerror(dnp, D_AGG_NULL, "expression has null effect: @%s\n", 10727c478bd9Sstevel@tonic-gate dnp->dn_ident->di_name); 10737c478bd9Sstevel@tonic-gate } 10747c478bd9Sstevel@tonic-gate 10757c478bd9Sstevel@tonic-gate aid = dnp->dn_ident; 10767c478bd9Sstevel@tonic-gate fid = dnp->dn_aggfun->dn_ident; 10777c478bd9Sstevel@tonic-gate 10787c478bd9Sstevel@tonic-gate if (dnp->dn_aggfun->dn_args != NULL && 10797c478bd9Sstevel@tonic-gate dt_node_is_scalar(dnp->dn_aggfun->dn_args) == 0) { 10807c478bd9Sstevel@tonic-gate dnerror(dnp->dn_aggfun, D_AGG_SCALAR, "%s( ) argument #1 must " 10817c478bd9Sstevel@tonic-gate "be of scalar type\n", fid->di_name); 10827c478bd9Sstevel@tonic-gate } 10837c478bd9Sstevel@tonic-gate 10847c478bd9Sstevel@tonic-gate /* 10857c478bd9Sstevel@tonic-gate * The ID of the aggregation itself is implicitly recorded as the first 10867c478bd9Sstevel@tonic-gate * member of each aggregation tuple so we can distinguish them later. 10877c478bd9Sstevel@tonic-gate */ 10887c478bd9Sstevel@tonic-gate ap = dt_stmt_action(dtp, sdp); 10897c478bd9Sstevel@tonic-gate dt_action_difconst(ap, aid->di_id, DTRACEACT_DIFEXPR); 10907c478bd9Sstevel@tonic-gate 10917c478bd9Sstevel@tonic-gate for (anp = dnp->dn_aggtup; anp != NULL; anp = anp->dn_list) { 10927c478bd9Sstevel@tonic-gate ap = dt_stmt_action(dtp, sdp); 10937c478bd9Sstevel@tonic-gate n++; 10947c478bd9Sstevel@tonic-gate 10957c478bd9Sstevel@tonic-gate if (anp->dn_kind == DT_NODE_FUNC) { 10967c478bd9Sstevel@tonic-gate if (anp->dn_ident->di_id == DT_ACT_STACK) { 10977c478bd9Sstevel@tonic-gate dt_action_stack_args(dtp, ap, anp->dn_args); 10987c478bd9Sstevel@tonic-gate continue; 10997c478bd9Sstevel@tonic-gate } 11007c478bd9Sstevel@tonic-gate 11017c478bd9Sstevel@tonic-gate if (anp->dn_ident->di_id == DT_ACT_USTACK || 11027c478bd9Sstevel@tonic-gate anp->dn_ident->di_id == DT_ACT_JSTACK) { 11037c478bd9Sstevel@tonic-gate dt_action_ustack_args(dtp, ap, anp); 11047c478bd9Sstevel@tonic-gate continue; 11057c478bd9Sstevel@tonic-gate } 11067c478bd9Sstevel@tonic-gate 1107*a1b5e537Sbmc switch (anp->dn_ident->di_id) { 1108*a1b5e537Sbmc case DT_ACT_UADDR: 1109*a1b5e537Sbmc dt_action_symmod_args(dtp, ap, 1110*a1b5e537Sbmc anp->dn_args, DTRACEACT_UADDR); 1111*a1b5e537Sbmc continue; 11127c478bd9Sstevel@tonic-gate 1113*a1b5e537Sbmc case DT_ACT_USYM: 1114*a1b5e537Sbmc dt_action_symmod_args(dtp, ap, 1115*a1b5e537Sbmc anp->dn_args, DTRACEACT_USYM); 1116*a1b5e537Sbmc continue; 11177c478bd9Sstevel@tonic-gate 1118*a1b5e537Sbmc case DT_ACT_UMOD: 1119*a1b5e537Sbmc dt_action_symmod_args(dtp, ap, 1120*a1b5e537Sbmc anp->dn_args, DTRACEACT_UMOD); 1121*a1b5e537Sbmc continue; 11227c478bd9Sstevel@tonic-gate 1123*a1b5e537Sbmc case DT_ACT_SYM: 1124*a1b5e537Sbmc dt_action_symmod_args(dtp, ap, 1125*a1b5e537Sbmc anp->dn_args, DTRACEACT_SYM); 1126*a1b5e537Sbmc continue; 1127*a1b5e537Sbmc 1128*a1b5e537Sbmc case DT_ACT_MOD: 1129*a1b5e537Sbmc dt_action_symmod_args(dtp, ap, 1130*a1b5e537Sbmc anp->dn_args, DTRACEACT_MOD); 1131*a1b5e537Sbmc continue; 1132*a1b5e537Sbmc 1133*a1b5e537Sbmc default: 1134*a1b5e537Sbmc break; 1135*a1b5e537Sbmc } 1136*a1b5e537Sbmc } 1137*a1b5e537Sbmc 1138*a1b5e537Sbmc dt_cg(yypcb, anp); 11397c478bd9Sstevel@tonic-gate ap->dtad_difo = dt_as(yypcb); 1140*a1b5e537Sbmc ap->dtad_kind = DTRACEACT_DIFEXPR; 11417c478bd9Sstevel@tonic-gate } 11427c478bd9Sstevel@tonic-gate 11437c478bd9Sstevel@tonic-gate if (fid->di_id == DTRACEAGG_LQUANTIZE) { 11447c478bd9Sstevel@tonic-gate /* 1145*a1b5e537Sbmc * For linear quantization, we have between two and four 1146*a1b5e537Sbmc * arguments in addition to the expression: 11477c478bd9Sstevel@tonic-gate * 11487c478bd9Sstevel@tonic-gate * arg1 => Base value 11497c478bd9Sstevel@tonic-gate * arg2 => Limit value 11507c478bd9Sstevel@tonic-gate * arg3 => Quantization level step size (defaults to 1) 1151*a1b5e537Sbmc * arg4 => Quantization increment value (defaults to 1) 11527c478bd9Sstevel@tonic-gate */ 11537c478bd9Sstevel@tonic-gate dt_node_t *arg1 = dnp->dn_aggfun->dn_args->dn_list; 11547c478bd9Sstevel@tonic-gate dt_node_t *arg2 = arg1->dn_list; 11557c478bd9Sstevel@tonic-gate dt_node_t *arg3 = arg2->dn_list; 11567c478bd9Sstevel@tonic-gate uint64_t nlevels, step = 1; 11577c478bd9Sstevel@tonic-gate int64_t baseval, limitval; 11587c478bd9Sstevel@tonic-gate 11597c478bd9Sstevel@tonic-gate if (arg1->dn_kind != DT_NODE_INT) { 11607c478bd9Sstevel@tonic-gate dnerror(arg1, D_LQUANT_BASETYPE, "lquantize( ) " 11617c478bd9Sstevel@tonic-gate "argument #1 must be an integer constant\n"); 11627c478bd9Sstevel@tonic-gate } 11637c478bd9Sstevel@tonic-gate 11647c478bd9Sstevel@tonic-gate baseval = (int64_t)arg1->dn_value; 11657c478bd9Sstevel@tonic-gate 11667c478bd9Sstevel@tonic-gate if (baseval < INT32_MIN || baseval > INT32_MAX) { 11677c478bd9Sstevel@tonic-gate dnerror(arg1, D_LQUANT_BASEVAL, "lquantize( ) " 11687c478bd9Sstevel@tonic-gate "argument #1 must be a 32-bit quantity\n"); 11697c478bd9Sstevel@tonic-gate } 11707c478bd9Sstevel@tonic-gate 11717c478bd9Sstevel@tonic-gate if (arg2->dn_kind != DT_NODE_INT) { 11727c478bd9Sstevel@tonic-gate dnerror(arg2, D_LQUANT_LIMTYPE, "lquantize( ) " 11737c478bd9Sstevel@tonic-gate "argument #2 must be an integer constant\n"); 11747c478bd9Sstevel@tonic-gate } 11757c478bd9Sstevel@tonic-gate 11767c478bd9Sstevel@tonic-gate limitval = (int64_t)arg2->dn_value; 11777c478bd9Sstevel@tonic-gate 11787c478bd9Sstevel@tonic-gate if (limitval < INT32_MIN || limitval > INT32_MAX) { 11797c478bd9Sstevel@tonic-gate dnerror(arg2, D_LQUANT_LIMVAL, "lquantize( ) " 11807c478bd9Sstevel@tonic-gate "argument #2 must be a 32-bit quantity\n"); 11817c478bd9Sstevel@tonic-gate } 11827c478bd9Sstevel@tonic-gate 11837c478bd9Sstevel@tonic-gate if (limitval < baseval) { 11847c478bd9Sstevel@tonic-gate dnerror(dnp, D_LQUANT_MISMATCH, 11857c478bd9Sstevel@tonic-gate "lquantize( ) base (argument #1) must be less " 11867c478bd9Sstevel@tonic-gate "than limit (argument #2)\n"); 11877c478bd9Sstevel@tonic-gate } 11887c478bd9Sstevel@tonic-gate 11897c478bd9Sstevel@tonic-gate if (arg3 != NULL) { 11907c478bd9Sstevel@tonic-gate if (!dt_node_is_posconst(arg3)) { 11917c478bd9Sstevel@tonic-gate dnerror(arg3, D_LQUANT_STEPTYPE, "lquantize( ) " 11927c478bd9Sstevel@tonic-gate "argument #3 must be a non-zero positive " 11937c478bd9Sstevel@tonic-gate "integer constant\n"); 11947c478bd9Sstevel@tonic-gate } 11957c478bd9Sstevel@tonic-gate 11967c478bd9Sstevel@tonic-gate if ((step = arg3->dn_value) > UINT16_MAX) { 11977c478bd9Sstevel@tonic-gate dnerror(arg3, D_LQUANT_STEPVAL, "lquantize( ) " 11987c478bd9Sstevel@tonic-gate "argument #3 must be a 16-bit quantity\n"); 11997c478bd9Sstevel@tonic-gate } 12007c478bd9Sstevel@tonic-gate } 12017c478bd9Sstevel@tonic-gate 12027c478bd9Sstevel@tonic-gate nlevels = (limitval - baseval) / step; 12037c478bd9Sstevel@tonic-gate 12047c478bd9Sstevel@tonic-gate if (nlevels == 0) { 12057c478bd9Sstevel@tonic-gate dnerror(dnp, D_LQUANT_STEPLARGE, 12067c478bd9Sstevel@tonic-gate "lquantize( ) step (argument #3) too large: must " 12077c478bd9Sstevel@tonic-gate "have at least one quantization level\n"); 12087c478bd9Sstevel@tonic-gate } 12097c478bd9Sstevel@tonic-gate 12107c478bd9Sstevel@tonic-gate if (nlevels > UINT16_MAX) { 12117c478bd9Sstevel@tonic-gate dnerror(dnp, D_LQUANT_STEPSMALL, "lquantize( ) step " 12127c478bd9Sstevel@tonic-gate "(argument #3) too small: number of quantization " 12137c478bd9Sstevel@tonic-gate "levels must be a 16-bit quantity\n"); 12147c478bd9Sstevel@tonic-gate } 12157c478bd9Sstevel@tonic-gate 1216*a1b5e537Sbmc arg = (step << DTRACE_LQUANTIZE_STEPSHIFT) | 12177c478bd9Sstevel@tonic-gate (nlevels << DTRACE_LQUANTIZE_LEVELSHIFT) | 12187c478bd9Sstevel@tonic-gate ((baseval << DTRACE_LQUANTIZE_BASESHIFT) & 12197c478bd9Sstevel@tonic-gate DTRACE_LQUANTIZE_BASEMASK); 1220*a1b5e537Sbmc 1221*a1b5e537Sbmc incr = arg3 != NULL ? arg3->dn_list : NULL; 1222*a1b5e537Sbmc argmax = 5; 1223*a1b5e537Sbmc } 1224*a1b5e537Sbmc 1225*a1b5e537Sbmc if (fid->di_id == DTRACEAGG_QUANTIZE) { 1226*a1b5e537Sbmc incr = dnp->dn_aggfun->dn_args->dn_list; 1227*a1b5e537Sbmc argmax = 2; 1228*a1b5e537Sbmc } 1229*a1b5e537Sbmc 1230*a1b5e537Sbmc if (incr != NULL) { 1231*a1b5e537Sbmc if (!dt_node_is_scalar(incr)) { 1232*a1b5e537Sbmc dnerror(dnp, D_PROTO_ARG, "%s( ) increment value " 1233*a1b5e537Sbmc "(argument #%d) must be of scalar type\n", 1234*a1b5e537Sbmc fid->di_name, argmax); 1235*a1b5e537Sbmc } 1236*a1b5e537Sbmc 1237*a1b5e537Sbmc if ((anp = incr->dn_list) != NULL) { 1238*a1b5e537Sbmc int argc = argmax; 1239*a1b5e537Sbmc 1240*a1b5e537Sbmc for (; anp != NULL; anp = anp->dn_list) 1241*a1b5e537Sbmc argc++; 1242*a1b5e537Sbmc 1243*a1b5e537Sbmc dnerror(incr, D_PROTO_LEN, "%s( ) prototype " 1244*a1b5e537Sbmc "mismatch: %d args passed, at most %d expected", 1245*a1b5e537Sbmc fid->di_name, argc, argmax); 1246*a1b5e537Sbmc } 1247*a1b5e537Sbmc 1248*a1b5e537Sbmc ap = dt_stmt_action(dtp, sdp); 1249*a1b5e537Sbmc n++; 1250*a1b5e537Sbmc 1251*a1b5e537Sbmc dt_cg(yypcb, incr); 1252*a1b5e537Sbmc ap->dtad_difo = dt_as(yypcb); 1253*a1b5e537Sbmc ap->dtad_difo->dtdo_rtype = dt_void_rtype; 1254*a1b5e537Sbmc ap->dtad_kind = DTRACEACT_DIFEXPR; 1255*a1b5e537Sbmc } 1256*a1b5e537Sbmc 1257*a1b5e537Sbmc assert(sdp->dtsd_aggdata == NULL); 1258*a1b5e537Sbmc sdp->dtsd_aggdata = aid; 1259*a1b5e537Sbmc 1260*a1b5e537Sbmc ap = dt_stmt_action(dtp, sdp); 1261*a1b5e537Sbmc assert(fid->di_kind == DT_IDENT_AGGFUNC); 1262*a1b5e537Sbmc assert(DTRACEACT_ISAGG(fid->di_id)); 1263*a1b5e537Sbmc ap->dtad_kind = fid->di_id; 1264*a1b5e537Sbmc ap->dtad_ntuple = n; 1265*a1b5e537Sbmc ap->dtad_arg = arg; 1266*a1b5e537Sbmc 1267*a1b5e537Sbmc if (dnp->dn_aggfun->dn_args != NULL) { 1268*a1b5e537Sbmc dt_cg(yypcb, dnp->dn_aggfun->dn_args); 1269*a1b5e537Sbmc ap->dtad_difo = dt_as(yypcb); 12707c478bd9Sstevel@tonic-gate } 12717c478bd9Sstevel@tonic-gate } 12727c478bd9Sstevel@tonic-gate 12737c478bd9Sstevel@tonic-gate static void 12747c478bd9Sstevel@tonic-gate dt_compile_one_clause(dtrace_hdl_t *dtp, dt_node_t *cnp, dt_node_t *pnp) 12757c478bd9Sstevel@tonic-gate { 12767c478bd9Sstevel@tonic-gate dtrace_ecbdesc_t *edp; 12777c478bd9Sstevel@tonic-gate dtrace_stmtdesc_t *sdp; 12787c478bd9Sstevel@tonic-gate dt_node_t *dnp; 12797c478bd9Sstevel@tonic-gate 12807c478bd9Sstevel@tonic-gate yylineno = pnp->dn_line; 12817c478bd9Sstevel@tonic-gate dt_setcontext(dtp, pnp->dn_desc); 12827c478bd9Sstevel@tonic-gate (void) dt_node_cook(cnp, DT_IDFLG_REF); 12837c478bd9Sstevel@tonic-gate 12847c478bd9Sstevel@tonic-gate if (DT_TREEDUMP_PASS(dtp, 2)) 12857c478bd9Sstevel@tonic-gate dt_node_printr(cnp, stderr, 0); 12867c478bd9Sstevel@tonic-gate 12871a7c1b72Smws if ((edp = dt_ecbdesc_create(dtp, pnp->dn_desc)) == NULL) 12887c478bd9Sstevel@tonic-gate longjmp(yypcb->pcb_jmpbuf, EDT_NOMEM); 12897c478bd9Sstevel@tonic-gate 12907c478bd9Sstevel@tonic-gate assert(yypcb->pcb_ecbdesc == NULL); 12917c478bd9Sstevel@tonic-gate yypcb->pcb_ecbdesc = edp; 12927c478bd9Sstevel@tonic-gate 12937c478bd9Sstevel@tonic-gate if (cnp->dn_pred != NULL) { 12947c478bd9Sstevel@tonic-gate dt_cg(yypcb, cnp->dn_pred); 12957c478bd9Sstevel@tonic-gate edp->dted_pred.dtpdd_difo = dt_as(yypcb); 12967c478bd9Sstevel@tonic-gate } 12977c478bd9Sstevel@tonic-gate 12987c478bd9Sstevel@tonic-gate if (cnp->dn_acts == NULL) { 12997c478bd9Sstevel@tonic-gate dt_stmt_append(dt_stmt_create(dtp, edp, 13007c478bd9Sstevel@tonic-gate cnp->dn_ctxattr, _dtrace_defattr), cnp); 13017c478bd9Sstevel@tonic-gate } 13027c478bd9Sstevel@tonic-gate 13037c478bd9Sstevel@tonic-gate for (dnp = cnp->dn_acts; dnp != NULL; dnp = dnp->dn_list) { 13047c478bd9Sstevel@tonic-gate assert(yypcb->pcb_stmt == NULL); 13057c478bd9Sstevel@tonic-gate sdp = dt_stmt_create(dtp, edp, cnp->dn_ctxattr, cnp->dn_attr); 13067c478bd9Sstevel@tonic-gate 13077c478bd9Sstevel@tonic-gate switch (dnp->dn_kind) { 13087c478bd9Sstevel@tonic-gate case DT_NODE_DEXPR: 13097c478bd9Sstevel@tonic-gate if (dnp->dn_expr->dn_kind == DT_NODE_AGG) 13107c478bd9Sstevel@tonic-gate dt_compile_agg(dtp, dnp->dn_expr, sdp); 13117c478bd9Sstevel@tonic-gate else 13127c478bd9Sstevel@tonic-gate dt_compile_exp(dtp, dnp, sdp); 13137c478bd9Sstevel@tonic-gate break; 13147c478bd9Sstevel@tonic-gate case DT_NODE_DFUNC: 13157c478bd9Sstevel@tonic-gate dt_compile_fun(dtp, dnp, sdp); 13167c478bd9Sstevel@tonic-gate break; 13177c478bd9Sstevel@tonic-gate case DT_NODE_AGG: 13187c478bd9Sstevel@tonic-gate dt_compile_agg(dtp, dnp, sdp); 13197c478bd9Sstevel@tonic-gate break; 13207c478bd9Sstevel@tonic-gate default: 13217c478bd9Sstevel@tonic-gate dnerror(dnp, D_UNKNOWN, "internal error -- node kind " 13227c478bd9Sstevel@tonic-gate "%u is not a valid statement\n", dnp->dn_kind); 13237c478bd9Sstevel@tonic-gate } 13247c478bd9Sstevel@tonic-gate 13257c478bd9Sstevel@tonic-gate assert(yypcb->pcb_stmt == sdp); 13267c478bd9Sstevel@tonic-gate dt_stmt_append(sdp, dnp); 13277c478bd9Sstevel@tonic-gate } 13287c478bd9Sstevel@tonic-gate 13297c478bd9Sstevel@tonic-gate assert(yypcb->pcb_ecbdesc == edp); 13301a7c1b72Smws dt_ecbdesc_release(dtp, edp); 13317c478bd9Sstevel@tonic-gate dt_endcontext(dtp); 13327c478bd9Sstevel@tonic-gate yypcb->pcb_ecbdesc = NULL; 13337c478bd9Sstevel@tonic-gate } 13347c478bd9Sstevel@tonic-gate 13357c478bd9Sstevel@tonic-gate static void 13367c478bd9Sstevel@tonic-gate dt_compile_clause(dtrace_hdl_t *dtp, dt_node_t *cnp) 13377c478bd9Sstevel@tonic-gate { 13387c478bd9Sstevel@tonic-gate dt_node_t *pnp; 13397c478bd9Sstevel@tonic-gate 13407c478bd9Sstevel@tonic-gate for (pnp = cnp->dn_pdescs; pnp != NULL; pnp = pnp->dn_list) 13417c478bd9Sstevel@tonic-gate dt_compile_one_clause(dtp, cnp, pnp); 13427c478bd9Sstevel@tonic-gate } 13437c478bd9Sstevel@tonic-gate 13441a7c1b72Smws static void 13451a7c1b72Smws dt_compile_xlator(dt_node_t *dnp) 13461a7c1b72Smws { 13471a7c1b72Smws dt_xlator_t *dxp = dnp->dn_xlator; 13481a7c1b72Smws dt_node_t *mnp; 13491a7c1b72Smws 13501a7c1b72Smws for (mnp = dnp->dn_members; mnp != NULL; mnp = mnp->dn_list) { 13511a7c1b72Smws assert(dxp->dx_membdif[mnp->dn_membid] == NULL); 13521a7c1b72Smws dt_cg(yypcb, mnp); 13531a7c1b72Smws dxp->dx_membdif[mnp->dn_membid] = dt_as(yypcb); 13541a7c1b72Smws } 13551a7c1b72Smws } 13561a7c1b72Smws 13577c478bd9Sstevel@tonic-gate void 13587c478bd9Sstevel@tonic-gate dt_setcontext(dtrace_hdl_t *dtp, dtrace_probedesc_t *pdp) 13597c478bd9Sstevel@tonic-gate { 13607c478bd9Sstevel@tonic-gate const dtrace_pattr_t *pap; 13617c478bd9Sstevel@tonic-gate dt_probe_t *prp; 13627c478bd9Sstevel@tonic-gate dt_ident_t *idp; 13637c478bd9Sstevel@tonic-gate char attrstr[8]; 13647c478bd9Sstevel@tonic-gate int err; 13657c478bd9Sstevel@tonic-gate 13667c478bd9Sstevel@tonic-gate /* 13677c478bd9Sstevel@tonic-gate * If the provider name ends with what could be interpreted as a 13687c478bd9Sstevel@tonic-gate * number, we assume that it's a pid and that we may need to 13697c478bd9Sstevel@tonic-gate * dynamically create those probes for that process. 13707c478bd9Sstevel@tonic-gate */ 13717c478bd9Sstevel@tonic-gate if (isdigit(pdp->dtpd_provider[strlen(pdp->dtpd_provider) - 1])) 13727c478bd9Sstevel@tonic-gate dt_pid_create_probes(pdp, dtp); 13737c478bd9Sstevel@tonic-gate 13747c478bd9Sstevel@tonic-gate /* 13757c478bd9Sstevel@tonic-gate * Call dt_probe_info() to get the probe arguments and attributes. If 13767c478bd9Sstevel@tonic-gate * a representative probe is found, set 'pap' to the probe provider's 13777c478bd9Sstevel@tonic-gate * attributes. Otherwise set 'pap' to default Unstable attributes. 13787c478bd9Sstevel@tonic-gate */ 13797c478bd9Sstevel@tonic-gate if ((prp = dt_probe_info(dtp, pdp, &yypcb->pcb_pinfo)) == NULL) { 13807c478bd9Sstevel@tonic-gate pap = &_dtrace_prvdesc; 13817c478bd9Sstevel@tonic-gate err = dtrace_errno(dtp); 13827c478bd9Sstevel@tonic-gate bzero(&yypcb->pcb_pinfo, sizeof (dtrace_probeinfo_t)); 13837c478bd9Sstevel@tonic-gate yypcb->pcb_pinfo.dtp_attr = pap->dtpa_provider; 13847c478bd9Sstevel@tonic-gate yypcb->pcb_pinfo.dtp_arga = pap->dtpa_args; 13857c478bd9Sstevel@tonic-gate } else { 13867c478bd9Sstevel@tonic-gate pap = &prp->pr_pvp->pv_desc.dtvd_attr; 13877c478bd9Sstevel@tonic-gate err = 0; 13887c478bd9Sstevel@tonic-gate } 13897c478bd9Sstevel@tonic-gate 13907c478bd9Sstevel@tonic-gate if (err == EDT_NOPROBE && !(yypcb->pcb_cflags & DTRACE_C_ZDEFS)) { 13917c478bd9Sstevel@tonic-gate xyerror(D_PDESC_ZERO, "probe description %s:%s:%s:%s does not " 13927c478bd9Sstevel@tonic-gate "match any probes\n", pdp->dtpd_provider, pdp->dtpd_mod, 13937c478bd9Sstevel@tonic-gate pdp->dtpd_func, pdp->dtpd_name); 13947c478bd9Sstevel@tonic-gate } 13957c478bd9Sstevel@tonic-gate 13967c478bd9Sstevel@tonic-gate if (err != EDT_NOPROBE && err != EDT_UNSTABLE && err != 0) 13977c478bd9Sstevel@tonic-gate xyerror(D_PDESC_INVAL, "%s\n", dtrace_errmsg(dtp, err)); 13987c478bd9Sstevel@tonic-gate 13997c478bd9Sstevel@tonic-gate dt_dprintf("set context to %s:%s:%s:%s [%u] prp=%p attr=%s argc=%d\n", 14007c478bd9Sstevel@tonic-gate pdp->dtpd_provider, pdp->dtpd_mod, pdp->dtpd_func, pdp->dtpd_name, 14017c478bd9Sstevel@tonic-gate pdp->dtpd_id, (void *)prp, dt_attr_str(yypcb->pcb_pinfo.dtp_attr, 14027c478bd9Sstevel@tonic-gate attrstr, sizeof (attrstr)), yypcb->pcb_pinfo.dtp_argc); 14037c478bd9Sstevel@tonic-gate 14047c478bd9Sstevel@tonic-gate /* 14057c478bd9Sstevel@tonic-gate * Reset the stability attributes of D global variables that vary 14067c478bd9Sstevel@tonic-gate * based on the attributes of the provider and context itself. 14077c478bd9Sstevel@tonic-gate */ 14087c478bd9Sstevel@tonic-gate if ((idp = dt_idhash_lookup(dtp->dt_globals, "probeprov")) != NULL) 14097c478bd9Sstevel@tonic-gate idp->di_attr = pap->dtpa_provider; 14107c478bd9Sstevel@tonic-gate if ((idp = dt_idhash_lookup(dtp->dt_globals, "probemod")) != NULL) 14117c478bd9Sstevel@tonic-gate idp->di_attr = pap->dtpa_mod; 14127c478bd9Sstevel@tonic-gate if ((idp = dt_idhash_lookup(dtp->dt_globals, "probefunc")) != NULL) 14137c478bd9Sstevel@tonic-gate idp->di_attr = pap->dtpa_func; 14147c478bd9Sstevel@tonic-gate if ((idp = dt_idhash_lookup(dtp->dt_globals, "probename")) != NULL) 14157c478bd9Sstevel@tonic-gate idp->di_attr = pap->dtpa_name; 14167c478bd9Sstevel@tonic-gate if ((idp = dt_idhash_lookup(dtp->dt_globals, "args")) != NULL) 14177c478bd9Sstevel@tonic-gate idp->di_attr = pap->dtpa_args; 14187c478bd9Sstevel@tonic-gate 14197c478bd9Sstevel@tonic-gate yypcb->pcb_pdesc = pdp; 14207c478bd9Sstevel@tonic-gate yypcb->pcb_probe = prp; 14217c478bd9Sstevel@tonic-gate } 14227c478bd9Sstevel@tonic-gate 14237c478bd9Sstevel@tonic-gate /* 14247c478bd9Sstevel@tonic-gate * Reset context-dependent variables and state at the end of cooking a D probe 14257c478bd9Sstevel@tonic-gate * definition clause. This ensures that external declarations between clauses 14267c478bd9Sstevel@tonic-gate * do not reference any stale context-dependent data from the previous clause. 14277c478bd9Sstevel@tonic-gate */ 14287c478bd9Sstevel@tonic-gate void 14297c478bd9Sstevel@tonic-gate dt_endcontext(dtrace_hdl_t *dtp) 14307c478bd9Sstevel@tonic-gate { 14317c478bd9Sstevel@tonic-gate static const char *const cvars[] = { 14327c478bd9Sstevel@tonic-gate "probeprov", "probemod", "probefunc", "probename", "args", NULL 14337c478bd9Sstevel@tonic-gate }; 14347c478bd9Sstevel@tonic-gate 14357c478bd9Sstevel@tonic-gate dt_ident_t *idp; 14367c478bd9Sstevel@tonic-gate int i; 14377c478bd9Sstevel@tonic-gate 14387c478bd9Sstevel@tonic-gate for (i = 0; cvars[i] != NULL; i++) { 14397c478bd9Sstevel@tonic-gate if ((idp = dt_idhash_lookup(dtp->dt_globals, cvars[i])) != NULL) 14407c478bd9Sstevel@tonic-gate idp->di_attr = _dtrace_defattr; 14417c478bd9Sstevel@tonic-gate } 14427c478bd9Sstevel@tonic-gate 14437c478bd9Sstevel@tonic-gate yypcb->pcb_pdesc = NULL; 14447c478bd9Sstevel@tonic-gate yypcb->pcb_probe = NULL; 14457c478bd9Sstevel@tonic-gate } 14467c478bd9Sstevel@tonic-gate 14477c478bd9Sstevel@tonic-gate static int 14487c478bd9Sstevel@tonic-gate dt_reduceid(dt_idhash_t *dhp, dt_ident_t *idp, dtrace_hdl_t *dtp) 14497c478bd9Sstevel@tonic-gate { 14507c478bd9Sstevel@tonic-gate if (idp->di_vers != 0 && idp->di_vers > dtp->dt_vmax) 14517c478bd9Sstevel@tonic-gate dt_idhash_delete(dhp, idp); 14527c478bd9Sstevel@tonic-gate 14537c478bd9Sstevel@tonic-gate return (0); 14547c478bd9Sstevel@tonic-gate } 14557c478bd9Sstevel@tonic-gate 14567c478bd9Sstevel@tonic-gate /* 14577c478bd9Sstevel@tonic-gate * When dtrace_setopt() is called for "version", it calls dt_reduce() to remove 14587c478bd9Sstevel@tonic-gate * any identifiers or translators that have been previously defined as bound to 14597c478bd9Sstevel@tonic-gate * a version greater than the specified version. Therefore, in our current 14607c478bd9Sstevel@tonic-gate * version implementation, establishing a binding is a one-way transformation. 14617c478bd9Sstevel@tonic-gate * In addition, no versioning is currently provided for types as our .d library 14627c478bd9Sstevel@tonic-gate * files do not define any types and we reserve prefixes DTRACE_ and dtrace_ 14637c478bd9Sstevel@tonic-gate * for our exclusive use. If required, type versioning will require more work. 14647c478bd9Sstevel@tonic-gate */ 14657c478bd9Sstevel@tonic-gate int 14667c478bd9Sstevel@tonic-gate dt_reduce(dtrace_hdl_t *dtp, dt_version_t v) 14677c478bd9Sstevel@tonic-gate { 14687c478bd9Sstevel@tonic-gate char s[DT_VERSION_STRMAX]; 14697c478bd9Sstevel@tonic-gate dt_xlator_t *dxp, *nxp; 14707c478bd9Sstevel@tonic-gate 14717c478bd9Sstevel@tonic-gate if (v > dtp->dt_vmax) 14727c478bd9Sstevel@tonic-gate return (dt_set_errno(dtp, EDT_VERSREDUCED)); 14737c478bd9Sstevel@tonic-gate else if (v == dtp->dt_vmax) 14747c478bd9Sstevel@tonic-gate return (0); /* no reduction necessary */ 14757c478bd9Sstevel@tonic-gate 14767c478bd9Sstevel@tonic-gate dt_dprintf("reducing api version to %s\n", 14777c478bd9Sstevel@tonic-gate dt_version_num2str(v, s, sizeof (s))); 14787c478bd9Sstevel@tonic-gate 14797c478bd9Sstevel@tonic-gate dtp->dt_vmax = v; 14807c478bd9Sstevel@tonic-gate 14817c478bd9Sstevel@tonic-gate for (dxp = dt_list_next(&dtp->dt_xlators); dxp != NULL; dxp = nxp) { 14827c478bd9Sstevel@tonic-gate nxp = dt_list_next(dxp); 14837c478bd9Sstevel@tonic-gate if ((dxp->dx_souid.di_vers != 0 && dxp->dx_souid.di_vers > v) || 14847c478bd9Sstevel@tonic-gate (dxp->dx_ptrid.di_vers != 0 && dxp->dx_ptrid.di_vers > v)) 14857c478bd9Sstevel@tonic-gate dt_list_delete(&dtp->dt_xlators, dxp); 14867c478bd9Sstevel@tonic-gate } 14877c478bd9Sstevel@tonic-gate 14887c478bd9Sstevel@tonic-gate (void) dt_idhash_iter(dtp->dt_macros, (dt_idhash_f *)dt_reduceid, dtp); 14897c478bd9Sstevel@tonic-gate (void) dt_idhash_iter(dtp->dt_aggs, (dt_idhash_f *)dt_reduceid, dtp); 14907c478bd9Sstevel@tonic-gate (void) dt_idhash_iter(dtp->dt_globals, (dt_idhash_f *)dt_reduceid, dtp); 14917c478bd9Sstevel@tonic-gate (void) dt_idhash_iter(dtp->dt_tls, (dt_idhash_f *)dt_reduceid, dtp); 14927c478bd9Sstevel@tonic-gate 14937c478bd9Sstevel@tonic-gate return (0); 14947c478bd9Sstevel@tonic-gate } 14957c478bd9Sstevel@tonic-gate 14967c478bd9Sstevel@tonic-gate /* 14977c478bd9Sstevel@tonic-gate * Fork and exec the cpp(1) preprocessor to run over the specified input file, 14987c478bd9Sstevel@tonic-gate * and return a FILE handle for the cpp output. We use the /dev/fd filesystem 14997c478bd9Sstevel@tonic-gate * here to simplify the code by leveraging file descriptor inheritance. 15007c478bd9Sstevel@tonic-gate */ 15017c478bd9Sstevel@tonic-gate static FILE * 15027c478bd9Sstevel@tonic-gate dt_preproc(dtrace_hdl_t *dtp, FILE *ifp) 15037c478bd9Sstevel@tonic-gate { 15047c478bd9Sstevel@tonic-gate int argc = dtp->dt_cpp_argc; 15057c478bd9Sstevel@tonic-gate char **argv = malloc(sizeof (char *) * (argc + 5)); 15067c478bd9Sstevel@tonic-gate FILE *ofp = tmpfile(); 15077c478bd9Sstevel@tonic-gate 15087c478bd9Sstevel@tonic-gate char ipath[20], opath[20]; /* big enough for /dev/fd/ + INT_MAX + \0 */ 15097c478bd9Sstevel@tonic-gate char verdef[32]; /* big enough for -D__SUNW_D_VERSION=0x%08x + \0 */ 15107c478bd9Sstevel@tonic-gate 15117c478bd9Sstevel@tonic-gate struct sigaction act, oact; 15127c478bd9Sstevel@tonic-gate sigset_t mask, omask; 15137c478bd9Sstevel@tonic-gate 15147c478bd9Sstevel@tonic-gate int wstat, estat; 15157c478bd9Sstevel@tonic-gate pid_t pid; 15167c478bd9Sstevel@tonic-gate off64_t off; 15177c478bd9Sstevel@tonic-gate int c; 15187c478bd9Sstevel@tonic-gate 15197c478bd9Sstevel@tonic-gate if (argv == NULL || ofp == NULL) { 15207c478bd9Sstevel@tonic-gate (void) dt_set_errno(dtp, errno); 15217c478bd9Sstevel@tonic-gate goto err; 15227c478bd9Sstevel@tonic-gate } 15237c478bd9Sstevel@tonic-gate 15247c478bd9Sstevel@tonic-gate /* 15257c478bd9Sstevel@tonic-gate * If the input is a seekable file, see if it is an interpreter file. 15267c478bd9Sstevel@tonic-gate * If we see #!, seek past the first line because cpp will choke on it. 15277c478bd9Sstevel@tonic-gate * We start cpp just prior to the \n at the end of this line so that 15287c478bd9Sstevel@tonic-gate * it still sees the newline, ensuring that #line values are correct. 15297c478bd9Sstevel@tonic-gate */ 15307c478bd9Sstevel@tonic-gate if (isatty(fileno(ifp)) == 0 && (off = ftello64(ifp)) != -1) { 15317c478bd9Sstevel@tonic-gate if ((c = fgetc(ifp)) == '#' && (c = fgetc(ifp)) == '!') { 15327c478bd9Sstevel@tonic-gate for (off += 2; c != '\n'; off++) { 15337c478bd9Sstevel@tonic-gate if ((c = fgetc(ifp)) == EOF) 15347c478bd9Sstevel@tonic-gate break; 15357c478bd9Sstevel@tonic-gate } 15367c478bd9Sstevel@tonic-gate if (c == '\n') 15377c478bd9Sstevel@tonic-gate off--; /* start cpp just prior to \n */ 15387c478bd9Sstevel@tonic-gate } 15397c478bd9Sstevel@tonic-gate (void) fflush(ifp); 15407c478bd9Sstevel@tonic-gate (void) fseeko64(ifp, off, SEEK_SET); 15417c478bd9Sstevel@tonic-gate } 15427c478bd9Sstevel@tonic-gate 15437c478bd9Sstevel@tonic-gate (void) snprintf(ipath, sizeof (ipath), "/dev/fd/%d", fileno(ifp)); 15447c478bd9Sstevel@tonic-gate (void) snprintf(opath, sizeof (opath), "/dev/fd/%d", fileno(ofp)); 15457c478bd9Sstevel@tonic-gate 15467c478bd9Sstevel@tonic-gate bcopy(dtp->dt_cpp_argv, argv, sizeof (char *) * argc); 15477c478bd9Sstevel@tonic-gate 15487c478bd9Sstevel@tonic-gate (void) snprintf(verdef, sizeof (verdef), 15497c478bd9Sstevel@tonic-gate "-D__SUNW_D_VERSION=0x%08x", dtp->dt_vmax); 15507c478bd9Sstevel@tonic-gate argv[argc++] = verdef; 15517c478bd9Sstevel@tonic-gate 15527c478bd9Sstevel@tonic-gate switch (dtp->dt_stdcmode) { 15537c478bd9Sstevel@tonic-gate case DT_STDC_XA: 15547c478bd9Sstevel@tonic-gate case DT_STDC_XT: 15557c478bd9Sstevel@tonic-gate argv[argc++] = "-D__STDC__=0"; 15567c478bd9Sstevel@tonic-gate break; 15577c478bd9Sstevel@tonic-gate case DT_STDC_XC: 15587c478bd9Sstevel@tonic-gate argv[argc++] = "-D__STDC__=1"; 15597c478bd9Sstevel@tonic-gate break; 15607c478bd9Sstevel@tonic-gate } 15617c478bd9Sstevel@tonic-gate 15627c478bd9Sstevel@tonic-gate argv[argc++] = ipath; 15637c478bd9Sstevel@tonic-gate argv[argc++] = opath; 15647c478bd9Sstevel@tonic-gate argv[argc] = NULL; 15657c478bd9Sstevel@tonic-gate 15667c478bd9Sstevel@tonic-gate /* 15677c478bd9Sstevel@tonic-gate * libdtrace must be able to be embedded in other programs that may 15687c478bd9Sstevel@tonic-gate * include application-specific signal handlers. Therefore, if we 15697c478bd9Sstevel@tonic-gate * need to fork to run cpp(1), we must avoid generating a SIGCHLD 15707c478bd9Sstevel@tonic-gate * that could confuse the containing application. To do this, 15717c478bd9Sstevel@tonic-gate * we block SIGCHLD and reset its disposition to SIG_DFL. 15727c478bd9Sstevel@tonic-gate * We restore our signal state once we are done. 15737c478bd9Sstevel@tonic-gate */ 15747c478bd9Sstevel@tonic-gate (void) sigemptyset(&mask); 15757c478bd9Sstevel@tonic-gate (void) sigaddset(&mask, SIGCHLD); 15767c478bd9Sstevel@tonic-gate (void) sigprocmask(SIG_BLOCK, &mask, &omask); 15777c478bd9Sstevel@tonic-gate 15787c478bd9Sstevel@tonic-gate bzero(&act, sizeof (act)); 15797c478bd9Sstevel@tonic-gate act.sa_handler = SIG_DFL; 15807c478bd9Sstevel@tonic-gate (void) sigaction(SIGCHLD, &act, &oact); 15817c478bd9Sstevel@tonic-gate 15827c478bd9Sstevel@tonic-gate if ((pid = fork1()) == -1) { 15837c478bd9Sstevel@tonic-gate (void) sigaction(SIGCHLD, &oact, NULL); 15847c478bd9Sstevel@tonic-gate (void) sigprocmask(SIG_SETMASK, &omask, NULL); 15857c478bd9Sstevel@tonic-gate (void) dt_set_errno(dtp, EDT_CPPFORK); 15867c478bd9Sstevel@tonic-gate goto err; 15877c478bd9Sstevel@tonic-gate } 15887c478bd9Sstevel@tonic-gate 15897c478bd9Sstevel@tonic-gate if (pid == 0) { 15907c478bd9Sstevel@tonic-gate (void) execvp(dtp->dt_cpp_path, argv); 15917c478bd9Sstevel@tonic-gate _exit(errno == ENOENT ? 127 : 126); 15927c478bd9Sstevel@tonic-gate } 15937c478bd9Sstevel@tonic-gate 15947c478bd9Sstevel@tonic-gate do { 15957c478bd9Sstevel@tonic-gate dt_dprintf("waiting for %s (PID %d)\n", dtp->dt_cpp_path, 15967c478bd9Sstevel@tonic-gate (int)pid); 15977c478bd9Sstevel@tonic-gate } while (waitpid(pid, &wstat, 0) == -1 && errno == EINTR); 15987c478bd9Sstevel@tonic-gate 15997c478bd9Sstevel@tonic-gate (void) sigaction(SIGCHLD, &oact, NULL); 16007c478bd9Sstevel@tonic-gate (void) sigprocmask(SIG_SETMASK, &omask, NULL); 16017c478bd9Sstevel@tonic-gate 16027c478bd9Sstevel@tonic-gate dt_dprintf("%s returned exit status 0x%x\n", dtp->dt_cpp_path, wstat); 16037c478bd9Sstevel@tonic-gate estat = WIFEXITED(wstat) ? WEXITSTATUS(wstat) : -1; 16047c478bd9Sstevel@tonic-gate 16057c478bd9Sstevel@tonic-gate if (estat != 0) { 16067c478bd9Sstevel@tonic-gate switch (estat) { 16077c478bd9Sstevel@tonic-gate case 126: 16087c478bd9Sstevel@tonic-gate (void) dt_set_errno(dtp, EDT_CPPEXEC); 16097c478bd9Sstevel@tonic-gate break; 16107c478bd9Sstevel@tonic-gate case 127: 16117c478bd9Sstevel@tonic-gate (void) dt_set_errno(dtp, EDT_CPPENT); 16127c478bd9Sstevel@tonic-gate break; 16137c478bd9Sstevel@tonic-gate default: 16147c478bd9Sstevel@tonic-gate (void) dt_set_errno(dtp, EDT_CPPERR); 16157c478bd9Sstevel@tonic-gate } 16167c478bd9Sstevel@tonic-gate goto err; 16177c478bd9Sstevel@tonic-gate } 16187c478bd9Sstevel@tonic-gate 16197c478bd9Sstevel@tonic-gate free(argv); 16207c478bd9Sstevel@tonic-gate (void) fflush(ofp); 16217c478bd9Sstevel@tonic-gate (void) fseek(ofp, 0, SEEK_SET); 16227c478bd9Sstevel@tonic-gate return (ofp); 16237c478bd9Sstevel@tonic-gate 16247c478bd9Sstevel@tonic-gate err: 16257c478bd9Sstevel@tonic-gate free(argv); 16267c478bd9Sstevel@tonic-gate (void) fclose(ofp); 16277c478bd9Sstevel@tonic-gate return (NULL); 16287c478bd9Sstevel@tonic-gate } 16297c478bd9Sstevel@tonic-gate 16307c478bd9Sstevel@tonic-gate /* 16317c478bd9Sstevel@tonic-gate * Open all of the .d library files found in the specified directory and try to 16327c478bd9Sstevel@tonic-gate * compile each one in order to cache its inlines and translators, etc. We 16337c478bd9Sstevel@tonic-gate * silently ignore any missing directories and other files found therein. 16347c478bd9Sstevel@tonic-gate * We only fail (and thereby fail dt_load_libs()) if we fail to compile a 16357c478bd9Sstevel@tonic-gate * library and the error is something other than #pragma D depends_on. 16367c478bd9Sstevel@tonic-gate * Dependency errors are silently ignored to permit a library directory to 16377c478bd9Sstevel@tonic-gate * contain libraries which may not be accessible depending on our privileges. 16387c478bd9Sstevel@tonic-gate * 16397c478bd9Sstevel@tonic-gate * Note that at present, no ordering is defined between library files found in 16407c478bd9Sstevel@tonic-gate * the same directory: if cross-library dependencies are eventually required, 16417c478bd9Sstevel@tonic-gate * we will need to extend the #pragma D depends_on directive with an additional 16427c478bd9Sstevel@tonic-gate * class for libraries, and this function will need to create a graph of the 16437c478bd9Sstevel@tonic-gate * various library pathnames and then perform a topological ordering using the 16447c478bd9Sstevel@tonic-gate * dependency information before we attempt to compile any of them. 16457c478bd9Sstevel@tonic-gate */ 16467c478bd9Sstevel@tonic-gate static int 16477c478bd9Sstevel@tonic-gate dt_load_libs_dir(dtrace_hdl_t *dtp, const char *path) 16487c478bd9Sstevel@tonic-gate { 16497c478bd9Sstevel@tonic-gate struct dirent *dp, *ep; 16507c478bd9Sstevel@tonic-gate const char *p; 16517c478bd9Sstevel@tonic-gate DIR *dirp; 16527c478bd9Sstevel@tonic-gate 16537c478bd9Sstevel@tonic-gate char fname[PATH_MAX]; 16547c478bd9Sstevel@tonic-gate dtrace_prog_t *pgp; 16557c478bd9Sstevel@tonic-gate FILE *fp; 16567c478bd9Sstevel@tonic-gate 16577c478bd9Sstevel@tonic-gate if ((dirp = opendir(path)) == NULL) { 16587c478bd9Sstevel@tonic-gate dt_dprintf("skipping lib dir %s: %s\n", path, strerror(errno)); 16597c478bd9Sstevel@tonic-gate return (0); 16607c478bd9Sstevel@tonic-gate } 16617c478bd9Sstevel@tonic-gate 16627c478bd9Sstevel@tonic-gate ep = alloca(sizeof (struct dirent) + PATH_MAX + 1); 16637c478bd9Sstevel@tonic-gate bzero(ep, sizeof (struct dirent) + PATH_MAX + 1); 16647c478bd9Sstevel@tonic-gate 16657c478bd9Sstevel@tonic-gate while (readdir_r(dirp, ep, &dp) == 0 && dp != NULL) { 16667c478bd9Sstevel@tonic-gate if ((p = strrchr(dp->d_name, '.')) == NULL || strcmp(p, ".d")) 16677c478bd9Sstevel@tonic-gate continue; /* skip any filename not ending in .d */ 16687c478bd9Sstevel@tonic-gate 16697c478bd9Sstevel@tonic-gate (void) snprintf(fname, sizeof (fname), 16707c478bd9Sstevel@tonic-gate "%s/%s", path, dp->d_name); 16717c478bd9Sstevel@tonic-gate 16727c478bd9Sstevel@tonic-gate if ((fp = fopen(fname, "r")) == NULL) { 16737c478bd9Sstevel@tonic-gate dt_dprintf("skipping library %s: %s\n", 16747c478bd9Sstevel@tonic-gate fname, strerror(errno)); 16757c478bd9Sstevel@tonic-gate continue; 16767c478bd9Sstevel@tonic-gate } 16777c478bd9Sstevel@tonic-gate 16787c478bd9Sstevel@tonic-gate dtp->dt_filetag = fname; 16797c478bd9Sstevel@tonic-gate pgp = dtrace_program_fcompile(dtp, fp, DTRACE_C_EMPTY, 0, NULL); 16807c478bd9Sstevel@tonic-gate (void) fclose(fp); 16817c478bd9Sstevel@tonic-gate dtp->dt_filetag = NULL; 16827c478bd9Sstevel@tonic-gate 16837c478bd9Sstevel@tonic-gate if (pgp == NULL && (dtp->dt_errno != EDT_COMPILER || 16847c478bd9Sstevel@tonic-gate dtp->dt_errtag != dt_errtag(D_PRAGMA_DEPEND))) { 16857c478bd9Sstevel@tonic-gate (void) closedir(dirp); 16867c478bd9Sstevel@tonic-gate return (-1); /* preserve dt_errno */ 16877c478bd9Sstevel@tonic-gate } 16887c478bd9Sstevel@tonic-gate 16897c478bd9Sstevel@tonic-gate if (pgp == NULL) { 16907c478bd9Sstevel@tonic-gate dt_dprintf("skipping library: %s\n", 16917c478bd9Sstevel@tonic-gate dtrace_errmsg(dtp, dtrace_errno(dtp))); 16927c478bd9Sstevel@tonic-gate } else 16931a7c1b72Smws dt_program_destroy(dtp, pgp); 16947c478bd9Sstevel@tonic-gate } 16957c478bd9Sstevel@tonic-gate 16967c478bd9Sstevel@tonic-gate (void) closedir(dirp); 16977c478bd9Sstevel@tonic-gate return (0); 16987c478bd9Sstevel@tonic-gate } 16997c478bd9Sstevel@tonic-gate 17007c478bd9Sstevel@tonic-gate /* 17017c478bd9Sstevel@tonic-gate * Load the contents of any appropriate DTrace .d library files. These files 17027c478bd9Sstevel@tonic-gate * contain inlines and translators that will be cached by the compiler. We 17037c478bd9Sstevel@tonic-gate * defer this activity until the first compile to permit libdtrace clients to 17047c478bd9Sstevel@tonic-gate * add their own library directories and so that we can properly report errors. 17057c478bd9Sstevel@tonic-gate */ 17067c478bd9Sstevel@tonic-gate static int 17077c478bd9Sstevel@tonic-gate dt_load_libs(dtrace_hdl_t *dtp) 17087c478bd9Sstevel@tonic-gate { 17097c478bd9Sstevel@tonic-gate dt_dirpath_t *dirp; 17107c478bd9Sstevel@tonic-gate 17117c478bd9Sstevel@tonic-gate if (dtp->dt_cflags & DTRACE_C_NOLIBS) 17127c478bd9Sstevel@tonic-gate return (0); /* libraries already processed */ 17137c478bd9Sstevel@tonic-gate 17147c478bd9Sstevel@tonic-gate dtp->dt_cflags |= DTRACE_C_NOLIBS; 17157c478bd9Sstevel@tonic-gate 17167c478bd9Sstevel@tonic-gate for (dirp = dt_list_next(&dtp->dt_lib_path); 17177c478bd9Sstevel@tonic-gate dirp != NULL; dirp = dt_list_next(dirp)) { 17187c478bd9Sstevel@tonic-gate if (dt_load_libs_dir(dtp, dirp->dir_path) != 0) { 17197c478bd9Sstevel@tonic-gate dtp->dt_cflags &= ~DTRACE_C_NOLIBS; 17207c478bd9Sstevel@tonic-gate return (-1); /* errno is set for us */ 17217c478bd9Sstevel@tonic-gate } 17227c478bd9Sstevel@tonic-gate } 17237c478bd9Sstevel@tonic-gate 17247c478bd9Sstevel@tonic-gate return (0); 17257c478bd9Sstevel@tonic-gate } 17267c478bd9Sstevel@tonic-gate 17277c478bd9Sstevel@tonic-gate static void * 17287c478bd9Sstevel@tonic-gate dt_compile(dtrace_hdl_t *dtp, int context, dtrace_probespec_t pspec, void *arg, 17297c478bd9Sstevel@tonic-gate uint_t cflags, int argc, char *const argv[], FILE *fp, const char *s) 17307c478bd9Sstevel@tonic-gate { 17317c478bd9Sstevel@tonic-gate dt_node_t *dnp; 17327c478bd9Sstevel@tonic-gate dt_decl_t *ddp; 17337c478bd9Sstevel@tonic-gate dt_pcb_t pcb; 17347c478bd9Sstevel@tonic-gate void *rv; 17357c478bd9Sstevel@tonic-gate int err; 17367c478bd9Sstevel@tonic-gate 17377c478bd9Sstevel@tonic-gate if ((fp == NULL && s == NULL) || (cflags & ~DTRACE_C_MASK) != 0) { 17387c478bd9Sstevel@tonic-gate (void) dt_set_errno(dtp, EINVAL); 17397c478bd9Sstevel@tonic-gate return (NULL); 17407c478bd9Sstevel@tonic-gate } 17417c478bd9Sstevel@tonic-gate 17427c478bd9Sstevel@tonic-gate if (dt_list_next(&dtp->dt_lib_path) != NULL && dt_load_libs(dtp) != 0) 17437c478bd9Sstevel@tonic-gate return (NULL); /* errno is set for us */ 17447c478bd9Sstevel@tonic-gate 17457c478bd9Sstevel@tonic-gate (void) ctf_discard(dtp->dt_cdefs->dm_ctfp); 17467c478bd9Sstevel@tonic-gate (void) ctf_discard(dtp->dt_ddefs->dm_ctfp); 17477c478bd9Sstevel@tonic-gate 17487c478bd9Sstevel@tonic-gate (void) dt_idhash_iter(dtp->dt_globals, dt_idreset, NULL); 17497c478bd9Sstevel@tonic-gate (void) dt_idhash_iter(dtp->dt_tls, dt_idreset, NULL); 17507c478bd9Sstevel@tonic-gate 17517c478bd9Sstevel@tonic-gate if (fp && (cflags & DTRACE_C_CPP) && (fp = dt_preproc(dtp, fp)) == NULL) 17527c478bd9Sstevel@tonic-gate return (NULL); /* errno is set for us */ 17537c478bd9Sstevel@tonic-gate 17547c478bd9Sstevel@tonic-gate dt_pcb_push(dtp, &pcb); 17557c478bd9Sstevel@tonic-gate 17567c478bd9Sstevel@tonic-gate pcb.pcb_fileptr = fp; 17577c478bd9Sstevel@tonic-gate pcb.pcb_string = s; 17587c478bd9Sstevel@tonic-gate pcb.pcb_strptr = s; 17597c478bd9Sstevel@tonic-gate pcb.pcb_strlen = s ? strlen(s) : 0; 17607c478bd9Sstevel@tonic-gate pcb.pcb_sargc = argc; 17617c478bd9Sstevel@tonic-gate pcb.pcb_sargv = argv; 17627c478bd9Sstevel@tonic-gate pcb.pcb_sflagv = argc ? calloc(argc, sizeof (ushort_t)) : NULL; 17637c478bd9Sstevel@tonic-gate pcb.pcb_pspec = pspec; 17647c478bd9Sstevel@tonic-gate pcb.pcb_cflags = dtp->dt_cflags | cflags; 17657c478bd9Sstevel@tonic-gate pcb.pcb_amin = dtp->dt_amin; 17667c478bd9Sstevel@tonic-gate pcb.pcb_yystate = -1; 17677c478bd9Sstevel@tonic-gate pcb.pcb_context = context; 17687c478bd9Sstevel@tonic-gate pcb.pcb_token = context; 17697c478bd9Sstevel@tonic-gate 17707c478bd9Sstevel@tonic-gate if (context == DT_CTX_DPROG) 17717c478bd9Sstevel@tonic-gate yybegin(YYS_CLAUSE); 17727c478bd9Sstevel@tonic-gate else 17737c478bd9Sstevel@tonic-gate yybegin(YYS_EXPR); 17747c478bd9Sstevel@tonic-gate 17757c478bd9Sstevel@tonic-gate if ((err = setjmp(yypcb->pcb_jmpbuf)) != 0) 17767c478bd9Sstevel@tonic-gate goto out; 17777c478bd9Sstevel@tonic-gate 17787c478bd9Sstevel@tonic-gate if (yypcb->pcb_sargc != 0 && yypcb->pcb_sflagv == NULL) 17797c478bd9Sstevel@tonic-gate longjmp(yypcb->pcb_jmpbuf, EDT_NOMEM); 17807c478bd9Sstevel@tonic-gate 17817c478bd9Sstevel@tonic-gate yypcb->pcb_idents = dt_idhash_create("ambiguous", NULL, 0, 0); 17827c478bd9Sstevel@tonic-gate yypcb->pcb_locals = dt_idhash_create("clause local", NULL, 17837c478bd9Sstevel@tonic-gate DIF_VAR_OTHER_UBASE, DIF_VAR_OTHER_MAX); 17847c478bd9Sstevel@tonic-gate 17857c478bd9Sstevel@tonic-gate if (yypcb->pcb_idents == NULL || yypcb->pcb_locals == NULL) 17867c478bd9Sstevel@tonic-gate longjmp(yypcb->pcb_jmpbuf, EDT_NOMEM); 17877c478bd9Sstevel@tonic-gate 17887c478bd9Sstevel@tonic-gate /* 17897c478bd9Sstevel@tonic-gate * Invoke the parser to evaluate the D source code. If any errors 17907c478bd9Sstevel@tonic-gate * occur during parsing, an error function will be called and we 17917c478bd9Sstevel@tonic-gate * will longjmp back to pcb_jmpbuf to abort. If parsing succeeds, 17927c478bd9Sstevel@tonic-gate * we optionally display the parse tree if debugging is enabled. 17937c478bd9Sstevel@tonic-gate */ 17947c478bd9Sstevel@tonic-gate if (yyparse() != 0 || yypcb->pcb_root == NULL) 17957c478bd9Sstevel@tonic-gate xyerror(D_EMPTY, "empty D program translation unit\n"); 17967c478bd9Sstevel@tonic-gate 17977c478bd9Sstevel@tonic-gate yybegin(YYS_DONE); 17987c478bd9Sstevel@tonic-gate 17997c478bd9Sstevel@tonic-gate if (context != DT_CTX_DTYPE && DT_TREEDUMP_PASS(dtp, 1)) 18007c478bd9Sstevel@tonic-gate dt_node_printr(yypcb->pcb_root, stderr, 0); 18017c478bd9Sstevel@tonic-gate 18027c478bd9Sstevel@tonic-gate if (yypcb->pcb_pragmas != NULL) 18037c478bd9Sstevel@tonic-gate (void) dt_idhash_iter(yypcb->pcb_pragmas, dt_idpragma, NULL); 18047c478bd9Sstevel@tonic-gate 18057c478bd9Sstevel@tonic-gate if (argc > 1 && !(yypcb->pcb_cflags & DTRACE_C_ARGREF) && 18067c478bd9Sstevel@tonic-gate !(yypcb->pcb_sflagv[argc - 1] & DT_IDFLG_REF)) { 18077c478bd9Sstevel@tonic-gate xyerror(D_MACRO_UNUSED, "extraneous argument '%s' ($%d is " 18087c478bd9Sstevel@tonic-gate "not referenced)\n", yypcb->pcb_sargv[argc - 1], argc - 1); 18097c478bd9Sstevel@tonic-gate } 18107c478bd9Sstevel@tonic-gate 18117c478bd9Sstevel@tonic-gate /* 18127c478bd9Sstevel@tonic-gate * If we have successfully created a parse tree for a D program, loop 18137c478bd9Sstevel@tonic-gate * over the clauses and actions and instantiate the corresponding 18147c478bd9Sstevel@tonic-gate * libdtrace program. If we are parsing a D expression, then we 18157c478bd9Sstevel@tonic-gate * simply run the code generator and assembler on the resulting tree. 18167c478bd9Sstevel@tonic-gate */ 18177c478bd9Sstevel@tonic-gate switch (context) { 18187c478bd9Sstevel@tonic-gate case DT_CTX_DPROG: 18197c478bd9Sstevel@tonic-gate assert(yypcb->pcb_root->dn_kind == DT_NODE_PROG); 18207c478bd9Sstevel@tonic-gate 18217c478bd9Sstevel@tonic-gate if ((dnp = yypcb->pcb_root->dn_list) == NULL && 18227c478bd9Sstevel@tonic-gate !(yypcb->pcb_cflags & DTRACE_C_EMPTY)) 18237c478bd9Sstevel@tonic-gate xyerror(D_EMPTY, "empty D program translation unit\n"); 18247c478bd9Sstevel@tonic-gate 18251a7c1b72Smws if ((yypcb->pcb_prog = dt_program_create(dtp)) == NULL) 18267c478bd9Sstevel@tonic-gate longjmp(yypcb->pcb_jmpbuf, dtrace_errno(dtp)); 18277c478bd9Sstevel@tonic-gate 18287c478bd9Sstevel@tonic-gate for (; dnp != NULL; dnp = dnp->dn_list) { 18297c478bd9Sstevel@tonic-gate switch (dnp->dn_kind) { 18307c478bd9Sstevel@tonic-gate case DT_NODE_CLAUSE: 18317c478bd9Sstevel@tonic-gate dt_compile_clause(dtp, dnp); 18327c478bd9Sstevel@tonic-gate break; 18331a7c1b72Smws case DT_NODE_XLATOR: 18341a7c1b72Smws if (dtp->dt_xlatemode == DT_XL_DYNAMIC) 18351a7c1b72Smws dt_compile_xlator(dnp); 18361a7c1b72Smws break; 18377c478bd9Sstevel@tonic-gate case DT_NODE_PROVIDER: 18387c478bd9Sstevel@tonic-gate (void) dt_node_cook(dnp, DT_IDFLG_REF); 18397c478bd9Sstevel@tonic-gate break; 18407c478bd9Sstevel@tonic-gate } 18417c478bd9Sstevel@tonic-gate } 18427c478bd9Sstevel@tonic-gate 18431a7c1b72Smws yypcb->pcb_prog->dp_xrefs = yypcb->pcb_asxrefs; 18441a7c1b72Smws yypcb->pcb_prog->dp_xrefslen = yypcb->pcb_asxreflen; 18451a7c1b72Smws yypcb->pcb_asxrefs = NULL; 18461a7c1b72Smws yypcb->pcb_asxreflen = 0; 18471a7c1b72Smws 18481a7c1b72Smws rv = yypcb->pcb_prog; 18497c478bd9Sstevel@tonic-gate break; 18507c478bd9Sstevel@tonic-gate 18517c478bd9Sstevel@tonic-gate case DT_CTX_DEXPR: 18527c478bd9Sstevel@tonic-gate (void) dt_node_cook(yypcb->pcb_root, DT_IDFLG_REF); 18537c478bd9Sstevel@tonic-gate dt_cg(yypcb, yypcb->pcb_root); 18547c478bd9Sstevel@tonic-gate rv = dt_as(yypcb); 18557c478bd9Sstevel@tonic-gate break; 18567c478bd9Sstevel@tonic-gate 18577c478bd9Sstevel@tonic-gate case DT_CTX_DTYPE: 18587c478bd9Sstevel@tonic-gate ddp = (dt_decl_t *)yypcb->pcb_root; /* root is really a decl */ 18597c478bd9Sstevel@tonic-gate err = dt_decl_type(ddp, arg); 18607c478bd9Sstevel@tonic-gate dt_decl_free(ddp); 18617c478bd9Sstevel@tonic-gate 18627c478bd9Sstevel@tonic-gate if (err != 0) 18637c478bd9Sstevel@tonic-gate longjmp(yypcb->pcb_jmpbuf, EDT_COMPILER); 18647c478bd9Sstevel@tonic-gate 18657c478bd9Sstevel@tonic-gate rv = NULL; 18667c478bd9Sstevel@tonic-gate break; 18677c478bd9Sstevel@tonic-gate } 18687c478bd9Sstevel@tonic-gate 18697c478bd9Sstevel@tonic-gate out: 18707c478bd9Sstevel@tonic-gate if (context != DT_CTX_DTYPE && DT_TREEDUMP_PASS(dtp, 3)) 18717c478bd9Sstevel@tonic-gate dt_node_printr(yypcb->pcb_root, stderr, 0); 18727c478bd9Sstevel@tonic-gate 18737c478bd9Sstevel@tonic-gate if (dtp->dt_cdefs_fd != -1 && (ftruncate64(dtp->dt_cdefs_fd, 0) == -1 || 18747c478bd9Sstevel@tonic-gate lseek64(dtp->dt_cdefs_fd, 0, SEEK_SET) == -1 || 18757c478bd9Sstevel@tonic-gate ctf_write(dtp->dt_cdefs->dm_ctfp, dtp->dt_cdefs_fd) == CTF_ERR)) 18767c478bd9Sstevel@tonic-gate dt_dprintf("failed to update CTF cache: %s\n", strerror(errno)); 18777c478bd9Sstevel@tonic-gate 18787c478bd9Sstevel@tonic-gate if (dtp->dt_ddefs_fd != -1 && (ftruncate64(dtp->dt_ddefs_fd, 0) == -1 || 18797c478bd9Sstevel@tonic-gate lseek64(dtp->dt_ddefs_fd, 0, SEEK_SET) == -1 || 18807c478bd9Sstevel@tonic-gate ctf_write(dtp->dt_ddefs->dm_ctfp, dtp->dt_ddefs_fd) == CTF_ERR)) 18817c478bd9Sstevel@tonic-gate dt_dprintf("failed to update CTF cache: %s\n", strerror(errno)); 18827c478bd9Sstevel@tonic-gate 18837c478bd9Sstevel@tonic-gate if (yypcb->pcb_fileptr && (cflags & DTRACE_C_CPP)) 18847c478bd9Sstevel@tonic-gate (void) fclose(yypcb->pcb_fileptr); /* close dt_preproc() file */ 18857c478bd9Sstevel@tonic-gate 18867c478bd9Sstevel@tonic-gate dt_pcb_pop(dtp, err); 18877c478bd9Sstevel@tonic-gate (void) dt_set_errno(dtp, err); 18887c478bd9Sstevel@tonic-gate return (err ? NULL : rv); 18897c478bd9Sstevel@tonic-gate } 18907c478bd9Sstevel@tonic-gate 18917c478bd9Sstevel@tonic-gate dtrace_prog_t * 18927c478bd9Sstevel@tonic-gate dtrace_program_strcompile(dtrace_hdl_t *dtp, const char *s, 18937c478bd9Sstevel@tonic-gate dtrace_probespec_t spec, uint_t cflags, int argc, char *const argv[]) 18947c478bd9Sstevel@tonic-gate { 18957c478bd9Sstevel@tonic-gate return (dt_compile(dtp, DT_CTX_DPROG, 18967c478bd9Sstevel@tonic-gate spec, NULL, cflags, argc, argv, NULL, s)); 18977c478bd9Sstevel@tonic-gate } 18987c478bd9Sstevel@tonic-gate 18997c478bd9Sstevel@tonic-gate dtrace_prog_t * 19007c478bd9Sstevel@tonic-gate dtrace_program_fcompile(dtrace_hdl_t *dtp, FILE *fp, 19017c478bd9Sstevel@tonic-gate uint_t cflags, int argc, char *const argv[]) 19027c478bd9Sstevel@tonic-gate { 19037c478bd9Sstevel@tonic-gate return (dt_compile(dtp, DT_CTX_DPROG, 19047c478bd9Sstevel@tonic-gate DTRACE_PROBESPEC_NAME, NULL, cflags, argc, argv, fp, NULL)); 19057c478bd9Sstevel@tonic-gate } 19067c478bd9Sstevel@tonic-gate 19077c478bd9Sstevel@tonic-gate int 19087c478bd9Sstevel@tonic-gate dtrace_type_strcompile(dtrace_hdl_t *dtp, const char *s, dtrace_typeinfo_t *dtt) 19097c478bd9Sstevel@tonic-gate { 19107c478bd9Sstevel@tonic-gate (void) dt_compile(dtp, DT_CTX_DTYPE, 19117c478bd9Sstevel@tonic-gate DTRACE_PROBESPEC_NONE, dtt, 0, 0, NULL, NULL, s); 19127c478bd9Sstevel@tonic-gate return (dtp->dt_errno ? -1 : 0); 19137c478bd9Sstevel@tonic-gate } 19147c478bd9Sstevel@tonic-gate 19157c478bd9Sstevel@tonic-gate int 19167c478bd9Sstevel@tonic-gate dtrace_type_fcompile(dtrace_hdl_t *dtp, FILE *fp, dtrace_typeinfo_t *dtt) 19177c478bd9Sstevel@tonic-gate { 19187c478bd9Sstevel@tonic-gate (void) dt_compile(dtp, DT_CTX_DTYPE, 19197c478bd9Sstevel@tonic-gate DTRACE_PROBESPEC_NONE, dtt, 0, 0, NULL, fp, NULL); 19207c478bd9Sstevel@tonic-gate return (dtp->dt_errno ? -1 : 0); 19217c478bd9Sstevel@tonic-gate } 1922