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