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 5c9d6cd77Sjhaslam * Common Development and Distribution License (the "License"). 6c9d6cd77Sjhaslam * You may not use this file except in compliance with the License. 77c478bd9Sstevel@tonic-gate * 87c478bd9Sstevel@tonic-gate * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE 97c478bd9Sstevel@tonic-gate * or http://www.opensolaris.org/os/licensing. 107c478bd9Sstevel@tonic-gate * See the License for the specific language governing permissions 117c478bd9Sstevel@tonic-gate * and limitations under the License. 127c478bd9Sstevel@tonic-gate * 137c478bd9Sstevel@tonic-gate * When distributing Covered Code, include this CDDL HEADER in each 147c478bd9Sstevel@tonic-gate * file and include the License file at usr/src/OPENSOLARIS.LICENSE. 157c478bd9Sstevel@tonic-gate * If applicable, add the following below this CDDL HEADER, with the 167c478bd9Sstevel@tonic-gate * fields enclosed by brackets "[]" replaced with your own identifying 177c478bd9Sstevel@tonic-gate * information: Portions Copyright [yyyy] [name of copyright owner] 187c478bd9Sstevel@tonic-gate * 197c478bd9Sstevel@tonic-gate * CDDL HEADER END 207c478bd9Sstevel@tonic-gate */ 21900524f3Sahl 227c478bd9Sstevel@tonic-gate /* 23c9a6ea2eSBryan Cantrill * Copyright (c) 2003, 2010, Oracle and/or its affiliates. All rights reserved. 245eb667acSRobert Mustacchi * Copyright (c) 2011, Joyent Inc. All rights reserved. 257c478bd9Sstevel@tonic-gate */ 267c478bd9Sstevel@tonic-gate 277c478bd9Sstevel@tonic-gate /* 287c478bd9Sstevel@tonic-gate * DTrace D Language Compiler 297c478bd9Sstevel@tonic-gate * 307c478bd9Sstevel@tonic-gate * The code in this source file implements the main engine for the D language 317c478bd9Sstevel@tonic-gate * compiler. The driver routine for the compiler is dt_compile(), below. The 327c478bd9Sstevel@tonic-gate * compiler operates on either stdio FILEs or in-memory strings as its input 337c478bd9Sstevel@tonic-gate * and can produce either dtrace_prog_t structures from a D program or a single 347c478bd9Sstevel@tonic-gate * dtrace_difo_t structure from a D expression. Multiple entry points are 357c478bd9Sstevel@tonic-gate * provided as wrappers around dt_compile() for the various input/output pairs. 367c478bd9Sstevel@tonic-gate * The compiler itself is implemented across the following source files: 377c478bd9Sstevel@tonic-gate * 387c478bd9Sstevel@tonic-gate * dt_lex.l - lex scanner 397c478bd9Sstevel@tonic-gate * dt_grammar.y - yacc grammar 407c478bd9Sstevel@tonic-gate * dt_parser.c - parse tree creation and semantic checking 417c478bd9Sstevel@tonic-gate * dt_decl.c - declaration stack processing 427c478bd9Sstevel@tonic-gate * dt_xlator.c - D translator lookup and creation 437c478bd9Sstevel@tonic-gate * dt_ident.c - identifier and symbol table routines 447c478bd9Sstevel@tonic-gate * dt_pragma.c - #pragma processing and D pragmas 457c478bd9Sstevel@tonic-gate * dt_printf.c - D printf() and printa() argument checking and processing 467c478bd9Sstevel@tonic-gate * dt_cc.c - compiler driver and dtrace_prog_t construction 477c478bd9Sstevel@tonic-gate * dt_cg.c - DIF code generator 487c478bd9Sstevel@tonic-gate * dt_as.c - DIF assembler 497c478bd9Sstevel@tonic-gate * dt_dof.c - dtrace_prog_t -> DOF conversion 507c478bd9Sstevel@tonic-gate * 517c478bd9Sstevel@tonic-gate * Several other source files provide collections of utility routines used by 527c478bd9Sstevel@tonic-gate * these major files. The compiler itself is implemented in multiple passes: 537c478bd9Sstevel@tonic-gate * 547c478bd9Sstevel@tonic-gate * (1) The input program is scanned and parsed by dt_lex.l and dt_grammar.y 557c478bd9Sstevel@tonic-gate * and parse tree nodes are constructed using the routines in dt_parser.c. 567c478bd9Sstevel@tonic-gate * This node construction pass is described further in dt_parser.c. 577c478bd9Sstevel@tonic-gate * 587c478bd9Sstevel@tonic-gate * (2) The parse tree is "cooked" by assigning each clause a context (see the 597c478bd9Sstevel@tonic-gate * routine dt_setcontext(), below) based on its probe description and then 607c478bd9Sstevel@tonic-gate * recursively descending the tree performing semantic checking. The cook 617c478bd9Sstevel@tonic-gate * routines are also implemented in dt_parser.c and described there. 627c478bd9Sstevel@tonic-gate * 637c478bd9Sstevel@tonic-gate * (3) For actions that are DIF expression statements, the DIF code generator 647c478bd9Sstevel@tonic-gate * and assembler are invoked to create a finished DIFO for the statement. 657c478bd9Sstevel@tonic-gate * 667c478bd9Sstevel@tonic-gate * (4) The dtrace_prog_t data structures for the program clauses and actions 677c478bd9Sstevel@tonic-gate * are built, containing pointers to any DIFOs created in step (3). 687c478bd9Sstevel@tonic-gate * 697c478bd9Sstevel@tonic-gate * (5) The caller invokes a routine in dt_dof.c to convert the finished program 707c478bd9Sstevel@tonic-gate * into DOF format for use in anonymous tracing or enabling in the kernel. 717c478bd9Sstevel@tonic-gate * 727c478bd9Sstevel@tonic-gate * In the implementation, steps 2-4 are intertwined in that they are performed 737c478bd9Sstevel@tonic-gate * in order for each clause as part of a loop that executes over the clauses. 747c478bd9Sstevel@tonic-gate * 757c478bd9Sstevel@tonic-gate * The D compiler currently implements nearly no optimization. The compiler 767c478bd9Sstevel@tonic-gate * implements integer constant folding as part of pass (1), and a set of very 777c478bd9Sstevel@tonic-gate * simple peephole optimizations as part of pass (3). As with any C compiler, 787c478bd9Sstevel@tonic-gate * a large number of optimizations are possible on both the intermediate data 797c478bd9Sstevel@tonic-gate * structures and the generated DIF code. These possibilities should be 807c478bd9Sstevel@tonic-gate * investigated in the context of whether they will have any substantive effect 817c478bd9Sstevel@tonic-gate * on the overall DTrace probe effect before they are undertaken. 827c478bd9Sstevel@tonic-gate */ 837c478bd9Sstevel@tonic-gate 847c478bd9Sstevel@tonic-gate #include <sys/types.h> 857c478bd9Sstevel@tonic-gate #include <sys/wait.h> 862b6389efSBryan Cantrill #include <sys/sysmacros.h> 877c478bd9Sstevel@tonic-gate 887c478bd9Sstevel@tonic-gate #include <assert.h> 897c478bd9Sstevel@tonic-gate #include <strings.h> 907c478bd9Sstevel@tonic-gate #include <signal.h> 917c478bd9Sstevel@tonic-gate #include <unistd.h> 927c478bd9Sstevel@tonic-gate #include <stdlib.h> 937c478bd9Sstevel@tonic-gate #include <stdio.h> 947c478bd9Sstevel@tonic-gate #include <errno.h> 957c478bd9Sstevel@tonic-gate #include <ucontext.h> 967c478bd9Sstevel@tonic-gate #include <limits.h> 977c478bd9Sstevel@tonic-gate #include <ctype.h> 987c478bd9Sstevel@tonic-gate #include <dirent.h> 997c478bd9Sstevel@tonic-gate #include <dt_module.h> 1001a7c1b72Smws #include <dt_program.h> 1017c478bd9Sstevel@tonic-gate #include <dt_provider.h> 1027c478bd9Sstevel@tonic-gate #include <dt_printf.h> 1037c478bd9Sstevel@tonic-gate #include <dt_pid.h> 1047c478bd9Sstevel@tonic-gate #include <dt_grammar.h> 1057c478bd9Sstevel@tonic-gate #include <dt_ident.h> 1067c478bd9Sstevel@tonic-gate #include <dt_string.h> 1077c478bd9Sstevel@tonic-gate #include <dt_impl.h> 1087c478bd9Sstevel@tonic-gate 1097c478bd9Sstevel@tonic-gate static const dtrace_diftype_t dt_void_rtype = { 1107c478bd9Sstevel@tonic-gate DIF_TYPE_CTF, CTF_K_INTEGER, 0, 0, 0 1117c478bd9Sstevel@tonic-gate }; 1127c478bd9Sstevel@tonic-gate 1137c478bd9Sstevel@tonic-gate static const dtrace_diftype_t dt_int_rtype = { 1147c478bd9Sstevel@tonic-gate DIF_TYPE_CTF, CTF_K_INTEGER, 0, 0, sizeof (uint64_t) 1157c478bd9Sstevel@tonic-gate }; 1167c478bd9Sstevel@tonic-gate 117c9d6cd77Sjhaslam static void *dt_compile(dtrace_hdl_t *, int, dtrace_probespec_t, void *, 118c9d6cd77Sjhaslam uint_t, int, char *const[], FILE *, const char *); 119c9d6cd77Sjhaslam 120c9d6cd77Sjhaslam 1217c478bd9Sstevel@tonic-gate /*ARGSUSED*/ 1227c478bd9Sstevel@tonic-gate static int 1237c478bd9Sstevel@tonic-gate dt_idreset(dt_idhash_t *dhp, dt_ident_t *idp, void *ignored) 1247c478bd9Sstevel@tonic-gate { 1257c478bd9Sstevel@tonic-gate idp->di_flags &= ~(DT_IDFLG_REF | DT_IDFLG_MOD | 1267c478bd9Sstevel@tonic-gate DT_IDFLG_DIFR | DT_IDFLG_DIFW); 1277c478bd9Sstevel@tonic-gate return (0); 1287c478bd9Sstevel@tonic-gate } 1297c478bd9Sstevel@tonic-gate 1307c478bd9Sstevel@tonic-gate /*ARGSUSED*/ 1317c478bd9Sstevel@tonic-gate static int 1327c478bd9Sstevel@tonic-gate dt_idpragma(dt_idhash_t *dhp, dt_ident_t *idp, void *ignored) 1337c478bd9Sstevel@tonic-gate { 1347c478bd9Sstevel@tonic-gate yylineno = idp->di_lineno; 1357c478bd9Sstevel@tonic-gate xyerror(D_PRAGMA_UNUSED, "unused #pragma %s\n", (char *)idp->di_iarg); 1367c478bd9Sstevel@tonic-gate return (0); 1377c478bd9Sstevel@tonic-gate } 1387c478bd9Sstevel@tonic-gate 1397c478bd9Sstevel@tonic-gate static dtrace_stmtdesc_t * 1407c478bd9Sstevel@tonic-gate dt_stmt_create(dtrace_hdl_t *dtp, dtrace_ecbdesc_t *edp, 1417c478bd9Sstevel@tonic-gate dtrace_attribute_t descattr, dtrace_attribute_t stmtattr) 1427c478bd9Sstevel@tonic-gate { 1437c478bd9Sstevel@tonic-gate dtrace_stmtdesc_t *sdp = dtrace_stmt_create(dtp, edp); 1447c478bd9Sstevel@tonic-gate 1457c478bd9Sstevel@tonic-gate if (sdp == NULL) 1467c478bd9Sstevel@tonic-gate longjmp(yypcb->pcb_jmpbuf, EDT_NOMEM); 1477c478bd9Sstevel@tonic-gate 1487c478bd9Sstevel@tonic-gate assert(yypcb->pcb_stmt == NULL); 1497c478bd9Sstevel@tonic-gate yypcb->pcb_stmt = sdp; 1507c478bd9Sstevel@tonic-gate 1517c478bd9Sstevel@tonic-gate sdp->dtsd_descattr = descattr; 1527c478bd9Sstevel@tonic-gate sdp->dtsd_stmtattr = stmtattr; 1537c478bd9Sstevel@tonic-gate 1547c478bd9Sstevel@tonic-gate return (sdp); 1557c478bd9Sstevel@tonic-gate } 1567c478bd9Sstevel@tonic-gate 1577c478bd9Sstevel@tonic-gate static dtrace_actdesc_t * 1587c478bd9Sstevel@tonic-gate dt_stmt_action(dtrace_hdl_t *dtp, dtrace_stmtdesc_t *sdp) 1597c478bd9Sstevel@tonic-gate { 1607c478bd9Sstevel@tonic-gate dtrace_actdesc_t *new; 1617c478bd9Sstevel@tonic-gate 1627c478bd9Sstevel@tonic-gate if ((new = dtrace_stmt_action(dtp, sdp)) == NULL) 1637c478bd9Sstevel@tonic-gate longjmp(yypcb->pcb_jmpbuf, EDT_NOMEM); 1647c478bd9Sstevel@tonic-gate 1657c478bd9Sstevel@tonic-gate return (new); 1667c478bd9Sstevel@tonic-gate } 1677c478bd9Sstevel@tonic-gate 1687c478bd9Sstevel@tonic-gate /* 1697c478bd9Sstevel@tonic-gate * Utility function to determine if a given action description is destructive. 1707c478bd9Sstevel@tonic-gate * The dtdo_destructive bit is set for us by the DIF assembler (see dt_as.c). 1717c478bd9Sstevel@tonic-gate */ 1727c478bd9Sstevel@tonic-gate static int 1737c478bd9Sstevel@tonic-gate dt_action_destructive(const dtrace_actdesc_t *ap) 1747c478bd9Sstevel@tonic-gate { 1757c478bd9Sstevel@tonic-gate return (DTRACEACT_ISDESTRUCTIVE(ap->dtad_kind) || (ap->dtad_kind == 1767c478bd9Sstevel@tonic-gate DTRACEACT_DIFEXPR && ap->dtad_difo->dtdo_destructive)); 1777c478bd9Sstevel@tonic-gate } 1787c478bd9Sstevel@tonic-gate 1797c478bd9Sstevel@tonic-gate static void 1807c478bd9Sstevel@tonic-gate dt_stmt_append(dtrace_stmtdesc_t *sdp, const dt_node_t *dnp) 1817c478bd9Sstevel@tonic-gate { 1827c478bd9Sstevel@tonic-gate dtrace_ecbdesc_t *edp = sdp->dtsd_ecbdesc; 1837c478bd9Sstevel@tonic-gate dtrace_actdesc_t *ap, *tap; 1847c478bd9Sstevel@tonic-gate int commit = 0; 1857c478bd9Sstevel@tonic-gate int speculate = 0; 1867c478bd9Sstevel@tonic-gate int datarec = 0; 1877c478bd9Sstevel@tonic-gate 1887c478bd9Sstevel@tonic-gate /* 1897c478bd9Sstevel@tonic-gate * Make sure that the new statement jibes with the rest of the ECB. 1907c478bd9Sstevel@tonic-gate */ 1917c478bd9Sstevel@tonic-gate for (ap = edp->dted_action; ap != NULL; ap = ap->dtad_next) { 1927c478bd9Sstevel@tonic-gate if (ap->dtad_kind == DTRACEACT_COMMIT) { 1937c478bd9Sstevel@tonic-gate if (commit) { 1947c478bd9Sstevel@tonic-gate dnerror(dnp, D_COMM_COMM, "commit( ) may " 1957c478bd9Sstevel@tonic-gate "not follow commit( )\n"); 1967c478bd9Sstevel@tonic-gate } 1977c478bd9Sstevel@tonic-gate 1987c478bd9Sstevel@tonic-gate if (datarec) { 1997c478bd9Sstevel@tonic-gate dnerror(dnp, D_COMM_DREC, "commit( ) may " 2007c478bd9Sstevel@tonic-gate "not follow data-recording action(s)\n"); 2017c478bd9Sstevel@tonic-gate } 2027c478bd9Sstevel@tonic-gate 2037c478bd9Sstevel@tonic-gate for (tap = ap; tap != NULL; tap = tap->dtad_next) { 2047c478bd9Sstevel@tonic-gate if (!DTRACEACT_ISAGG(tap->dtad_kind)) 2057c478bd9Sstevel@tonic-gate continue; 2067c478bd9Sstevel@tonic-gate 2077c478bd9Sstevel@tonic-gate dnerror(dnp, D_AGG_COMM, "aggregating actions " 2087c478bd9Sstevel@tonic-gate "may not follow commit( )\n"); 2097c478bd9Sstevel@tonic-gate } 2107c478bd9Sstevel@tonic-gate 2117c478bd9Sstevel@tonic-gate commit = 1; 2127c478bd9Sstevel@tonic-gate continue; 2137c478bd9Sstevel@tonic-gate } 2147c478bd9Sstevel@tonic-gate 2157c478bd9Sstevel@tonic-gate if (ap->dtad_kind == DTRACEACT_SPECULATE) { 2167c478bd9Sstevel@tonic-gate if (speculate) { 2177c478bd9Sstevel@tonic-gate dnerror(dnp, D_SPEC_SPEC, "speculate( ) may " 2187c478bd9Sstevel@tonic-gate "not follow speculate( )\n"); 2197c478bd9Sstevel@tonic-gate } 2207c478bd9Sstevel@tonic-gate 2217c478bd9Sstevel@tonic-gate if (commit) { 2227c478bd9Sstevel@tonic-gate dnerror(dnp, D_SPEC_COMM, "speculate( ) may " 2237c478bd9Sstevel@tonic-gate "not follow commit( )\n"); 2247c478bd9Sstevel@tonic-gate } 2257c478bd9Sstevel@tonic-gate 2267c478bd9Sstevel@tonic-gate if (datarec) { 2277c478bd9Sstevel@tonic-gate dnerror(dnp, D_SPEC_DREC, "speculate( ) may " 2287c478bd9Sstevel@tonic-gate "not follow data-recording action(s)\n"); 2297c478bd9Sstevel@tonic-gate } 2307c478bd9Sstevel@tonic-gate 2317c478bd9Sstevel@tonic-gate speculate = 1; 2327c478bd9Sstevel@tonic-gate continue; 2337c478bd9Sstevel@tonic-gate } 2347c478bd9Sstevel@tonic-gate 2357c478bd9Sstevel@tonic-gate if (DTRACEACT_ISAGG(ap->dtad_kind)) { 2367c478bd9Sstevel@tonic-gate if (speculate) { 2377c478bd9Sstevel@tonic-gate dnerror(dnp, D_AGG_SPEC, "aggregating actions " 2387c478bd9Sstevel@tonic-gate "may not follow speculate( )\n"); 2397c478bd9Sstevel@tonic-gate } 2407c478bd9Sstevel@tonic-gate 2417c478bd9Sstevel@tonic-gate datarec = 1; 2427c478bd9Sstevel@tonic-gate continue; 2437c478bd9Sstevel@tonic-gate } 2447c478bd9Sstevel@tonic-gate 2457c478bd9Sstevel@tonic-gate if (speculate) { 2467c478bd9Sstevel@tonic-gate if (dt_action_destructive(ap)) { 2477c478bd9Sstevel@tonic-gate dnerror(dnp, D_ACT_SPEC, "destructive actions " 2487c478bd9Sstevel@tonic-gate "may not follow speculate( )\n"); 2497c478bd9Sstevel@tonic-gate } 2507c478bd9Sstevel@tonic-gate 2517c478bd9Sstevel@tonic-gate if (ap->dtad_kind == DTRACEACT_EXIT) { 2527c478bd9Sstevel@tonic-gate dnerror(dnp, D_EXIT_SPEC, "exit( ) may not " 2537c478bd9Sstevel@tonic-gate "follow speculate( )\n"); 2547c478bd9Sstevel@tonic-gate } 2557c478bd9Sstevel@tonic-gate } 2567c478bd9Sstevel@tonic-gate 2577c478bd9Sstevel@tonic-gate /* 2587c478bd9Sstevel@tonic-gate * Exclude all non data-recording actions. 2597c478bd9Sstevel@tonic-gate */ 2607c478bd9Sstevel@tonic-gate if (dt_action_destructive(ap) || 2617c478bd9Sstevel@tonic-gate ap->dtad_kind == DTRACEACT_DISCARD) 2627c478bd9Sstevel@tonic-gate continue; 2637c478bd9Sstevel@tonic-gate 2647c478bd9Sstevel@tonic-gate if (ap->dtad_kind == DTRACEACT_DIFEXPR && 2657c478bd9Sstevel@tonic-gate ap->dtad_difo->dtdo_rtype.dtdt_kind == DIF_TYPE_CTF && 2667c478bd9Sstevel@tonic-gate ap->dtad_difo->dtdo_rtype.dtdt_size == 0) 2677c478bd9Sstevel@tonic-gate continue; 2687c478bd9Sstevel@tonic-gate 2697c478bd9Sstevel@tonic-gate if (commit) { 2707c478bd9Sstevel@tonic-gate dnerror(dnp, D_DREC_COMM, "data-recording actions " 2717c478bd9Sstevel@tonic-gate "may not follow commit( )\n"); 2727c478bd9Sstevel@tonic-gate } 2737c478bd9Sstevel@tonic-gate 2747c478bd9Sstevel@tonic-gate if (!speculate) 2757c478bd9Sstevel@tonic-gate datarec = 1; 2767c478bd9Sstevel@tonic-gate } 2777c478bd9Sstevel@tonic-gate 2787c478bd9Sstevel@tonic-gate if (dtrace_stmt_add(yypcb->pcb_hdl, yypcb->pcb_prog, sdp) != 0) 2797c478bd9Sstevel@tonic-gate longjmp(yypcb->pcb_jmpbuf, dtrace_errno(yypcb->pcb_hdl)); 2807c478bd9Sstevel@tonic-gate 2817c478bd9Sstevel@tonic-gate if (yypcb->pcb_stmt == sdp) 2827c478bd9Sstevel@tonic-gate yypcb->pcb_stmt = NULL; 2837c478bd9Sstevel@tonic-gate } 2847c478bd9Sstevel@tonic-gate 2857c478bd9Sstevel@tonic-gate /* 2867c478bd9Sstevel@tonic-gate * For the first element of an aggregation tuple or for printa(), we create a 2877c478bd9Sstevel@tonic-gate * simple DIF program that simply returns the immediate value that is the ID 2887c478bd9Sstevel@tonic-gate * of the aggregation itself. This could be optimized in the future by 2897c478bd9Sstevel@tonic-gate * creating a new in-kernel dtad_kind that just returns an integer. 2907c478bd9Sstevel@tonic-gate */ 2917c478bd9Sstevel@tonic-gate static void 2927c478bd9Sstevel@tonic-gate dt_action_difconst(dtrace_actdesc_t *ap, uint_t id, dtrace_actkind_t kind) 2937c478bd9Sstevel@tonic-gate { 2941a7c1b72Smws dtrace_hdl_t *dtp = yypcb->pcb_hdl; 2951a7c1b72Smws dtrace_difo_t *dp = dt_zalloc(dtp, sizeof (dtrace_difo_t)); 2967c478bd9Sstevel@tonic-gate 2977c478bd9Sstevel@tonic-gate if (dp == NULL) 2987c478bd9Sstevel@tonic-gate longjmp(yypcb->pcb_jmpbuf, EDT_NOMEM); 2997c478bd9Sstevel@tonic-gate 3001a7c1b72Smws dp->dtdo_buf = dt_alloc(dtp, sizeof (dif_instr_t) * 2); 3011a7c1b72Smws dp->dtdo_inttab = dt_alloc(dtp, sizeof (uint64_t)); 3027c478bd9Sstevel@tonic-gate 3037c478bd9Sstevel@tonic-gate if (dp->dtdo_buf == NULL || dp->dtdo_inttab == NULL) { 3041a7c1b72Smws dt_difo_free(dtp, dp); 3057c478bd9Sstevel@tonic-gate longjmp(yypcb->pcb_jmpbuf, EDT_NOMEM); 3067c478bd9Sstevel@tonic-gate } 3077c478bd9Sstevel@tonic-gate 3087c478bd9Sstevel@tonic-gate dp->dtdo_buf[0] = DIF_INSTR_SETX(0, 1); /* setx DIF_INTEGER[0], %r1 */ 3097c478bd9Sstevel@tonic-gate dp->dtdo_buf[1] = DIF_INSTR_RET(1); /* ret %r1 */ 3107c478bd9Sstevel@tonic-gate dp->dtdo_len = 2; 3117c478bd9Sstevel@tonic-gate dp->dtdo_inttab[0] = id; 3127c478bd9Sstevel@tonic-gate dp->dtdo_intlen = 1; 3137c478bd9Sstevel@tonic-gate dp->dtdo_rtype = dt_int_rtype; 3147c478bd9Sstevel@tonic-gate 3157c478bd9Sstevel@tonic-gate ap->dtad_difo = dp; 3167c478bd9Sstevel@tonic-gate ap->dtad_kind = kind; 3177c478bd9Sstevel@tonic-gate } 3187c478bd9Sstevel@tonic-gate 3197c478bd9Sstevel@tonic-gate static void 3207c478bd9Sstevel@tonic-gate dt_action_clear(dtrace_hdl_t *dtp, dt_node_t *dnp, dtrace_stmtdesc_t *sdp) 3217c478bd9Sstevel@tonic-gate { 3227c478bd9Sstevel@tonic-gate dt_ident_t *aid; 3237c478bd9Sstevel@tonic-gate dtrace_actdesc_t *ap; 3247c478bd9Sstevel@tonic-gate dt_node_t *anp; 3257c478bd9Sstevel@tonic-gate 3267c478bd9Sstevel@tonic-gate char n[DT_TYPE_NAMELEN]; 3277c478bd9Sstevel@tonic-gate int argc = 0; 3287c478bd9Sstevel@tonic-gate 3297c478bd9Sstevel@tonic-gate for (anp = dnp->dn_args; anp != NULL; anp = anp->dn_list) 3307c478bd9Sstevel@tonic-gate argc++; /* count up arguments for error messages below */ 3317c478bd9Sstevel@tonic-gate 3327c478bd9Sstevel@tonic-gate if (argc != 1) { 3337c478bd9Sstevel@tonic-gate dnerror(dnp, D_CLEAR_PROTO, 3347c478bd9Sstevel@tonic-gate "%s( ) prototype mismatch: %d args passed, 1 expected\n", 3357c478bd9Sstevel@tonic-gate dnp->dn_ident->di_name, argc); 3367c478bd9Sstevel@tonic-gate } 3377c478bd9Sstevel@tonic-gate 3387c478bd9Sstevel@tonic-gate anp = dnp->dn_args; 3397c478bd9Sstevel@tonic-gate assert(anp != NULL); 3407c478bd9Sstevel@tonic-gate 3417c478bd9Sstevel@tonic-gate if (anp->dn_kind != DT_NODE_AGG) { 3427c478bd9Sstevel@tonic-gate dnerror(dnp, D_CLEAR_AGGARG, 3437c478bd9Sstevel@tonic-gate "%s( ) argument #1 is incompatible with prototype:\n" 3447c478bd9Sstevel@tonic-gate "\tprototype: aggregation\n\t argument: %s\n", 3457c478bd9Sstevel@tonic-gate dnp->dn_ident->di_name, 3467c478bd9Sstevel@tonic-gate dt_node_type_name(anp, n, sizeof (n))); 3477c478bd9Sstevel@tonic-gate } 3487c478bd9Sstevel@tonic-gate 3497c478bd9Sstevel@tonic-gate aid = anp->dn_ident; 3507c478bd9Sstevel@tonic-gate 3517c478bd9Sstevel@tonic-gate if (aid->di_gen == dtp->dt_gen && !(aid->di_flags & DT_IDFLG_MOD)) { 3527c478bd9Sstevel@tonic-gate dnerror(dnp, D_CLEAR_AGGBAD, 3537c478bd9Sstevel@tonic-gate "undefined aggregation: @%s\n", aid->di_name); 3547c478bd9Sstevel@tonic-gate } 3557c478bd9Sstevel@tonic-gate 3567c478bd9Sstevel@tonic-gate ap = dt_stmt_action(dtp, sdp); 3577c478bd9Sstevel@tonic-gate dt_action_difconst(ap, anp->dn_ident->di_id, DTRACEACT_LIBACT); 3587c478bd9Sstevel@tonic-gate ap->dtad_arg = DT_ACT_CLEAR; 3597c478bd9Sstevel@tonic-gate } 3607c478bd9Sstevel@tonic-gate 3617c478bd9Sstevel@tonic-gate static void 3627c478bd9Sstevel@tonic-gate dt_action_normalize(dtrace_hdl_t *dtp, dt_node_t *dnp, dtrace_stmtdesc_t *sdp) 3637c478bd9Sstevel@tonic-gate { 3647c478bd9Sstevel@tonic-gate dt_ident_t *aid; 3657c478bd9Sstevel@tonic-gate dtrace_actdesc_t *ap; 3667c478bd9Sstevel@tonic-gate dt_node_t *anp, *normal; 3677c478bd9Sstevel@tonic-gate int denormal = (strcmp(dnp->dn_ident->di_name, "denormalize") == 0); 3687c478bd9Sstevel@tonic-gate 3697c478bd9Sstevel@tonic-gate char n[DT_TYPE_NAMELEN]; 3707c478bd9Sstevel@tonic-gate int argc = 0; 3717c478bd9Sstevel@tonic-gate 3727c478bd9Sstevel@tonic-gate for (anp = dnp->dn_args; anp != NULL; anp = anp->dn_list) 3737c478bd9Sstevel@tonic-gate argc++; /* count up arguments for error messages below */ 3747c478bd9Sstevel@tonic-gate 3757c478bd9Sstevel@tonic-gate if ((denormal && argc != 1) || (!denormal && argc != 2)) { 3767c478bd9Sstevel@tonic-gate dnerror(dnp, D_NORMALIZE_PROTO, 3777c478bd9Sstevel@tonic-gate "%s( ) prototype mismatch: %d args passed, %d expected\n", 3787c478bd9Sstevel@tonic-gate dnp->dn_ident->di_name, argc, denormal ? 1 : 2); 3797c478bd9Sstevel@tonic-gate } 3807c478bd9Sstevel@tonic-gate 3817c478bd9Sstevel@tonic-gate anp = dnp->dn_args; 3827c478bd9Sstevel@tonic-gate assert(anp != NULL); 3837c478bd9Sstevel@tonic-gate 3847c478bd9Sstevel@tonic-gate if (anp->dn_kind != DT_NODE_AGG) { 3857c478bd9Sstevel@tonic-gate dnerror(dnp, D_NORMALIZE_AGGARG, 3867c478bd9Sstevel@tonic-gate "%s( ) argument #1 is incompatible with prototype:\n" 3877c478bd9Sstevel@tonic-gate "\tprototype: aggregation\n\t argument: %s\n", 3887c478bd9Sstevel@tonic-gate dnp->dn_ident->di_name, 3897c478bd9Sstevel@tonic-gate dt_node_type_name(anp, n, sizeof (n))); 3907c478bd9Sstevel@tonic-gate } 3917c478bd9Sstevel@tonic-gate 3927c478bd9Sstevel@tonic-gate if ((normal = anp->dn_list) != NULL && !dt_node_is_scalar(normal)) { 3937c478bd9Sstevel@tonic-gate dnerror(dnp, D_NORMALIZE_SCALAR, 3947c478bd9Sstevel@tonic-gate "%s( ) argument #2 must be of scalar type\n", 3957c478bd9Sstevel@tonic-gate dnp->dn_ident->di_name); 3967c478bd9Sstevel@tonic-gate } 3977c478bd9Sstevel@tonic-gate 3987c478bd9Sstevel@tonic-gate aid = anp->dn_ident; 3997c478bd9Sstevel@tonic-gate 4007c478bd9Sstevel@tonic-gate if (aid->di_gen == dtp->dt_gen && !(aid->di_flags & DT_IDFLG_MOD)) { 4017c478bd9Sstevel@tonic-gate dnerror(dnp, D_NORMALIZE_AGGBAD, 4027c478bd9Sstevel@tonic-gate "undefined aggregation: @%s\n", aid->di_name); 4037c478bd9Sstevel@tonic-gate } 4047c478bd9Sstevel@tonic-gate 4057c478bd9Sstevel@tonic-gate ap = dt_stmt_action(dtp, sdp); 4067c478bd9Sstevel@tonic-gate dt_action_difconst(ap, anp->dn_ident->di_id, DTRACEACT_LIBACT); 4077c478bd9Sstevel@tonic-gate 4087c478bd9Sstevel@tonic-gate if (denormal) { 4097c478bd9Sstevel@tonic-gate ap->dtad_arg = DT_ACT_DENORMALIZE; 4107c478bd9Sstevel@tonic-gate return; 4117c478bd9Sstevel@tonic-gate } 4127c478bd9Sstevel@tonic-gate 4137c478bd9Sstevel@tonic-gate ap->dtad_arg = DT_ACT_NORMALIZE; 4147c478bd9Sstevel@tonic-gate 4157c478bd9Sstevel@tonic-gate assert(normal != NULL); 4167c478bd9Sstevel@tonic-gate ap = dt_stmt_action(dtp, sdp); 4177c478bd9Sstevel@tonic-gate dt_cg(yypcb, normal); 4187c478bd9Sstevel@tonic-gate 4197c478bd9Sstevel@tonic-gate ap->dtad_difo = dt_as(yypcb); 4207c478bd9Sstevel@tonic-gate ap->dtad_kind = DTRACEACT_LIBACT; 4217c478bd9Sstevel@tonic-gate ap->dtad_arg = DT_ACT_NORMALIZE; 4227c478bd9Sstevel@tonic-gate } 4237c478bd9Sstevel@tonic-gate 4247c478bd9Sstevel@tonic-gate static void 4257c478bd9Sstevel@tonic-gate dt_action_trunc(dtrace_hdl_t *dtp, dt_node_t *dnp, dtrace_stmtdesc_t *sdp) 4267c478bd9Sstevel@tonic-gate { 4277c478bd9Sstevel@tonic-gate dt_ident_t *aid; 4287c478bd9Sstevel@tonic-gate dtrace_actdesc_t *ap; 4297c478bd9Sstevel@tonic-gate dt_node_t *anp, *trunc; 4307c478bd9Sstevel@tonic-gate 4317c478bd9Sstevel@tonic-gate char n[DT_TYPE_NAMELEN]; 4327c478bd9Sstevel@tonic-gate int argc = 0; 4337c478bd9Sstevel@tonic-gate 4347c478bd9Sstevel@tonic-gate for (anp = dnp->dn_args; anp != NULL; anp = anp->dn_list) 4357c478bd9Sstevel@tonic-gate argc++; /* count up arguments for error messages below */ 4367c478bd9Sstevel@tonic-gate 4377c478bd9Sstevel@tonic-gate if (argc > 2 || argc < 1) { 4387c478bd9Sstevel@tonic-gate dnerror(dnp, D_TRUNC_PROTO, 4397c478bd9Sstevel@tonic-gate "%s( ) prototype mismatch: %d args passed, %s expected\n", 4407c478bd9Sstevel@tonic-gate dnp->dn_ident->di_name, argc, 4417c478bd9Sstevel@tonic-gate argc < 1 ? "at least 1" : "no more than 2"); 4427c478bd9Sstevel@tonic-gate } 4437c478bd9Sstevel@tonic-gate 4447c478bd9Sstevel@tonic-gate anp = dnp->dn_args; 4457c478bd9Sstevel@tonic-gate assert(anp != NULL); 4467c478bd9Sstevel@tonic-gate trunc = anp->dn_list; 4477c478bd9Sstevel@tonic-gate 4487c478bd9Sstevel@tonic-gate if (anp->dn_kind != DT_NODE_AGG) { 4497c478bd9Sstevel@tonic-gate dnerror(dnp, D_TRUNC_AGGARG, 4507c478bd9Sstevel@tonic-gate "%s( ) argument #1 is incompatible with prototype:\n" 4517c478bd9Sstevel@tonic-gate "\tprototype: aggregation\n\t argument: %s\n", 4527c478bd9Sstevel@tonic-gate dnp->dn_ident->di_name, 4537c478bd9Sstevel@tonic-gate dt_node_type_name(anp, n, sizeof (n))); 4547c478bd9Sstevel@tonic-gate } 4557c478bd9Sstevel@tonic-gate 4567c478bd9Sstevel@tonic-gate if (argc == 2) { 4577c478bd9Sstevel@tonic-gate assert(trunc != NULL); 4587c478bd9Sstevel@tonic-gate if (!dt_node_is_scalar(trunc)) { 4597c478bd9Sstevel@tonic-gate dnerror(dnp, D_TRUNC_SCALAR, 4607c478bd9Sstevel@tonic-gate "%s( ) argument #2 must be of scalar type\n", 4617c478bd9Sstevel@tonic-gate dnp->dn_ident->di_name); 4627c478bd9Sstevel@tonic-gate } 4637c478bd9Sstevel@tonic-gate } 4647c478bd9Sstevel@tonic-gate 4657c478bd9Sstevel@tonic-gate aid = anp->dn_ident; 4667c478bd9Sstevel@tonic-gate 4677c478bd9Sstevel@tonic-gate if (aid->di_gen == dtp->dt_gen && !(aid->di_flags & DT_IDFLG_MOD)) { 4687c478bd9Sstevel@tonic-gate dnerror(dnp, D_TRUNC_AGGBAD, 4697c478bd9Sstevel@tonic-gate "undefined aggregation: @%s\n", aid->di_name); 4707c478bd9Sstevel@tonic-gate } 4717c478bd9Sstevel@tonic-gate 4727c478bd9Sstevel@tonic-gate ap = dt_stmt_action(dtp, sdp); 4737c478bd9Sstevel@tonic-gate dt_action_difconst(ap, anp->dn_ident->di_id, DTRACEACT_LIBACT); 4747c478bd9Sstevel@tonic-gate ap->dtad_arg = DT_ACT_TRUNC; 4757c478bd9Sstevel@tonic-gate 4767c478bd9Sstevel@tonic-gate ap = dt_stmt_action(dtp, sdp); 4777c478bd9Sstevel@tonic-gate 4787c478bd9Sstevel@tonic-gate if (argc == 1) { 4797c478bd9Sstevel@tonic-gate dt_action_difconst(ap, 0, DTRACEACT_LIBACT); 4807c478bd9Sstevel@tonic-gate } else { 4817c478bd9Sstevel@tonic-gate assert(trunc != NULL); 4827c478bd9Sstevel@tonic-gate dt_cg(yypcb, trunc); 4837c478bd9Sstevel@tonic-gate ap->dtad_difo = dt_as(yypcb); 4847c478bd9Sstevel@tonic-gate ap->dtad_kind = DTRACEACT_LIBACT; 4857c478bd9Sstevel@tonic-gate } 4867c478bd9Sstevel@tonic-gate 4877c478bd9Sstevel@tonic-gate ap->dtad_arg = DT_ACT_TRUNC; 4887c478bd9Sstevel@tonic-gate } 4897c478bd9Sstevel@tonic-gate 4907c478bd9Sstevel@tonic-gate static void 4917c478bd9Sstevel@tonic-gate dt_action_printa(dtrace_hdl_t *dtp, dt_node_t *dnp, dtrace_stmtdesc_t *sdp) 4927c478bd9Sstevel@tonic-gate { 4937c478bd9Sstevel@tonic-gate dt_ident_t *aid, *fid; 4947c478bd9Sstevel@tonic-gate dtrace_actdesc_t *ap; 4957c478bd9Sstevel@tonic-gate const char *format; 49630ef842dSbmc dt_node_t *anp, *proto = NULL; 4977c478bd9Sstevel@tonic-gate 4987c478bd9Sstevel@tonic-gate char n[DT_TYPE_NAMELEN]; 4997c478bd9Sstevel@tonic-gate int argc = 0, argr = 0; 5007c478bd9Sstevel@tonic-gate 5017c478bd9Sstevel@tonic-gate for (anp = dnp->dn_args; anp != NULL; anp = anp->dn_list) 5027c478bd9Sstevel@tonic-gate argc++; /* count up arguments for error messages below */ 5037c478bd9Sstevel@tonic-gate 5047c478bd9Sstevel@tonic-gate switch (dnp->dn_args->dn_kind) { 5057c478bd9Sstevel@tonic-gate case DT_NODE_STRING: 5067c478bd9Sstevel@tonic-gate format = dnp->dn_args->dn_string; 5077c478bd9Sstevel@tonic-gate anp = dnp->dn_args->dn_list; 5087c478bd9Sstevel@tonic-gate argr = 2; 5097c478bd9Sstevel@tonic-gate break; 5107c478bd9Sstevel@tonic-gate case DT_NODE_AGG: 5117c478bd9Sstevel@tonic-gate format = NULL; 5127c478bd9Sstevel@tonic-gate anp = dnp->dn_args; 5137c478bd9Sstevel@tonic-gate argr = 1; 5147c478bd9Sstevel@tonic-gate break; 5157c478bd9Sstevel@tonic-gate default: 5167c478bd9Sstevel@tonic-gate format = NULL; 5177c478bd9Sstevel@tonic-gate anp = dnp->dn_args; 5187c478bd9Sstevel@tonic-gate argr = 1; 5197c478bd9Sstevel@tonic-gate } 5207c478bd9Sstevel@tonic-gate 52130ef842dSbmc if (argc < argr) { 5227c478bd9Sstevel@tonic-gate dnerror(dnp, D_PRINTA_PROTO, 5237c478bd9Sstevel@tonic-gate "%s( ) prototype mismatch: %d args passed, %d expected\n", 5247c478bd9Sstevel@tonic-gate dnp->dn_ident->di_name, argc, argr); 5257c478bd9Sstevel@tonic-gate } 5267c478bd9Sstevel@tonic-gate 52730ef842dSbmc assert(anp != NULL); 5287c478bd9Sstevel@tonic-gate 52930ef842dSbmc while (anp != NULL) { 53030ef842dSbmc if (anp->dn_kind != DT_NODE_AGG) { 53130ef842dSbmc dnerror(dnp, D_PRINTA_AGGARG, 53230ef842dSbmc "%s( ) argument #%d is incompatible with " 53330ef842dSbmc "prototype:\n\tprototype: aggregation\n" 53430ef842dSbmc "\t argument: %s\n", dnp->dn_ident->di_name, argr, 53530ef842dSbmc dt_node_type_name(anp, n, sizeof (n))); 53630ef842dSbmc } 5377c478bd9Sstevel@tonic-gate 53830ef842dSbmc aid = anp->dn_ident; 53930ef842dSbmc fid = aid->di_iarg; 5407c478bd9Sstevel@tonic-gate 54130ef842dSbmc if (aid->di_gen == dtp->dt_gen && 54230ef842dSbmc !(aid->di_flags & DT_IDFLG_MOD)) { 54330ef842dSbmc dnerror(dnp, D_PRINTA_AGGBAD, 54430ef842dSbmc "undefined aggregation: @%s\n", aid->di_name); 54530ef842dSbmc } 5467c478bd9Sstevel@tonic-gate 54730ef842dSbmc /* 54830ef842dSbmc * If we have multiple aggregations, we must be sure that 54930ef842dSbmc * their key signatures match. 55030ef842dSbmc */ 55130ef842dSbmc if (proto != NULL) { 55230ef842dSbmc dt_printa_validate(proto, anp); 55330ef842dSbmc } else { 55430ef842dSbmc proto = anp; 55530ef842dSbmc } 5567c478bd9Sstevel@tonic-gate 55730ef842dSbmc if (format != NULL) { 55830ef842dSbmc yylineno = dnp->dn_line; 55930ef842dSbmc 56030ef842dSbmc sdp->dtsd_fmtdata = 56130ef842dSbmc dt_printf_create(yypcb->pcb_hdl, format); 56230ef842dSbmc dt_printf_validate(sdp->dtsd_fmtdata, 56330ef842dSbmc DT_PRINTF_AGGREGATION, dnp->dn_ident, 1, 56430ef842dSbmc fid->di_id, ((dt_idsig_t *)aid->di_data)->dis_args); 56530ef842dSbmc format = NULL; 56630ef842dSbmc } 56730ef842dSbmc 56830ef842dSbmc ap = dt_stmt_action(dtp, sdp); 56930ef842dSbmc dt_action_difconst(ap, anp->dn_ident->di_id, DTRACEACT_PRINTA); 57030ef842dSbmc 57130ef842dSbmc anp = anp->dn_list; 57230ef842dSbmc argr++; 57330ef842dSbmc } 5747c478bd9Sstevel@tonic-gate } 5757c478bd9Sstevel@tonic-gate 5767c478bd9Sstevel@tonic-gate static void 5777c478bd9Sstevel@tonic-gate dt_action_printflike(dtrace_hdl_t *dtp, dt_node_t *dnp, dtrace_stmtdesc_t *sdp, 5787c478bd9Sstevel@tonic-gate dtrace_actkind_t kind) 5797c478bd9Sstevel@tonic-gate { 5807c478bd9Sstevel@tonic-gate dt_node_t *anp, *arg1; 5817c478bd9Sstevel@tonic-gate dtrace_actdesc_t *ap = NULL; 5827c478bd9Sstevel@tonic-gate char n[DT_TYPE_NAMELEN], *str; 5837c478bd9Sstevel@tonic-gate 5847c478bd9Sstevel@tonic-gate assert(DTRACEACT_ISPRINTFLIKE(kind)); 5857c478bd9Sstevel@tonic-gate 5867c478bd9Sstevel@tonic-gate if (dnp->dn_args->dn_kind != DT_NODE_STRING) { 5877c478bd9Sstevel@tonic-gate dnerror(dnp, D_PRINTF_ARG_FMT, 5887c478bd9Sstevel@tonic-gate "%s( ) argument #1 is incompatible with prototype:\n" 5897c478bd9Sstevel@tonic-gate "\tprototype: string constant\n\t argument: %s\n", 5907c478bd9Sstevel@tonic-gate dnp->dn_ident->di_name, 5917c478bd9Sstevel@tonic-gate dt_node_type_name(dnp->dn_args, n, sizeof (n))); 5927c478bd9Sstevel@tonic-gate } 5937c478bd9Sstevel@tonic-gate 5947c478bd9Sstevel@tonic-gate arg1 = dnp->dn_args->dn_list; 5957c478bd9Sstevel@tonic-gate yylineno = dnp->dn_line; 5967c478bd9Sstevel@tonic-gate str = dnp->dn_args->dn_string; 5977c478bd9Sstevel@tonic-gate 5987c478bd9Sstevel@tonic-gate 5997c478bd9Sstevel@tonic-gate /* 6007c478bd9Sstevel@tonic-gate * If this is an freopen(), we use an empty string to denote that 6017c478bd9Sstevel@tonic-gate * stdout should be restored. For other printf()-like actions, an 6027c478bd9Sstevel@tonic-gate * empty format string is illegal: an empty format string would 6037c478bd9Sstevel@tonic-gate * result in malformed DOF, and the compiler thus flags an empty 6047c478bd9Sstevel@tonic-gate * format string as a compile-time error. To avoid propagating the 6057c478bd9Sstevel@tonic-gate * freopen() special case throughout the system, we simply transpose 6067c478bd9Sstevel@tonic-gate * an empty string into a sentinel string (DT_FREOPEN_RESTORE) that 6077c478bd9Sstevel@tonic-gate * denotes that stdout should be restored. 6087c478bd9Sstevel@tonic-gate */ 6097c478bd9Sstevel@tonic-gate if (kind == DTRACEACT_FREOPEN) { 6107c478bd9Sstevel@tonic-gate if (strcmp(str, DT_FREOPEN_RESTORE) == 0) { 6117c478bd9Sstevel@tonic-gate /* 6127c478bd9Sstevel@tonic-gate * Our sentinel is always an invalid argument to 6137c478bd9Sstevel@tonic-gate * freopen(), but if it's been manually specified, we 6147c478bd9Sstevel@tonic-gate * must fail now instead of when the freopen() is 6157c478bd9Sstevel@tonic-gate * actually evaluated. 6167c478bd9Sstevel@tonic-gate */ 6177c478bd9Sstevel@tonic-gate dnerror(dnp, D_FREOPEN_INVALID, 6187c478bd9Sstevel@tonic-gate "%s( ) argument #1 cannot be \"%s\"\n", 6197c478bd9Sstevel@tonic-gate dnp->dn_ident->di_name, DT_FREOPEN_RESTORE); 6207c478bd9Sstevel@tonic-gate } 6217c478bd9Sstevel@tonic-gate 6227c478bd9Sstevel@tonic-gate if (str[0] == '\0') 6237c478bd9Sstevel@tonic-gate str = DT_FREOPEN_RESTORE; 6247c478bd9Sstevel@tonic-gate } 6257c478bd9Sstevel@tonic-gate 6261a7c1b72Smws sdp->dtsd_fmtdata = dt_printf_create(dtp, str); 6277c478bd9Sstevel@tonic-gate 6287c478bd9Sstevel@tonic-gate dt_printf_validate(sdp->dtsd_fmtdata, DT_PRINTF_EXACTLEN, 6297c478bd9Sstevel@tonic-gate dnp->dn_ident, 1, DTRACEACT_AGGREGATION, arg1); 6307c478bd9Sstevel@tonic-gate 6317c478bd9Sstevel@tonic-gate if (arg1 == NULL) { 6327c478bd9Sstevel@tonic-gate dif_instr_t *dbuf; 6337c478bd9Sstevel@tonic-gate dtrace_difo_t *dp; 6347c478bd9Sstevel@tonic-gate 6351a7c1b72Smws if ((dbuf = dt_alloc(dtp, sizeof (dif_instr_t))) == NULL || 6361a7c1b72Smws (dp = dt_zalloc(dtp, sizeof (dtrace_difo_t))) == NULL) { 6371a7c1b72Smws dt_free(dtp, dbuf); 6387c478bd9Sstevel@tonic-gate longjmp(yypcb->pcb_jmpbuf, EDT_NOMEM); 6397c478bd9Sstevel@tonic-gate } 6407c478bd9Sstevel@tonic-gate 6417c478bd9Sstevel@tonic-gate dbuf[0] = DIF_INSTR_RET(DIF_REG_R0); /* ret %r0 */ 6427c478bd9Sstevel@tonic-gate 6437c478bd9Sstevel@tonic-gate dp->dtdo_buf = dbuf; 6447c478bd9Sstevel@tonic-gate dp->dtdo_len = 1; 6457c478bd9Sstevel@tonic-gate dp->dtdo_rtype = dt_int_rtype; 6467c478bd9Sstevel@tonic-gate 6477c478bd9Sstevel@tonic-gate ap = dt_stmt_action(dtp, sdp); 6487c478bd9Sstevel@tonic-gate ap->dtad_difo = dp; 6497c478bd9Sstevel@tonic-gate ap->dtad_kind = kind; 6507c478bd9Sstevel@tonic-gate return; 6517c478bd9Sstevel@tonic-gate } 6527c478bd9Sstevel@tonic-gate 6537c478bd9Sstevel@tonic-gate for (anp = arg1; anp != NULL; anp = anp->dn_list) { 6547c478bd9Sstevel@tonic-gate ap = dt_stmt_action(dtp, sdp); 6557c478bd9Sstevel@tonic-gate dt_cg(yypcb, anp); 6567c478bd9Sstevel@tonic-gate ap->dtad_difo = dt_as(yypcb); 6577c478bd9Sstevel@tonic-gate ap->dtad_kind = kind; 6587c478bd9Sstevel@tonic-gate } 6597c478bd9Sstevel@tonic-gate } 6607c478bd9Sstevel@tonic-gate 6617c478bd9Sstevel@tonic-gate static void 6627c478bd9Sstevel@tonic-gate dt_action_trace(dtrace_hdl_t *dtp, dt_node_t *dnp, dtrace_stmtdesc_t *sdp) 6637c478bd9Sstevel@tonic-gate { 6647c478bd9Sstevel@tonic-gate dtrace_actdesc_t *ap = dt_stmt_action(dtp, sdp); 6657c478bd9Sstevel@tonic-gate 6667c478bd9Sstevel@tonic-gate if (dt_node_is_void(dnp->dn_args)) { 6677c478bd9Sstevel@tonic-gate dnerror(dnp->dn_args, D_TRACE_VOID, 6687c478bd9Sstevel@tonic-gate "trace( ) may not be applied to a void expression\n"); 6697c478bd9Sstevel@tonic-gate } 6707c478bd9Sstevel@tonic-gate 6717c478bd9Sstevel@tonic-gate if (dt_node_is_dynamic(dnp->dn_args)) { 6727c478bd9Sstevel@tonic-gate dnerror(dnp->dn_args, D_TRACE_DYN, 6737c478bd9Sstevel@tonic-gate "trace( ) may not be applied to a dynamic expression\n"); 6747c478bd9Sstevel@tonic-gate } 6757c478bd9Sstevel@tonic-gate 6767c478bd9Sstevel@tonic-gate dt_cg(yypcb, dnp->dn_args); 6777c478bd9Sstevel@tonic-gate ap->dtad_difo = dt_as(yypcb); 6787c478bd9Sstevel@tonic-gate ap->dtad_kind = DTRACEACT_DIFEXPR; 6797c478bd9Sstevel@tonic-gate } 6807c478bd9Sstevel@tonic-gate 6817c478bd9Sstevel@tonic-gate static void 6827c478bd9Sstevel@tonic-gate dt_action_tracemem(dtrace_hdl_t *dtp, dt_node_t *dnp, dtrace_stmtdesc_t *sdp) 6837c478bd9Sstevel@tonic-gate { 6847c478bd9Sstevel@tonic-gate dtrace_actdesc_t *ap = dt_stmt_action(dtp, sdp); 6857c478bd9Sstevel@tonic-gate 6867c478bd9Sstevel@tonic-gate dt_node_t *addr = dnp->dn_args; 687*1ea5f93dSBryan Cantrill dt_node_t *max = dnp->dn_args->dn_list; 688*1ea5f93dSBryan Cantrill dt_node_t *size; 6897c478bd9Sstevel@tonic-gate 6907c478bd9Sstevel@tonic-gate char n[DT_TYPE_NAMELEN]; 6917c478bd9Sstevel@tonic-gate 6927c478bd9Sstevel@tonic-gate if (dt_node_is_integer(addr) == 0 && dt_node_is_pointer(addr) == 0) { 6937c478bd9Sstevel@tonic-gate dnerror(addr, D_TRACEMEM_ADDR, 6947c478bd9Sstevel@tonic-gate "tracemem( ) argument #1 is incompatible with " 6957c478bd9Sstevel@tonic-gate "prototype:\n\tprototype: pointer or integer\n" 6967c478bd9Sstevel@tonic-gate "\t argument: %s\n", 6977c478bd9Sstevel@tonic-gate dt_node_type_name(addr, n, sizeof (n))); 6987c478bd9Sstevel@tonic-gate } 6997c478bd9Sstevel@tonic-gate 700*1ea5f93dSBryan Cantrill if (dt_node_is_posconst(max) == 0) { 701*1ea5f93dSBryan Cantrill dnerror(max, D_TRACEMEM_SIZE, "tracemem( ) argument #2 must " 7027c478bd9Sstevel@tonic-gate "be a non-zero positive integral constant expression\n"); 7037c478bd9Sstevel@tonic-gate } 7047c478bd9Sstevel@tonic-gate 705*1ea5f93dSBryan Cantrill if ((size = max->dn_list) != NULL) { 706*1ea5f93dSBryan Cantrill if (size->dn_list != NULL) { 707*1ea5f93dSBryan Cantrill dnerror(size, D_TRACEMEM_ARGS, "tracemem ( ) prototype " 708*1ea5f93dSBryan Cantrill "mismatch: expected at most 3 args\n"); 709*1ea5f93dSBryan Cantrill } 710*1ea5f93dSBryan Cantrill 711*1ea5f93dSBryan Cantrill if (!dt_node_is_scalar(size)) { 712*1ea5f93dSBryan Cantrill dnerror(size, D_TRACEMEM_DYNSIZE, "tracemem ( ) " 713*1ea5f93dSBryan Cantrill "dynamic size (argument #3) must be of " 714*1ea5f93dSBryan Cantrill "scalar type\n"); 715*1ea5f93dSBryan Cantrill } 716*1ea5f93dSBryan Cantrill 717*1ea5f93dSBryan Cantrill dt_cg(yypcb, size); 718*1ea5f93dSBryan Cantrill ap->dtad_difo = dt_as(yypcb); 719*1ea5f93dSBryan Cantrill ap->dtad_difo->dtdo_rtype = dt_int_rtype; 720*1ea5f93dSBryan Cantrill ap->dtad_kind = DTRACEACT_TRACEMEM_DYNSIZE; 721*1ea5f93dSBryan Cantrill 722*1ea5f93dSBryan Cantrill ap = dt_stmt_action(dtp, sdp); 723*1ea5f93dSBryan Cantrill } 724*1ea5f93dSBryan Cantrill 7257c478bd9Sstevel@tonic-gate dt_cg(yypcb, addr); 7267c478bd9Sstevel@tonic-gate ap->dtad_difo = dt_as(yypcb); 727*1ea5f93dSBryan Cantrill ap->dtad_kind = DTRACEACT_TRACEMEM; 7287c478bd9Sstevel@tonic-gate 7297c478bd9Sstevel@tonic-gate ap->dtad_difo->dtdo_rtype.dtdt_flags |= DIF_TF_BYREF; 730*1ea5f93dSBryan Cantrill ap->dtad_difo->dtdo_rtype.dtdt_size = max->dn_value; 7317c478bd9Sstevel@tonic-gate } 7327c478bd9Sstevel@tonic-gate 7337c478bd9Sstevel@tonic-gate static void 7347c478bd9Sstevel@tonic-gate dt_action_stack_args(dtrace_hdl_t *dtp, dtrace_actdesc_t *ap, dt_node_t *arg0) 7357c478bd9Sstevel@tonic-gate { 7367c478bd9Sstevel@tonic-gate ap->dtad_kind = DTRACEACT_STACK; 7377c478bd9Sstevel@tonic-gate 7387c478bd9Sstevel@tonic-gate if (dtp->dt_options[DTRACEOPT_STACKFRAMES] != DTRACEOPT_UNSET) { 7397c478bd9Sstevel@tonic-gate ap->dtad_arg = dtp->dt_options[DTRACEOPT_STACKFRAMES]; 7407c478bd9Sstevel@tonic-gate } else { 7417c478bd9Sstevel@tonic-gate ap->dtad_arg = 0; 7427c478bd9Sstevel@tonic-gate } 7437c478bd9Sstevel@tonic-gate 7447c478bd9Sstevel@tonic-gate if (arg0 != NULL) { 7457c478bd9Sstevel@tonic-gate if (arg0->dn_list != NULL) { 7467c478bd9Sstevel@tonic-gate dnerror(arg0, D_STACK_PROTO, "stack( ) prototype " 7477c478bd9Sstevel@tonic-gate "mismatch: too many arguments\n"); 7487c478bd9Sstevel@tonic-gate } 7497c478bd9Sstevel@tonic-gate 7507c478bd9Sstevel@tonic-gate if (dt_node_is_posconst(arg0) == 0) { 7517c478bd9Sstevel@tonic-gate dnerror(arg0, D_STACK_SIZE, "stack( ) size must be a " 7527c478bd9Sstevel@tonic-gate "non-zero positive integral constant expression\n"); 7537c478bd9Sstevel@tonic-gate } 7547c478bd9Sstevel@tonic-gate 7557c478bd9Sstevel@tonic-gate ap->dtad_arg = arg0->dn_value; 7567c478bd9Sstevel@tonic-gate } 7577c478bd9Sstevel@tonic-gate } 7587c478bd9Sstevel@tonic-gate 7597c478bd9Sstevel@tonic-gate static void 7607c478bd9Sstevel@tonic-gate dt_action_stack(dtrace_hdl_t *dtp, dt_node_t *dnp, dtrace_stmtdesc_t *sdp) 7617c478bd9Sstevel@tonic-gate { 7627c478bd9Sstevel@tonic-gate dtrace_actdesc_t *ap = dt_stmt_action(dtp, sdp); 7637c478bd9Sstevel@tonic-gate dt_action_stack_args(dtp, ap, dnp->dn_args); 7647c478bd9Sstevel@tonic-gate } 7657c478bd9Sstevel@tonic-gate 7667c478bd9Sstevel@tonic-gate static void 7677c478bd9Sstevel@tonic-gate dt_action_ustack_args(dtrace_hdl_t *dtp, dtrace_actdesc_t *ap, dt_node_t *dnp) 7687c478bd9Sstevel@tonic-gate { 7697c478bd9Sstevel@tonic-gate uint32_t nframes = 0; 7707c478bd9Sstevel@tonic-gate uint32_t strsize = 0; /* default string table size */ 7717c478bd9Sstevel@tonic-gate dt_node_t *arg0 = dnp->dn_args; 7727c478bd9Sstevel@tonic-gate dt_node_t *arg1 = arg0 != NULL ? arg0->dn_list : NULL; 7737c478bd9Sstevel@tonic-gate 7747c478bd9Sstevel@tonic-gate assert(dnp->dn_ident->di_id == DT_ACT_JSTACK || 7757c478bd9Sstevel@tonic-gate dnp->dn_ident->di_id == DT_ACT_USTACK); 7767c478bd9Sstevel@tonic-gate 7777c478bd9Sstevel@tonic-gate if (dnp->dn_ident->di_id == DT_ACT_JSTACK) { 7787c478bd9Sstevel@tonic-gate if (dtp->dt_options[DTRACEOPT_JSTACKFRAMES] != DTRACEOPT_UNSET) 7797c478bd9Sstevel@tonic-gate nframes = dtp->dt_options[DTRACEOPT_JSTACKFRAMES]; 7807c478bd9Sstevel@tonic-gate 7817c478bd9Sstevel@tonic-gate if (dtp->dt_options[DTRACEOPT_JSTACKSTRSIZE] != DTRACEOPT_UNSET) 7827c478bd9Sstevel@tonic-gate strsize = dtp->dt_options[DTRACEOPT_JSTACKSTRSIZE]; 7837c478bd9Sstevel@tonic-gate 7847c478bd9Sstevel@tonic-gate ap->dtad_kind = DTRACEACT_JSTACK; 7857c478bd9Sstevel@tonic-gate } else { 7867c478bd9Sstevel@tonic-gate assert(dnp->dn_ident->di_id == DT_ACT_USTACK); 7877c478bd9Sstevel@tonic-gate 7887c478bd9Sstevel@tonic-gate if (dtp->dt_options[DTRACEOPT_USTACKFRAMES] != DTRACEOPT_UNSET) 7897c478bd9Sstevel@tonic-gate nframes = dtp->dt_options[DTRACEOPT_USTACKFRAMES]; 7907c478bd9Sstevel@tonic-gate 7917c478bd9Sstevel@tonic-gate ap->dtad_kind = DTRACEACT_USTACK; 7927c478bd9Sstevel@tonic-gate } 7937c478bd9Sstevel@tonic-gate 7947c478bd9Sstevel@tonic-gate if (arg0 != NULL) { 7957c478bd9Sstevel@tonic-gate if (!dt_node_is_posconst(arg0)) { 7967c478bd9Sstevel@tonic-gate dnerror(arg0, D_USTACK_FRAMES, "ustack( ) argument #1 " 7977c478bd9Sstevel@tonic-gate "must be a non-zero positive integer constant\n"); 7987c478bd9Sstevel@tonic-gate } 7997c478bd9Sstevel@tonic-gate nframes = (uint32_t)arg0->dn_value; 8007c478bd9Sstevel@tonic-gate } 8017c478bd9Sstevel@tonic-gate 8027c478bd9Sstevel@tonic-gate if (arg1 != NULL) { 8037c478bd9Sstevel@tonic-gate if (arg1->dn_kind != DT_NODE_INT || 8047c478bd9Sstevel@tonic-gate ((arg1->dn_flags & DT_NF_SIGNED) && 8057c478bd9Sstevel@tonic-gate (int64_t)arg1->dn_value < 0)) { 8067c478bd9Sstevel@tonic-gate dnerror(arg1, D_USTACK_STRSIZE, "ustack( ) argument #2 " 8077c478bd9Sstevel@tonic-gate "must be a positive integer constant\n"); 8087c478bd9Sstevel@tonic-gate } 8097c478bd9Sstevel@tonic-gate 8107c478bd9Sstevel@tonic-gate if (arg1->dn_list != NULL) { 8117c478bd9Sstevel@tonic-gate dnerror(arg1, D_USTACK_PROTO, "ustack( ) prototype " 8127c478bd9Sstevel@tonic-gate "mismatch: too many arguments\n"); 8137c478bd9Sstevel@tonic-gate } 8147c478bd9Sstevel@tonic-gate 8157c478bd9Sstevel@tonic-gate strsize = (uint32_t)arg1->dn_value; 8167c478bd9Sstevel@tonic-gate } 8177c478bd9Sstevel@tonic-gate 8187c478bd9Sstevel@tonic-gate ap->dtad_arg = DTRACE_USTACK_ARG(nframes, strsize); 8197c478bd9Sstevel@tonic-gate } 8207c478bd9Sstevel@tonic-gate 8217c478bd9Sstevel@tonic-gate static void 8227c478bd9Sstevel@tonic-gate dt_action_ustack(dtrace_hdl_t *dtp, dt_node_t *dnp, dtrace_stmtdesc_t *sdp) 8237c478bd9Sstevel@tonic-gate { 8247c478bd9Sstevel@tonic-gate dtrace_actdesc_t *ap = dt_stmt_action(dtp, sdp); 8257c478bd9Sstevel@tonic-gate dt_action_ustack_args(dtp, ap, dnp); 8267c478bd9Sstevel@tonic-gate } 8277c478bd9Sstevel@tonic-gate 828a1b5e537Sbmc static void 829a1b5e537Sbmc dt_action_setopt(dtrace_hdl_t *dtp, dt_node_t *dnp, dtrace_stmtdesc_t *sdp) 830a1b5e537Sbmc { 831a1b5e537Sbmc dtrace_actdesc_t *ap; 832a1b5e537Sbmc dt_node_t *arg0, *arg1; 833a1b5e537Sbmc 834a1b5e537Sbmc /* 835a1b5e537Sbmc * The prototype guarantees that we are called with either one or 836a1b5e537Sbmc * two arguments, and that any arguments that are present are strings. 837a1b5e537Sbmc */ 838a1b5e537Sbmc arg0 = dnp->dn_args; 839a1b5e537Sbmc arg1 = arg0->dn_list; 840a1b5e537Sbmc 841a1b5e537Sbmc ap = dt_stmt_action(dtp, sdp); 842a1b5e537Sbmc dt_cg(yypcb, arg0); 843a1b5e537Sbmc ap->dtad_difo = dt_as(yypcb); 844a1b5e537Sbmc ap->dtad_kind = DTRACEACT_LIBACT; 845a1b5e537Sbmc ap->dtad_arg = DT_ACT_SETOPT; 846a1b5e537Sbmc 847a1b5e537Sbmc ap = dt_stmt_action(dtp, sdp); 848a1b5e537Sbmc 849a1b5e537Sbmc if (arg1 == NULL) { 850a1b5e537Sbmc dt_action_difconst(ap, 0, DTRACEACT_LIBACT); 851a1b5e537Sbmc } else { 852a1b5e537Sbmc dt_cg(yypcb, arg1); 853a1b5e537Sbmc ap->dtad_difo = dt_as(yypcb); 854a1b5e537Sbmc ap->dtad_kind = DTRACEACT_LIBACT; 855a1b5e537Sbmc } 856a1b5e537Sbmc 857a1b5e537Sbmc ap->dtad_arg = DT_ACT_SETOPT; 858a1b5e537Sbmc } 859a1b5e537Sbmc 860a1b5e537Sbmc /*ARGSUSED*/ 861a1b5e537Sbmc static void 862a1b5e537Sbmc dt_action_symmod_args(dtrace_hdl_t *dtp, dtrace_actdesc_t *ap, 863a1b5e537Sbmc dt_node_t *dnp, dtrace_actkind_t kind) 864a1b5e537Sbmc { 865a1b5e537Sbmc assert(kind == DTRACEACT_SYM || kind == DTRACEACT_MOD || 866a1b5e537Sbmc kind == DTRACEACT_USYM || kind == DTRACEACT_UMOD || 867a1b5e537Sbmc kind == DTRACEACT_UADDR); 868a1b5e537Sbmc 869a1b5e537Sbmc dt_cg(yypcb, dnp); 870a1b5e537Sbmc ap->dtad_difo = dt_as(yypcb); 871a1b5e537Sbmc ap->dtad_kind = kind; 872a1b5e537Sbmc ap->dtad_difo->dtdo_rtype.dtdt_size = sizeof (uint64_t); 873a1b5e537Sbmc } 874a1b5e537Sbmc 875a1b5e537Sbmc static void 876a1b5e537Sbmc dt_action_symmod(dtrace_hdl_t *dtp, dt_node_t *dnp, dtrace_stmtdesc_t *sdp, 877a1b5e537Sbmc dtrace_actkind_t kind) 878a1b5e537Sbmc { 879a1b5e537Sbmc dtrace_actdesc_t *ap = dt_stmt_action(dtp, sdp); 880a1b5e537Sbmc dt_action_symmod_args(dtp, ap, dnp->dn_args, kind); 881a1b5e537Sbmc } 882a1b5e537Sbmc 8837c478bd9Sstevel@tonic-gate /*ARGSUSED*/ 8847c478bd9Sstevel@tonic-gate static void 8857c478bd9Sstevel@tonic-gate dt_action_ftruncate(dtrace_hdl_t *dtp, dt_node_t *dnp, dtrace_stmtdesc_t *sdp) 8867c478bd9Sstevel@tonic-gate { 8877c478bd9Sstevel@tonic-gate dtrace_actdesc_t *ap = dt_stmt_action(dtp, sdp); 8887c478bd9Sstevel@tonic-gate 8897c478bd9Sstevel@tonic-gate /* 8907c478bd9Sstevel@tonic-gate * Library actions need a DIFO that serves as an argument. As 8917c478bd9Sstevel@tonic-gate * ftruncate() doesn't take an argument, we generate the constant 0 8927c478bd9Sstevel@tonic-gate * in a DIFO; this constant will be ignored when the ftruncate() is 8937c478bd9Sstevel@tonic-gate * processed. 8947c478bd9Sstevel@tonic-gate */ 8957c478bd9Sstevel@tonic-gate dt_action_difconst(ap, 0, DTRACEACT_LIBACT); 8967c478bd9Sstevel@tonic-gate ap->dtad_arg = DT_ACT_FTRUNCATE; 8977c478bd9Sstevel@tonic-gate } 8987c478bd9Sstevel@tonic-gate 8997c478bd9Sstevel@tonic-gate /*ARGSUSED*/ 9007c478bd9Sstevel@tonic-gate static void 9017c478bd9Sstevel@tonic-gate dt_action_stop(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 ap->dtad_kind = DTRACEACT_STOP; 9067c478bd9Sstevel@tonic-gate ap->dtad_arg = 0; 9077c478bd9Sstevel@tonic-gate } 9087c478bd9Sstevel@tonic-gate 9097c478bd9Sstevel@tonic-gate /*ARGSUSED*/ 9107c478bd9Sstevel@tonic-gate static void 9117c478bd9Sstevel@tonic-gate dt_action_breakpoint(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 ap->dtad_kind = DTRACEACT_BREAKPOINT; 9167c478bd9Sstevel@tonic-gate ap->dtad_arg = 0; 9177c478bd9Sstevel@tonic-gate } 9187c478bd9Sstevel@tonic-gate 9197c478bd9Sstevel@tonic-gate /*ARGSUSED*/ 9207c478bd9Sstevel@tonic-gate static void 9217c478bd9Sstevel@tonic-gate dt_action_panic(dtrace_hdl_t *dtp, dt_node_t *dnp, dtrace_stmtdesc_t *sdp) 9227c478bd9Sstevel@tonic-gate { 9237c478bd9Sstevel@tonic-gate dtrace_actdesc_t *ap = dt_stmt_action(dtp, sdp); 9247c478bd9Sstevel@tonic-gate 9257c478bd9Sstevel@tonic-gate ap->dtad_kind = DTRACEACT_PANIC; 9267c478bd9Sstevel@tonic-gate ap->dtad_arg = 0; 9277c478bd9Sstevel@tonic-gate } 9287c478bd9Sstevel@tonic-gate 9297c478bd9Sstevel@tonic-gate static void 9307c478bd9Sstevel@tonic-gate dt_action_chill(dtrace_hdl_t *dtp, dt_node_t *dnp, dtrace_stmtdesc_t *sdp) 9317c478bd9Sstevel@tonic-gate { 9327c478bd9Sstevel@tonic-gate dtrace_actdesc_t *ap = dt_stmt_action(dtp, sdp); 9337c478bd9Sstevel@tonic-gate 9347c478bd9Sstevel@tonic-gate dt_cg(yypcb, dnp->dn_args); 9357c478bd9Sstevel@tonic-gate ap->dtad_difo = dt_as(yypcb); 9367c478bd9Sstevel@tonic-gate ap->dtad_kind = DTRACEACT_CHILL; 9377c478bd9Sstevel@tonic-gate } 9387c478bd9Sstevel@tonic-gate 9397c478bd9Sstevel@tonic-gate static void 9407c478bd9Sstevel@tonic-gate dt_action_raise(dtrace_hdl_t *dtp, dt_node_t *dnp, dtrace_stmtdesc_t *sdp) 9417c478bd9Sstevel@tonic-gate { 9427c478bd9Sstevel@tonic-gate dtrace_actdesc_t *ap = dt_stmt_action(dtp, sdp); 9437c478bd9Sstevel@tonic-gate 9447c478bd9Sstevel@tonic-gate dt_cg(yypcb, dnp->dn_args); 9457c478bd9Sstevel@tonic-gate ap->dtad_difo = dt_as(yypcb); 9467c478bd9Sstevel@tonic-gate ap->dtad_kind = DTRACEACT_RAISE; 9477c478bd9Sstevel@tonic-gate } 9487c478bd9Sstevel@tonic-gate 9497c478bd9Sstevel@tonic-gate static void 9507c478bd9Sstevel@tonic-gate dt_action_exit(dtrace_hdl_t *dtp, dt_node_t *dnp, dtrace_stmtdesc_t *sdp) 9517c478bd9Sstevel@tonic-gate { 9527c478bd9Sstevel@tonic-gate dtrace_actdesc_t *ap = dt_stmt_action(dtp, sdp); 9537c478bd9Sstevel@tonic-gate 9547c478bd9Sstevel@tonic-gate dt_cg(yypcb, dnp->dn_args); 9557c478bd9Sstevel@tonic-gate ap->dtad_difo = dt_as(yypcb); 9567c478bd9Sstevel@tonic-gate ap->dtad_kind = DTRACEACT_EXIT; 9577c478bd9Sstevel@tonic-gate ap->dtad_difo->dtdo_rtype.dtdt_size = sizeof (int); 9587c478bd9Sstevel@tonic-gate } 9597c478bd9Sstevel@tonic-gate 9607c478bd9Sstevel@tonic-gate static void 9617c478bd9Sstevel@tonic-gate dt_action_speculate(dtrace_hdl_t *dtp, dt_node_t *dnp, dtrace_stmtdesc_t *sdp) 9627c478bd9Sstevel@tonic-gate { 9637c478bd9Sstevel@tonic-gate dtrace_actdesc_t *ap = dt_stmt_action(dtp, sdp); 9647c478bd9Sstevel@tonic-gate 9657c478bd9Sstevel@tonic-gate dt_cg(yypcb, dnp->dn_args); 9667c478bd9Sstevel@tonic-gate ap->dtad_difo = dt_as(yypcb); 9677c478bd9Sstevel@tonic-gate ap->dtad_kind = DTRACEACT_SPECULATE; 9687c478bd9Sstevel@tonic-gate } 9697c478bd9Sstevel@tonic-gate 9707c478bd9Sstevel@tonic-gate static void 9717c478bd9Sstevel@tonic-gate dt_action_commit(dtrace_hdl_t *dtp, dt_node_t *dnp, dtrace_stmtdesc_t *sdp) 9727c478bd9Sstevel@tonic-gate { 9737c478bd9Sstevel@tonic-gate dtrace_actdesc_t *ap = dt_stmt_action(dtp, sdp); 9747c478bd9Sstevel@tonic-gate 9757c478bd9Sstevel@tonic-gate dt_cg(yypcb, dnp->dn_args); 9767c478bd9Sstevel@tonic-gate ap->dtad_difo = dt_as(yypcb); 9777c478bd9Sstevel@tonic-gate ap->dtad_kind = DTRACEACT_COMMIT; 9787c478bd9Sstevel@tonic-gate } 9797c478bd9Sstevel@tonic-gate 9807c478bd9Sstevel@tonic-gate static void 9817c478bd9Sstevel@tonic-gate dt_action_discard(dtrace_hdl_t *dtp, dt_node_t *dnp, dtrace_stmtdesc_t *sdp) 9827c478bd9Sstevel@tonic-gate { 9837c478bd9Sstevel@tonic-gate dtrace_actdesc_t *ap = dt_stmt_action(dtp, sdp); 9847c478bd9Sstevel@tonic-gate 9857c478bd9Sstevel@tonic-gate dt_cg(yypcb, dnp->dn_args); 9867c478bd9Sstevel@tonic-gate ap->dtad_difo = dt_as(yypcb); 9877c478bd9Sstevel@tonic-gate ap->dtad_kind = DTRACEACT_DISCARD; 9887c478bd9Sstevel@tonic-gate } 9897c478bd9Sstevel@tonic-gate 9907c478bd9Sstevel@tonic-gate static void 9917c478bd9Sstevel@tonic-gate dt_compile_fun(dtrace_hdl_t *dtp, dt_node_t *dnp, dtrace_stmtdesc_t *sdp) 9927c478bd9Sstevel@tonic-gate { 9937c478bd9Sstevel@tonic-gate switch (dnp->dn_expr->dn_ident->di_id) { 9947c478bd9Sstevel@tonic-gate case DT_ACT_BREAKPOINT: 9957c478bd9Sstevel@tonic-gate dt_action_breakpoint(dtp, dnp->dn_expr, sdp); 9967c478bd9Sstevel@tonic-gate break; 9977c478bd9Sstevel@tonic-gate case DT_ACT_CHILL: 9987c478bd9Sstevel@tonic-gate dt_action_chill(dtp, dnp->dn_expr, sdp); 9997c478bd9Sstevel@tonic-gate break; 10007c478bd9Sstevel@tonic-gate case DT_ACT_CLEAR: 10017c478bd9Sstevel@tonic-gate dt_action_clear(dtp, dnp->dn_expr, sdp); 10027c478bd9Sstevel@tonic-gate break; 10037c478bd9Sstevel@tonic-gate case DT_ACT_COMMIT: 10047c478bd9Sstevel@tonic-gate dt_action_commit(dtp, dnp->dn_expr, sdp); 10057c478bd9Sstevel@tonic-gate break; 10067c478bd9Sstevel@tonic-gate case DT_ACT_DENORMALIZE: 10077c478bd9Sstevel@tonic-gate dt_action_normalize(dtp, dnp->dn_expr, sdp); 10087c478bd9Sstevel@tonic-gate break; 10097c478bd9Sstevel@tonic-gate case DT_ACT_DISCARD: 10107c478bd9Sstevel@tonic-gate dt_action_discard(dtp, dnp->dn_expr, sdp); 10117c478bd9Sstevel@tonic-gate break; 10127c478bd9Sstevel@tonic-gate case DT_ACT_EXIT: 10137c478bd9Sstevel@tonic-gate dt_action_exit(dtp, dnp->dn_expr, sdp); 10147c478bd9Sstevel@tonic-gate break; 10157c478bd9Sstevel@tonic-gate case DT_ACT_FREOPEN: 10167c478bd9Sstevel@tonic-gate dt_action_printflike(dtp, dnp->dn_expr, sdp, DTRACEACT_FREOPEN); 10177c478bd9Sstevel@tonic-gate break; 10187c478bd9Sstevel@tonic-gate case DT_ACT_FTRUNCATE: 10197c478bd9Sstevel@tonic-gate dt_action_ftruncate(dtp, dnp->dn_expr, sdp); 10207c478bd9Sstevel@tonic-gate break; 1021a1b5e537Sbmc case DT_ACT_MOD: 1022a1b5e537Sbmc dt_action_symmod(dtp, dnp->dn_expr, sdp, DTRACEACT_MOD); 1023a1b5e537Sbmc break; 10247c478bd9Sstevel@tonic-gate case DT_ACT_NORMALIZE: 10257c478bd9Sstevel@tonic-gate dt_action_normalize(dtp, dnp->dn_expr, sdp); 10267c478bd9Sstevel@tonic-gate break; 10277c478bd9Sstevel@tonic-gate case DT_ACT_PANIC: 10287c478bd9Sstevel@tonic-gate dt_action_panic(dtp, dnp->dn_expr, sdp); 10297c478bd9Sstevel@tonic-gate break; 10307c478bd9Sstevel@tonic-gate case DT_ACT_PRINTA: 10317c478bd9Sstevel@tonic-gate dt_action_printa(dtp, dnp->dn_expr, sdp); 10327c478bd9Sstevel@tonic-gate break; 10337c478bd9Sstevel@tonic-gate case DT_ACT_PRINTF: 10347c478bd9Sstevel@tonic-gate dt_action_printflike(dtp, dnp->dn_expr, sdp, DTRACEACT_PRINTF); 10357c478bd9Sstevel@tonic-gate break; 10367c478bd9Sstevel@tonic-gate case DT_ACT_RAISE: 10377c478bd9Sstevel@tonic-gate dt_action_raise(dtp, dnp->dn_expr, sdp); 10387c478bd9Sstevel@tonic-gate break; 1039a1b5e537Sbmc case DT_ACT_SETOPT: 1040a1b5e537Sbmc dt_action_setopt(dtp, dnp->dn_expr, sdp); 1041a1b5e537Sbmc break; 10427c478bd9Sstevel@tonic-gate case DT_ACT_SPECULATE: 10437c478bd9Sstevel@tonic-gate dt_action_speculate(dtp, dnp->dn_expr, sdp); 10447c478bd9Sstevel@tonic-gate break; 10457c478bd9Sstevel@tonic-gate case DT_ACT_STACK: 10467c478bd9Sstevel@tonic-gate dt_action_stack(dtp, dnp->dn_expr, sdp); 10477c478bd9Sstevel@tonic-gate break; 10487c478bd9Sstevel@tonic-gate case DT_ACT_STOP: 10497c478bd9Sstevel@tonic-gate dt_action_stop(dtp, dnp->dn_expr, sdp); 10507c478bd9Sstevel@tonic-gate break; 1051a1b5e537Sbmc case DT_ACT_SYM: 1052a1b5e537Sbmc dt_action_symmod(dtp, dnp->dn_expr, sdp, DTRACEACT_SYM); 1053a1b5e537Sbmc break; 10547c478bd9Sstevel@tonic-gate case DT_ACT_SYSTEM: 10557c478bd9Sstevel@tonic-gate dt_action_printflike(dtp, dnp->dn_expr, sdp, DTRACEACT_SYSTEM); 10567c478bd9Sstevel@tonic-gate break; 10577c478bd9Sstevel@tonic-gate case DT_ACT_TRACE: 10587c478bd9Sstevel@tonic-gate dt_action_trace(dtp, dnp->dn_expr, sdp); 10597c478bd9Sstevel@tonic-gate break; 10607c478bd9Sstevel@tonic-gate case DT_ACT_TRACEMEM: 10617c478bd9Sstevel@tonic-gate dt_action_tracemem(dtp, dnp->dn_expr, sdp); 10627c478bd9Sstevel@tonic-gate break; 10637c478bd9Sstevel@tonic-gate case DT_ACT_TRUNC: 10647c478bd9Sstevel@tonic-gate dt_action_trunc(dtp, dnp->dn_expr, sdp); 10657c478bd9Sstevel@tonic-gate break; 1066a1b5e537Sbmc case DT_ACT_UADDR: 1067a1b5e537Sbmc dt_action_symmod(dtp, dnp->dn_expr, sdp, DTRACEACT_UADDR); 1068a1b5e537Sbmc break; 1069a1b5e537Sbmc case DT_ACT_UMOD: 1070a1b5e537Sbmc dt_action_symmod(dtp, dnp->dn_expr, sdp, DTRACEACT_UMOD); 1071a1b5e537Sbmc break; 1072a1b5e537Sbmc case DT_ACT_USYM: 1073a1b5e537Sbmc dt_action_symmod(dtp, dnp->dn_expr, sdp, DTRACEACT_USYM); 1074a1b5e537Sbmc break; 10757c478bd9Sstevel@tonic-gate case DT_ACT_USTACK: 10767c478bd9Sstevel@tonic-gate case DT_ACT_JSTACK: 10777c478bd9Sstevel@tonic-gate dt_action_ustack(dtp, dnp->dn_expr, sdp); 10787c478bd9Sstevel@tonic-gate break; 10797c478bd9Sstevel@tonic-gate default: 10807c478bd9Sstevel@tonic-gate dnerror(dnp->dn_expr, D_UNKNOWN, "tracing function %s( ) is " 10817c478bd9Sstevel@tonic-gate "not yet supported\n", dnp->dn_expr->dn_ident->di_name); 10827c478bd9Sstevel@tonic-gate } 10837c478bd9Sstevel@tonic-gate } 10847c478bd9Sstevel@tonic-gate 10857c478bd9Sstevel@tonic-gate static void 10867c478bd9Sstevel@tonic-gate dt_compile_exp(dtrace_hdl_t *dtp, dt_node_t *dnp, dtrace_stmtdesc_t *sdp) 10877c478bd9Sstevel@tonic-gate { 10887c478bd9Sstevel@tonic-gate dtrace_actdesc_t *ap = dt_stmt_action(dtp, sdp); 10897c478bd9Sstevel@tonic-gate 10907c478bd9Sstevel@tonic-gate dt_cg(yypcb, dnp->dn_expr); 10917c478bd9Sstevel@tonic-gate ap->dtad_difo = dt_as(yypcb); 10927c478bd9Sstevel@tonic-gate ap->dtad_difo->dtdo_rtype = dt_void_rtype; 10937c478bd9Sstevel@tonic-gate ap->dtad_kind = DTRACEACT_DIFEXPR; 10947c478bd9Sstevel@tonic-gate } 10957c478bd9Sstevel@tonic-gate 10967c478bd9Sstevel@tonic-gate static void 10977c478bd9Sstevel@tonic-gate dt_compile_agg(dtrace_hdl_t *dtp, dt_node_t *dnp, dtrace_stmtdesc_t *sdp) 10987c478bd9Sstevel@tonic-gate { 10997c478bd9Sstevel@tonic-gate dt_ident_t *aid, *fid; 1100a1b5e537Sbmc dt_node_t *anp, *incr = NULL; 11017c478bd9Sstevel@tonic-gate dtrace_actdesc_t *ap; 1102a1b5e537Sbmc uint_t n = 1, argmax; 1103a1b5e537Sbmc uint64_t arg = 0; 11047c478bd9Sstevel@tonic-gate 11057c478bd9Sstevel@tonic-gate /* 11067c478bd9Sstevel@tonic-gate * If the aggregation has no aggregating function applied to it, then 11077c478bd9Sstevel@tonic-gate * this statement has no effect. Flag this as a programming error. 11087c478bd9Sstevel@tonic-gate */ 11097c478bd9Sstevel@tonic-gate if (dnp->dn_aggfun == NULL) { 11107c478bd9Sstevel@tonic-gate dnerror(dnp, D_AGG_NULL, "expression has null effect: @%s\n", 11117c478bd9Sstevel@tonic-gate dnp->dn_ident->di_name); 11127c478bd9Sstevel@tonic-gate } 11137c478bd9Sstevel@tonic-gate 11147c478bd9Sstevel@tonic-gate aid = dnp->dn_ident; 11157c478bd9Sstevel@tonic-gate fid = dnp->dn_aggfun->dn_ident; 11167c478bd9Sstevel@tonic-gate 11177c478bd9Sstevel@tonic-gate if (dnp->dn_aggfun->dn_args != NULL && 11187c478bd9Sstevel@tonic-gate dt_node_is_scalar(dnp->dn_aggfun->dn_args) == 0) { 11197c478bd9Sstevel@tonic-gate dnerror(dnp->dn_aggfun, D_AGG_SCALAR, "%s( ) argument #1 must " 11207c478bd9Sstevel@tonic-gate "be of scalar type\n", fid->di_name); 11217c478bd9Sstevel@tonic-gate } 11227c478bd9Sstevel@tonic-gate 11237c478bd9Sstevel@tonic-gate /* 11247c478bd9Sstevel@tonic-gate * The ID of the aggregation itself is implicitly recorded as the first 11257c478bd9Sstevel@tonic-gate * member of each aggregation tuple so we can distinguish them later. 11267c478bd9Sstevel@tonic-gate */ 11277c478bd9Sstevel@tonic-gate ap = dt_stmt_action(dtp, sdp); 11287c478bd9Sstevel@tonic-gate dt_action_difconst(ap, aid->di_id, DTRACEACT_DIFEXPR); 11297c478bd9Sstevel@tonic-gate 11307c478bd9Sstevel@tonic-gate for (anp = dnp->dn_aggtup; anp != NULL; anp = anp->dn_list) { 11317c478bd9Sstevel@tonic-gate ap = dt_stmt_action(dtp, sdp); 11327c478bd9Sstevel@tonic-gate n++; 11337c478bd9Sstevel@tonic-gate 11347c478bd9Sstevel@tonic-gate if (anp->dn_kind == DT_NODE_FUNC) { 11357c478bd9Sstevel@tonic-gate if (anp->dn_ident->di_id == DT_ACT_STACK) { 11367c478bd9Sstevel@tonic-gate dt_action_stack_args(dtp, ap, anp->dn_args); 11377c478bd9Sstevel@tonic-gate continue; 11387c478bd9Sstevel@tonic-gate } 11397c478bd9Sstevel@tonic-gate 11407c478bd9Sstevel@tonic-gate if (anp->dn_ident->di_id == DT_ACT_USTACK || 11417c478bd9Sstevel@tonic-gate anp->dn_ident->di_id == DT_ACT_JSTACK) { 11427c478bd9Sstevel@tonic-gate dt_action_ustack_args(dtp, ap, anp); 11437c478bd9Sstevel@tonic-gate continue; 11447c478bd9Sstevel@tonic-gate } 11457c478bd9Sstevel@tonic-gate 1146a1b5e537Sbmc switch (anp->dn_ident->di_id) { 1147a1b5e537Sbmc case DT_ACT_UADDR: 1148a1b5e537Sbmc dt_action_symmod_args(dtp, ap, 1149a1b5e537Sbmc anp->dn_args, DTRACEACT_UADDR); 1150a1b5e537Sbmc continue; 11517c478bd9Sstevel@tonic-gate 1152a1b5e537Sbmc case DT_ACT_USYM: 1153a1b5e537Sbmc dt_action_symmod_args(dtp, ap, 1154a1b5e537Sbmc anp->dn_args, DTRACEACT_USYM); 1155a1b5e537Sbmc continue; 11567c478bd9Sstevel@tonic-gate 1157a1b5e537Sbmc case DT_ACT_UMOD: 1158a1b5e537Sbmc dt_action_symmod_args(dtp, ap, 1159a1b5e537Sbmc anp->dn_args, DTRACEACT_UMOD); 1160a1b5e537Sbmc continue; 11617c478bd9Sstevel@tonic-gate 1162a1b5e537Sbmc case DT_ACT_SYM: 1163a1b5e537Sbmc dt_action_symmod_args(dtp, ap, 1164a1b5e537Sbmc anp->dn_args, DTRACEACT_SYM); 1165a1b5e537Sbmc continue; 1166a1b5e537Sbmc 1167a1b5e537Sbmc case DT_ACT_MOD: 1168a1b5e537Sbmc dt_action_symmod_args(dtp, ap, 1169a1b5e537Sbmc anp->dn_args, DTRACEACT_MOD); 1170a1b5e537Sbmc continue; 1171a1b5e537Sbmc 1172a1b5e537Sbmc default: 1173a1b5e537Sbmc break; 1174a1b5e537Sbmc } 1175a1b5e537Sbmc } 1176a1b5e537Sbmc 1177a1b5e537Sbmc dt_cg(yypcb, anp); 11787c478bd9Sstevel@tonic-gate ap->dtad_difo = dt_as(yypcb); 1179a1b5e537Sbmc ap->dtad_kind = DTRACEACT_DIFEXPR; 11807c478bd9Sstevel@tonic-gate } 11817c478bd9Sstevel@tonic-gate 11827c478bd9Sstevel@tonic-gate if (fid->di_id == DTRACEAGG_LQUANTIZE) { 11837c478bd9Sstevel@tonic-gate /* 1184a1b5e537Sbmc * For linear quantization, we have between two and four 1185a1b5e537Sbmc * arguments in addition to the expression: 11867c478bd9Sstevel@tonic-gate * 11877c478bd9Sstevel@tonic-gate * arg1 => Base value 11887c478bd9Sstevel@tonic-gate * arg2 => Limit value 11897c478bd9Sstevel@tonic-gate * arg3 => Quantization level step size (defaults to 1) 1190a1b5e537Sbmc * arg4 => Quantization increment value (defaults to 1) 11917c478bd9Sstevel@tonic-gate */ 11927c478bd9Sstevel@tonic-gate dt_node_t *arg1 = dnp->dn_aggfun->dn_args->dn_list; 11937c478bd9Sstevel@tonic-gate dt_node_t *arg2 = arg1->dn_list; 11947c478bd9Sstevel@tonic-gate dt_node_t *arg3 = arg2->dn_list; 119530ef842dSbmc dt_idsig_t *isp; 119630ef842dSbmc uint64_t nlevels, step = 1, oarg; 11977c478bd9Sstevel@tonic-gate int64_t baseval, limitval; 11987c478bd9Sstevel@tonic-gate 11997c478bd9Sstevel@tonic-gate if (arg1->dn_kind != DT_NODE_INT) { 12007c478bd9Sstevel@tonic-gate dnerror(arg1, D_LQUANT_BASETYPE, "lquantize( ) " 12017c478bd9Sstevel@tonic-gate "argument #1 must be an integer constant\n"); 12027c478bd9Sstevel@tonic-gate } 12037c478bd9Sstevel@tonic-gate 12047c478bd9Sstevel@tonic-gate baseval = (int64_t)arg1->dn_value; 12057c478bd9Sstevel@tonic-gate 12067c478bd9Sstevel@tonic-gate if (baseval < INT32_MIN || baseval > INT32_MAX) { 12077c478bd9Sstevel@tonic-gate dnerror(arg1, D_LQUANT_BASEVAL, "lquantize( ) " 12087c478bd9Sstevel@tonic-gate "argument #1 must be a 32-bit quantity\n"); 12097c478bd9Sstevel@tonic-gate } 12107c478bd9Sstevel@tonic-gate 12117c478bd9Sstevel@tonic-gate if (arg2->dn_kind != DT_NODE_INT) { 12127c478bd9Sstevel@tonic-gate dnerror(arg2, D_LQUANT_LIMTYPE, "lquantize( ) " 12137c478bd9Sstevel@tonic-gate "argument #2 must be an integer constant\n"); 12147c478bd9Sstevel@tonic-gate } 12157c478bd9Sstevel@tonic-gate 12167c478bd9Sstevel@tonic-gate limitval = (int64_t)arg2->dn_value; 12177c478bd9Sstevel@tonic-gate 12187c478bd9Sstevel@tonic-gate if (limitval < INT32_MIN || limitval > INT32_MAX) { 12197c478bd9Sstevel@tonic-gate dnerror(arg2, D_LQUANT_LIMVAL, "lquantize( ) " 12207c478bd9Sstevel@tonic-gate "argument #2 must be a 32-bit quantity\n"); 12217c478bd9Sstevel@tonic-gate } 12227c478bd9Sstevel@tonic-gate 12237c478bd9Sstevel@tonic-gate if (limitval < baseval) { 12247c478bd9Sstevel@tonic-gate dnerror(dnp, D_LQUANT_MISMATCH, 12257c478bd9Sstevel@tonic-gate "lquantize( ) base (argument #1) must be less " 12267c478bd9Sstevel@tonic-gate "than limit (argument #2)\n"); 12277c478bd9Sstevel@tonic-gate } 12287c478bd9Sstevel@tonic-gate 12297c478bd9Sstevel@tonic-gate if (arg3 != NULL) { 12307c478bd9Sstevel@tonic-gate if (!dt_node_is_posconst(arg3)) { 12317c478bd9Sstevel@tonic-gate dnerror(arg3, D_LQUANT_STEPTYPE, "lquantize( ) " 12327c478bd9Sstevel@tonic-gate "argument #3 must be a non-zero positive " 12337c478bd9Sstevel@tonic-gate "integer constant\n"); 12347c478bd9Sstevel@tonic-gate } 12357c478bd9Sstevel@tonic-gate 12367c478bd9Sstevel@tonic-gate if ((step = arg3->dn_value) > UINT16_MAX) { 12377c478bd9Sstevel@tonic-gate dnerror(arg3, D_LQUANT_STEPVAL, "lquantize( ) " 12387c478bd9Sstevel@tonic-gate "argument #3 must be a 16-bit quantity\n"); 12397c478bd9Sstevel@tonic-gate } 12407c478bd9Sstevel@tonic-gate } 12417c478bd9Sstevel@tonic-gate 12427c478bd9Sstevel@tonic-gate nlevels = (limitval - baseval) / step; 12437c478bd9Sstevel@tonic-gate 12447c478bd9Sstevel@tonic-gate if (nlevels == 0) { 12457c478bd9Sstevel@tonic-gate dnerror(dnp, D_LQUANT_STEPLARGE, 12467c478bd9Sstevel@tonic-gate "lquantize( ) step (argument #3) too large: must " 12477c478bd9Sstevel@tonic-gate "have at least one quantization level\n"); 12487c478bd9Sstevel@tonic-gate } 12497c478bd9Sstevel@tonic-gate 12507c478bd9Sstevel@tonic-gate if (nlevels > UINT16_MAX) { 12517c478bd9Sstevel@tonic-gate dnerror(dnp, D_LQUANT_STEPSMALL, "lquantize( ) step " 12527c478bd9Sstevel@tonic-gate "(argument #3) too small: number of quantization " 12537c478bd9Sstevel@tonic-gate "levels must be a 16-bit quantity\n"); 12547c478bd9Sstevel@tonic-gate } 12557c478bd9Sstevel@tonic-gate 1256a1b5e537Sbmc arg = (step << DTRACE_LQUANTIZE_STEPSHIFT) | 12577c478bd9Sstevel@tonic-gate (nlevels << DTRACE_LQUANTIZE_LEVELSHIFT) | 12587c478bd9Sstevel@tonic-gate ((baseval << DTRACE_LQUANTIZE_BASESHIFT) & 12597c478bd9Sstevel@tonic-gate DTRACE_LQUANTIZE_BASEMASK); 1260a1b5e537Sbmc 126130ef842dSbmc assert(arg != 0); 126230ef842dSbmc 126330ef842dSbmc isp = (dt_idsig_t *)aid->di_data; 126430ef842dSbmc 126530ef842dSbmc if (isp->dis_auxinfo == 0) { 126630ef842dSbmc /* 126730ef842dSbmc * This is the first time we've seen an lquantize() 126830ef842dSbmc * for this aggregation; we'll store our argument 126930ef842dSbmc * as the auxiliary signature information. 127030ef842dSbmc */ 127130ef842dSbmc isp->dis_auxinfo = arg; 127230ef842dSbmc } else if ((oarg = isp->dis_auxinfo) != arg) { 127330ef842dSbmc /* 127430ef842dSbmc * If we have seen this lquantize() before and the 127530ef842dSbmc * argument doesn't match the original argument, pick 127630ef842dSbmc * the original argument apart to concisely report the 127730ef842dSbmc * mismatch. 127830ef842dSbmc */ 127930ef842dSbmc int obaseval = DTRACE_LQUANTIZE_BASE(oarg); 128030ef842dSbmc int onlevels = DTRACE_LQUANTIZE_LEVELS(oarg); 128130ef842dSbmc int ostep = DTRACE_LQUANTIZE_STEP(oarg); 128230ef842dSbmc 128330ef842dSbmc if (obaseval != baseval) { 128430ef842dSbmc dnerror(dnp, D_LQUANT_MATCHBASE, "lquantize( ) " 128530ef842dSbmc "base (argument #1) doesn't match previous " 128630ef842dSbmc "declaration: expected %d, found %d\n", 128730ef842dSbmc obaseval, (int)baseval); 128830ef842dSbmc } 128930ef842dSbmc 129030ef842dSbmc if (onlevels * ostep != nlevels * step) { 129130ef842dSbmc dnerror(dnp, D_LQUANT_MATCHLIM, "lquantize( ) " 129230ef842dSbmc "limit (argument #2) doesn't match previous" 129330ef842dSbmc " declaration: expected %d, found %d\n", 129430ef842dSbmc obaseval + onlevels * ostep, 129530ef842dSbmc (int)baseval + (int)nlevels * (int)step); 129630ef842dSbmc } 129730ef842dSbmc 129830ef842dSbmc if (ostep != step) { 129930ef842dSbmc dnerror(dnp, D_LQUANT_MATCHSTEP, "lquantize( ) " 130030ef842dSbmc "step (argument #3) doesn't match previous " 130130ef842dSbmc "declaration: expected %d, found %d\n", 130230ef842dSbmc ostep, (int)step); 130330ef842dSbmc } 130430ef842dSbmc 130530ef842dSbmc /* 130630ef842dSbmc * We shouldn't be able to get here -- one of the 130730ef842dSbmc * parameters must be mismatched if the arguments 130830ef842dSbmc * didn't match. 130930ef842dSbmc */ 131030ef842dSbmc assert(0); 131130ef842dSbmc } 131230ef842dSbmc 1313a1b5e537Sbmc incr = arg3 != NULL ? arg3->dn_list : NULL; 1314a1b5e537Sbmc argmax = 5; 1315a1b5e537Sbmc } 1316a1b5e537Sbmc 13172b6389efSBryan Cantrill if (fid->di_id == DTRACEAGG_LLQUANTIZE) { 13182b6389efSBryan Cantrill /* 13192b6389efSBryan Cantrill * For log/linear quantizations, we have between one and five 13202b6389efSBryan Cantrill * arguments in addition to the expression: 13212b6389efSBryan Cantrill * 13222b6389efSBryan Cantrill * arg1 => Factor 13232b6389efSBryan Cantrill * arg2 => Low magnitude 13242b6389efSBryan Cantrill * arg3 => High magnitude 13252b6389efSBryan Cantrill * arg4 => Number of steps per magnitude 13262b6389efSBryan Cantrill * arg5 => Quantization increment value (defaults to 1) 13272b6389efSBryan Cantrill */ 13282b6389efSBryan Cantrill dt_node_t *llarg = dnp->dn_aggfun->dn_args->dn_list; 13292b6389efSBryan Cantrill uint64_t oarg, order, v; 13302b6389efSBryan Cantrill dt_idsig_t *isp; 13312b6389efSBryan Cantrill int i; 13322b6389efSBryan Cantrill 13332b6389efSBryan Cantrill struct { 13342b6389efSBryan Cantrill char *str; /* string identifier */ 13352b6389efSBryan Cantrill int badtype; /* error on bad type */ 13362b6389efSBryan Cantrill int badval; /* error on bad value */ 13372b6389efSBryan Cantrill int mismatch; /* error on bad match */ 13382b6389efSBryan Cantrill int shift; /* shift value */ 13392b6389efSBryan Cantrill uint16_t value; /* value itself */ 13402b6389efSBryan Cantrill } args[] = { 13412b6389efSBryan Cantrill { "factor", D_LLQUANT_FACTORTYPE, 13422b6389efSBryan Cantrill D_LLQUANT_FACTORVAL, D_LLQUANT_FACTORMATCH, 13432b6389efSBryan Cantrill DTRACE_LLQUANTIZE_FACTORSHIFT }, 13442b6389efSBryan Cantrill { "low magnitude", D_LLQUANT_LOWTYPE, 13452b6389efSBryan Cantrill D_LLQUANT_LOWVAL, D_LLQUANT_LOWMATCH, 13462b6389efSBryan Cantrill DTRACE_LLQUANTIZE_LOWSHIFT }, 13472b6389efSBryan Cantrill { "high magnitude", D_LLQUANT_HIGHTYPE, 13482b6389efSBryan Cantrill D_LLQUANT_HIGHVAL, D_LLQUANT_HIGHMATCH, 13492b6389efSBryan Cantrill DTRACE_LLQUANTIZE_HIGHSHIFT }, 13502b6389efSBryan Cantrill { "linear steps per magnitude", D_LLQUANT_NSTEPTYPE, 13512b6389efSBryan Cantrill D_LLQUANT_NSTEPVAL, D_LLQUANT_NSTEPMATCH, 13522b6389efSBryan Cantrill DTRACE_LLQUANTIZE_NSTEPSHIFT }, 13532b6389efSBryan Cantrill { NULL } 13542b6389efSBryan Cantrill }; 13552b6389efSBryan Cantrill 13562b6389efSBryan Cantrill assert(arg == 0); 13572b6389efSBryan Cantrill 13582b6389efSBryan Cantrill for (i = 0; args[i].str != NULL; i++) { 13592b6389efSBryan Cantrill if (llarg->dn_kind != DT_NODE_INT) { 13602b6389efSBryan Cantrill dnerror(llarg, args[i].badtype, "llquantize( ) " 13612b6389efSBryan Cantrill "argument #%d (%s) must be an " 13622b6389efSBryan Cantrill "integer constant\n", i + 1, args[i].str); 13632b6389efSBryan Cantrill } 13642b6389efSBryan Cantrill 13652b6389efSBryan Cantrill if ((uint64_t)llarg->dn_value > UINT16_MAX) { 13662b6389efSBryan Cantrill dnerror(llarg, args[i].badval, "llquantize( ) " 13672b6389efSBryan Cantrill "argument #%d (%s) must be an unsigned " 13682b6389efSBryan Cantrill "16-bit quantity\n", i + 1, args[i].str); 13692b6389efSBryan Cantrill } 13702b6389efSBryan Cantrill 13712b6389efSBryan Cantrill args[i].value = (uint16_t)llarg->dn_value; 13722b6389efSBryan Cantrill 13732b6389efSBryan Cantrill assert(!(arg & (UINT16_MAX << args[i].shift))); 13742b6389efSBryan Cantrill arg |= ((uint64_t)args[i].value << args[i].shift); 13752b6389efSBryan Cantrill llarg = llarg->dn_list; 13762b6389efSBryan Cantrill } 13772b6389efSBryan Cantrill 13782b6389efSBryan Cantrill assert(arg != 0); 13792b6389efSBryan Cantrill 13802b6389efSBryan Cantrill if (args[0].value < 2) { 13812b6389efSBryan Cantrill dnerror(dnp, D_LLQUANT_FACTORSMALL, "llquantize( ) " 13822b6389efSBryan Cantrill "factor (argument #1) must be two or more\n"); 13832b6389efSBryan Cantrill } 13842b6389efSBryan Cantrill 13852b6389efSBryan Cantrill if (args[1].value >= args[2].value) { 13862b6389efSBryan Cantrill dnerror(dnp, D_LLQUANT_MAGRANGE, "llquantize( ) " 13872b6389efSBryan Cantrill "high magnitude (argument #3) must be greater " 13882b6389efSBryan Cantrill "than low magnitude (argument #2)\n"); 13892b6389efSBryan Cantrill } 13902b6389efSBryan Cantrill 13912b6389efSBryan Cantrill if (args[3].value < args[0].value) { 13922b6389efSBryan Cantrill dnerror(dnp, D_LLQUANT_FACTORNSTEPS, "llquantize( ) " 13932b6389efSBryan Cantrill "factor (argument #1) must be less than or " 13942b6389efSBryan Cantrill "equal to the number of linear steps per " 13952b6389efSBryan Cantrill "magnitude (argument #4)\n"); 13962b6389efSBryan Cantrill } 13972b6389efSBryan Cantrill 13982b6389efSBryan Cantrill for (v = args[0].value; v < args[3].value; v *= args[0].value) 13992b6389efSBryan Cantrill continue; 14002b6389efSBryan Cantrill 14012b6389efSBryan Cantrill if ((args[3].value % args[0].value) || (v % args[3].value)) { 14022b6389efSBryan Cantrill dnerror(dnp, D_LLQUANT_FACTOREVEN, "llquantize( ) " 14032b6389efSBryan Cantrill "factor (argument #1) must evenly divide the " 14042b6389efSBryan Cantrill "number of steps per magnitude (argument #4), " 14052b6389efSBryan Cantrill "and the number of steps per magnitude must evenly " 14062b6389efSBryan Cantrill "divide a power of the factor\n"); 14072b6389efSBryan Cantrill } 14082b6389efSBryan Cantrill 14092b6389efSBryan Cantrill for (i = 0, order = 1; i < args[2].value; i++) { 14102b6389efSBryan Cantrill if (order * args[0].value > order) { 14112b6389efSBryan Cantrill order *= args[0].value; 14122b6389efSBryan Cantrill continue; 14132b6389efSBryan Cantrill } 14142b6389efSBryan Cantrill 14152b6389efSBryan Cantrill dnerror(dnp, D_LLQUANT_MAGTOOBIG, "llquantize( ) " 14162b6389efSBryan Cantrill "factor (%d) raised to power of high magnitude " 14172b6389efSBryan Cantrill "(%d) overflows 64-bits\n", args[0].value, 14182b6389efSBryan Cantrill args[2].value); 14192b6389efSBryan Cantrill } 14202b6389efSBryan Cantrill 14212b6389efSBryan Cantrill isp = (dt_idsig_t *)aid->di_data; 14222b6389efSBryan Cantrill 14232b6389efSBryan Cantrill if (isp->dis_auxinfo == 0) { 14242b6389efSBryan Cantrill /* 14252b6389efSBryan Cantrill * This is the first time we've seen an llquantize() 14262b6389efSBryan Cantrill * for this aggregation; we'll store our argument 14272b6389efSBryan Cantrill * as the auxiliary signature information. 14282b6389efSBryan Cantrill */ 14292b6389efSBryan Cantrill isp->dis_auxinfo = arg; 14302b6389efSBryan Cantrill } else if ((oarg = isp->dis_auxinfo) != arg) { 14312b6389efSBryan Cantrill /* 14322b6389efSBryan Cantrill * If we have seen this llquantize() before and the 14332b6389efSBryan Cantrill * argument doesn't match the original argument, pick 14342b6389efSBryan Cantrill * the original argument apart to concisely report the 14352b6389efSBryan Cantrill * mismatch. 14362b6389efSBryan Cantrill */ 14372b6389efSBryan Cantrill int expected = 0, found = 0; 14382b6389efSBryan Cantrill 14392b6389efSBryan Cantrill for (i = 0; expected == found; i++) { 14402b6389efSBryan Cantrill assert(args[i].str != NULL); 14412b6389efSBryan Cantrill 14422b6389efSBryan Cantrill expected = (oarg >> args[i].shift) & UINT16_MAX; 14432b6389efSBryan Cantrill found = (arg >> args[i].shift) & UINT16_MAX; 14442b6389efSBryan Cantrill } 14452b6389efSBryan Cantrill 14462b6389efSBryan Cantrill dnerror(dnp, args[i - 1].mismatch, "llquantize( ) " 14472b6389efSBryan Cantrill "%s (argument #%d) doesn't match previous " 14482b6389efSBryan Cantrill "declaration: expected %d, found %d\n", 14492b6389efSBryan Cantrill args[i - 1].str, i, expected, found); 14502b6389efSBryan Cantrill } 14512b6389efSBryan Cantrill 14522b6389efSBryan Cantrill incr = llarg; 14532b6389efSBryan Cantrill argmax = 6; 14542b6389efSBryan Cantrill } 14552b6389efSBryan Cantrill 1456a1b5e537Sbmc if (fid->di_id == DTRACEAGG_QUANTIZE) { 1457a1b5e537Sbmc incr = dnp->dn_aggfun->dn_args->dn_list; 1458a1b5e537Sbmc argmax = 2; 1459a1b5e537Sbmc } 1460a1b5e537Sbmc 1461a1b5e537Sbmc if (incr != NULL) { 1462a1b5e537Sbmc if (!dt_node_is_scalar(incr)) { 1463a1b5e537Sbmc dnerror(dnp, D_PROTO_ARG, "%s( ) increment value " 1464a1b5e537Sbmc "(argument #%d) must be of scalar type\n", 1465a1b5e537Sbmc fid->di_name, argmax); 1466a1b5e537Sbmc } 1467a1b5e537Sbmc 1468a1b5e537Sbmc if ((anp = incr->dn_list) != NULL) { 1469a1b5e537Sbmc int argc = argmax; 1470a1b5e537Sbmc 1471a1b5e537Sbmc for (; anp != NULL; anp = anp->dn_list) 1472a1b5e537Sbmc argc++; 1473a1b5e537Sbmc 1474a1b5e537Sbmc dnerror(incr, D_PROTO_LEN, "%s( ) prototype " 1475a1b5e537Sbmc "mismatch: %d args passed, at most %d expected", 1476a1b5e537Sbmc fid->di_name, argc, argmax); 1477a1b5e537Sbmc } 1478a1b5e537Sbmc 1479a1b5e537Sbmc ap = dt_stmt_action(dtp, sdp); 1480a1b5e537Sbmc n++; 1481a1b5e537Sbmc 1482a1b5e537Sbmc dt_cg(yypcb, incr); 1483a1b5e537Sbmc ap->dtad_difo = dt_as(yypcb); 1484a1b5e537Sbmc ap->dtad_difo->dtdo_rtype = dt_void_rtype; 1485a1b5e537Sbmc ap->dtad_kind = DTRACEACT_DIFEXPR; 1486a1b5e537Sbmc } 1487a1b5e537Sbmc 1488a1b5e537Sbmc assert(sdp->dtsd_aggdata == NULL); 1489a1b5e537Sbmc sdp->dtsd_aggdata = aid; 1490a1b5e537Sbmc 1491a1b5e537Sbmc ap = dt_stmt_action(dtp, sdp); 1492a1b5e537Sbmc assert(fid->di_kind == DT_IDENT_AGGFUNC); 1493a1b5e537Sbmc assert(DTRACEACT_ISAGG(fid->di_id)); 1494a1b5e537Sbmc ap->dtad_kind = fid->di_id; 1495a1b5e537Sbmc ap->dtad_ntuple = n; 1496a1b5e537Sbmc ap->dtad_arg = arg; 1497a1b5e537Sbmc 1498a1b5e537Sbmc if (dnp->dn_aggfun->dn_args != NULL) { 1499a1b5e537Sbmc dt_cg(yypcb, dnp->dn_aggfun->dn_args); 1500a1b5e537Sbmc ap->dtad_difo = dt_as(yypcb); 15017c478bd9Sstevel@tonic-gate } 15027c478bd9Sstevel@tonic-gate } 15037c478bd9Sstevel@tonic-gate 15047c478bd9Sstevel@tonic-gate static void 15057c478bd9Sstevel@tonic-gate dt_compile_one_clause(dtrace_hdl_t *dtp, dt_node_t *cnp, dt_node_t *pnp) 15067c478bd9Sstevel@tonic-gate { 15077c478bd9Sstevel@tonic-gate dtrace_ecbdesc_t *edp; 15087c478bd9Sstevel@tonic-gate dtrace_stmtdesc_t *sdp; 15097c478bd9Sstevel@tonic-gate dt_node_t *dnp; 15107c478bd9Sstevel@tonic-gate 15117c478bd9Sstevel@tonic-gate yylineno = pnp->dn_line; 15127c478bd9Sstevel@tonic-gate dt_setcontext(dtp, pnp->dn_desc); 15137c478bd9Sstevel@tonic-gate (void) dt_node_cook(cnp, DT_IDFLG_REF); 15147c478bd9Sstevel@tonic-gate 15157c478bd9Sstevel@tonic-gate if (DT_TREEDUMP_PASS(dtp, 2)) 15167c478bd9Sstevel@tonic-gate dt_node_printr(cnp, stderr, 0); 15177c478bd9Sstevel@tonic-gate 15181a7c1b72Smws if ((edp = dt_ecbdesc_create(dtp, pnp->dn_desc)) == NULL) 15197c478bd9Sstevel@tonic-gate longjmp(yypcb->pcb_jmpbuf, EDT_NOMEM); 15207c478bd9Sstevel@tonic-gate 15217c478bd9Sstevel@tonic-gate assert(yypcb->pcb_ecbdesc == NULL); 15227c478bd9Sstevel@tonic-gate yypcb->pcb_ecbdesc = edp; 15237c478bd9Sstevel@tonic-gate 15247c478bd9Sstevel@tonic-gate if (cnp->dn_pred != NULL) { 15257c478bd9Sstevel@tonic-gate dt_cg(yypcb, cnp->dn_pred); 15267c478bd9Sstevel@tonic-gate edp->dted_pred.dtpdd_difo = dt_as(yypcb); 15277c478bd9Sstevel@tonic-gate } 15287c478bd9Sstevel@tonic-gate 15297c478bd9Sstevel@tonic-gate if (cnp->dn_acts == NULL) { 15307c478bd9Sstevel@tonic-gate dt_stmt_append(dt_stmt_create(dtp, edp, 15317c478bd9Sstevel@tonic-gate cnp->dn_ctxattr, _dtrace_defattr), cnp); 15327c478bd9Sstevel@tonic-gate } 15337c478bd9Sstevel@tonic-gate 15347c478bd9Sstevel@tonic-gate for (dnp = cnp->dn_acts; dnp != NULL; dnp = dnp->dn_list) { 15357c478bd9Sstevel@tonic-gate assert(yypcb->pcb_stmt == NULL); 15367c478bd9Sstevel@tonic-gate sdp = dt_stmt_create(dtp, edp, cnp->dn_ctxattr, cnp->dn_attr); 15377c478bd9Sstevel@tonic-gate 15387c478bd9Sstevel@tonic-gate switch (dnp->dn_kind) { 15397c478bd9Sstevel@tonic-gate case DT_NODE_DEXPR: 15407c478bd9Sstevel@tonic-gate if (dnp->dn_expr->dn_kind == DT_NODE_AGG) 15417c478bd9Sstevel@tonic-gate dt_compile_agg(dtp, dnp->dn_expr, sdp); 15427c478bd9Sstevel@tonic-gate else 15437c478bd9Sstevel@tonic-gate dt_compile_exp(dtp, dnp, sdp); 15447c478bd9Sstevel@tonic-gate break; 15457c478bd9Sstevel@tonic-gate case DT_NODE_DFUNC: 15467c478bd9Sstevel@tonic-gate dt_compile_fun(dtp, dnp, sdp); 15477c478bd9Sstevel@tonic-gate break; 15487c478bd9Sstevel@tonic-gate case DT_NODE_AGG: 15497c478bd9Sstevel@tonic-gate dt_compile_agg(dtp, dnp, sdp); 15507c478bd9Sstevel@tonic-gate break; 15517c478bd9Sstevel@tonic-gate default: 15527c478bd9Sstevel@tonic-gate dnerror(dnp, D_UNKNOWN, "internal error -- node kind " 15537c478bd9Sstevel@tonic-gate "%u is not a valid statement\n", dnp->dn_kind); 15547c478bd9Sstevel@tonic-gate } 15557c478bd9Sstevel@tonic-gate 15567c478bd9Sstevel@tonic-gate assert(yypcb->pcb_stmt == sdp); 15577c478bd9Sstevel@tonic-gate dt_stmt_append(sdp, dnp); 15587c478bd9Sstevel@tonic-gate } 15597c478bd9Sstevel@tonic-gate 15607c478bd9Sstevel@tonic-gate assert(yypcb->pcb_ecbdesc == edp); 15611a7c1b72Smws dt_ecbdesc_release(dtp, edp); 15627c478bd9Sstevel@tonic-gate dt_endcontext(dtp); 15637c478bd9Sstevel@tonic-gate yypcb->pcb_ecbdesc = NULL; 15647c478bd9Sstevel@tonic-gate } 15657c478bd9Sstevel@tonic-gate 15667c478bd9Sstevel@tonic-gate static void 15677c478bd9Sstevel@tonic-gate dt_compile_clause(dtrace_hdl_t *dtp, dt_node_t *cnp) 15687c478bd9Sstevel@tonic-gate { 15697c478bd9Sstevel@tonic-gate dt_node_t *pnp; 15707c478bd9Sstevel@tonic-gate 15717c478bd9Sstevel@tonic-gate for (pnp = cnp->dn_pdescs; pnp != NULL; pnp = pnp->dn_list) 15727c478bd9Sstevel@tonic-gate dt_compile_one_clause(dtp, cnp, pnp); 15737c478bd9Sstevel@tonic-gate } 15747c478bd9Sstevel@tonic-gate 15751a7c1b72Smws static void 15761a7c1b72Smws dt_compile_xlator(dt_node_t *dnp) 15771a7c1b72Smws { 15781a7c1b72Smws dt_xlator_t *dxp = dnp->dn_xlator; 15791a7c1b72Smws dt_node_t *mnp; 15801a7c1b72Smws 15811a7c1b72Smws for (mnp = dnp->dn_members; mnp != NULL; mnp = mnp->dn_list) { 15821a7c1b72Smws assert(dxp->dx_membdif[mnp->dn_membid] == NULL); 15831a7c1b72Smws dt_cg(yypcb, mnp); 15841a7c1b72Smws dxp->dx_membdif[mnp->dn_membid] = dt_as(yypcb); 15851a7c1b72Smws } 15861a7c1b72Smws } 15871a7c1b72Smws 15887c478bd9Sstevel@tonic-gate void 15897c478bd9Sstevel@tonic-gate dt_setcontext(dtrace_hdl_t *dtp, dtrace_probedesc_t *pdp) 15907c478bd9Sstevel@tonic-gate { 15917c478bd9Sstevel@tonic-gate const dtrace_pattr_t *pap; 15927c478bd9Sstevel@tonic-gate dt_probe_t *prp; 1593c9d6cd77Sjhaslam dt_provider_t *pvp; 15947c478bd9Sstevel@tonic-gate dt_ident_t *idp; 15957c478bd9Sstevel@tonic-gate char attrstr[8]; 15967c478bd9Sstevel@tonic-gate int err; 15977c478bd9Sstevel@tonic-gate 15987c478bd9Sstevel@tonic-gate /* 1599c9d6cd77Sjhaslam * Both kernel and pid based providers are allowed to have names 1600c9d6cd77Sjhaslam * ending with what could be interpreted as a number. We assume it's 1601c9d6cd77Sjhaslam * a pid and that we may need to dynamically create probes for 1602c9d6cd77Sjhaslam * that process if: 1603c9d6cd77Sjhaslam * 1604c9d6cd77Sjhaslam * (1) The provider doesn't exist, or, 1605c9d6cd77Sjhaslam * (2) The provider exists and has DTRACE_PRIV_PROC privilege. 1606c9d6cd77Sjhaslam * 1607c9d6cd77Sjhaslam * On an error, dt_pid_create_probes() will set the error message 1608c9d6cd77Sjhaslam * and tag -- we just have to longjmp() out of here. 16097c478bd9Sstevel@tonic-gate */ 1610900524f3Sahl if (isdigit(pdp->dtpd_provider[strlen(pdp->dtpd_provider) - 1]) && 1611c9d6cd77Sjhaslam ((pvp = dt_provider_lookup(dtp, pdp->dtpd_provider)) == NULL || 1612c9d6cd77Sjhaslam pvp->pv_desc.dtvd_priv.dtpp_flags & DTRACE_PRIV_PROC) && 1613900524f3Sahl dt_pid_create_probes(pdp, dtp, yypcb) != 0) { 1614900524f3Sahl longjmp(yypcb->pcb_jmpbuf, EDT_COMPILER); 1615900524f3Sahl } 16167c478bd9Sstevel@tonic-gate 16177c478bd9Sstevel@tonic-gate /* 16187c478bd9Sstevel@tonic-gate * Call dt_probe_info() to get the probe arguments and attributes. If 16197c478bd9Sstevel@tonic-gate * a representative probe is found, set 'pap' to the probe provider's 16207c478bd9Sstevel@tonic-gate * attributes. Otherwise set 'pap' to default Unstable attributes. 16217c478bd9Sstevel@tonic-gate */ 16227c478bd9Sstevel@tonic-gate if ((prp = dt_probe_info(dtp, pdp, &yypcb->pcb_pinfo)) == NULL) { 16237c478bd9Sstevel@tonic-gate pap = &_dtrace_prvdesc; 16247c478bd9Sstevel@tonic-gate err = dtrace_errno(dtp); 16257c478bd9Sstevel@tonic-gate bzero(&yypcb->pcb_pinfo, sizeof (dtrace_probeinfo_t)); 16267c478bd9Sstevel@tonic-gate yypcb->pcb_pinfo.dtp_attr = pap->dtpa_provider; 16277c478bd9Sstevel@tonic-gate yypcb->pcb_pinfo.dtp_arga = pap->dtpa_args; 16287c478bd9Sstevel@tonic-gate } else { 16297c478bd9Sstevel@tonic-gate pap = &prp->pr_pvp->pv_desc.dtvd_attr; 16307c478bd9Sstevel@tonic-gate err = 0; 16317c478bd9Sstevel@tonic-gate } 16327c478bd9Sstevel@tonic-gate 16337c478bd9Sstevel@tonic-gate if (err == EDT_NOPROBE && !(yypcb->pcb_cflags & DTRACE_C_ZDEFS)) { 16347c478bd9Sstevel@tonic-gate xyerror(D_PDESC_ZERO, "probe description %s:%s:%s:%s does not " 16357c478bd9Sstevel@tonic-gate "match any probes\n", pdp->dtpd_provider, pdp->dtpd_mod, 16367c478bd9Sstevel@tonic-gate pdp->dtpd_func, pdp->dtpd_name); 16377c478bd9Sstevel@tonic-gate } 16387c478bd9Sstevel@tonic-gate 16397c478bd9Sstevel@tonic-gate if (err != EDT_NOPROBE && err != EDT_UNSTABLE && err != 0) 16407c478bd9Sstevel@tonic-gate xyerror(D_PDESC_INVAL, "%s\n", dtrace_errmsg(dtp, err)); 16417c478bd9Sstevel@tonic-gate 16427c478bd9Sstevel@tonic-gate dt_dprintf("set context to %s:%s:%s:%s [%u] prp=%p attr=%s argc=%d\n", 16437c478bd9Sstevel@tonic-gate pdp->dtpd_provider, pdp->dtpd_mod, pdp->dtpd_func, pdp->dtpd_name, 16447c478bd9Sstevel@tonic-gate pdp->dtpd_id, (void *)prp, dt_attr_str(yypcb->pcb_pinfo.dtp_attr, 16457c478bd9Sstevel@tonic-gate attrstr, sizeof (attrstr)), yypcb->pcb_pinfo.dtp_argc); 16467c478bd9Sstevel@tonic-gate 16477c478bd9Sstevel@tonic-gate /* 16487c478bd9Sstevel@tonic-gate * Reset the stability attributes of D global variables that vary 16497c478bd9Sstevel@tonic-gate * based on the attributes of the provider and context itself. 16507c478bd9Sstevel@tonic-gate */ 16517c478bd9Sstevel@tonic-gate if ((idp = dt_idhash_lookup(dtp->dt_globals, "probeprov")) != NULL) 16527c478bd9Sstevel@tonic-gate idp->di_attr = pap->dtpa_provider; 16537c478bd9Sstevel@tonic-gate if ((idp = dt_idhash_lookup(dtp->dt_globals, "probemod")) != NULL) 16547c478bd9Sstevel@tonic-gate idp->di_attr = pap->dtpa_mod; 16557c478bd9Sstevel@tonic-gate if ((idp = dt_idhash_lookup(dtp->dt_globals, "probefunc")) != NULL) 16567c478bd9Sstevel@tonic-gate idp->di_attr = pap->dtpa_func; 16577c478bd9Sstevel@tonic-gate if ((idp = dt_idhash_lookup(dtp->dt_globals, "probename")) != NULL) 16587c478bd9Sstevel@tonic-gate idp->di_attr = pap->dtpa_name; 16597c478bd9Sstevel@tonic-gate if ((idp = dt_idhash_lookup(dtp->dt_globals, "args")) != NULL) 16607c478bd9Sstevel@tonic-gate idp->di_attr = pap->dtpa_args; 16617c478bd9Sstevel@tonic-gate 16627c478bd9Sstevel@tonic-gate yypcb->pcb_pdesc = pdp; 16637c478bd9Sstevel@tonic-gate yypcb->pcb_probe = prp; 16647c478bd9Sstevel@tonic-gate } 16657c478bd9Sstevel@tonic-gate 16667c478bd9Sstevel@tonic-gate /* 16677c478bd9Sstevel@tonic-gate * Reset context-dependent variables and state at the end of cooking a D probe 16687c478bd9Sstevel@tonic-gate * definition clause. This ensures that external declarations between clauses 16697c478bd9Sstevel@tonic-gate * do not reference any stale context-dependent data from the previous clause. 16707c478bd9Sstevel@tonic-gate */ 16717c478bd9Sstevel@tonic-gate void 16727c478bd9Sstevel@tonic-gate dt_endcontext(dtrace_hdl_t *dtp) 16737c478bd9Sstevel@tonic-gate { 16747c478bd9Sstevel@tonic-gate static const char *const cvars[] = { 16757c478bd9Sstevel@tonic-gate "probeprov", "probemod", "probefunc", "probename", "args", NULL 16767c478bd9Sstevel@tonic-gate }; 16777c478bd9Sstevel@tonic-gate 16787c478bd9Sstevel@tonic-gate dt_ident_t *idp; 16797c478bd9Sstevel@tonic-gate int i; 16807c478bd9Sstevel@tonic-gate 16817c478bd9Sstevel@tonic-gate for (i = 0; cvars[i] != NULL; i++) { 16827c478bd9Sstevel@tonic-gate if ((idp = dt_idhash_lookup(dtp->dt_globals, cvars[i])) != NULL) 16837c478bd9Sstevel@tonic-gate idp->di_attr = _dtrace_defattr; 16847c478bd9Sstevel@tonic-gate } 16857c478bd9Sstevel@tonic-gate 16867c478bd9Sstevel@tonic-gate yypcb->pcb_pdesc = NULL; 16877c478bd9Sstevel@tonic-gate yypcb->pcb_probe = NULL; 16887c478bd9Sstevel@tonic-gate } 16897c478bd9Sstevel@tonic-gate 16907c478bd9Sstevel@tonic-gate static int 16917c478bd9Sstevel@tonic-gate dt_reduceid(dt_idhash_t *dhp, dt_ident_t *idp, dtrace_hdl_t *dtp) 16927c478bd9Sstevel@tonic-gate { 16937c478bd9Sstevel@tonic-gate if (idp->di_vers != 0 && idp->di_vers > dtp->dt_vmax) 16947c478bd9Sstevel@tonic-gate dt_idhash_delete(dhp, idp); 16957c478bd9Sstevel@tonic-gate 16967c478bd9Sstevel@tonic-gate return (0); 16977c478bd9Sstevel@tonic-gate } 16987c478bd9Sstevel@tonic-gate 16997c478bd9Sstevel@tonic-gate /* 17007c478bd9Sstevel@tonic-gate * When dtrace_setopt() is called for "version", it calls dt_reduce() to remove 17017c478bd9Sstevel@tonic-gate * any identifiers or translators that have been previously defined as bound to 17027c478bd9Sstevel@tonic-gate * a version greater than the specified version. Therefore, in our current 17037c478bd9Sstevel@tonic-gate * version implementation, establishing a binding is a one-way transformation. 17047c478bd9Sstevel@tonic-gate * In addition, no versioning is currently provided for types as our .d library 17057c478bd9Sstevel@tonic-gate * files do not define any types and we reserve prefixes DTRACE_ and dtrace_ 17067c478bd9Sstevel@tonic-gate * for our exclusive use. If required, type versioning will require more work. 17077c478bd9Sstevel@tonic-gate */ 17087c478bd9Sstevel@tonic-gate int 17097c478bd9Sstevel@tonic-gate dt_reduce(dtrace_hdl_t *dtp, dt_version_t v) 17107c478bd9Sstevel@tonic-gate { 17117c478bd9Sstevel@tonic-gate char s[DT_VERSION_STRMAX]; 17127c478bd9Sstevel@tonic-gate dt_xlator_t *dxp, *nxp; 17137c478bd9Sstevel@tonic-gate 17147c478bd9Sstevel@tonic-gate if (v > dtp->dt_vmax) 17157c478bd9Sstevel@tonic-gate return (dt_set_errno(dtp, EDT_VERSREDUCED)); 17167c478bd9Sstevel@tonic-gate else if (v == dtp->dt_vmax) 17177c478bd9Sstevel@tonic-gate return (0); /* no reduction necessary */ 17187c478bd9Sstevel@tonic-gate 17197c478bd9Sstevel@tonic-gate dt_dprintf("reducing api version to %s\n", 17207c478bd9Sstevel@tonic-gate dt_version_num2str(v, s, sizeof (s))); 17217c478bd9Sstevel@tonic-gate 17227c478bd9Sstevel@tonic-gate dtp->dt_vmax = v; 17237c478bd9Sstevel@tonic-gate 17247c478bd9Sstevel@tonic-gate for (dxp = dt_list_next(&dtp->dt_xlators); dxp != NULL; dxp = nxp) { 17257c478bd9Sstevel@tonic-gate nxp = dt_list_next(dxp); 17267c478bd9Sstevel@tonic-gate if ((dxp->dx_souid.di_vers != 0 && dxp->dx_souid.di_vers > v) || 17277c478bd9Sstevel@tonic-gate (dxp->dx_ptrid.di_vers != 0 && dxp->dx_ptrid.di_vers > v)) 17287c478bd9Sstevel@tonic-gate dt_list_delete(&dtp->dt_xlators, dxp); 17297c478bd9Sstevel@tonic-gate } 17307c478bd9Sstevel@tonic-gate 17317c478bd9Sstevel@tonic-gate (void) dt_idhash_iter(dtp->dt_macros, (dt_idhash_f *)dt_reduceid, dtp); 17327c478bd9Sstevel@tonic-gate (void) dt_idhash_iter(dtp->dt_aggs, (dt_idhash_f *)dt_reduceid, dtp); 17337c478bd9Sstevel@tonic-gate (void) dt_idhash_iter(dtp->dt_globals, (dt_idhash_f *)dt_reduceid, dtp); 17347c478bd9Sstevel@tonic-gate (void) dt_idhash_iter(dtp->dt_tls, (dt_idhash_f *)dt_reduceid, dtp); 17357c478bd9Sstevel@tonic-gate 17367c478bd9Sstevel@tonic-gate return (0); 17377c478bd9Sstevel@tonic-gate } 17387c478bd9Sstevel@tonic-gate 17397c478bd9Sstevel@tonic-gate /* 17407c478bd9Sstevel@tonic-gate * Fork and exec the cpp(1) preprocessor to run over the specified input file, 17417c478bd9Sstevel@tonic-gate * and return a FILE handle for the cpp output. We use the /dev/fd filesystem 17427c478bd9Sstevel@tonic-gate * here to simplify the code by leveraging file descriptor inheritance. 17437c478bd9Sstevel@tonic-gate */ 17447c478bd9Sstevel@tonic-gate static FILE * 17457c478bd9Sstevel@tonic-gate dt_preproc(dtrace_hdl_t *dtp, FILE *ifp) 17467c478bd9Sstevel@tonic-gate { 17477c478bd9Sstevel@tonic-gate int argc = dtp->dt_cpp_argc; 17487c478bd9Sstevel@tonic-gate char **argv = malloc(sizeof (char *) * (argc + 5)); 17497c478bd9Sstevel@tonic-gate FILE *ofp = tmpfile(); 17507c478bd9Sstevel@tonic-gate 17517c478bd9Sstevel@tonic-gate char ipath[20], opath[20]; /* big enough for /dev/fd/ + INT_MAX + \0 */ 17527c478bd9Sstevel@tonic-gate char verdef[32]; /* big enough for -D__SUNW_D_VERSION=0x%08x + \0 */ 17537c478bd9Sstevel@tonic-gate 17547c478bd9Sstevel@tonic-gate struct sigaction act, oact; 17557c478bd9Sstevel@tonic-gate sigset_t mask, omask; 17567c478bd9Sstevel@tonic-gate 17577c478bd9Sstevel@tonic-gate int wstat, estat; 17587c478bd9Sstevel@tonic-gate pid_t pid; 17597c478bd9Sstevel@tonic-gate off64_t off; 17607c478bd9Sstevel@tonic-gate int c; 17617c478bd9Sstevel@tonic-gate 17627c478bd9Sstevel@tonic-gate if (argv == NULL || ofp == NULL) { 17637c478bd9Sstevel@tonic-gate (void) dt_set_errno(dtp, errno); 17647c478bd9Sstevel@tonic-gate goto err; 17657c478bd9Sstevel@tonic-gate } 17667c478bd9Sstevel@tonic-gate 17677c478bd9Sstevel@tonic-gate /* 17687c478bd9Sstevel@tonic-gate * If the input is a seekable file, see if it is an interpreter file. 17697c478bd9Sstevel@tonic-gate * If we see #!, seek past the first line because cpp will choke on it. 17707c478bd9Sstevel@tonic-gate * We start cpp just prior to the \n at the end of this line so that 17717c478bd9Sstevel@tonic-gate * it still sees the newline, ensuring that #line values are correct. 17727c478bd9Sstevel@tonic-gate */ 17737c478bd9Sstevel@tonic-gate if (isatty(fileno(ifp)) == 0 && (off = ftello64(ifp)) != -1) { 17747c478bd9Sstevel@tonic-gate if ((c = fgetc(ifp)) == '#' && (c = fgetc(ifp)) == '!') { 17757c478bd9Sstevel@tonic-gate for (off += 2; c != '\n'; off++) { 17767c478bd9Sstevel@tonic-gate if ((c = fgetc(ifp)) == EOF) 17777c478bd9Sstevel@tonic-gate break; 17787c478bd9Sstevel@tonic-gate } 17797c478bd9Sstevel@tonic-gate if (c == '\n') 17807c478bd9Sstevel@tonic-gate off--; /* start cpp just prior to \n */ 17817c478bd9Sstevel@tonic-gate } 17827c478bd9Sstevel@tonic-gate (void) fflush(ifp); 17837c478bd9Sstevel@tonic-gate (void) fseeko64(ifp, off, SEEK_SET); 17847c478bd9Sstevel@tonic-gate } 17857c478bd9Sstevel@tonic-gate 17867c478bd9Sstevel@tonic-gate (void) snprintf(ipath, sizeof (ipath), "/dev/fd/%d", fileno(ifp)); 17877c478bd9Sstevel@tonic-gate (void) snprintf(opath, sizeof (opath), "/dev/fd/%d", fileno(ofp)); 17887c478bd9Sstevel@tonic-gate 17897c478bd9Sstevel@tonic-gate bcopy(dtp->dt_cpp_argv, argv, sizeof (char *) * argc); 17907c478bd9Sstevel@tonic-gate 17917c478bd9Sstevel@tonic-gate (void) snprintf(verdef, sizeof (verdef), 17927c478bd9Sstevel@tonic-gate "-D__SUNW_D_VERSION=0x%08x", dtp->dt_vmax); 17937c478bd9Sstevel@tonic-gate argv[argc++] = verdef; 17947c478bd9Sstevel@tonic-gate 17957c478bd9Sstevel@tonic-gate switch (dtp->dt_stdcmode) { 17967c478bd9Sstevel@tonic-gate case DT_STDC_XA: 17977c478bd9Sstevel@tonic-gate case DT_STDC_XT: 17987c478bd9Sstevel@tonic-gate argv[argc++] = "-D__STDC__=0"; 17997c478bd9Sstevel@tonic-gate break; 18007c478bd9Sstevel@tonic-gate case DT_STDC_XC: 18017c478bd9Sstevel@tonic-gate argv[argc++] = "-D__STDC__=1"; 18027c478bd9Sstevel@tonic-gate break; 18037c478bd9Sstevel@tonic-gate } 18047c478bd9Sstevel@tonic-gate 18057c478bd9Sstevel@tonic-gate argv[argc++] = ipath; 18067c478bd9Sstevel@tonic-gate argv[argc++] = opath; 18077c478bd9Sstevel@tonic-gate argv[argc] = NULL; 18087c478bd9Sstevel@tonic-gate 18097c478bd9Sstevel@tonic-gate /* 18107c478bd9Sstevel@tonic-gate * libdtrace must be able to be embedded in other programs that may 18117c478bd9Sstevel@tonic-gate * include application-specific signal handlers. Therefore, if we 18127c478bd9Sstevel@tonic-gate * need to fork to run cpp(1), we must avoid generating a SIGCHLD 18137c478bd9Sstevel@tonic-gate * that could confuse the containing application. To do this, 18147c478bd9Sstevel@tonic-gate * we block SIGCHLD and reset its disposition to SIG_DFL. 18157c478bd9Sstevel@tonic-gate * We restore our signal state once we are done. 18167c478bd9Sstevel@tonic-gate */ 18177c478bd9Sstevel@tonic-gate (void) sigemptyset(&mask); 18187c478bd9Sstevel@tonic-gate (void) sigaddset(&mask, SIGCHLD); 18197c478bd9Sstevel@tonic-gate (void) sigprocmask(SIG_BLOCK, &mask, &omask); 18207c478bd9Sstevel@tonic-gate 18217c478bd9Sstevel@tonic-gate bzero(&act, sizeof (act)); 18227c478bd9Sstevel@tonic-gate act.sa_handler = SIG_DFL; 18237c478bd9Sstevel@tonic-gate (void) sigaction(SIGCHLD, &act, &oact); 18247c478bd9Sstevel@tonic-gate 18257c478bd9Sstevel@tonic-gate if ((pid = fork1()) == -1) { 18267c478bd9Sstevel@tonic-gate (void) sigaction(SIGCHLD, &oact, NULL); 18277c478bd9Sstevel@tonic-gate (void) sigprocmask(SIG_SETMASK, &omask, NULL); 18287c478bd9Sstevel@tonic-gate (void) dt_set_errno(dtp, EDT_CPPFORK); 18297c478bd9Sstevel@tonic-gate goto err; 18307c478bd9Sstevel@tonic-gate } 18317c478bd9Sstevel@tonic-gate 18327c478bd9Sstevel@tonic-gate if (pid == 0) { 18337c478bd9Sstevel@tonic-gate (void) execvp(dtp->dt_cpp_path, argv); 18347c478bd9Sstevel@tonic-gate _exit(errno == ENOENT ? 127 : 126); 18357c478bd9Sstevel@tonic-gate } 18367c478bd9Sstevel@tonic-gate 18377c478bd9Sstevel@tonic-gate do { 18387c478bd9Sstevel@tonic-gate dt_dprintf("waiting for %s (PID %d)\n", dtp->dt_cpp_path, 18397c478bd9Sstevel@tonic-gate (int)pid); 18407c478bd9Sstevel@tonic-gate } while (waitpid(pid, &wstat, 0) == -1 && errno == EINTR); 18417c478bd9Sstevel@tonic-gate 18427c478bd9Sstevel@tonic-gate (void) sigaction(SIGCHLD, &oact, NULL); 18437c478bd9Sstevel@tonic-gate (void) sigprocmask(SIG_SETMASK, &omask, NULL); 18447c478bd9Sstevel@tonic-gate 18457c478bd9Sstevel@tonic-gate dt_dprintf("%s returned exit status 0x%x\n", dtp->dt_cpp_path, wstat); 18467c478bd9Sstevel@tonic-gate estat = WIFEXITED(wstat) ? WEXITSTATUS(wstat) : -1; 18477c478bd9Sstevel@tonic-gate 18487c478bd9Sstevel@tonic-gate if (estat != 0) { 18497c478bd9Sstevel@tonic-gate switch (estat) { 18507c478bd9Sstevel@tonic-gate case 126: 18517c478bd9Sstevel@tonic-gate (void) dt_set_errno(dtp, EDT_CPPEXEC); 18527c478bd9Sstevel@tonic-gate break; 18537c478bd9Sstevel@tonic-gate case 127: 18547c478bd9Sstevel@tonic-gate (void) dt_set_errno(dtp, EDT_CPPENT); 18557c478bd9Sstevel@tonic-gate break; 18567c478bd9Sstevel@tonic-gate default: 18577c478bd9Sstevel@tonic-gate (void) dt_set_errno(dtp, EDT_CPPERR); 18587c478bd9Sstevel@tonic-gate } 18597c478bd9Sstevel@tonic-gate goto err; 18607c478bd9Sstevel@tonic-gate } 18617c478bd9Sstevel@tonic-gate 18627c478bd9Sstevel@tonic-gate free(argv); 18637c478bd9Sstevel@tonic-gate (void) fflush(ofp); 18647c478bd9Sstevel@tonic-gate (void) fseek(ofp, 0, SEEK_SET); 18657c478bd9Sstevel@tonic-gate return (ofp); 18667c478bd9Sstevel@tonic-gate 18677c478bd9Sstevel@tonic-gate err: 18687c478bd9Sstevel@tonic-gate free(argv); 18697c478bd9Sstevel@tonic-gate (void) fclose(ofp); 18707c478bd9Sstevel@tonic-gate return (NULL); 18717c478bd9Sstevel@tonic-gate } 18727c478bd9Sstevel@tonic-gate 1873c9d6cd77Sjhaslam static void 1874c9d6cd77Sjhaslam dt_lib_depend_error(dtrace_hdl_t *dtp, const char *format, ...) 1875c9d6cd77Sjhaslam { 1876c9d6cd77Sjhaslam va_list ap; 1877c9d6cd77Sjhaslam 1878c9d6cd77Sjhaslam va_start(ap, format); 1879c9d6cd77Sjhaslam dt_set_errmsg(dtp, NULL, NULL, NULL, 0, format, ap); 1880c9d6cd77Sjhaslam va_end(ap); 1881c9d6cd77Sjhaslam } 1882c9d6cd77Sjhaslam 1883c9d6cd77Sjhaslam int 1884c9d6cd77Sjhaslam dt_lib_depend_add(dtrace_hdl_t *dtp, dt_list_t *dlp, const char *arg) 1885c9d6cd77Sjhaslam { 1886c9d6cd77Sjhaslam dt_lib_depend_t *dld; 1887c9d6cd77Sjhaslam const char *end; 1888c9d6cd77Sjhaslam 1889c9d6cd77Sjhaslam assert(arg != NULL); 1890c9d6cd77Sjhaslam 1891c9d6cd77Sjhaslam if ((end = strrchr(arg, '/')) == NULL) 1892c9d6cd77Sjhaslam return (dt_set_errno(dtp, EINVAL)); 1893c9d6cd77Sjhaslam 1894c9d6cd77Sjhaslam if ((dld = dt_zalloc(dtp, sizeof (dt_lib_depend_t))) == NULL) 1895c9d6cd77Sjhaslam return (-1); 1896c9d6cd77Sjhaslam 1897c9d6cd77Sjhaslam if ((dld->dtld_libpath = dt_alloc(dtp, MAXPATHLEN)) == NULL) { 1898c9d6cd77Sjhaslam dt_free(dtp, dld); 1899c9d6cd77Sjhaslam return (-1); 1900c9d6cd77Sjhaslam } 1901c9d6cd77Sjhaslam 1902c9d6cd77Sjhaslam (void) strlcpy(dld->dtld_libpath, arg, end - arg + 2); 1903c9d6cd77Sjhaslam if ((dld->dtld_library = strdup(arg)) == NULL) { 1904c9d6cd77Sjhaslam dt_free(dtp, dld->dtld_libpath); 1905c9d6cd77Sjhaslam dt_free(dtp, dld); 1906c9d6cd77Sjhaslam return (dt_set_errno(dtp, EDT_NOMEM)); 1907c9d6cd77Sjhaslam } 1908c9d6cd77Sjhaslam 1909c9d6cd77Sjhaslam dt_list_append(dlp, dld); 1910c9d6cd77Sjhaslam return (0); 1911c9d6cd77Sjhaslam } 1912c9d6cd77Sjhaslam 1913c9d6cd77Sjhaslam dt_lib_depend_t * 1914c9d6cd77Sjhaslam dt_lib_depend_lookup(dt_list_t *dld, const char *arg) 1915c9d6cd77Sjhaslam { 1916c9d6cd77Sjhaslam dt_lib_depend_t *dldn; 1917c9d6cd77Sjhaslam 1918c9d6cd77Sjhaslam for (dldn = dt_list_next(dld); dldn != NULL; 1919c9d6cd77Sjhaslam dldn = dt_list_next(dldn)) { 1920c9d6cd77Sjhaslam if (strcmp(dldn->dtld_library, arg) == 0) 1921c9d6cd77Sjhaslam return (dldn); 1922c9d6cd77Sjhaslam } 1923c9d6cd77Sjhaslam 1924c9d6cd77Sjhaslam return (NULL); 1925c9d6cd77Sjhaslam } 1926c9d6cd77Sjhaslam 1927c9d6cd77Sjhaslam /* 1928c9d6cd77Sjhaslam * Go through all the library files, and, if any library dependencies exist for 1929c9d6cd77Sjhaslam * that file, add it to that node's list of dependents. The result of this 1930c9d6cd77Sjhaslam * will be a graph which can then be topologically sorted to produce a 1931c9d6cd77Sjhaslam * compilation order. 1932c9d6cd77Sjhaslam */ 1933c9d6cd77Sjhaslam static int 1934c9d6cd77Sjhaslam dt_lib_build_graph(dtrace_hdl_t *dtp) 1935c9d6cd77Sjhaslam { 1936c9d6cd77Sjhaslam dt_lib_depend_t *dld, *dpld; 1937c9d6cd77Sjhaslam 1938c9d6cd77Sjhaslam for (dld = dt_list_next(&dtp->dt_lib_dep); dld != NULL; 1939c9d6cd77Sjhaslam dld = dt_list_next(dld)) { 1940c9d6cd77Sjhaslam char *library = dld->dtld_library; 1941c9d6cd77Sjhaslam 1942c9d6cd77Sjhaslam for (dpld = dt_list_next(&dld->dtld_dependencies); dpld != NULL; 1943c9d6cd77Sjhaslam dpld = dt_list_next(dpld)) { 1944c9d6cd77Sjhaslam dt_lib_depend_t *dlda; 1945c9d6cd77Sjhaslam 1946c9d6cd77Sjhaslam if ((dlda = dt_lib_depend_lookup(&dtp->dt_lib_dep, 1947c9d6cd77Sjhaslam dpld->dtld_library)) == NULL) { 1948c9d6cd77Sjhaslam dt_lib_depend_error(dtp, 1949c9d6cd77Sjhaslam "Invalid library dependency in %s: %s\n", 1950c9d6cd77Sjhaslam dld->dtld_library, dpld->dtld_library); 1951c9d6cd77Sjhaslam 1952c9d6cd77Sjhaslam return (dt_set_errno(dtp, EDT_COMPILER)); 1953c9d6cd77Sjhaslam } 1954c9d6cd77Sjhaslam 1955c9d6cd77Sjhaslam if ((dt_lib_depend_add(dtp, &dlda->dtld_dependents, 1956c9d6cd77Sjhaslam library)) != 0) { 1957c9d6cd77Sjhaslam return (-1); /* preserve dt_errno */ 1958c9d6cd77Sjhaslam } 1959c9d6cd77Sjhaslam } 1960c9d6cd77Sjhaslam } 1961c9d6cd77Sjhaslam return (0); 1962c9d6cd77Sjhaslam } 1963c9d6cd77Sjhaslam 1964c9d6cd77Sjhaslam static int 1965c9d6cd77Sjhaslam dt_topo_sort(dtrace_hdl_t *dtp, dt_lib_depend_t *dld, int *count) 1966c9d6cd77Sjhaslam { 1967c9d6cd77Sjhaslam dt_lib_depend_t *dpld, *dlda, *new; 1968c9d6cd77Sjhaslam 1969c9d6cd77Sjhaslam dld->dtld_start = ++(*count); 1970c9d6cd77Sjhaslam 1971c9d6cd77Sjhaslam for (dpld = dt_list_next(&dld->dtld_dependents); dpld != NULL; 1972c9d6cd77Sjhaslam dpld = dt_list_next(dpld)) { 1973c9d6cd77Sjhaslam dlda = dt_lib_depend_lookup(&dtp->dt_lib_dep, 1974c9d6cd77Sjhaslam dpld->dtld_library); 1975c9d6cd77Sjhaslam assert(dlda != NULL); 1976c9d6cd77Sjhaslam 1977c9d6cd77Sjhaslam if (dlda->dtld_start == 0 && 1978c9d6cd77Sjhaslam dt_topo_sort(dtp, dlda, count) == -1) 1979c9d6cd77Sjhaslam return (-1); 1980c9d6cd77Sjhaslam } 1981c9d6cd77Sjhaslam 1982c9d6cd77Sjhaslam if ((new = dt_zalloc(dtp, sizeof (dt_lib_depend_t))) == NULL) 1983c9d6cd77Sjhaslam return (-1); 1984c9d6cd77Sjhaslam 1985c9d6cd77Sjhaslam if ((new->dtld_library = strdup(dld->dtld_library)) == NULL) { 1986c9d6cd77Sjhaslam dt_free(dtp, new); 1987c9d6cd77Sjhaslam return (dt_set_errno(dtp, EDT_NOMEM)); 1988c9d6cd77Sjhaslam } 1989c9d6cd77Sjhaslam 1990c9d6cd77Sjhaslam new->dtld_start = dld->dtld_start; 1991c9d6cd77Sjhaslam new->dtld_finish = dld->dtld_finish = ++(*count); 1992c9d6cd77Sjhaslam dt_list_prepend(&dtp->dt_lib_dep_sorted, new); 1993c9d6cd77Sjhaslam 1994c9d6cd77Sjhaslam dt_dprintf("library %s sorted (%d/%d)\n", new->dtld_library, 1995c9d6cd77Sjhaslam new->dtld_start, new->dtld_finish); 1996c9d6cd77Sjhaslam 1997c9d6cd77Sjhaslam return (0); 1998c9d6cd77Sjhaslam } 1999c9d6cd77Sjhaslam 2000c9d6cd77Sjhaslam static int 2001c9d6cd77Sjhaslam dt_lib_depend_sort(dtrace_hdl_t *dtp) 2002c9d6cd77Sjhaslam { 2003c9d6cd77Sjhaslam dt_lib_depend_t *dld, *dpld, *dlda; 2004c9d6cd77Sjhaslam int count = 0; 2005c9d6cd77Sjhaslam 2006c9d6cd77Sjhaslam if (dt_lib_build_graph(dtp) == -1) 2007c9d6cd77Sjhaslam return (-1); /* preserve dt_errno */ 2008c9d6cd77Sjhaslam 2009c9d6cd77Sjhaslam /* 2010c9d6cd77Sjhaslam * Perform a topological sort of the graph that hangs off 2011c9d6cd77Sjhaslam * dtp->dt_lib_dep. The result of this process will be a 2012c9d6cd77Sjhaslam * dependency ordered list located at dtp->dt_lib_dep_sorted. 2013c9d6cd77Sjhaslam */ 2014c9d6cd77Sjhaslam for (dld = dt_list_next(&dtp->dt_lib_dep); dld != NULL; 2015c9d6cd77Sjhaslam dld = dt_list_next(dld)) { 2016c9d6cd77Sjhaslam if (dld->dtld_start == 0 && 2017c9d6cd77Sjhaslam dt_topo_sort(dtp, dld, &count) == -1) 2018c9d6cd77Sjhaslam return (-1); /* preserve dt_errno */; 2019c9d6cd77Sjhaslam } 2020c9d6cd77Sjhaslam 2021c9d6cd77Sjhaslam /* 2022c9d6cd77Sjhaslam * Check the graph for cycles. If an ancestor's finishing time is 2023c9d6cd77Sjhaslam * less than any of its dependent's finishing times then a back edge 2024c9d6cd77Sjhaslam * exists in the graph and this is a cycle. 2025c9d6cd77Sjhaslam */ 2026c9d6cd77Sjhaslam for (dld = dt_list_next(&dtp->dt_lib_dep); dld != NULL; 2027c9d6cd77Sjhaslam dld = dt_list_next(dld)) { 2028c9d6cd77Sjhaslam for (dpld = dt_list_next(&dld->dtld_dependents); dpld != NULL; 2029c9d6cd77Sjhaslam dpld = dt_list_next(dpld)) { 2030c9d6cd77Sjhaslam dlda = dt_lib_depend_lookup(&dtp->dt_lib_dep_sorted, 2031c9d6cd77Sjhaslam dpld->dtld_library); 2032c9d6cd77Sjhaslam assert(dlda != NULL); 2033c9d6cd77Sjhaslam 2034c9d6cd77Sjhaslam if (dlda->dtld_finish > dld->dtld_finish) { 2035c9d6cd77Sjhaslam dt_lib_depend_error(dtp, 2036c9d6cd77Sjhaslam "Cyclic dependency detected: %s => %s\n", 2037c9d6cd77Sjhaslam dld->dtld_library, dpld->dtld_library); 2038c9d6cd77Sjhaslam 2039c9d6cd77Sjhaslam return (dt_set_errno(dtp, EDT_COMPILER)); 2040c9d6cd77Sjhaslam } 2041c9d6cd77Sjhaslam } 2042c9d6cd77Sjhaslam } 2043c9d6cd77Sjhaslam 2044c9d6cd77Sjhaslam return (0); 2045c9d6cd77Sjhaslam } 2046c9d6cd77Sjhaslam 2047c9d6cd77Sjhaslam static void 2048c9d6cd77Sjhaslam dt_lib_depend_free(dtrace_hdl_t *dtp) 2049c9d6cd77Sjhaslam { 2050c9d6cd77Sjhaslam dt_lib_depend_t *dld, *dlda; 2051c9d6cd77Sjhaslam 2052c9d6cd77Sjhaslam while ((dld = dt_list_next(&dtp->dt_lib_dep)) != NULL) { 2053c9d6cd77Sjhaslam while ((dlda = dt_list_next(&dld->dtld_dependencies)) != NULL) { 2054c9d6cd77Sjhaslam dt_list_delete(&dld->dtld_dependencies, dlda); 2055c9d6cd77Sjhaslam dt_free(dtp, dlda->dtld_library); 2056c9d6cd77Sjhaslam dt_free(dtp, dlda->dtld_libpath); 2057c9d6cd77Sjhaslam dt_free(dtp, dlda); 2058c9d6cd77Sjhaslam } 2059c9d6cd77Sjhaslam while ((dlda = dt_list_next(&dld->dtld_dependents)) != NULL) { 2060c9d6cd77Sjhaslam dt_list_delete(&dld->dtld_dependents, dlda); 2061c9d6cd77Sjhaslam dt_free(dtp, dlda->dtld_library); 2062c9d6cd77Sjhaslam dt_free(dtp, dlda->dtld_libpath); 2063c9d6cd77Sjhaslam dt_free(dtp, dlda); 2064c9d6cd77Sjhaslam } 2065c9d6cd77Sjhaslam dt_list_delete(&dtp->dt_lib_dep, dld); 2066c9d6cd77Sjhaslam dt_free(dtp, dld->dtld_library); 2067c9d6cd77Sjhaslam dt_free(dtp, dld->dtld_libpath); 2068c9d6cd77Sjhaslam dt_free(dtp, dld); 2069c9d6cd77Sjhaslam } 2070c9d6cd77Sjhaslam 2071c9d6cd77Sjhaslam while ((dld = dt_list_next(&dtp->dt_lib_dep_sorted)) != NULL) { 2072c9d6cd77Sjhaslam dt_list_delete(&dtp->dt_lib_dep_sorted, dld); 2073c9d6cd77Sjhaslam dt_free(dtp, dld->dtld_library); 2074c9d6cd77Sjhaslam dt_free(dtp, dld); 2075c9d6cd77Sjhaslam } 2076c9d6cd77Sjhaslam } 2077c9d6cd77Sjhaslam 20787c478bd9Sstevel@tonic-gate /* 20795eb667acSRobert Mustacchi * Open all the .d library files found in the specified directory and 20805eb667acSRobert Mustacchi * compile each one of them. We silently ignore any missing directories and 20815eb667acSRobert Mustacchi * other files found therein. We only fail (and thereby fail dt_load_libs()) if 20825eb667acSRobert Mustacchi * we fail to compile a library and the error is something other than #pragma D 20835eb667acSRobert Mustacchi * depends_on. Dependency errors are silently ignored to permit a library 20845eb667acSRobert Mustacchi * directory to contain libraries which may not be accessible depending on our 20855eb667acSRobert Mustacchi * privileges. 20867c478bd9Sstevel@tonic-gate */ 20877c478bd9Sstevel@tonic-gate static int 20887c478bd9Sstevel@tonic-gate dt_load_libs_dir(dtrace_hdl_t *dtp, const char *path) 20897c478bd9Sstevel@tonic-gate { 20904bc0a2efScasper struct dirent *dp; 2091afab0816SRobert Mustacchi const char *p, *end; 20927c478bd9Sstevel@tonic-gate DIR *dirp; 20937c478bd9Sstevel@tonic-gate 20947c478bd9Sstevel@tonic-gate char fname[PATH_MAX]; 20957c478bd9Sstevel@tonic-gate FILE *fp; 2096c9d6cd77Sjhaslam void *rv; 2097afab0816SRobert Mustacchi dt_lib_depend_t *dld; 20987c478bd9Sstevel@tonic-gate 20997c478bd9Sstevel@tonic-gate if ((dirp = opendir(path)) == NULL) { 21007c478bd9Sstevel@tonic-gate dt_dprintf("skipping lib dir %s: %s\n", path, strerror(errno)); 21017c478bd9Sstevel@tonic-gate return (0); 21027c478bd9Sstevel@tonic-gate } 21037c478bd9Sstevel@tonic-gate 2104c9d6cd77Sjhaslam /* First, parse each file for library dependencies. */ 21054bc0a2efScasper while ((dp = readdir(dirp)) != NULL) { 21067c478bd9Sstevel@tonic-gate if ((p = strrchr(dp->d_name, '.')) == NULL || strcmp(p, ".d")) 21077c478bd9Sstevel@tonic-gate continue; /* skip any filename not ending in .d */ 21087c478bd9Sstevel@tonic-gate 21097c478bd9Sstevel@tonic-gate (void) snprintf(fname, sizeof (fname), 21107c478bd9Sstevel@tonic-gate "%s/%s", path, dp->d_name); 21117c478bd9Sstevel@tonic-gate 21127c478bd9Sstevel@tonic-gate if ((fp = fopen(fname, "r")) == NULL) { 21137c478bd9Sstevel@tonic-gate dt_dprintf("skipping library %s: %s\n", 21147c478bd9Sstevel@tonic-gate fname, strerror(errno)); 21157c478bd9Sstevel@tonic-gate continue; 21167c478bd9Sstevel@tonic-gate } 21177c478bd9Sstevel@tonic-gate 2118afab0816SRobert Mustacchi /* 2119afab0816SRobert Mustacchi * Skip files whose name match an already processed library 2120afab0816SRobert Mustacchi */ 2121afab0816SRobert Mustacchi for (dld = dt_list_next(&dtp->dt_lib_dep); dld != NULL; 2122afab0816SRobert Mustacchi dld = dt_list_next(dld)) { 2123afab0816SRobert Mustacchi end = strrchr(dld->dtld_library, '/'); 2124afab0816SRobert Mustacchi /* dt_lib_depend_add ensures this */ 2125afab0816SRobert Mustacchi assert(end != NULL); 2126afab0816SRobert Mustacchi if (strcmp(end + 1, dp->d_name) == 0) 2127afab0816SRobert Mustacchi break; 2128afab0816SRobert Mustacchi } 2129afab0816SRobert Mustacchi 2130afab0816SRobert Mustacchi if (dld != NULL) { 2131afab0816SRobert Mustacchi dt_dprintf("skipping library %s, already processed " 2132afab0816SRobert Mustacchi "library with the same name: %s", dp->d_name, 2133afab0816SRobert Mustacchi dld->dtld_library); 2134afab0816SRobert Mustacchi continue; 2135afab0816SRobert Mustacchi } 2136afab0816SRobert Mustacchi 21377c478bd9Sstevel@tonic-gate dtp->dt_filetag = fname; 2138c9d6cd77Sjhaslam if (dt_lib_depend_add(dtp, &dtp->dt_lib_dep, fname) != 0) 21395eb667acSRobert Mustacchi return (-1); /* preserve dt_errno */ 2140c9d6cd77Sjhaslam 2141c9d6cd77Sjhaslam rv = dt_compile(dtp, DT_CTX_DPROG, 2142c9d6cd77Sjhaslam DTRACE_PROBESPEC_NAME, NULL, 2143c9d6cd77Sjhaslam DTRACE_C_EMPTY | DTRACE_C_CTL, 0, NULL, fp, NULL); 2144c9d6cd77Sjhaslam 2145c9d6cd77Sjhaslam if (rv != NULL && dtp->dt_errno && 2146c9d6cd77Sjhaslam (dtp->dt_errno != EDT_COMPILER || 2147c9d6cd77Sjhaslam dtp->dt_errtag != dt_errtag(D_PRAGMA_DEPEND))) 21485eb667acSRobert Mustacchi return (-1); /* preserve dt_errno */ 2149c9d6cd77Sjhaslam 2150c9d6cd77Sjhaslam if (dtp->dt_errno) 2151c9d6cd77Sjhaslam dt_dprintf("error parsing library %s: %s\n", 2152c9d6cd77Sjhaslam fname, dtrace_errmsg(dtp, dtrace_errno(dtp))); 2153c9d6cd77Sjhaslam 2154c9d6cd77Sjhaslam (void) fclose(fp); 2155c9d6cd77Sjhaslam dtp->dt_filetag = NULL; 2156c9d6cd77Sjhaslam } 2157c9d6cd77Sjhaslam 2158c9d6cd77Sjhaslam (void) closedir(dirp); 21595eb667acSRobert Mustacchi 21605eb667acSRobert Mustacchi return (0); 21615eb667acSRobert Mustacchi } 21625eb667acSRobert Mustacchi 21635eb667acSRobert Mustacchi /* 21645eb667acSRobert Mustacchi * Perform a topological sorting of all the libraries found across the entire 21655eb667acSRobert Mustacchi * dt_lib_path. Once sorted, compile each one in topological order to cache its 21665eb667acSRobert Mustacchi * inlines and translators, etc. We silently ignore any missing directories and 21675eb667acSRobert Mustacchi * other files found therein. We only fail (and thereby fail dt_load_libs()) if 21685eb667acSRobert Mustacchi * we fail to compile a library and the error is something other than #pragma D 21695eb667acSRobert Mustacchi * depends_on. Dependency errors are silently ignored to permit a library 21705eb667acSRobert Mustacchi * directory to contain libraries which may not be accessible depending on our 21715eb667acSRobert Mustacchi * privileges. 21725eb667acSRobert Mustacchi */ 21735eb667acSRobert Mustacchi static int 21745eb667acSRobert Mustacchi dt_load_libs_sort(dtrace_hdl_t *dtp) 21755eb667acSRobert Mustacchi { 21765eb667acSRobert Mustacchi dtrace_prog_t *pgp; 21775eb667acSRobert Mustacchi FILE *fp; 21785eb667acSRobert Mustacchi dt_lib_depend_t *dld; 21795eb667acSRobert Mustacchi 2180c9d6cd77Sjhaslam /* 2181c9d6cd77Sjhaslam * Finish building the graph containing the library dependencies 2182c9d6cd77Sjhaslam * and perform a topological sort to generate an ordered list 2183c9d6cd77Sjhaslam * for compilation. 2184c9d6cd77Sjhaslam */ 2185c9d6cd77Sjhaslam if (dt_lib_depend_sort(dtp) == -1) 2186c9d6cd77Sjhaslam goto err; 2187c9d6cd77Sjhaslam 2188c9d6cd77Sjhaslam for (dld = dt_list_next(&dtp->dt_lib_dep_sorted); dld != NULL; 2189c9d6cd77Sjhaslam dld = dt_list_next(dld)) { 2190c9d6cd77Sjhaslam 2191c9d6cd77Sjhaslam if ((fp = fopen(dld->dtld_library, "r")) == NULL) { 2192c9d6cd77Sjhaslam dt_dprintf("skipping library %s: %s\n", 2193c9d6cd77Sjhaslam dld->dtld_library, strerror(errno)); 2194c9d6cd77Sjhaslam continue; 2195c9d6cd77Sjhaslam } 2196c9d6cd77Sjhaslam 2197c9d6cd77Sjhaslam dtp->dt_filetag = dld->dtld_library; 21987c478bd9Sstevel@tonic-gate pgp = dtrace_program_fcompile(dtp, fp, DTRACE_C_EMPTY, 0, NULL); 21997c478bd9Sstevel@tonic-gate (void) fclose(fp); 22007c478bd9Sstevel@tonic-gate dtp->dt_filetag = NULL; 22017c478bd9Sstevel@tonic-gate 22027c478bd9Sstevel@tonic-gate if (pgp == NULL && (dtp->dt_errno != EDT_COMPILER || 2203c9d6cd77Sjhaslam dtp->dt_errtag != dt_errtag(D_PRAGMA_DEPEND))) 2204c9d6cd77Sjhaslam goto err; 22057c478bd9Sstevel@tonic-gate 22067c478bd9Sstevel@tonic-gate if (pgp == NULL) { 2207c9d6cd77Sjhaslam dt_dprintf("skipping library %s: %s\n", 2208c9d6cd77Sjhaslam dld->dtld_library, 22097c478bd9Sstevel@tonic-gate dtrace_errmsg(dtp, dtrace_errno(dtp))); 22106009dbc6Sahl } else { 22116009dbc6Sahl dld->dtld_loaded = B_TRUE; 22121a7c1b72Smws dt_program_destroy(dtp, pgp); 22136009dbc6Sahl } 22147c478bd9Sstevel@tonic-gate } 22157c478bd9Sstevel@tonic-gate 2216c9d6cd77Sjhaslam dt_lib_depend_free(dtp); 22177c478bd9Sstevel@tonic-gate return (0); 2218c9d6cd77Sjhaslam 2219c9d6cd77Sjhaslam err: 2220c9d6cd77Sjhaslam dt_lib_depend_free(dtp); 2221c9d6cd77Sjhaslam return (-1); /* preserve dt_errno */ 22227c478bd9Sstevel@tonic-gate } 22237c478bd9Sstevel@tonic-gate 22247c478bd9Sstevel@tonic-gate /* 22257c478bd9Sstevel@tonic-gate * Load the contents of any appropriate DTrace .d library files. These files 22267c478bd9Sstevel@tonic-gate * contain inlines and translators that will be cached by the compiler. We 22277c478bd9Sstevel@tonic-gate * defer this activity until the first compile to permit libdtrace clients to 22287c478bd9Sstevel@tonic-gate * add their own library directories and so that we can properly report errors. 22297c478bd9Sstevel@tonic-gate */ 22307c478bd9Sstevel@tonic-gate static int 22317c478bd9Sstevel@tonic-gate dt_load_libs(dtrace_hdl_t *dtp) 22327c478bd9Sstevel@tonic-gate { 22337c478bd9Sstevel@tonic-gate dt_dirpath_t *dirp; 22347c478bd9Sstevel@tonic-gate 22357c478bd9Sstevel@tonic-gate if (dtp->dt_cflags & DTRACE_C_NOLIBS) 22367c478bd9Sstevel@tonic-gate return (0); /* libraries already processed */ 22377c478bd9Sstevel@tonic-gate 22387c478bd9Sstevel@tonic-gate dtp->dt_cflags |= DTRACE_C_NOLIBS; 22397c478bd9Sstevel@tonic-gate 2240afab0816SRobert Mustacchi /* 2241afab0816SRobert Mustacchi * /usr/lib/dtrace is always at the head of the list. The rest of the 2242afab0816SRobert Mustacchi * list is specified in the precedence order the user requested. Process 2243afab0816SRobert Mustacchi * everything other than the head first. DTRACE_C_NOLIBS has already 2244afab0816SRobert Mustacchi * been spcified so dt_vopen will ensure that there is always one entry 2245afab0816SRobert Mustacchi * in dt_lib_path. 2246afab0816SRobert Mustacchi */ 2247afab0816SRobert Mustacchi for (dirp = dt_list_next(dt_list_next(&dtp->dt_lib_path)); 22487c478bd9Sstevel@tonic-gate dirp != NULL; dirp = dt_list_next(dirp)) { 22497c478bd9Sstevel@tonic-gate if (dt_load_libs_dir(dtp, dirp->dir_path) != 0) { 22507c478bd9Sstevel@tonic-gate dtp->dt_cflags &= ~DTRACE_C_NOLIBS; 22517c478bd9Sstevel@tonic-gate return (-1); /* errno is set for us */ 22527c478bd9Sstevel@tonic-gate } 22537c478bd9Sstevel@tonic-gate } 22547c478bd9Sstevel@tonic-gate 2255afab0816SRobert Mustacchi /* Handle /usr/lib/dtrace */ 2256afab0816SRobert Mustacchi dirp = dt_list_next(&dtp->dt_lib_path); 2257afab0816SRobert Mustacchi if (dt_load_libs_dir(dtp, dirp->dir_path) != 0) { 2258afab0816SRobert Mustacchi dtp->dt_cflags &= ~DTRACE_C_NOLIBS; 2259afab0816SRobert Mustacchi return (-1); /* errno is set for us */ 2260afab0816SRobert Mustacchi } 2261afab0816SRobert Mustacchi 22625eb667acSRobert Mustacchi if (dt_load_libs_sort(dtp) < 0) 22635eb667acSRobert Mustacchi return (-1); /* errno is set for us */ 22645eb667acSRobert Mustacchi 22657c478bd9Sstevel@tonic-gate return (0); 22667c478bd9Sstevel@tonic-gate } 22677c478bd9Sstevel@tonic-gate 22687c478bd9Sstevel@tonic-gate static void * 22697c478bd9Sstevel@tonic-gate dt_compile(dtrace_hdl_t *dtp, int context, dtrace_probespec_t pspec, void *arg, 22707c478bd9Sstevel@tonic-gate uint_t cflags, int argc, char *const argv[], FILE *fp, const char *s) 22717c478bd9Sstevel@tonic-gate { 22727c478bd9Sstevel@tonic-gate dt_node_t *dnp; 22737c478bd9Sstevel@tonic-gate dt_decl_t *ddp; 22747c478bd9Sstevel@tonic-gate dt_pcb_t pcb; 22757c478bd9Sstevel@tonic-gate void *rv; 22767c478bd9Sstevel@tonic-gate int err; 22777c478bd9Sstevel@tonic-gate 22787c478bd9Sstevel@tonic-gate if ((fp == NULL && s == NULL) || (cflags & ~DTRACE_C_MASK) != 0) { 22797c478bd9Sstevel@tonic-gate (void) dt_set_errno(dtp, EINVAL); 22807c478bd9Sstevel@tonic-gate return (NULL); 22817c478bd9Sstevel@tonic-gate } 22827c478bd9Sstevel@tonic-gate 22837c478bd9Sstevel@tonic-gate if (dt_list_next(&dtp->dt_lib_path) != NULL && dt_load_libs(dtp) != 0) 22847c478bd9Sstevel@tonic-gate return (NULL); /* errno is set for us */ 22857c478bd9Sstevel@tonic-gate 2286c9a6ea2eSBryan Cantrill if (dtp->dt_globals->dh_nelems != 0) 2287c9a6ea2eSBryan Cantrill (void) dt_idhash_iter(dtp->dt_globals, dt_idreset, NULL); 22887c478bd9Sstevel@tonic-gate 2289c9a6ea2eSBryan Cantrill if (dtp->dt_tls->dh_nelems != 0) 2290c9a6ea2eSBryan Cantrill (void) dt_idhash_iter(dtp->dt_tls, dt_idreset, NULL); 22917c478bd9Sstevel@tonic-gate 22927c478bd9Sstevel@tonic-gate if (fp && (cflags & DTRACE_C_CPP) && (fp = dt_preproc(dtp, fp)) == NULL) 22937c478bd9Sstevel@tonic-gate return (NULL); /* errno is set for us */ 22947c478bd9Sstevel@tonic-gate 22957c478bd9Sstevel@tonic-gate dt_pcb_push(dtp, &pcb); 22967c478bd9Sstevel@tonic-gate 22977c478bd9Sstevel@tonic-gate pcb.pcb_fileptr = fp; 22987c478bd9Sstevel@tonic-gate pcb.pcb_string = s; 22997c478bd9Sstevel@tonic-gate pcb.pcb_strptr = s; 23007c478bd9Sstevel@tonic-gate pcb.pcb_strlen = s ? strlen(s) : 0; 23017c478bd9Sstevel@tonic-gate pcb.pcb_sargc = argc; 23027c478bd9Sstevel@tonic-gate pcb.pcb_sargv = argv; 23037c478bd9Sstevel@tonic-gate pcb.pcb_sflagv = argc ? calloc(argc, sizeof (ushort_t)) : NULL; 23047c478bd9Sstevel@tonic-gate pcb.pcb_pspec = pspec; 23057c478bd9Sstevel@tonic-gate pcb.pcb_cflags = dtp->dt_cflags | cflags; 23067c478bd9Sstevel@tonic-gate pcb.pcb_amin = dtp->dt_amin; 23077c478bd9Sstevel@tonic-gate pcb.pcb_yystate = -1; 23087c478bd9Sstevel@tonic-gate pcb.pcb_context = context; 23097c478bd9Sstevel@tonic-gate pcb.pcb_token = context; 23107c478bd9Sstevel@tonic-gate 2311c9d6cd77Sjhaslam if (context != DT_CTX_DPROG) 23127c478bd9Sstevel@tonic-gate yybegin(YYS_EXPR); 2313c9d6cd77Sjhaslam else if (cflags & DTRACE_C_CTL) 2314c9d6cd77Sjhaslam yybegin(YYS_CONTROL); 2315c9d6cd77Sjhaslam else 2316c9d6cd77Sjhaslam yybegin(YYS_CLAUSE); 23177c478bd9Sstevel@tonic-gate 23187c478bd9Sstevel@tonic-gate if ((err = setjmp(yypcb->pcb_jmpbuf)) != 0) 23197c478bd9Sstevel@tonic-gate goto out; 23207c478bd9Sstevel@tonic-gate 23217c478bd9Sstevel@tonic-gate if (yypcb->pcb_sargc != 0 && yypcb->pcb_sflagv == NULL) 23227c478bd9Sstevel@tonic-gate longjmp(yypcb->pcb_jmpbuf, EDT_NOMEM); 23237c478bd9Sstevel@tonic-gate 23247c478bd9Sstevel@tonic-gate yypcb->pcb_idents = dt_idhash_create("ambiguous", NULL, 0, 0); 23257c478bd9Sstevel@tonic-gate yypcb->pcb_locals = dt_idhash_create("clause local", NULL, 23267c478bd9Sstevel@tonic-gate DIF_VAR_OTHER_UBASE, DIF_VAR_OTHER_MAX); 23277c478bd9Sstevel@tonic-gate 23287c478bd9Sstevel@tonic-gate if (yypcb->pcb_idents == NULL || yypcb->pcb_locals == NULL) 23297c478bd9Sstevel@tonic-gate longjmp(yypcb->pcb_jmpbuf, EDT_NOMEM); 23307c478bd9Sstevel@tonic-gate 23317c478bd9Sstevel@tonic-gate /* 23327c478bd9Sstevel@tonic-gate * Invoke the parser to evaluate the D source code. If any errors 23337c478bd9Sstevel@tonic-gate * occur during parsing, an error function will be called and we 23347c478bd9Sstevel@tonic-gate * will longjmp back to pcb_jmpbuf to abort. If parsing succeeds, 23357c478bd9Sstevel@tonic-gate * we optionally display the parse tree if debugging is enabled. 23367c478bd9Sstevel@tonic-gate */ 23377c478bd9Sstevel@tonic-gate if (yyparse() != 0 || yypcb->pcb_root == NULL) 23387c478bd9Sstevel@tonic-gate xyerror(D_EMPTY, "empty D program translation unit\n"); 23397c478bd9Sstevel@tonic-gate 23407c478bd9Sstevel@tonic-gate yybegin(YYS_DONE); 23417c478bd9Sstevel@tonic-gate 2342c9d6cd77Sjhaslam if (cflags & DTRACE_C_CTL) 2343c9d6cd77Sjhaslam goto out; 2344c9d6cd77Sjhaslam 23457c478bd9Sstevel@tonic-gate if (context != DT_CTX_DTYPE && DT_TREEDUMP_PASS(dtp, 1)) 23467c478bd9Sstevel@tonic-gate dt_node_printr(yypcb->pcb_root, stderr, 0); 23477c478bd9Sstevel@tonic-gate 23487c478bd9Sstevel@tonic-gate if (yypcb->pcb_pragmas != NULL) 23497c478bd9Sstevel@tonic-gate (void) dt_idhash_iter(yypcb->pcb_pragmas, dt_idpragma, NULL); 23507c478bd9Sstevel@tonic-gate 23517c478bd9Sstevel@tonic-gate if (argc > 1 && !(yypcb->pcb_cflags & DTRACE_C_ARGREF) && 23527c478bd9Sstevel@tonic-gate !(yypcb->pcb_sflagv[argc - 1] & DT_IDFLG_REF)) { 23537c478bd9Sstevel@tonic-gate xyerror(D_MACRO_UNUSED, "extraneous argument '%s' ($%d is " 23547c478bd9Sstevel@tonic-gate "not referenced)\n", yypcb->pcb_sargv[argc - 1], argc - 1); 23557c478bd9Sstevel@tonic-gate } 23567c478bd9Sstevel@tonic-gate 23577c478bd9Sstevel@tonic-gate /* 23587c478bd9Sstevel@tonic-gate * If we have successfully created a parse tree for a D program, loop 23597c478bd9Sstevel@tonic-gate * over the clauses and actions and instantiate the corresponding 23607c478bd9Sstevel@tonic-gate * libdtrace program. If we are parsing a D expression, then we 23617c478bd9Sstevel@tonic-gate * simply run the code generator and assembler on the resulting tree. 23627c478bd9Sstevel@tonic-gate */ 23637c478bd9Sstevel@tonic-gate switch (context) { 23647c478bd9Sstevel@tonic-gate case DT_CTX_DPROG: 23657c478bd9Sstevel@tonic-gate assert(yypcb->pcb_root->dn_kind == DT_NODE_PROG); 23667c478bd9Sstevel@tonic-gate 23677c478bd9Sstevel@tonic-gate if ((dnp = yypcb->pcb_root->dn_list) == NULL && 23687c478bd9Sstevel@tonic-gate !(yypcb->pcb_cflags & DTRACE_C_EMPTY)) 23697c478bd9Sstevel@tonic-gate xyerror(D_EMPTY, "empty D program translation unit\n"); 23707c478bd9Sstevel@tonic-gate 23711a7c1b72Smws if ((yypcb->pcb_prog = dt_program_create(dtp)) == NULL) 23727c478bd9Sstevel@tonic-gate longjmp(yypcb->pcb_jmpbuf, dtrace_errno(dtp)); 23737c478bd9Sstevel@tonic-gate 23747c478bd9Sstevel@tonic-gate for (; dnp != NULL; dnp = dnp->dn_list) { 23757c478bd9Sstevel@tonic-gate switch (dnp->dn_kind) { 23767c478bd9Sstevel@tonic-gate case DT_NODE_CLAUSE: 23777c478bd9Sstevel@tonic-gate dt_compile_clause(dtp, dnp); 23787c478bd9Sstevel@tonic-gate break; 23791a7c1b72Smws case DT_NODE_XLATOR: 23801a7c1b72Smws if (dtp->dt_xlatemode == DT_XL_DYNAMIC) 23811a7c1b72Smws dt_compile_xlator(dnp); 23821a7c1b72Smws break; 23837c478bd9Sstevel@tonic-gate case DT_NODE_PROVIDER: 23847c478bd9Sstevel@tonic-gate (void) dt_node_cook(dnp, DT_IDFLG_REF); 23857c478bd9Sstevel@tonic-gate break; 23867c478bd9Sstevel@tonic-gate } 23877c478bd9Sstevel@tonic-gate } 23887c478bd9Sstevel@tonic-gate 23891a7c1b72Smws yypcb->pcb_prog->dp_xrefs = yypcb->pcb_asxrefs; 23901a7c1b72Smws yypcb->pcb_prog->dp_xrefslen = yypcb->pcb_asxreflen; 23911a7c1b72Smws yypcb->pcb_asxrefs = NULL; 23921a7c1b72Smws yypcb->pcb_asxreflen = 0; 23931a7c1b72Smws 23941a7c1b72Smws rv = yypcb->pcb_prog; 23957c478bd9Sstevel@tonic-gate break; 23967c478bd9Sstevel@tonic-gate 23977c478bd9Sstevel@tonic-gate case DT_CTX_DEXPR: 23987c478bd9Sstevel@tonic-gate (void) dt_node_cook(yypcb->pcb_root, DT_IDFLG_REF); 23997c478bd9Sstevel@tonic-gate dt_cg(yypcb, yypcb->pcb_root); 24007c478bd9Sstevel@tonic-gate rv = dt_as(yypcb); 24017c478bd9Sstevel@tonic-gate break; 24027c478bd9Sstevel@tonic-gate 24037c478bd9Sstevel@tonic-gate case DT_CTX_DTYPE: 24047c478bd9Sstevel@tonic-gate ddp = (dt_decl_t *)yypcb->pcb_root; /* root is really a decl */ 24057c478bd9Sstevel@tonic-gate err = dt_decl_type(ddp, arg); 24067c478bd9Sstevel@tonic-gate dt_decl_free(ddp); 24077c478bd9Sstevel@tonic-gate 24087c478bd9Sstevel@tonic-gate if (err != 0) 24097c478bd9Sstevel@tonic-gate longjmp(yypcb->pcb_jmpbuf, EDT_COMPILER); 24107c478bd9Sstevel@tonic-gate 24117c478bd9Sstevel@tonic-gate rv = NULL; 24127c478bd9Sstevel@tonic-gate break; 24137c478bd9Sstevel@tonic-gate } 24147c478bd9Sstevel@tonic-gate 24157c478bd9Sstevel@tonic-gate out: 24167c478bd9Sstevel@tonic-gate if (context != DT_CTX_DTYPE && DT_TREEDUMP_PASS(dtp, 3)) 24177c478bd9Sstevel@tonic-gate dt_node_printr(yypcb->pcb_root, stderr, 0); 24187c478bd9Sstevel@tonic-gate 24197c478bd9Sstevel@tonic-gate if (dtp->dt_cdefs_fd != -1 && (ftruncate64(dtp->dt_cdefs_fd, 0) == -1 || 24207c478bd9Sstevel@tonic-gate lseek64(dtp->dt_cdefs_fd, 0, SEEK_SET) == -1 || 24217c478bd9Sstevel@tonic-gate ctf_write(dtp->dt_cdefs->dm_ctfp, dtp->dt_cdefs_fd) == CTF_ERR)) 24227c478bd9Sstevel@tonic-gate dt_dprintf("failed to update CTF cache: %s\n", strerror(errno)); 24237c478bd9Sstevel@tonic-gate 24247c478bd9Sstevel@tonic-gate if (dtp->dt_ddefs_fd != -1 && (ftruncate64(dtp->dt_ddefs_fd, 0) == -1 || 24257c478bd9Sstevel@tonic-gate lseek64(dtp->dt_ddefs_fd, 0, SEEK_SET) == -1 || 24267c478bd9Sstevel@tonic-gate ctf_write(dtp->dt_ddefs->dm_ctfp, dtp->dt_ddefs_fd) == CTF_ERR)) 24277c478bd9Sstevel@tonic-gate dt_dprintf("failed to update CTF cache: %s\n", strerror(errno)); 24287c478bd9Sstevel@tonic-gate 24297c478bd9Sstevel@tonic-gate if (yypcb->pcb_fileptr && (cflags & DTRACE_C_CPP)) 24307c478bd9Sstevel@tonic-gate (void) fclose(yypcb->pcb_fileptr); /* close dt_preproc() file */ 24317c478bd9Sstevel@tonic-gate 24327c478bd9Sstevel@tonic-gate dt_pcb_pop(dtp, err); 24337c478bd9Sstevel@tonic-gate (void) dt_set_errno(dtp, err); 24347c478bd9Sstevel@tonic-gate return (err ? NULL : rv); 24357c478bd9Sstevel@tonic-gate } 24367c478bd9Sstevel@tonic-gate 24377c478bd9Sstevel@tonic-gate dtrace_prog_t * 24387c478bd9Sstevel@tonic-gate dtrace_program_strcompile(dtrace_hdl_t *dtp, const char *s, 24397c478bd9Sstevel@tonic-gate dtrace_probespec_t spec, uint_t cflags, int argc, char *const argv[]) 24407c478bd9Sstevel@tonic-gate { 24417c478bd9Sstevel@tonic-gate return (dt_compile(dtp, DT_CTX_DPROG, 24427c478bd9Sstevel@tonic-gate spec, NULL, cflags, argc, argv, NULL, s)); 24437c478bd9Sstevel@tonic-gate } 24447c478bd9Sstevel@tonic-gate 24457c478bd9Sstevel@tonic-gate dtrace_prog_t * 24467c478bd9Sstevel@tonic-gate dtrace_program_fcompile(dtrace_hdl_t *dtp, FILE *fp, 24477c478bd9Sstevel@tonic-gate uint_t cflags, int argc, char *const argv[]) 24487c478bd9Sstevel@tonic-gate { 24497c478bd9Sstevel@tonic-gate return (dt_compile(dtp, DT_CTX_DPROG, 24507c478bd9Sstevel@tonic-gate DTRACE_PROBESPEC_NAME, NULL, cflags, argc, argv, fp, NULL)); 24517c478bd9Sstevel@tonic-gate } 24527c478bd9Sstevel@tonic-gate 24537c478bd9Sstevel@tonic-gate int 24547c478bd9Sstevel@tonic-gate dtrace_type_strcompile(dtrace_hdl_t *dtp, const char *s, dtrace_typeinfo_t *dtt) 24557c478bd9Sstevel@tonic-gate { 24567c478bd9Sstevel@tonic-gate (void) dt_compile(dtp, DT_CTX_DTYPE, 24577c478bd9Sstevel@tonic-gate DTRACE_PROBESPEC_NONE, dtt, 0, 0, NULL, NULL, s); 24587c478bd9Sstevel@tonic-gate return (dtp->dt_errno ? -1 : 0); 24597c478bd9Sstevel@tonic-gate } 24607c478bd9Sstevel@tonic-gate 24617c478bd9Sstevel@tonic-gate int 24627c478bd9Sstevel@tonic-gate dtrace_type_fcompile(dtrace_hdl_t *dtp, FILE *fp, dtrace_typeinfo_t *dtt) 24637c478bd9Sstevel@tonic-gate { 24647c478bd9Sstevel@tonic-gate (void) dt_compile(dtp, DT_CTX_DTYPE, 24657c478bd9Sstevel@tonic-gate DTRACE_PROBESPEC_NONE, dtt, 0, 0, NULL, fp, NULL); 24667c478bd9Sstevel@tonic-gate return (dtp->dt_errno ? -1 : 0); 24677c478bd9Sstevel@tonic-gate } 2468