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