1 /*
2 * CDDL HEADER START
3 *
4 * The contents of this file are subject to the terms of the
5 * Common Development and Distribution License (the "License").
6 * You may not use this file except in compliance with the License.
7 *
8 * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE
9 * or http://www.opensolaris.org/os/licensing.
10 * See the License for the specific language governing permissions
11 * and limitations under the License.
12 *
13 * When distributing Covered Code, include this CDDL HEADER in each
14 * file and include the License file at usr/src/OPENSOLARIS.LICENSE.
15 * If applicable, add the following below this CDDL HEADER, with the
16 * fields enclosed by brackets "[]" replaced with your own identifying
17 * information: Portions Copyright [yyyy] [name of copyright owner]
18 *
19 * CDDL HEADER END
20 */
21
22 /*
23 * Copyright (c) 2003, 2010, Oracle and/or its affiliates. All rights reserved.
24 * Copyright (c) 2012, 2014 by Delphix. All rights reserved.
25 * Copyright (c) 2013, Joyent Inc. All rights reserved.
26 */
27
28 /*
29 * DTrace D Language Parser
30 *
31 * The D Parser is a lex/yacc parser consisting of the lexer dt_lex.l, the
32 * parsing grammar dt_grammar.y, and this file, dt_parser.c, which handles
33 * the construction of the parse tree nodes and their syntactic validation.
34 * The parse tree is constructed of dt_node_t structures (see <dt_parser.h>)
35 * that are built in two passes: (1) the "create" pass, where the parse tree
36 * nodes are allocated by calls from the grammar to dt_node_*() subroutines,
37 * and (2) the "cook" pass, where nodes are coalesced, assigned D types, and
38 * validated according to the syntactic rules of the language.
39 *
40 * All node allocations are performed using dt_node_alloc(). All node frees
41 * during the parsing phase are performed by dt_node_free(), which frees node-
42 * internal state but does not actually free the nodes. All final node frees
43 * are done as part of the end of dt_compile() or as part of destroying
44 * persistent identifiers or translators which have embedded nodes.
45 *
46 * The dt_node_* routines that implement pass (1) may allocate new nodes. The
47 * dt_cook_* routines that implement pass (2) may *not* allocate new nodes.
48 * They may free existing nodes using dt_node_free(), but they may not actually
49 * deallocate any dt_node_t's. Currently dt_cook_op2() is an exception to this
50 * rule: see the comments therein for how this issue is resolved.
51 *
52 * The dt_cook_* routines are responsible for (at minimum) setting the final
53 * node type (dn_ctfp/dn_type) and attributes (dn_attr). If dn_ctfp/dn_type
54 * are set manually (i.e. not by one of the type assignment functions), then
55 * the DT_NF_COOKED flag must be set manually on the node.
56 *
57 * The cooking pass can be applied to the same parse tree more than once (used
58 * in the case of a comma-separated list of probe descriptions). As such, the
59 * cook routines must not perform any parse tree transformations which would
60 * be invalid if the tree were subsequently cooked using a different context.
61 *
62 * The dn_ctfp and dn_type fields form the type of the node. This tuple can
63 * take on the following set of values, which form our type invariants:
64 *
65 * 1. dn_ctfp = NULL, dn_type = CTF_ERR
66 *
67 * In this state, the node has unknown type and is not yet cooked. The
68 * DT_NF_COOKED flag is not yet set on the node.
69 *
70 * 2. dn_ctfp = DT_DYN_CTFP(dtp), dn_type = DT_DYN_TYPE(dtp)
71 *
72 * In this state, the node is a dynamic D type. This means that generic
73 * operations are not valid on this node and only code that knows how to
74 * examine the inner details of the node can operate on it. A <DYN> node
75 * must have dn_ident set to point to an identifier describing the object
76 * and its type. The DT_NF_REF flag is set for all nodes of type <DYN>.
77 * At present, the D compiler uses the <DYN> type for:
78 *
79 * - associative arrays that do not yet have a value type defined
80 * - translated data (i.e. the result of the xlate operator)
81 * - aggregations
82 *
83 * 3. dn_ctfp = DT_STR_CTFP(dtp), dn_type = DT_STR_TYPE(dtp)
84 *
85 * In this state, the node is of type D string. The string type is really
86 * a char[0] typedef, but requires special handling throughout the compiler.
87 *
88 * 4. dn_ctfp != NULL, dn_type = any other type ID
89 *
90 * In this state, the node is of some known D/CTF type. The normal libctf
91 * APIs can be used to learn more about the type name or structure. When
92 * the type is assigned, the DT_NF_SIGNED, DT_NF_REF, and DT_NF_BITFIELD
93 * flags cache the corresponding attributes of the underlying CTF type.
94 */
95
96 #include <sys/param.h>
97 #include <sys/sysmacros.h>
98 #include <limits.h>
99 #include <setjmp.h>
100 #include <strings.h>
101 #include <assert.h>
102 #include <alloca.h>
103 #include <stdlib.h>
104 #include <stdarg.h>
105 #include <stdio.h>
106 #include <errno.h>
107 #include <ctype.h>
108
109 #include <dt_impl.h>
110 #include <dt_grammar.h>
111 #include <dt_module.h>
112 #include <dt_provider.h>
113 #include <dt_string.h>
114 #include <dt_as.h>
115
116 dt_pcb_t *yypcb; /* current control block for parser */
117 dt_node_t *yypragma; /* lex token list for control lines */
118 char yyintprefix; /* int token macro prefix (+/-) */
119 char yyintsuffix[4]; /* int token suffix string [uU][lL] */
120 int yyintdecimal; /* int token format flag (1=decimal, 0=octal/hex) */
121
122 static const char *
123 opstr(int op)
124 {
125 switch (op) {
126 case DT_TOK_COMMA: return (",");
127 case DT_TOK_ELLIPSIS: return ("...");
128 case DT_TOK_ASGN: return ("=");
129 case DT_TOK_ADD_EQ: return ("+=");
130 case DT_TOK_SUB_EQ: return ("-=");
131 case DT_TOK_MUL_EQ: return ("*=");
132 case DT_TOK_DIV_EQ: return ("/=");
133 case DT_TOK_MOD_EQ: return ("%=");
134 case DT_TOK_AND_EQ: return ("&=");
135 case DT_TOK_XOR_EQ: return ("^=");
136 case DT_TOK_OR_EQ: return ("|=");
137 case DT_TOK_LSH_EQ: return ("<<=");
138 case DT_TOK_RSH_EQ: return (">>=");
139 case DT_TOK_QUESTION: return ("?");
140 case DT_TOK_COLON: return (":");
141 case DT_TOK_LOR: return ("||");
142 case DT_TOK_LXOR: return ("^^");
143 case DT_TOK_LAND: return ("&&");
144 case DT_TOK_BOR: return ("|");
145 case DT_TOK_XOR: return ("^");
146 case DT_TOK_BAND: return ("&");
147 case DT_TOK_EQU: return ("==");
148 case DT_TOK_NEQ: return ("!=");
149 case DT_TOK_LT: return ("<");
150 case DT_TOK_LE: return ("<=");
151 case DT_TOK_GT: return (">");
152 case DT_TOK_GE: return (">=");
153 case DT_TOK_LSH: return ("<<");
154 case DT_TOK_RSH: return (">>");
155 case DT_TOK_ADD: return ("+");
156 case DT_TOK_SUB: return ("-");
157 case DT_TOK_MUL: return ("*");
158 case DT_TOK_DIV: return ("/");
159 case DT_TOK_MOD: return ("%");
160 case DT_TOK_LNEG: return ("!");
161 case DT_TOK_BNEG: return ("~");
162 case DT_TOK_ADDADD: return ("++");
163 case DT_TOK_PREINC: return ("++");
164 case DT_TOK_POSTINC: return ("++");
165 case DT_TOK_SUBSUB: return ("--");
166 case DT_TOK_PREDEC: return ("--");
167 case DT_TOK_POSTDEC: return ("--");
168 case DT_TOK_IPOS: return ("+");
169 case DT_TOK_INEG: return ("-");
170 case DT_TOK_DEREF: return ("*");
171 case DT_TOK_ADDROF: return ("&");
172 case DT_TOK_OFFSETOF: return ("offsetof");
173 case DT_TOK_SIZEOF: return ("sizeof");
174 case DT_TOK_STRINGOF: return ("stringof");
175 case DT_TOK_XLATE: return ("xlate");
176 case DT_TOK_LPAR: return ("(");
177 case DT_TOK_RPAR: return (")");
178 case DT_TOK_LBRAC: return ("[");
179 case DT_TOK_RBRAC: return ("]");
180 case DT_TOK_PTR: return ("->");
181 case DT_TOK_DOT: return (".");
182 case DT_TOK_STRING: return ("<string>");
183 case DT_TOK_IDENT: return ("<ident>");
184 case DT_TOK_TNAME: return ("<type>");
185 case DT_TOK_INT: return ("<int>");
186 default: return ("<?>");
187 }
188 }
189
190 int
191 dt_type_lookup(const char *s, dtrace_typeinfo_t *tip)
192 {
193 static const char delimiters[] = " \t\n\r\v\f*`";
194 dtrace_hdl_t *dtp = yypcb->pcb_hdl;
195 const char *p, *q, *r, *end, *obj;
196
197 for (p = s, end = s + strlen(s); *p != '\0'; p = q) {
198 while (isspace(*p))
199 p++; /* skip leading whitespace prior to token */
200
201 if (p == end || (q = strpbrk(p + 1, delimiters)) == NULL)
202 break; /* empty string or single token remaining */
203
204 if (*q == '`') {
205 char *object = alloca((size_t)(q - p) + 1);
206 char *type = alloca((size_t)(end - s) + 1);
207
208 /*
209 * Copy from the start of the token (p) to the location
210 * backquote (q) to extract the nul-terminated object.
211 */
212 bcopy(p, object, (size_t)(q - p));
213 object[(size_t)(q - p)] = '\0';
214
215 /*
216 * Copy the original string up to the start of this
217 * token (p) into type, and then concatenate everything
218 * after q. This is the type name without the object.
219 */
220 bcopy(s, type, (size_t)(p - s));
221 bcopy(q + 1, type + (size_t)(p - s), strlen(q + 1) + 1);
222
223 /*
224 * There may be at most three delimeters. The second
225 * delimeter is usually used to distinguish the type
226 * within a given module, however, there could be a link
227 * map id on the scene in which case that delimeter
228 * would be the third. We determine presence of the lmid
229 * if it rouglhly meets the from LM[0-9]
230 */
231 if ((r = strchr(q + 1, '`')) != NULL &&
232 ((r = strchr(r + 1, '`')) != NULL)) {
233 if (strchr(r + 1, '`') != NULL)
234 return (dt_set_errno(dtp,
235 EDT_BADSCOPE));
236 if (q[1] != 'L' || q[2] != 'M')
237 return (dt_set_errno(dtp,
238 EDT_BADSCOPE));
239 }
240
241 return (dtrace_lookup_by_type(dtp, object, type, tip));
242 }
243 }
244
245 if (yypcb->pcb_idepth != 0)
246 obj = DTRACE_OBJ_CDEFS;
247 else
248 obj = DTRACE_OBJ_EVERY;
249
250 return (dtrace_lookup_by_type(dtp, obj, s, tip));
251 }
252
253 /*
254 * When we parse type expressions or parse an expression with unary "&", we
255 * need to find a type that is a pointer to a previously known type.
256 * Unfortunately CTF is limited to a per-container view, so ctf_type_pointer()
257 * alone does not suffice for our needs. We provide a more intelligent wrapper
258 * for the compiler that attempts to compute a pointer to either the given type
259 * or its base (that is, we try both "foo_t *" and "struct foo *"), and also
260 * to potentially construct the required type on-the-fly.
261 */
262 int
263 dt_type_pointer(dtrace_typeinfo_t *tip)
264 {
265 dtrace_hdl_t *dtp = yypcb->pcb_hdl;
266 ctf_file_t *ctfp = tip->dtt_ctfp;
267 ctf_id_t type = tip->dtt_type;
268 ctf_id_t base = ctf_type_resolve(ctfp, type);
269 uint_t bflags = tip->dtt_flags;
270
271 dt_module_t *dmp;
272 ctf_id_t ptr;
273
274 if ((ptr = ctf_type_pointer(ctfp, type)) != CTF_ERR ||
275 (ptr = ctf_type_pointer(ctfp, base)) != CTF_ERR) {
276 tip->dtt_type = ptr;
277 return (0);
278 }
279
280 if (yypcb->pcb_idepth != 0)
281 dmp = dtp->dt_cdefs;
282 else
283 dmp = dtp->dt_ddefs;
284
285 if (ctfp != dmp->dm_ctfp && ctfp != ctf_parent_file(dmp->dm_ctfp) &&
286 (type = ctf_add_type(dmp->dm_ctfp, ctfp, type)) == CTF_ERR) {
287 dtp->dt_ctferr = ctf_errno(dmp->dm_ctfp);
288 return (dt_set_errno(dtp, EDT_CTF));
289 }
290
291 ptr = ctf_add_pointer(dmp->dm_ctfp, CTF_ADD_ROOT, type);
292
293 if (ptr == CTF_ERR || ctf_update(dmp->dm_ctfp) == CTF_ERR) {
294 dtp->dt_ctferr = ctf_errno(dmp->dm_ctfp);
295 return (dt_set_errno(dtp, EDT_CTF));
296 }
297
298 tip->dtt_object = dmp->dm_name;
299 tip->dtt_ctfp = dmp->dm_ctfp;
300 tip->dtt_type = ptr;
301 tip->dtt_flags = bflags;
302
303 return (0);
304 }
305
306 const char *
307 dt_type_name(ctf_file_t *ctfp, ctf_id_t type, char *buf, size_t len)
308 {
309 dtrace_hdl_t *dtp = yypcb->pcb_hdl;
310
311 if (ctfp == DT_FPTR_CTFP(dtp) && type == DT_FPTR_TYPE(dtp))
312 (void) snprintf(buf, len, "function pointer");
313 else if (ctfp == DT_FUNC_CTFP(dtp) && type == DT_FUNC_TYPE(dtp))
314 (void) snprintf(buf, len, "function");
315 else if (ctfp == DT_DYN_CTFP(dtp) && type == DT_DYN_TYPE(dtp))
316 (void) snprintf(buf, len, "dynamic variable");
317 else if (ctfp == NULL)
318 (void) snprintf(buf, len, "<none>");
319 else if (ctf_type_name(ctfp, type, buf, len) == NULL)
320 (void) snprintf(buf, len, "unknown");
321
322 return (buf);
323 }
324
325 /*
326 * Perform the "usual arithmetic conversions" to determine which of the two
327 * input operand types should be promoted and used as a result type. The
328 * rules for this are described in ISOC[6.3.1.8] and K&R[A6.5].
329 */
330 static void
331 dt_type_promote(dt_node_t *lp, dt_node_t *rp, ctf_file_t **ofp, ctf_id_t *otype)
332 {
333 ctf_file_t *lfp = lp->dn_ctfp;
334 ctf_id_t ltype = lp->dn_type;
335
336 ctf_file_t *rfp = rp->dn_ctfp;
337 ctf_id_t rtype = rp->dn_type;
338
339 ctf_id_t lbase = ctf_type_resolve(lfp, ltype);
340 uint_t lkind = ctf_type_kind(lfp, lbase);
341
342 ctf_id_t rbase = ctf_type_resolve(rfp, rtype);
343 uint_t rkind = ctf_type_kind(rfp, rbase);
344
345 dtrace_hdl_t *dtp = yypcb->pcb_hdl;
346 ctf_encoding_t le, re;
347 uint_t lrank, rrank;
348
349 assert(lkind == CTF_K_INTEGER || lkind == CTF_K_ENUM);
350 assert(rkind == CTF_K_INTEGER || rkind == CTF_K_ENUM);
351
352 if (lkind == CTF_K_ENUM) {
353 lfp = DT_INT_CTFP(dtp);
354 ltype = lbase = DT_INT_TYPE(dtp);
355 }
356
357 if (rkind == CTF_K_ENUM) {
358 rfp = DT_INT_CTFP(dtp);
359 rtype = rbase = DT_INT_TYPE(dtp);
360 }
361
362 if (ctf_type_encoding(lfp, lbase, &le) == CTF_ERR) {
363 yypcb->pcb_hdl->dt_ctferr = ctf_errno(lfp);
364 longjmp(yypcb->pcb_jmpbuf, EDT_CTF);
365 }
366
367 if (ctf_type_encoding(rfp, rbase, &re) == CTF_ERR) {
368 yypcb->pcb_hdl->dt_ctferr = ctf_errno(rfp);
369 longjmp(yypcb->pcb_jmpbuf, EDT_CTF);
370 }
371
372 /*
373 * Compute an integer rank based on the size and unsigned status.
374 * If rank is identical, pick the "larger" of the equivalent types
375 * which we define as having a larger base ctf_id_t. If rank is
376 * different, pick the type with the greater rank.
377 */
378 lrank = le.cte_bits + ((le.cte_format & CTF_INT_SIGNED) == 0);
379 rrank = re.cte_bits + ((re.cte_format & CTF_INT_SIGNED) == 0);
380
381 if (lrank == rrank) {
382 if (lbase - rbase < 0)
383 goto return_rtype;
384 else
385 goto return_ltype;
386 } else if (lrank > rrank) {
387 goto return_ltype;
388 } else
389 goto return_rtype;
390
391 return_ltype:
392 *ofp = lfp;
393 *otype = ltype;
394 return;
395
396 return_rtype:
397 *ofp = rfp;
398 *otype = rtype;
399 }
400
401 void
402 dt_node_promote(dt_node_t *lp, dt_node_t *rp, dt_node_t *dnp)
403 {
404 dt_type_promote(lp, rp, &dnp->dn_ctfp, &dnp->dn_type);
405 dt_node_type_assign(dnp, dnp->dn_ctfp, dnp->dn_type, B_FALSE);
406 dt_node_attr_assign(dnp, dt_attr_min(lp->dn_attr, rp->dn_attr));
407 }
408
409 const char *
410 dt_node_name(const dt_node_t *dnp, char *buf, size_t len)
411 {
412 char n1[DT_TYPE_NAMELEN];
413 char n2[DT_TYPE_NAMELEN];
414
415 const char *prefix = "", *suffix = "";
416 const dtrace_syminfo_t *dts;
417 char *s;
418
419 switch (dnp->dn_kind) {
420 case DT_NODE_INT:
421 (void) snprintf(buf, len, "integer constant 0x%llx",
422 (u_longlong_t)dnp->dn_value);
423 break;
424 case DT_NODE_STRING:
425 s = strchr2esc(dnp->dn_string, strlen(dnp->dn_string));
426 (void) snprintf(buf, len, "string constant \"%s\"",
427 s != NULL ? s : dnp->dn_string);
428 free(s);
429 break;
430 case DT_NODE_IDENT:
431 (void) snprintf(buf, len, "identifier %s", dnp->dn_string);
432 break;
433 case DT_NODE_VAR:
434 case DT_NODE_FUNC:
435 case DT_NODE_AGG:
436 case DT_NODE_INLINE:
437 switch (dnp->dn_ident->di_kind) {
438 case DT_IDENT_FUNC:
439 case DT_IDENT_AGGFUNC:
440 case DT_IDENT_ACTFUNC:
441 suffix = "( )";
442 break;
443 case DT_IDENT_AGG:
444 prefix = "@";
445 break;
446 }
447 (void) snprintf(buf, len, "%s %s%s%s",
448 dt_idkind_name(dnp->dn_ident->di_kind),
449 prefix, dnp->dn_ident->di_name, suffix);
450 break;
451 case DT_NODE_SYM:
452 dts = dnp->dn_ident->di_data;
453 (void) snprintf(buf, len, "symbol %s`%s",
454 dts->dts_object, dts->dts_name);
455 break;
456 case DT_NODE_TYPE:
457 (void) snprintf(buf, len, "type %s",
458 dt_node_type_name(dnp, n1, sizeof (n1)));
459 break;
460 case DT_NODE_OP1:
461 case DT_NODE_OP2:
462 case DT_NODE_OP3:
463 (void) snprintf(buf, len, "operator %s", opstr(dnp->dn_op));
464 break;
465 case DT_NODE_DEXPR:
466 case DT_NODE_DFUNC:
467 if (dnp->dn_expr)
468 return (dt_node_name(dnp->dn_expr, buf, len));
469 (void) snprintf(buf, len, "%s", "statement");
470 break;
471 case DT_NODE_PDESC:
472 if (dnp->dn_desc->dtpd_id == 0) {
473 (void) snprintf(buf, len,
474 "probe description %s:%s:%s:%s",
475 dnp->dn_desc->dtpd_provider, dnp->dn_desc->dtpd_mod,
476 dnp->dn_desc->dtpd_func, dnp->dn_desc->dtpd_name);
477 } else {
478 (void) snprintf(buf, len, "probe description %u",
479 dnp->dn_desc->dtpd_id);
480 }
481 break;
482 case DT_NODE_CLAUSE:
483 (void) snprintf(buf, len, "%s", "clause");
484 break;
485 case DT_NODE_MEMBER:
486 (void) snprintf(buf, len, "member %s", dnp->dn_membname);
487 break;
488 case DT_NODE_XLATOR:
489 (void) snprintf(buf, len, "translator <%s> (%s)",
490 dt_type_name(dnp->dn_xlator->dx_dst_ctfp,
491 dnp->dn_xlator->dx_dst_type, n1, sizeof (n1)),
492 dt_type_name(dnp->dn_xlator->dx_src_ctfp,
493 dnp->dn_xlator->dx_src_type, n2, sizeof (n2)));
494 break;
495 case DT_NODE_PROG:
496 (void) snprintf(buf, len, "%s", "program");
497 break;
498 default:
499 (void) snprintf(buf, len, "node <%u>", dnp->dn_kind);
500 break;
501 }
502
503 return (buf);
504 }
505
506 /*
507 * dt_node_xalloc() can be used to create new parse nodes from any libdtrace
508 * caller. The caller is responsible for assigning dn_link appropriately.
509 */
510 dt_node_t *
511 dt_node_xalloc(dtrace_hdl_t *dtp, int kind)
512 {
513 dt_node_t *dnp = dt_alloc(dtp, sizeof (dt_node_t));
514
515 if (dnp == NULL)
516 return (NULL);
517
518 dnp->dn_ctfp = NULL;
519 dnp->dn_type = CTF_ERR;
520 dnp->dn_kind = (uchar_t)kind;
521 dnp->dn_flags = 0;
522 dnp->dn_op = 0;
523 dnp->dn_line = -1;
524 dnp->dn_reg = -1;
525 dnp->dn_attr = _dtrace_defattr;
526 dnp->dn_list = NULL;
527 dnp->dn_link = NULL;
528 bzero(&dnp->dn_u, sizeof (dnp->dn_u));
529
530 return (dnp);
531 }
532
533 /*
534 * dt_node_alloc() is used to create new parse nodes from the parser. It
535 * assigns the node location based on the current lexer line number and places
536 * the new node on the default allocation list. If allocation fails, we
537 * automatically longjmp the caller back to the enclosing compilation call.
538 */
539 static dt_node_t *
540 dt_node_alloc(int kind)
541 {
542 dt_node_t *dnp = dt_node_xalloc(yypcb->pcb_hdl, kind);
543
544 if (dnp == NULL)
545 longjmp(yypcb->pcb_jmpbuf, EDT_NOMEM);
546
547 dnp->dn_line = yylineno;
548 dnp->dn_link = yypcb->pcb_list;
549 yypcb->pcb_list = dnp;
550
551 return (dnp);
552 }
553
554 void
555 dt_node_free(dt_node_t *dnp)
556 {
557 uchar_t kind = dnp->dn_kind;
558
559 dnp->dn_kind = DT_NODE_FREE;
560
561 switch (kind) {
562 case DT_NODE_STRING:
563 case DT_NODE_IDENT:
564 case DT_NODE_TYPE:
565 free(dnp->dn_string);
566 dnp->dn_string = NULL;
567 break;
568
569 case DT_NODE_VAR:
570 case DT_NODE_FUNC:
571 case DT_NODE_PROBE:
572 if (dnp->dn_ident != NULL) {
573 if (dnp->dn_ident->di_flags & DT_IDFLG_ORPHAN)
574 dt_ident_destroy(dnp->dn_ident);
575 dnp->dn_ident = NULL;
576 }
577 dt_node_list_free(&dnp->dn_args);
578 break;
579
580 case DT_NODE_OP1:
581 if (dnp->dn_child != NULL) {
582 dt_node_free(dnp->dn_child);
583 dnp->dn_child = NULL;
584 }
585 break;
586
587 case DT_NODE_OP3:
588 if (dnp->dn_expr != NULL) {
589 dt_node_free(dnp->dn_expr);
590 dnp->dn_expr = NULL;
591 }
592 /*FALLTHRU*/
593 case DT_NODE_OP2:
594 if (dnp->dn_left != NULL) {
595 dt_node_free(dnp->dn_left);
596 dnp->dn_left = NULL;
597 }
598 if (dnp->dn_right != NULL) {
599 dt_node_free(dnp->dn_right);
600 dnp->dn_right = NULL;
601 }
602 break;
603
604 case DT_NODE_DEXPR:
605 case DT_NODE_DFUNC:
606 if (dnp->dn_expr != NULL) {
607 dt_node_free(dnp->dn_expr);
608 dnp->dn_expr = NULL;
609 }
610 break;
611
612 case DT_NODE_AGG:
613 if (dnp->dn_aggfun != NULL) {
614 dt_node_free(dnp->dn_aggfun);
615 dnp->dn_aggfun = NULL;
616 }
617 dt_node_list_free(&dnp->dn_aggtup);
618 break;
619
620 case DT_NODE_PDESC:
621 free(dnp->dn_spec);
622 dnp->dn_spec = NULL;
623 free(dnp->dn_desc);
624 dnp->dn_desc = NULL;
625 break;
626
627 case DT_NODE_CLAUSE:
628 if (dnp->dn_pred != NULL)
629 dt_node_free(dnp->dn_pred);
630 if (dnp->dn_locals != NULL)
631 dt_idhash_destroy(dnp->dn_locals);
632 dt_node_list_free(&dnp->dn_pdescs);
633 dt_node_list_free(&dnp->dn_acts);
634 break;
635
636 case DT_NODE_MEMBER:
637 free(dnp->dn_membname);
638 dnp->dn_membname = NULL;
639 if (dnp->dn_membexpr != NULL) {
640 dt_node_free(dnp->dn_membexpr);
641 dnp->dn_membexpr = NULL;
642 }
643 break;
644
645 case DT_NODE_PROVIDER:
646 dt_node_list_free(&dnp->dn_probes);
647 free(dnp->dn_provname);
648 dnp->dn_provname = NULL;
649 break;
650
651 case DT_NODE_PROG:
652 dt_node_list_free(&dnp->dn_list);
653 break;
654 }
655 }
656
657 void
658 dt_node_attr_assign(dt_node_t *dnp, dtrace_attribute_t attr)
659 {
660 if ((yypcb->pcb_cflags & DTRACE_C_EATTR) &&
661 (dt_attr_cmp(attr, yypcb->pcb_amin) < 0)) {
662 char a[DTRACE_ATTR2STR_MAX];
663 char s[BUFSIZ];
664
665 dnerror(dnp, D_ATTR_MIN, "attributes for %s (%s) are less than "
666 "predefined minimum\n", dt_node_name(dnp, s, sizeof (s)),
667 dtrace_attr2str(attr, a, sizeof (a)));
668 }
669
670 dnp->dn_attr = attr;
671 }
672
673 void
674 dt_node_type_assign(dt_node_t *dnp, ctf_file_t *fp, ctf_id_t type,
675 boolean_t user)
676 {
677 ctf_id_t base = ctf_type_resolve(fp, type);
678 uint_t kind = ctf_type_kind(fp, base);
679 ctf_encoding_t e;
680
681 dnp->dn_flags &=
682 ~(DT_NF_SIGNED | DT_NF_REF | DT_NF_BITFIELD | DT_NF_USERLAND);
683
684 if (kind == CTF_K_INTEGER && ctf_type_encoding(fp, base, &e) == 0) {
685 size_t size = e.cte_bits / NBBY;
686
687 if (size > 8 || (e.cte_bits % NBBY) != 0 || (size & (size - 1)))
688 dnp->dn_flags |= DT_NF_BITFIELD;
689
690 if (e.cte_format & CTF_INT_SIGNED)
691 dnp->dn_flags |= DT_NF_SIGNED;
692 }
693
694 if (kind == CTF_K_FLOAT && ctf_type_encoding(fp, base, &e) == 0) {
695 if (e.cte_bits / NBBY > sizeof (uint64_t))
696 dnp->dn_flags |= DT_NF_REF;
697 }
698
699 if (kind == CTF_K_STRUCT || kind == CTF_K_UNION ||
700 kind == CTF_K_FORWARD ||
701 kind == CTF_K_ARRAY || kind == CTF_K_FUNCTION)
702 dnp->dn_flags |= DT_NF_REF;
703 else if (yypcb != NULL && fp == DT_DYN_CTFP(yypcb->pcb_hdl) &&
704 type == DT_DYN_TYPE(yypcb->pcb_hdl))
705 dnp->dn_flags |= DT_NF_REF;
706
707 if (user)
708 dnp->dn_flags |= DT_NF_USERLAND;
709
710 dnp->dn_flags |= DT_NF_COOKED;
711 dnp->dn_ctfp = fp;
712 dnp->dn_type = type;
713 }
714
715 void
716 dt_node_type_propagate(const dt_node_t *src, dt_node_t *dst)
717 {
718 assert(src->dn_flags & DT_NF_COOKED);
719 dst->dn_flags = src->dn_flags & ~DT_NF_LVALUE;
720 dst->dn_ctfp = src->dn_ctfp;
721 dst->dn_type = src->dn_type;
722 }
723
724 const char *
725 dt_node_type_name(const dt_node_t *dnp, char *buf, size_t len)
726 {
727 if (dt_node_is_dynamic(dnp) && dnp->dn_ident != NULL) {
728 (void) snprintf(buf, len, "%s",
729 dt_idkind_name(dt_ident_resolve(dnp->dn_ident)->di_kind));
730 return (buf);
731 }
732
733 if (dnp->dn_flags & DT_NF_USERLAND) {
734 size_t n = snprintf(buf, len, "userland ");
735 len = len > n ? len - n : 0;
736 (void) dt_type_name(dnp->dn_ctfp, dnp->dn_type, buf + n, len);
737 return (buf);
738 }
739
740 return (dt_type_name(dnp->dn_ctfp, dnp->dn_type, buf, len));
741 }
742
743 size_t
744 dt_node_type_size(const dt_node_t *dnp)
745 {
746 ctf_id_t base;
747 dtrace_hdl_t *dtp = yypcb->pcb_hdl;
748
749 if (dnp->dn_kind == DT_NODE_STRING)
750 return (strlen(dnp->dn_string) + 1);
751
752 if (dt_node_is_dynamic(dnp) && dnp->dn_ident != NULL)
753 return (dt_ident_size(dnp->dn_ident));
754
755 base = ctf_type_resolve(dnp->dn_ctfp, dnp->dn_type);
756
757 if (ctf_type_kind(dnp->dn_ctfp, base) == CTF_K_FORWARD)
758 return (0);
759
760 /*
761 * Here we have a 32-bit user pointer that is being used with a 64-bit
762 * kernel. When we're using it and its tagged as a userland reference --
763 * then we need to keep it as a 32-bit pointer. However, if we are
764 * referring to it as a kernel address, eg. being used after a copyin()
765 * then we need to make sure that we actually return the kernel's size
766 * of a pointer, 8 bytes.
767 */
768 if (ctf_type_kind(dnp->dn_ctfp, base) == CTF_K_POINTER &&
769 ctf_getmodel(dnp->dn_ctfp) == CTF_MODEL_ILP32 &&
770 !(dnp->dn_flags & DT_NF_USERLAND) &&
771 dtp->dt_conf.dtc_ctfmodel == CTF_MODEL_LP64)
772 return (8);
773
774 return (ctf_type_size(dnp->dn_ctfp, dnp->dn_type));
775 }
776
777 /*
778 * Determine if the specified parse tree node references an identifier of the
779 * specified kind, and if so return a pointer to it; otherwise return NULL.
780 * This function resolves the identifier itself, following through any inlines.
781 */
782 dt_ident_t *
783 dt_node_resolve(const dt_node_t *dnp, uint_t idkind)
784 {
785 dt_ident_t *idp;
786
787 switch (dnp->dn_kind) {
788 case DT_NODE_VAR:
789 case DT_NODE_SYM:
790 case DT_NODE_FUNC:
791 case DT_NODE_AGG:
792 case DT_NODE_INLINE:
793 case DT_NODE_PROBE:
794 idp = dt_ident_resolve(dnp->dn_ident);
795 return (idp->di_kind == idkind ? idp : NULL);
796 }
797
798 if (dt_node_is_dynamic(dnp)) {
799 idp = dt_ident_resolve(dnp->dn_ident);
800 return (idp->di_kind == idkind ? idp : NULL);
801 }
802
803 return (NULL);
804 }
805
806 size_t
807 dt_node_sizeof(const dt_node_t *dnp)
808 {
809 dtrace_syminfo_t *sip;
810 GElf_Sym sym;
811 dtrace_hdl_t *dtp = yypcb->pcb_hdl;
812
813 /*
814 * The size of the node as used for the sizeof() operator depends on
815 * the kind of the node. If the node is a SYM, the size is obtained
816 * from the symbol table; if it is not a SYM, the size is determined
817 * from the node's type. This is slightly different from C's sizeof()
818 * operator in that (for example) when applied to a function, sizeof()
819 * will evaluate to the length of the function rather than the size of
820 * the function type.
821 */
822 if (dnp->dn_kind != DT_NODE_SYM)
823 return (dt_node_type_size(dnp));
824
825 sip = dnp->dn_ident->di_data;
826
827 if (dtrace_lookup_by_name(dtp, sip->dts_object,
828 sip->dts_name, &sym, NULL) == -1)
829 return (0);
830
831 return (sym.st_size);
832 }
833
834 int
835 dt_node_is_integer(const dt_node_t *dnp)
836 {
837 ctf_file_t *fp = dnp->dn_ctfp;
838 ctf_encoding_t e;
839 ctf_id_t type;
840 uint_t kind;
841
842 assert(dnp->dn_flags & DT_NF_COOKED);
843
844 type = ctf_type_resolve(fp, dnp->dn_type);
845 kind = ctf_type_kind(fp, type);
846
847 if (kind == CTF_K_INTEGER &&
848 ctf_type_encoding(fp, type, &e) == 0 && IS_VOID(e))
849 return (0); /* void integer */
850
851 return (kind == CTF_K_INTEGER || kind == CTF_K_ENUM);
852 }
853
854 int
855 dt_node_is_float(const dt_node_t *dnp)
856 {
857 ctf_file_t *fp = dnp->dn_ctfp;
858 ctf_encoding_t e;
859 ctf_id_t type;
860 uint_t kind;
861
862 assert(dnp->dn_flags & DT_NF_COOKED);
863
864 type = ctf_type_resolve(fp, dnp->dn_type);
865 kind = ctf_type_kind(fp, type);
866
867 return (kind == CTF_K_FLOAT &&
868 ctf_type_encoding(dnp->dn_ctfp, type, &e) == 0 && (
869 e.cte_format == CTF_FP_SINGLE || e.cte_format == CTF_FP_DOUBLE ||
870 e.cte_format == CTF_FP_LDOUBLE));
871 }
872
873 int
874 dt_node_is_scalar(const dt_node_t *dnp)
875 {
876 ctf_file_t *fp = dnp->dn_ctfp;
877 ctf_encoding_t e;
878 ctf_id_t type;
879 uint_t kind;
880
881 assert(dnp->dn_flags & DT_NF_COOKED);
882
883 type = ctf_type_resolve(fp, dnp->dn_type);
884 kind = ctf_type_kind(fp, type);
885
886 if (kind == CTF_K_INTEGER &&
887 ctf_type_encoding(fp, type, &e) == 0 && IS_VOID(e))
888 return (0); /* void cannot be used as a scalar */
889
890 return (kind == CTF_K_INTEGER || kind == CTF_K_ENUM ||
891 kind == CTF_K_POINTER);
892 }
893
894 int
895 dt_node_is_arith(const dt_node_t *dnp)
896 {
897 ctf_file_t *fp = dnp->dn_ctfp;
898 ctf_encoding_t e;
899 ctf_id_t type;
900 uint_t kind;
901
902 assert(dnp->dn_flags & DT_NF_COOKED);
903
904 type = ctf_type_resolve(fp, dnp->dn_type);
905 kind = ctf_type_kind(fp, type);
906
907 if (kind == CTF_K_INTEGER)
908 return (ctf_type_encoding(fp, type, &e) == 0 && !IS_VOID(e));
909 else
910 return (kind == CTF_K_ENUM);
911 }
912
913 int
914 dt_node_is_vfptr(const dt_node_t *dnp)
915 {
916 ctf_file_t *fp = dnp->dn_ctfp;
917 ctf_encoding_t e;
918 ctf_id_t type;
919 uint_t kind;
920
921 assert(dnp->dn_flags & DT_NF_COOKED);
922
923 type = ctf_type_resolve(fp, dnp->dn_type);
924 if (ctf_type_kind(fp, type) != CTF_K_POINTER)
925 return (0); /* type is not a pointer */
926
927 type = ctf_type_resolve(fp, ctf_type_reference(fp, type));
928 kind = ctf_type_kind(fp, type);
929
930 return (kind == CTF_K_FUNCTION || (kind == CTF_K_INTEGER &&
931 ctf_type_encoding(fp, type, &e) == 0 && IS_VOID(e)));
932 }
933
934 int
935 dt_node_is_dynamic(const dt_node_t *dnp)
936 {
937 if (dnp->dn_kind == DT_NODE_VAR &&
938 (dnp->dn_ident->di_flags & DT_IDFLG_INLINE)) {
939 const dt_idnode_t *inp = dnp->dn_ident->di_iarg;
940 return (inp->din_root ? dt_node_is_dynamic(inp->din_root) : 0);
941 }
942
943 return (dnp->dn_ctfp == DT_DYN_CTFP(yypcb->pcb_hdl) &&
944 dnp->dn_type == DT_DYN_TYPE(yypcb->pcb_hdl));
945 }
946
947 int
948 dt_node_is_string(const dt_node_t *dnp)
949 {
950 return (dnp->dn_ctfp == DT_STR_CTFP(yypcb->pcb_hdl) &&
951 dnp->dn_type == DT_STR_TYPE(yypcb->pcb_hdl));
952 }
953
954 int
955 dt_node_is_stack(const dt_node_t *dnp)
956 {
957 return (dnp->dn_ctfp == DT_STACK_CTFP(yypcb->pcb_hdl) &&
958 dnp->dn_type == DT_STACK_TYPE(yypcb->pcb_hdl));
959 }
960
961 int
962 dt_node_is_symaddr(const dt_node_t *dnp)
963 {
964 return (dnp->dn_ctfp == DT_SYMADDR_CTFP(yypcb->pcb_hdl) &&
965 dnp->dn_type == DT_SYMADDR_TYPE(yypcb->pcb_hdl));
966 }
967
968 int
969 dt_node_is_usymaddr(const dt_node_t *dnp)
970 {
971 return (dnp->dn_ctfp == DT_USYMADDR_CTFP(yypcb->pcb_hdl) &&
972 dnp->dn_type == DT_USYMADDR_TYPE(yypcb->pcb_hdl));
973 }
974
975 int
976 dt_node_is_strcompat(const dt_node_t *dnp)
977 {
978 ctf_file_t *fp = dnp->dn_ctfp;
979 ctf_encoding_t e;
980 ctf_arinfo_t r;
981 ctf_id_t base;
982 uint_t kind;
983
984 assert(dnp->dn_flags & DT_NF_COOKED);
985
986 base = ctf_type_resolve(fp, dnp->dn_type);
987 kind = ctf_type_kind(fp, base);
988
989 if (kind == CTF_K_POINTER &&
990 (base = ctf_type_reference(fp, base)) != CTF_ERR &&
991 (base = ctf_type_resolve(fp, base)) != CTF_ERR &&
992 ctf_type_encoding(fp, base, &e) == 0 && IS_CHAR(e))
993 return (1); /* promote char pointer to string */
994
995 if (kind == CTF_K_ARRAY && ctf_array_info(fp, base, &r) == 0 &&
996 (base = ctf_type_resolve(fp, r.ctr_contents)) != CTF_ERR &&
997 ctf_type_encoding(fp, base, &e) == 0 && IS_CHAR(e))
998 return (1); /* promote char array to string */
999
1000 return (0);
1001 }
1002
1003 int
1004 dt_node_is_pointer(const dt_node_t *dnp)
1005 {
1006 ctf_file_t *fp = dnp->dn_ctfp;
1007 uint_t kind;
1008
1009 assert(dnp->dn_flags & DT_NF_COOKED);
1010
1011 if (dt_node_is_string(dnp))
1012 return (0); /* string are pass-by-ref but act like structs */
1013
1014 kind = ctf_type_kind(fp, ctf_type_resolve(fp, dnp->dn_type));
1015 return (kind == CTF_K_POINTER || kind == CTF_K_ARRAY);
1016 }
1017
1018 int
1019 dt_node_is_void(const dt_node_t *dnp)
1020 {
1021 ctf_file_t *fp = dnp->dn_ctfp;
1022 ctf_encoding_t e;
1023 ctf_id_t type;
1024
1025 if (dt_node_is_dynamic(dnp))
1026 return (0); /* <DYN> is an alias for void but not the same */
1027
1028 if (dt_node_is_stack(dnp))
1029 return (0);
1030
1031 if (dt_node_is_symaddr(dnp) || dt_node_is_usymaddr(dnp))
1032 return (0);
1033
1034 type = ctf_type_resolve(fp, dnp->dn_type);
1035
1036 return (ctf_type_kind(fp, type) == CTF_K_INTEGER &&
1037 ctf_type_encoding(fp, type, &e) == 0 && IS_VOID(e));
1038 }
1039
1040 int
1041 dt_node_is_ptrcompat(const dt_node_t *lp, const dt_node_t *rp,
1042 ctf_file_t **fpp, ctf_id_t *tp)
1043 {
1044 ctf_file_t *lfp = lp->dn_ctfp;
1045 ctf_file_t *rfp = rp->dn_ctfp;
1046
1047 ctf_id_t lbase = CTF_ERR, rbase = CTF_ERR;
1048 ctf_id_t lref = CTF_ERR, rref = CTF_ERR;
1049
1050 int lp_is_void, rp_is_void, lp_is_int, rp_is_int, compat;
1051 uint_t lkind, rkind;
1052 ctf_encoding_t e;
1053 ctf_arinfo_t r;
1054
1055 assert(lp->dn_flags & DT_NF_COOKED);
1056 assert(rp->dn_flags & DT_NF_COOKED);
1057
1058 if (dt_node_is_dynamic(lp) || dt_node_is_dynamic(rp))
1059 return (0); /* fail if either node is a dynamic variable */
1060
1061 lp_is_int = dt_node_is_integer(lp);
1062 rp_is_int = dt_node_is_integer(rp);
1063
1064 if (lp_is_int && rp_is_int)
1065 return (0); /* fail if both nodes are integers */
1066
1067 if (lp_is_int && (lp->dn_kind != DT_NODE_INT || lp->dn_value != 0))
1068 return (0); /* fail if lp is an integer that isn't 0 constant */
1069
1070 if (rp_is_int && (rp->dn_kind != DT_NODE_INT || rp->dn_value != 0))
1071 return (0); /* fail if rp is an integer that isn't 0 constant */
1072
1073 if ((lp_is_int == 0 && rp_is_int == 0) && (
1074 (lp->dn_flags & DT_NF_USERLAND) ^ (rp->dn_flags & DT_NF_USERLAND)))
1075 return (0); /* fail if only one pointer is a userland address */
1076
1077 /*
1078 * Resolve the left-hand and right-hand types to their base type, and
1079 * then resolve the referenced type as well (assuming the base type
1080 * is CTF_K_POINTER or CTF_K_ARRAY). Otherwise [lr]ref = CTF_ERR.
1081 */
1082 if (!lp_is_int) {
1083 lbase = ctf_type_resolve(lfp, lp->dn_type);
1084 lkind = ctf_type_kind(lfp, lbase);
1085
1086 if (lkind == CTF_K_POINTER) {
1087 lref = ctf_type_resolve(lfp,
1088 ctf_type_reference(lfp, lbase));
1089 } else if (lkind == CTF_K_ARRAY &&
1090 ctf_array_info(lfp, lbase, &r) == 0) {
1091 lref = ctf_type_resolve(lfp, r.ctr_contents);
1092 }
1093 }
1094
1095 if (!rp_is_int) {
1096 rbase = ctf_type_resolve(rfp, rp->dn_type);
1097 rkind = ctf_type_kind(rfp, rbase);
1098
1099 if (rkind == CTF_K_POINTER) {
1100 rref = ctf_type_resolve(rfp,
1101 ctf_type_reference(rfp, rbase));
1102 } else if (rkind == CTF_K_ARRAY &&
1103 ctf_array_info(rfp, rbase, &r) == 0) {
1104 rref = ctf_type_resolve(rfp, r.ctr_contents);
1105 }
1106 }
1107
1108 /*
1109 * We know that one or the other type may still be a zero-valued
1110 * integer constant. To simplify the code below, set the integer
1111 * type variables equal to the non-integer types and proceed.
1112 */
1113 if (lp_is_int) {
1114 lbase = rbase;
1115 lkind = rkind;
1116 lref = rref;
1117 lfp = rfp;
1118 } else if (rp_is_int) {
1119 rbase = lbase;
1120 rkind = lkind;
1121 rref = lref;
1122 rfp = lfp;
1123 }
1124
1125 lp_is_void = ctf_type_encoding(lfp, lref, &e) == 0 && IS_VOID(e);
1126 rp_is_void = ctf_type_encoding(rfp, rref, &e) == 0 && IS_VOID(e);
1127
1128 /*
1129 * The types are compatible if both are pointers to the same type, or
1130 * if either pointer is a void pointer. If they are compatible, set
1131 * tp to point to the more specific pointer type and return it.
1132 */
1133 compat = (lkind == CTF_K_POINTER || lkind == CTF_K_ARRAY) &&
1134 (rkind == CTF_K_POINTER || rkind == CTF_K_ARRAY) &&
1135 (lp_is_void || rp_is_void || ctf_type_compat(lfp, lref, rfp, rref));
1136
1137 if (compat) {
1138 if (fpp != NULL)
1139 *fpp = rp_is_void ? lfp : rfp;
1140 if (tp != NULL)
1141 *tp = rp_is_void ? lbase : rbase;
1142 }
1143
1144 return (compat);
1145 }
1146
1147 /*
1148 * The rules for checking argument types against parameter types are described
1149 * in the ANSI-C spec (see K&R[A7.3.2] and K&R[A7.17]). We use the same rule
1150 * set to determine whether associative array arguments match the prototype.
1151 */
1152 int
1153 dt_node_is_argcompat(const dt_node_t *lp, const dt_node_t *rp)
1154 {
1155 ctf_file_t *lfp = lp->dn_ctfp;
1156 ctf_file_t *rfp = rp->dn_ctfp;
1157
1158 assert(lp->dn_flags & DT_NF_COOKED);
1159 assert(rp->dn_flags & DT_NF_COOKED);
1160
1161 if (dt_node_is_integer(lp) && dt_node_is_integer(rp))
1162 return (1); /* integer types are compatible */
1163
1164 if (dt_node_is_strcompat(lp) && dt_node_is_strcompat(rp))
1165 return (1); /* string types are compatible */
1166
1167 if (dt_node_is_stack(lp) && dt_node_is_stack(rp))
1168 return (1); /* stack types are compatible */
1169
1170 if (dt_node_is_symaddr(lp) && dt_node_is_symaddr(rp))
1171 return (1); /* symaddr types are compatible */
1172
1173 if (dt_node_is_usymaddr(lp) && dt_node_is_usymaddr(rp))
1174 return (1); /* usymaddr types are compatible */
1175
1176 switch (ctf_type_kind(lfp, ctf_type_resolve(lfp, lp->dn_type))) {
1177 case CTF_K_FUNCTION:
1178 case CTF_K_STRUCT:
1179 case CTF_K_UNION:
1180 return (ctf_type_compat(lfp, lp->dn_type, rfp, rp->dn_type));
1181 default:
1182 return (dt_node_is_ptrcompat(lp, rp, NULL, NULL));
1183 }
1184 }
1185
1186 /*
1187 * We provide dt_node_is_posconst() as a convenience routine for callers who
1188 * wish to verify that an argument is a positive non-zero integer constant.
1189 */
1190 int
1191 dt_node_is_posconst(const dt_node_t *dnp)
1192 {
1193 return (dnp->dn_kind == DT_NODE_INT && dnp->dn_value != 0 && (
1194 (dnp->dn_flags & DT_NF_SIGNED) == 0 || (int64_t)dnp->dn_value > 0));
1195 }
1196
1197 int
1198 dt_node_is_actfunc(const dt_node_t *dnp)
1199 {
1200 return (dnp->dn_kind == DT_NODE_FUNC &&
1201 dnp->dn_ident->di_kind == DT_IDENT_ACTFUNC);
1202 }
1203
1204 /*
1205 * The original rules for integer constant typing are described in K&R[A2.5.1].
1206 * However, since we support long long, we instead use the rules from ISO C99
1207 * clause 6.4.4.1 since that is where long longs are formally described. The
1208 * rules require us to know whether the constant was specified in decimal or
1209 * in octal or hex, which we do by looking at our lexer's 'yyintdecimal' flag.
1210 * The type of an integer constant is the first of the corresponding list in
1211 * which its value can be represented:
1212 *
1213 * unsuffixed decimal: int, long, long long
1214 * unsuffixed oct/hex: int, unsigned int, long, unsigned long,
1215 * long long, unsigned long long
1216 * suffix [uU]: unsigned int, unsigned long, unsigned long long
1217 * suffix [lL] decimal: long, long long
1218 * suffix [lL] oct/hex: long, unsigned long, long long, unsigned long long
1219 * suffix [uU][Ll]: unsigned long, unsigned long long
1220 * suffix ll/LL decimal: long long
1221 * suffix ll/LL oct/hex: long long, unsigned long long
1222 * suffix [uU][ll/LL]: unsigned long long
1223 *
1224 * Given that our lexer has already validated the suffixes by regexp matching,
1225 * there is an obvious way to concisely encode these rules: construct an array
1226 * of the types in the order int, unsigned int, long, unsigned long, long long,
1227 * unsigned long long. Compute an integer array starting index based on the
1228 * suffix (e.g. none = 0, u = 1, ull = 5), and compute an increment based on
1229 * the specifier (dec/oct/hex) and suffix (u). Then iterate from the starting
1230 * index to the end, advancing using the increment, and searching until we
1231 * find a limit that matches or we run out of choices (overflow). To make it
1232 * even faster, we precompute the table of type information in dtrace_open().
1233 */
1234 dt_node_t *
1235 dt_node_int(uintmax_t value)
1236 {
1237 dt_node_t *dnp = dt_node_alloc(DT_NODE_INT);
1238 dtrace_hdl_t *dtp = yypcb->pcb_hdl;
1239
1240 int n = (yyintdecimal | (yyintsuffix[0] == 'u')) + 1;
1241 int i = 0;
1242
1243 const char *p;
1244 char c;
1245
1246 dnp->dn_op = DT_TOK_INT;
1247 dnp->dn_value = value;
1248
1249 for (p = yyintsuffix; (c = *p) != '\0'; p++) {
1250 if (c == 'U' || c == 'u')
1251 i += 1;
1252 else if (c == 'L' || c == 'l')
1253 i += 2;
1254 }
1255
1256 for (; i < sizeof (dtp->dt_ints) / sizeof (dtp->dt_ints[0]); i += n) {
1257 if (value <= dtp->dt_ints[i].did_limit) {
1258 dt_node_type_assign(dnp,
1259 dtp->dt_ints[i].did_ctfp,
1260 dtp->dt_ints[i].did_type, B_FALSE);
1261
1262 /*
1263 * If a prefix character is present in macro text, add
1264 * in the corresponding operator node (see dt_lex.l).
1265 */
1266 switch (yyintprefix) {
1267 case '+':
1268 return (dt_node_op1(DT_TOK_IPOS, dnp));
1269 case '-':
1270 return (dt_node_op1(DT_TOK_INEG, dnp));
1271 default:
1272 return (dnp);
1273 }
1274 }
1275 }
1276
1277 xyerror(D_INT_OFLOW, "integer constant 0x%llx cannot be represented "
1278 "in any built-in integral type\n", (u_longlong_t)value);
1279 /*NOTREACHED*/
1280 return (NULL); /* keep gcc happy */
1281 }
1282
1283 dt_node_t *
1284 dt_node_string(char *string)
1285 {
1286 dtrace_hdl_t *dtp = yypcb->pcb_hdl;
1287 dt_node_t *dnp;
1288
1289 if (string == NULL)
1290 longjmp(yypcb->pcb_jmpbuf, EDT_NOMEM);
1291
1292 dnp = dt_node_alloc(DT_NODE_STRING);
1293 dnp->dn_op = DT_TOK_STRING;
1294 dnp->dn_string = string;
1295 dt_node_type_assign(dnp, DT_STR_CTFP(dtp), DT_STR_TYPE(dtp), B_FALSE);
1296
1297 return (dnp);
1298 }
1299
1300 dt_node_t *
1301 dt_node_ident(char *name)
1302 {
1303 dt_ident_t *idp;
1304 dt_node_t *dnp;
1305
1306 if (name == NULL)
1307 longjmp(yypcb->pcb_jmpbuf, EDT_NOMEM);
1308
1309 /*
1310 * If the identifier is an inlined integer constant, then create an INT
1311 * node that is a clone of the inline parse tree node and return that
1312 * immediately, allowing this inline to be used in parsing contexts
1313 * that require constant expressions (e.g. scalar array sizes).
1314 */
1315 if ((idp = dt_idstack_lookup(&yypcb->pcb_globals, name)) != NULL &&
1316 (idp->di_flags & DT_IDFLG_INLINE)) {
1317 dt_idnode_t *inp = idp->di_iarg;
1318
1319 if (inp->din_root != NULL &&
1320 inp->din_root->dn_kind == DT_NODE_INT) {
1321 free(name);
1322
1323 dnp = dt_node_alloc(DT_NODE_INT);
1324 dnp->dn_op = DT_TOK_INT;
1325 dnp->dn_value = inp->din_root->dn_value;
1326 dt_node_type_propagate(inp->din_root, dnp);
1327
1328 return (dnp);
1329 }
1330 }
1331
1332 dnp = dt_node_alloc(DT_NODE_IDENT);
1333 dnp->dn_op = name[0] == '@' ? DT_TOK_AGG : DT_TOK_IDENT;
1334 dnp->dn_string = name;
1335
1336 return (dnp);
1337 }
1338
1339 /*
1340 * Create an empty node of type corresponding to the given declaration.
1341 * Explicit references to user types (C or D) are assigned the default
1342 * stability; references to other types are _dtrace_typattr (Private).
1343 */
1344 dt_node_t *
1345 dt_node_type(dt_decl_t *ddp)
1346 {
1347 dtrace_hdl_t *dtp = yypcb->pcb_hdl;
1348 dtrace_typeinfo_t dtt;
1349 dt_node_t *dnp;
1350 char *name = NULL;
1351 int err;
1352
1353 /*
1354 * If 'ddp' is NULL, we get a decl by popping the decl stack. This
1355 * form of dt_node_type() is used by parameter rules in dt_grammar.y.
1356 */
1357 if (ddp == NULL)
1358 ddp = dt_decl_pop_param(&name);
1359
1360 err = dt_decl_type(ddp, &dtt);
1361 dt_decl_free(ddp);
1362
1363 if (err != 0) {
1364 free(name);
1365 longjmp(yypcb->pcb_jmpbuf, EDT_COMPILER);
1366 }
1367
1368 dnp = dt_node_alloc(DT_NODE_TYPE);
1369 dnp->dn_op = DT_TOK_IDENT;
1370 dnp->dn_string = name;
1371
1372 dt_node_type_assign(dnp, dtt.dtt_ctfp, dtt.dtt_type, dtt.dtt_flags);
1373
1374 if (dtt.dtt_ctfp == dtp->dt_cdefs->dm_ctfp ||
1375 dtt.dtt_ctfp == dtp->dt_ddefs->dm_ctfp)
1376 dt_node_attr_assign(dnp, _dtrace_defattr);
1377 else
1378 dt_node_attr_assign(dnp, _dtrace_typattr);
1379
1380 return (dnp);
1381 }
1382
1383 /*
1384 * Create a type node corresponding to a varargs (...) parameter by just
1385 * assigning it type CTF_ERR. The decl processing code will handle this.
1386 */
1387 dt_node_t *
1388 dt_node_vatype(void)
1389 {
1390 dt_node_t *dnp = dt_node_alloc(DT_NODE_TYPE);
1391
1392 dnp->dn_op = DT_TOK_IDENT;
1393 dnp->dn_ctfp = yypcb->pcb_hdl->dt_cdefs->dm_ctfp;
1394 dnp->dn_type = CTF_ERR;
1395 dnp->dn_attr = _dtrace_defattr;
1396
1397 return (dnp);
1398 }
1399
1400 /*
1401 * Instantiate a decl using the contents of the current declaration stack. As
1402 * we do not currently permit decls to be initialized, this function currently
1403 * returns NULL and no parse node is created. When this function is called,
1404 * the topmost scope's ds_ident pointer will be set to NULL (indicating no
1405 * init_declarator rule was matched) or will point to the identifier to use.
1406 */
1407 dt_node_t *
1408 dt_node_decl(void)
1409 {
1410 dtrace_hdl_t *dtp = yypcb->pcb_hdl;
1411 dt_scope_t *dsp = &yypcb->pcb_dstack;
1412 dt_dclass_t class = dsp->ds_class;
1413 dt_decl_t *ddp = dt_decl_top();
1414
1415 dt_module_t *dmp;
1416 dtrace_typeinfo_t dtt;
1417 ctf_id_t type;
1418
1419 char n1[DT_TYPE_NAMELEN];
1420 char n2[DT_TYPE_NAMELEN];
1421
1422 if (dt_decl_type(ddp, &dtt) != 0)
1423 longjmp(yypcb->pcb_jmpbuf, EDT_COMPILER);
1424
1425 /*
1426 * If we have no declaration identifier, then this is either a spurious
1427 * declaration of an intrinsic type (e.g. "extern int;") or declaration
1428 * or redeclaration of a struct, union, or enum type or tag.
1429 */
1430 if (dsp->ds_ident == NULL) {
1431 if (ddp->dd_kind != CTF_K_STRUCT &&
1432 ddp->dd_kind != CTF_K_UNION && ddp->dd_kind != CTF_K_ENUM)
1433 xyerror(D_DECL_USELESS, "useless declaration\n");
1434
1435 dt_dprintf("type %s added as id %ld\n", dt_type_name(
1436 ddp->dd_ctfp, ddp->dd_type, n1, sizeof (n1)), ddp->dd_type);
1437
1438 return (NULL);
1439 }
1440
1441 if (strchr(dsp->ds_ident, '`') != NULL) {
1442 xyerror(D_DECL_SCOPE, "D scoping operator may not be used in "
1443 "a declaration name (%s)\n", dsp->ds_ident);
1444 }
1445
1446 /*
1447 * If we are nested inside of a C include file, add the declaration to
1448 * the C definition module; otherwise use the D definition module.
1449 */
1450 if (yypcb->pcb_idepth != 0)
1451 dmp = dtp->dt_cdefs;
1452 else
1453 dmp = dtp->dt_ddefs;
1454
1455 /*
1456 * If we see a global or static declaration of a function prototype,
1457 * treat this as equivalent to a D extern declaration.
1458 */
1459 if (ctf_type_kind(dtt.dtt_ctfp, dtt.dtt_type) == CTF_K_FUNCTION &&
1460 (class == DT_DC_DEFAULT || class == DT_DC_STATIC))
1461 class = DT_DC_EXTERN;
1462
1463 switch (class) {
1464 case DT_DC_AUTO:
1465 case DT_DC_REGISTER:
1466 case DT_DC_STATIC:
1467 xyerror(D_DECL_BADCLASS, "specified storage class not "
1468 "appropriate in D\n");
1469 /*NOTREACHED*/
1470
1471 case DT_DC_EXTERN: {
1472 dtrace_typeinfo_t ott;
1473 dtrace_syminfo_t dts;
1474 GElf_Sym sym;
1475
1476 int exists = dtrace_lookup_by_name(dtp,
1477 dmp->dm_name, dsp->ds_ident, &sym, &dts) == 0;
1478
1479 if (exists && (dtrace_symbol_type(dtp, &sym, &dts, &ott) != 0 ||
1480 ctf_type_cmp(dtt.dtt_ctfp, dtt.dtt_type,
1481 ott.dtt_ctfp, ott.dtt_type) != 0)) {
1482 xyerror(D_DECL_IDRED, "identifier redeclared: %s`%s\n"
1483 "\t current: %s\n\tprevious: %s\n",
1484 dmp->dm_name, dsp->ds_ident,
1485 dt_type_name(dtt.dtt_ctfp, dtt.dtt_type,
1486 n1, sizeof (n1)),
1487 dt_type_name(ott.dtt_ctfp, ott.dtt_type,
1488 n2, sizeof (n2)));
1489 } else if (!exists && dt_module_extern(dtp, dmp,
1490 dsp->ds_ident, &dtt) == NULL) {
1491 xyerror(D_UNKNOWN,
1492 "failed to extern %s: %s\n", dsp->ds_ident,
1493 dtrace_errmsg(dtp, dtrace_errno(dtp)));
1494 } else {
1495 dt_dprintf("extern %s`%s type=<%s>\n",
1496 dmp->dm_name, dsp->ds_ident,
1497 dt_type_name(dtt.dtt_ctfp, dtt.dtt_type,
1498 n1, sizeof (n1)));
1499 }
1500 break;
1501 }
1502
1503 case DT_DC_TYPEDEF:
1504 if (dt_idstack_lookup(&yypcb->pcb_globals, dsp->ds_ident)) {
1505 xyerror(D_DECL_IDRED, "global variable identifier "
1506 "redeclared: %s\n", dsp->ds_ident);
1507 }
1508
1509 if (ctf_lookup_by_name(dmp->dm_ctfp,
1510 dsp->ds_ident) != CTF_ERR) {
1511 xyerror(D_DECL_IDRED,
1512 "typedef redeclared: %s\n", dsp->ds_ident);
1513 }
1514
1515 /*
1516 * If the source type for the typedef is not defined in the
1517 * target container or its parent, copy the type to the target
1518 * container and reset dtt_ctfp and dtt_type to the copy.
1519 */
1520 if (dtt.dtt_ctfp != dmp->dm_ctfp &&
1521 dtt.dtt_ctfp != ctf_parent_file(dmp->dm_ctfp)) {
1522
1523 dtt.dtt_type = ctf_add_type(dmp->dm_ctfp,
1524 dtt.dtt_ctfp, dtt.dtt_type);
1525 dtt.dtt_ctfp = dmp->dm_ctfp;
1526
1527 if (dtt.dtt_type == CTF_ERR ||
1528 ctf_update(dtt.dtt_ctfp) == CTF_ERR) {
1529 xyerror(D_UNKNOWN, "failed to copy typedef %s "
1530 "source type: %s\n", dsp->ds_ident,
1531 ctf_errmsg(ctf_errno(dtt.dtt_ctfp)));
1532 }
1533 }
1534
1535 type = ctf_add_typedef(dmp->dm_ctfp,
1536 CTF_ADD_ROOT, dsp->ds_ident, dtt.dtt_type);
1537
1538 if (type == CTF_ERR || ctf_update(dmp->dm_ctfp) == CTF_ERR) {
1539 xyerror(D_UNKNOWN, "failed to typedef %s: %s\n",
1540 dsp->ds_ident, ctf_errmsg(ctf_errno(dmp->dm_ctfp)));
1541 }
1542
1543 dt_dprintf("typedef %s added as id %ld\n", dsp->ds_ident, type);
1544 break;
1545
1546 default: {
1547 ctf_encoding_t cte;
1548 dt_idhash_t *dhp;
1549 dt_ident_t *idp;
1550 dt_node_t idn;
1551 int assc, idkind;
1552 uint_t id, kind;
1553 ushort_t idflags;
1554
1555 switch (class) {
1556 case DT_DC_THIS:
1557 dhp = yypcb->pcb_locals;
1558 idflags = DT_IDFLG_LOCAL;
1559 idp = dt_idhash_lookup(dhp, dsp->ds_ident);
1560 break;
1561 case DT_DC_SELF:
1562 dhp = dtp->dt_tls;
1563 idflags = DT_IDFLG_TLS;
1564 idp = dt_idhash_lookup(dhp, dsp->ds_ident);
1565 break;
1566 default:
1567 dhp = dtp->dt_globals;
1568 idflags = 0;
1569 idp = dt_idstack_lookup(
1570 &yypcb->pcb_globals, dsp->ds_ident);
1571 break;
1572 }
1573
1574 if (ddp->dd_kind == CTF_K_ARRAY && ddp->dd_node == NULL) {
1575 xyerror(D_DECL_ARRNULL,
1576 "array declaration requires array dimension or "
1577 "tuple signature: %s\n", dsp->ds_ident);
1578 }
1579
1580 if (idp != NULL && idp->di_gen == 0) {
1581 xyerror(D_DECL_IDRED, "built-in identifier "
1582 "redeclared: %s\n", idp->di_name);
1583 }
1584
1585 if (dtrace_lookup_by_type(dtp, DTRACE_OBJ_CDEFS,
1586 dsp->ds_ident, NULL) == 0 ||
1587 dtrace_lookup_by_type(dtp, DTRACE_OBJ_DDEFS,
1588 dsp->ds_ident, NULL) == 0) {
1589 xyerror(D_DECL_IDRED, "typedef identifier "
1590 "redeclared: %s\n", dsp->ds_ident);
1591 }
1592
1593 /*
1594 * Cache some attributes of the decl to make the rest of this
1595 * code simpler: if the decl is an array which is subscripted
1596 * by a type rather than an integer, then it's an associative
1597 * array (assc). We then expect to match either DT_IDENT_ARRAY
1598 * for associative arrays or DT_IDENT_SCALAR for anything else.
1599 */
1600 assc = ddp->dd_kind == CTF_K_ARRAY &&
1601 ddp->dd_node->dn_kind == DT_NODE_TYPE;
1602
1603 idkind = assc ? DT_IDENT_ARRAY : DT_IDENT_SCALAR;
1604
1605 /*
1606 * Create a fake dt_node_t on the stack so we can determine the
1607 * type of any matching identifier by assigning to this node.
1608 * If the pre-existing ident has its di_type set, propagate
1609 * the type by hand so as not to trigger a prototype check for
1610 * arrays (yet); otherwise we use dt_ident_cook() on the ident
1611 * to ensure it is fully initialized before looking at it.
1612 */
1613 bzero(&idn, sizeof (dt_node_t));
1614
1615 if (idp != NULL && idp->di_type != CTF_ERR)
1616 dt_node_type_assign(&idn, idp->di_ctfp, idp->di_type,
1617 B_FALSE);
1618 else if (idp != NULL)
1619 (void) dt_ident_cook(&idn, idp, NULL);
1620
1621 if (assc) {
1622 if (class == DT_DC_THIS) {
1623 xyerror(D_DECL_LOCASSC, "associative arrays "
1624 "may not be declared as local variables:"
1625 " %s\n", dsp->ds_ident);
1626 }
1627
1628 if (dt_decl_type(ddp->dd_next, &dtt) != 0)
1629 longjmp(yypcb->pcb_jmpbuf, EDT_COMPILER);
1630 }
1631
1632 if (idp != NULL && (idp->di_kind != idkind ||
1633 ctf_type_cmp(dtt.dtt_ctfp, dtt.dtt_type,
1634 idn.dn_ctfp, idn.dn_type) != 0)) {
1635 xyerror(D_DECL_IDRED, "identifier redeclared: %s\n"
1636 "\t current: %s %s\n\tprevious: %s %s\n",
1637 dsp->ds_ident, dt_idkind_name(idkind),
1638 dt_type_name(dtt.dtt_ctfp,
1639 dtt.dtt_type, n1, sizeof (n1)),
1640 dt_idkind_name(idp->di_kind),
1641 dt_node_type_name(&idn, n2, sizeof (n2)));
1642
1643 } else if (idp != NULL && assc) {
1644 const dt_idsig_t *isp = idp->di_data;
1645 dt_node_t *dnp = ddp->dd_node;
1646 int argc = 0;
1647
1648 for (; dnp != NULL; dnp = dnp->dn_list, argc++) {
1649 const dt_node_t *pnp = &isp->dis_args[argc];
1650
1651 if (argc >= isp->dis_argc)
1652 continue; /* tuple length mismatch */
1653
1654 if (ctf_type_cmp(dnp->dn_ctfp, dnp->dn_type,
1655 pnp->dn_ctfp, pnp->dn_type) == 0)
1656 continue;
1657
1658 xyerror(D_DECL_IDRED,
1659 "identifier redeclared: %s\n"
1660 "\t current: %s, key #%d of type %s\n"
1661 "\tprevious: %s, key #%d of type %s\n",
1662 dsp->ds_ident,
1663 dt_idkind_name(idkind), argc + 1,
1664 dt_node_type_name(dnp, n1, sizeof (n1)),
1665 dt_idkind_name(idp->di_kind), argc + 1,
1666 dt_node_type_name(pnp, n2, sizeof (n2)));
1667 }
1668
1669 if (isp->dis_argc != argc) {
1670 xyerror(D_DECL_IDRED,
1671 "identifier redeclared: %s\n"
1672 "\t current: %s of %s, tuple length %d\n"
1673 "\tprevious: %s of %s, tuple length %d\n",
1674 dsp->ds_ident, dt_idkind_name(idkind),
1675 dt_type_name(dtt.dtt_ctfp, dtt.dtt_type,
1676 n1, sizeof (n1)), argc,
1677 dt_idkind_name(idp->di_kind),
1678 dt_node_type_name(&idn, n2, sizeof (n2)),
1679 isp->dis_argc);
1680 }
1681
1682 } else if (idp == NULL) {
1683 type = ctf_type_resolve(dtt.dtt_ctfp, dtt.dtt_type);
1684 kind = ctf_type_kind(dtt.dtt_ctfp, type);
1685
1686 switch (kind) {
1687 case CTF_K_INTEGER:
1688 if (ctf_type_encoding(dtt.dtt_ctfp, type,
1689 &cte) == 0 && IS_VOID(cte)) {
1690 xyerror(D_DECL_VOIDOBJ, "cannot have "
1691 "void object: %s\n", dsp->ds_ident);
1692 }
1693 break;
1694 case CTF_K_STRUCT:
1695 case CTF_K_UNION:
1696 if (ctf_type_size(dtt.dtt_ctfp, type) != 0)
1697 break; /* proceed to declaring */
1698 /*FALLTHRU*/
1699 case CTF_K_FORWARD:
1700 xyerror(D_DECL_INCOMPLETE,
1701 "incomplete struct/union/enum %s: %s\n",
1702 dt_type_name(dtt.dtt_ctfp, dtt.dtt_type,
1703 n1, sizeof (n1)), dsp->ds_ident);
1704 /*NOTREACHED*/
1705 }
1706
1707 if (dt_idhash_nextid(dhp, &id) == -1) {
1708 xyerror(D_ID_OFLOW, "cannot create %s: limit "
1709 "on number of %s variables exceeded\n",
1710 dsp->ds_ident, dt_idhash_name(dhp));
1711 }
1712
1713 dt_dprintf("declare %s %s variable %s, id=%u\n",
1714 dt_idhash_name(dhp), dt_idkind_name(idkind),
1715 dsp->ds_ident, id);
1716
1717 idp = dt_idhash_insert(dhp, dsp->ds_ident, idkind,
1718 idflags | DT_IDFLG_WRITE | DT_IDFLG_DECL, id,
1719 _dtrace_defattr, 0, assc ? &dt_idops_assc :
1720 &dt_idops_thaw, NULL, dtp->dt_gen);
1721
1722 if (idp == NULL)
1723 longjmp(yypcb->pcb_jmpbuf, EDT_NOMEM);
1724
1725 dt_ident_type_assign(idp, dtt.dtt_ctfp, dtt.dtt_type);
1726
1727 /*
1728 * If we are declaring an associative array, use our
1729 * fake parse node to cook the new assoc identifier.
1730 * This will force the ident code to instantiate the
1731 * array type signature corresponding to the list of
1732 * types pointed to by ddp->dd_node. We also reset
1733 * the identifier's attributes based upon the result.
1734 */
1735 if (assc) {
1736 idp->di_attr =
1737 dt_ident_cook(&idn, idp, &ddp->dd_node);
1738 }
1739 }
1740 }
1741
1742 } /* end of switch */
1743
1744 free(dsp->ds_ident);
1745 dsp->ds_ident = NULL;
1746
1747 return (NULL);
1748 }
1749
1750 dt_node_t *
1751 dt_node_func(dt_node_t *dnp, dt_node_t *args)
1752 {
1753 dt_ident_t *idp;
1754
1755 if (dnp->dn_kind != DT_NODE_IDENT) {
1756 xyerror(D_FUNC_IDENT,
1757 "function designator is not of function type\n");
1758 }
1759
1760 idp = dt_idstack_lookup(&yypcb->pcb_globals, dnp->dn_string);
1761
1762 if (idp == NULL) {
1763 xyerror(D_FUNC_UNDEF,
1764 "undefined function name: %s\n", dnp->dn_string);
1765 }
1766
1767 if (idp->di_kind != DT_IDENT_FUNC &&
1768 idp->di_kind != DT_IDENT_AGGFUNC &&
1769 idp->di_kind != DT_IDENT_ACTFUNC) {
1770 xyerror(D_FUNC_IDKIND, "%s '%s' may not be referenced as a "
1771 "function\n", dt_idkind_name(idp->di_kind), idp->di_name);
1772 }
1773
1774 free(dnp->dn_string);
1775 dnp->dn_string = NULL;
1776
1777 dnp->dn_kind = DT_NODE_FUNC;
1778 dnp->dn_flags &= ~DT_NF_COOKED;
1779 dnp->dn_ident = idp;
1780 dnp->dn_args = args;
1781 dnp->dn_list = NULL;
1782
1783 return (dnp);
1784 }
1785
1786 /*
1787 * The offsetof() function is special because it takes a type name as an
1788 * argument. It does not actually construct its own node; after looking up the
1789 * structure or union offset, we just return an integer node with the offset.
1790 */
1791 dt_node_t *
1792 dt_node_offsetof(dt_decl_t *ddp, char *s)
1793 {
1794 dtrace_typeinfo_t dtt;
1795 dt_node_t dn;
1796 char *name;
1797 int err;
1798
1799 ctf_membinfo_t ctm;
1800 ctf_id_t type;
1801 uint_t kind;
1802
1803 name = strdupa(s);
1804 free(s);
1805
1806 err = dt_decl_type(ddp, &dtt);
1807 dt_decl_free(ddp);
1808
1809 if (err != 0)
1810 longjmp(yypcb->pcb_jmpbuf, EDT_COMPILER);
1811
1812 type = ctf_type_resolve(dtt.dtt_ctfp, dtt.dtt_type);
1813 kind = ctf_type_kind(dtt.dtt_ctfp, type);
1814
1815 if (kind != CTF_K_STRUCT && kind != CTF_K_UNION) {
1816 xyerror(D_OFFSETOF_TYPE,
1817 "offsetof operand must be a struct or union type\n");
1818 }
1819
1820 if (ctf_member_info(dtt.dtt_ctfp, type, name, &ctm) == CTF_ERR) {
1821 xyerror(D_UNKNOWN, "failed to determine offset of %s: %s\n",
1822 name, ctf_errmsg(ctf_errno(dtt.dtt_ctfp)));
1823 }
1824
1825 bzero(&dn, sizeof (dn));
1826 dt_node_type_assign(&dn, dtt.dtt_ctfp, ctm.ctm_type, B_FALSE);
1827
1828 if (dn.dn_flags & DT_NF_BITFIELD) {
1829 xyerror(D_OFFSETOF_BITFIELD,
1830 "cannot take offset of a bit-field: %s\n", name);
1831 }
1832
1833 return (dt_node_int(ctm.ctm_offset / NBBY));
1834 }
1835
1836 dt_node_t *
1837 dt_node_op1(int op, dt_node_t *cp)
1838 {
1839 dt_node_t *dnp;
1840
1841 if (cp->dn_kind == DT_NODE_INT) {
1842 switch (op) {
1843 case DT_TOK_INEG:
1844 /*
1845 * If we're negating an unsigned integer, zero out any
1846 * extra top bits to truncate the value to the size of
1847 * the effective type determined by dt_node_int().
1848 */
1849 cp->dn_value = -cp->dn_value;
1850 if (!(cp->dn_flags & DT_NF_SIGNED)) {
1851 cp->dn_value &= ~0ULL >>
1852 (64 - dt_node_type_size(cp) * NBBY);
1853 }
1854 /*FALLTHRU*/
1855 case DT_TOK_IPOS:
1856 return (cp);
1857 case DT_TOK_BNEG:
1858 cp->dn_value = ~cp->dn_value;
1859 return (cp);
1860 case DT_TOK_LNEG:
1861 cp->dn_value = !cp->dn_value;
1862 return (cp);
1863 }
1864 }
1865
1866 /*
1867 * If sizeof is applied to a type_name or string constant, we can
1868 * transform 'cp' into an integer constant in the node construction
1869 * pass so that it can then be used for arithmetic in this pass.
1870 */
1871 if (op == DT_TOK_SIZEOF &&
1872 (cp->dn_kind == DT_NODE_STRING || cp->dn_kind == DT_NODE_TYPE)) {
1873 dtrace_hdl_t *dtp = yypcb->pcb_hdl;
1874 size_t size = dt_node_type_size(cp);
1875
1876 if (size == 0) {
1877 xyerror(D_SIZEOF_TYPE, "cannot apply sizeof to an "
1878 "operand of unknown size\n");
1879 }
1880
1881 dt_node_type_assign(cp, dtp->dt_ddefs->dm_ctfp,
1882 ctf_lookup_by_name(dtp->dt_ddefs->dm_ctfp, "size_t"),
1883 B_FALSE);
1884
1885 cp->dn_kind = DT_NODE_INT;
1886 cp->dn_op = DT_TOK_INT;
1887 cp->dn_value = size;
1888
1889 return (cp);
1890 }
1891
1892 dnp = dt_node_alloc(DT_NODE_OP1);
1893 assert(op <= USHRT_MAX);
1894 dnp->dn_op = (ushort_t)op;
1895 dnp->dn_child = cp;
1896
1897 return (dnp);
1898 }
1899
1900 /*
1901 * If an integer constant is being cast to another integer type, we can
1902 * perform the cast as part of integer constant folding in this pass. We must
1903 * take action when the integer is being cast to a smaller type or if it is
1904 * changing signed-ness. If so, we first shift rp's bits bits high (losing
1905 * excess bits if narrowing) and then shift them down with either a logical
1906 * shift (unsigned) or arithmetic shift (signed).
1907 */
1908 static void
1909 dt_cast(dt_node_t *lp, dt_node_t *rp)
1910 {
1911 size_t srcsize = dt_node_type_size(rp);
1912 size_t dstsize = dt_node_type_size(lp);
1913
1914 if (dstsize < srcsize) {
1915 int n = (sizeof (uint64_t) - dstsize) * NBBY;
1916 rp->dn_value <<= n;
1917 rp->dn_value >>= n;
1918 } else if (dstsize > srcsize) {
1919 int n = (sizeof (uint64_t) - srcsize) * NBBY;
1920 int s = (dstsize - srcsize) * NBBY;
1921
1922 rp->dn_value <<= n;
1923 if (rp->dn_flags & DT_NF_SIGNED) {
1924 rp->dn_value = (intmax_t)rp->dn_value >> s;
1925 rp->dn_value >>= n - s;
1926 } else {
1927 rp->dn_value >>= n;
1928 }
1929 }
1930 }
1931
1932 dt_node_t *
1933 dt_node_op2(int op, dt_node_t *lp, dt_node_t *rp)
1934 {
1935 dtrace_hdl_t *dtp = yypcb->pcb_hdl;
1936 dt_node_t *dnp;
1937
1938 /*
1939 * First we check for operations that are illegal -- namely those that
1940 * might result in integer division by zero, and abort if one is found.
1941 */
1942 if (rp->dn_kind == DT_NODE_INT && rp->dn_value == 0 &&
1943 (op == DT_TOK_MOD || op == DT_TOK_DIV ||
1944 op == DT_TOK_MOD_EQ || op == DT_TOK_DIV_EQ))
1945 xyerror(D_DIV_ZERO, "expression contains division by zero\n");
1946
1947 /*
1948 * If both children are immediate values, we can just perform inline
1949 * calculation and return a new immediate node with the result.
1950 */
1951 if (lp->dn_kind == DT_NODE_INT && rp->dn_kind == DT_NODE_INT) {
1952 uintmax_t l = lp->dn_value;
1953 uintmax_t r = rp->dn_value;
1954
1955 dnp = dt_node_int(0); /* allocate new integer node for result */
1956
1957 switch (op) {
1958 case DT_TOK_LOR:
1959 dnp->dn_value = l || r;
1960 dt_node_type_assign(dnp,
1961 DT_INT_CTFP(dtp), DT_INT_TYPE(dtp), B_FALSE);
1962 break;
1963 case DT_TOK_LXOR:
1964 dnp->dn_value = (l != 0) ^ (r != 0);
1965 dt_node_type_assign(dnp,
1966 DT_INT_CTFP(dtp), DT_INT_TYPE(dtp), B_FALSE);
1967 break;
1968 case DT_TOK_LAND:
1969 dnp->dn_value = l && r;
1970 dt_node_type_assign(dnp,
1971 DT_INT_CTFP(dtp), DT_INT_TYPE(dtp), B_FALSE);
1972 break;
1973 case DT_TOK_BOR:
1974 dnp->dn_value = l | r;
1975 dt_node_promote(lp, rp, dnp);
1976 break;
1977 case DT_TOK_XOR:
1978 dnp->dn_value = l ^ r;
1979 dt_node_promote(lp, rp, dnp);
1980 break;
1981 case DT_TOK_BAND:
1982 dnp->dn_value = l & r;
1983 dt_node_promote(lp, rp, dnp);
1984 break;
1985 case DT_TOK_EQU:
1986 dnp->dn_value = l == r;
1987 dt_node_type_assign(dnp,
1988 DT_INT_CTFP(dtp), DT_INT_TYPE(dtp), B_FALSE);
1989 break;
1990 case DT_TOK_NEQ:
1991 dnp->dn_value = l != r;
1992 dt_node_type_assign(dnp,
1993 DT_INT_CTFP(dtp), DT_INT_TYPE(dtp), B_FALSE);
1994 break;
1995 case DT_TOK_LT:
1996 dt_node_promote(lp, rp, dnp);
1997 if (dnp->dn_flags & DT_NF_SIGNED)
1998 dnp->dn_value = (intmax_t)l < (intmax_t)r;
1999 else
2000 dnp->dn_value = l < r;
2001 dt_node_type_assign(dnp,
2002 DT_INT_CTFP(dtp), DT_INT_TYPE(dtp), B_FALSE);
2003 break;
2004 case DT_TOK_LE:
2005 dt_node_promote(lp, rp, dnp);
2006 if (dnp->dn_flags & DT_NF_SIGNED)
2007 dnp->dn_value = (intmax_t)l <= (intmax_t)r;
2008 else
2009 dnp->dn_value = l <= r;
2010 dt_node_type_assign(dnp,
2011 DT_INT_CTFP(dtp), DT_INT_TYPE(dtp), B_FALSE);
2012 break;
2013 case DT_TOK_GT:
2014 dt_node_promote(lp, rp, dnp);
2015 if (dnp->dn_flags & DT_NF_SIGNED)
2016 dnp->dn_value = (intmax_t)l > (intmax_t)r;
2017 else
2018 dnp->dn_value = l > r;
2019 dt_node_type_assign(dnp,
2020 DT_INT_CTFP(dtp), DT_INT_TYPE(dtp), B_FALSE);
2021 break;
2022 case DT_TOK_GE:
2023 dt_node_promote(lp, rp, dnp);
2024 if (dnp->dn_flags & DT_NF_SIGNED)
2025 dnp->dn_value = (intmax_t)l >= (intmax_t)r;
2026 else
2027 dnp->dn_value = l >= r;
2028 dt_node_type_assign(dnp,
2029 DT_INT_CTFP(dtp), DT_INT_TYPE(dtp), B_FALSE);
2030 break;
2031 case DT_TOK_LSH:
2032 dnp->dn_value = l << r;
2033 dt_node_type_propagate(lp, dnp);
2034 dt_node_attr_assign(rp,
2035 dt_attr_min(lp->dn_attr, rp->dn_attr));
2036 break;
2037 case DT_TOK_RSH:
2038 dnp->dn_value = l >> r;
2039 dt_node_type_propagate(lp, dnp);
2040 dt_node_attr_assign(rp,
2041 dt_attr_min(lp->dn_attr, rp->dn_attr));
2042 break;
2043 case DT_TOK_ADD:
2044 dnp->dn_value = l + r;
2045 dt_node_promote(lp, rp, dnp);
2046 break;
2047 case DT_TOK_SUB:
2048 dnp->dn_value = l - r;
2049 dt_node_promote(lp, rp, dnp);
2050 break;
2051 case DT_TOK_MUL:
2052 dnp->dn_value = l * r;
2053 dt_node_promote(lp, rp, dnp);
2054 break;
2055 case DT_TOK_DIV:
2056 dt_node_promote(lp, rp, dnp);
2057 if (dnp->dn_flags & DT_NF_SIGNED)
2058 dnp->dn_value = (intmax_t)l / (intmax_t)r;
2059 else
2060 dnp->dn_value = l / r;
2061 break;
2062 case DT_TOK_MOD:
2063 dt_node_promote(lp, rp, dnp);
2064 if (dnp->dn_flags & DT_NF_SIGNED)
2065 dnp->dn_value = (intmax_t)l % (intmax_t)r;
2066 else
2067 dnp->dn_value = l % r;
2068 break;
2069 default:
2070 dt_node_free(dnp);
2071 dnp = NULL;
2072 }
2073
2074 if (dnp != NULL) {
2075 dt_node_free(lp);
2076 dt_node_free(rp);
2077 return (dnp);
2078 }
2079 }
2080
2081 if (op == DT_TOK_LPAR && rp->dn_kind == DT_NODE_INT &&
2082 dt_node_is_integer(lp)) {
2083 dt_cast(lp, rp);
2084 dt_node_type_propagate(lp, rp);
2085 dt_node_attr_assign(rp, dt_attr_min(lp->dn_attr, rp->dn_attr));
2086 dt_node_free(lp);
2087
2088 return (rp);
2089 }
2090
2091 /*
2092 * If no immediate optimizations are available, create an new OP2 node
2093 * and glue the left and right children into place and return.
2094 */
2095 dnp = dt_node_alloc(DT_NODE_OP2);
2096 assert(op <= USHRT_MAX);
2097 dnp->dn_op = (ushort_t)op;
2098 dnp->dn_left = lp;
2099 dnp->dn_right = rp;
2100
2101 return (dnp);
2102 }
2103
2104 dt_node_t *
2105 dt_node_op3(dt_node_t *expr, dt_node_t *lp, dt_node_t *rp)
2106 {
2107 dt_node_t *dnp;
2108
2109 if (expr->dn_kind == DT_NODE_INT)
2110 return (expr->dn_value != 0 ? lp : rp);
2111
2112 dnp = dt_node_alloc(DT_NODE_OP3);
2113 dnp->dn_op = DT_TOK_QUESTION;
2114 dnp->dn_expr = expr;
2115 dnp->dn_left = lp;
2116 dnp->dn_right = rp;
2117
2118 return (dnp);
2119 }
2120
2121 dt_node_t *
2122 dt_node_statement(dt_node_t *expr)
2123 {
2124 dt_node_t *dnp;
2125
2126 if (expr->dn_kind == DT_NODE_AGG)
2127 return (expr);
2128
2129 if (expr->dn_kind == DT_NODE_FUNC &&
2130 expr->dn_ident->di_kind == DT_IDENT_ACTFUNC)
2131 dnp = dt_node_alloc(DT_NODE_DFUNC);
2132 else
2133 dnp = dt_node_alloc(DT_NODE_DEXPR);
2134
2135 dnp->dn_expr = expr;
2136 return (dnp);
2137 }
2138
2139 dt_node_t *
2140 dt_node_if(dt_node_t *pred, dt_node_t *acts, dt_node_t *else_acts)
2141 {
2142 dt_node_t *dnp = dt_node_alloc(DT_NODE_IF);
2143 dnp->dn_conditional = pred;
2144 dnp->dn_body = acts;
2145 dnp->dn_alternate_body = else_acts;
2146
2147 return (dnp);
2148 }
2149
2150 dt_node_t *
2151 dt_node_pdesc_by_name(char *spec)
2152 {
2153 dtrace_hdl_t *dtp = yypcb->pcb_hdl;
2154 dt_node_t *dnp;
2155
2156 if (spec == NULL)
2157 longjmp(yypcb->pcb_jmpbuf, EDT_NOMEM);
2158
2159 dnp = dt_node_alloc(DT_NODE_PDESC);
2160 dnp->dn_spec = spec;
2161 dnp->dn_desc = malloc(sizeof (dtrace_probedesc_t));
2162
2163 if (dnp->dn_desc == NULL)
2164 longjmp(yypcb->pcb_jmpbuf, EDT_NOMEM);
2165
2166 if (dtrace_xstr2desc(dtp, yypcb->pcb_pspec, dnp->dn_spec,
2167 yypcb->pcb_sargc, yypcb->pcb_sargv, dnp->dn_desc) != 0) {
2168 xyerror(D_PDESC_INVAL, "invalid probe description \"%s\": %s\n",
2169 dnp->dn_spec, dtrace_errmsg(dtp, dtrace_errno(dtp)));
2170 }
2171
2172 free(dnp->dn_spec);
2173 dnp->dn_spec = NULL;
2174
2175 return (dnp);
2176 }
2177
2178 dt_node_t *
2179 dt_node_pdesc_by_id(uintmax_t id)
2180 {
2181 static const char *const names[] = {
2182 "providers", "modules", "functions"
2183 };
2184
2185 dtrace_hdl_t *dtp = yypcb->pcb_hdl;
2186 dt_node_t *dnp = dt_node_alloc(DT_NODE_PDESC);
2187
2188 if ((dnp->dn_desc = malloc(sizeof (dtrace_probedesc_t))) == NULL)
2189 longjmp(yypcb->pcb_jmpbuf, EDT_NOMEM);
2190
2191 if (id > UINT_MAX) {
2192 xyerror(D_PDESC_INVAL, "identifier %llu exceeds maximum "
2193 "probe id\n", (u_longlong_t)id);
2194 }
2195
2196 if (yypcb->pcb_pspec != DTRACE_PROBESPEC_NAME) {
2197 xyerror(D_PDESC_INVAL, "probe identifier %llu not permitted "
2198 "when specifying %s\n", (u_longlong_t)id,
2199 names[yypcb->pcb_pspec]);
2200 }
2201
2202 if (dtrace_id2desc(dtp, (dtrace_id_t)id, dnp->dn_desc) != 0) {
2203 xyerror(D_PDESC_INVAL, "invalid probe identifier %llu: %s\n",
2204 (u_longlong_t)id, dtrace_errmsg(dtp, dtrace_errno(dtp)));
2205 }
2206
2207 return (dnp);
2208 }
2209
2210 dt_node_t *
2211 dt_node_clause(dt_node_t *pdescs, dt_node_t *pred, dt_node_t *acts)
2212 {
2213 dt_node_t *dnp = dt_node_alloc(DT_NODE_CLAUSE);
2214
2215 dnp->dn_pdescs = pdescs;
2216 dnp->dn_pred = pred;
2217 dnp->dn_acts = acts;
2218
2219 return (dnp);
2220 }
2221
2222 dt_node_t *
2223 dt_node_inline(dt_node_t *expr)
2224 {
2225 dtrace_hdl_t *dtp = yypcb->pcb_hdl;
2226 dt_scope_t *dsp = &yypcb->pcb_dstack;
2227 dt_decl_t *ddp = dt_decl_top();
2228
2229 char n[DT_TYPE_NAMELEN];
2230 dtrace_typeinfo_t dtt;
2231
2232 dt_ident_t *idp, *rdp;
2233 dt_idnode_t *inp;
2234 dt_node_t *dnp;
2235
2236 if (dt_decl_type(ddp, &dtt) != 0)
2237 longjmp(yypcb->pcb_jmpbuf, EDT_COMPILER);
2238
2239 if (dsp->ds_class != DT_DC_DEFAULT) {
2240 xyerror(D_DECL_BADCLASS, "specified storage class not "
2241 "appropriate for inline declaration\n");
2242 }
2243
2244 if (dsp->ds_ident == NULL)
2245 xyerror(D_DECL_USELESS, "inline declaration requires a name\n");
2246
2247 if ((idp = dt_idstack_lookup(
2248 &yypcb->pcb_globals, dsp->ds_ident)) != NULL) {
2249 xyerror(D_DECL_IDRED, "identifier redefined: %s\n\t current: "
2250 "inline definition\n\tprevious: %s %s\n",
2251 idp->di_name, dt_idkind_name(idp->di_kind),
2252 (idp->di_flags & DT_IDFLG_INLINE) ? "inline" : "");
2253 }
2254
2255 /*
2256 * If we are declaring an inlined array, verify that we have a tuple
2257 * signature, and then recompute 'dtt' as the array's value type.
2258 */
2259 if (ddp->dd_kind == CTF_K_ARRAY) {
2260 if (ddp->dd_node == NULL) {
2261 xyerror(D_DECL_ARRNULL, "inline declaration requires "
2262 "array tuple signature: %s\n", dsp->ds_ident);
2263 }
2264
2265 if (ddp->dd_node->dn_kind != DT_NODE_TYPE) {
2266 xyerror(D_DECL_ARRNULL, "inline declaration cannot be "
2267 "of scalar array type: %s\n", dsp->ds_ident);
2268 }
2269
2270 if (dt_decl_type(ddp->dd_next, &dtt) != 0)
2271 longjmp(yypcb->pcb_jmpbuf, EDT_COMPILER);
2272 }
2273
2274 /*
2275 * If the inline identifier is not defined, then create it with the
2276 * orphan flag set. We do not insert the identifier into dt_globals
2277 * until we have successfully cooked the right-hand expression, below.
2278 */
2279 dnp = dt_node_alloc(DT_NODE_INLINE);
2280 dt_node_type_assign(dnp, dtt.dtt_ctfp, dtt.dtt_type, B_FALSE);
2281 dt_node_attr_assign(dnp, _dtrace_defattr);
2282
2283 if (dt_node_is_void(dnp)) {
2284 xyerror(D_DECL_VOIDOBJ,
2285 "cannot declare void inline: %s\n", dsp->ds_ident);
2286 }
2287
2288 if (ctf_type_kind(dnp->dn_ctfp, ctf_type_resolve(
2289 dnp->dn_ctfp, dnp->dn_type)) == CTF_K_FORWARD) {
2290 xyerror(D_DECL_INCOMPLETE,
2291 "incomplete struct/union/enum %s: %s\n",
2292 dt_node_type_name(dnp, n, sizeof (n)), dsp->ds_ident);
2293 }
2294
2295 if ((inp = malloc(sizeof (dt_idnode_t))) == NULL)
2296 longjmp(yypcb->pcb_jmpbuf, EDT_NOMEM);
2297
2298 bzero(inp, sizeof (dt_idnode_t));
2299
2300 idp = dnp->dn_ident = dt_ident_create(dsp->ds_ident,
2301 ddp->dd_kind == CTF_K_ARRAY ? DT_IDENT_ARRAY : DT_IDENT_SCALAR,
2302 DT_IDFLG_INLINE | DT_IDFLG_REF | DT_IDFLG_DECL | DT_IDFLG_ORPHAN, 0,
2303 _dtrace_defattr, 0, &dt_idops_inline, inp, dtp->dt_gen);
2304
2305 if (idp == NULL) {
2306 free(inp);
2307 longjmp(yypcb->pcb_jmpbuf, EDT_NOMEM);
2308 }
2309
2310 /*
2311 * If we're inlining an associative array, create a private identifier
2312 * hash containing the named parameters and store it in inp->din_hash.
2313 * We then push this hash on to the top of the pcb_globals stack.
2314 */
2315 if (ddp->dd_kind == CTF_K_ARRAY) {
2316 dt_idnode_t *pinp;
2317 dt_ident_t *pidp;
2318 dt_node_t *pnp;
2319 uint_t i = 0;
2320
2321 for (pnp = ddp->dd_node; pnp != NULL; pnp = pnp->dn_list)
2322 i++; /* count up parameters for din_argv[] */
2323
2324 inp->din_hash = dt_idhash_create("inline args", NULL, 0, 0);
2325 inp->din_argv = calloc(i, sizeof (dt_ident_t *));
2326
2327 if (inp->din_hash == NULL || inp->din_argv == NULL)
2328 longjmp(yypcb->pcb_jmpbuf, EDT_NOMEM);
2329
2330 /*
2331 * Create an identifier for each parameter as a scalar inline,
2332 * and store it in din_hash and in position in din_argv[]. The
2333 * parameter identifiers also use dt_idops_inline, but we leave
2334 * the dt_idnode_t argument 'pinp' zeroed. This will be filled
2335 * in by the code generation pass with references to the args.
2336 */
2337 for (i = 0, pnp = ddp->dd_node;
2338 pnp != NULL; pnp = pnp->dn_list, i++) {
2339
2340 if (pnp->dn_string == NULL)
2341 continue; /* ignore anonymous parameters */
2342
2343 if ((pinp = malloc(sizeof (dt_idnode_t))) == NULL)
2344 longjmp(yypcb->pcb_jmpbuf, EDT_NOMEM);
2345
2346 pidp = dt_idhash_insert(inp->din_hash, pnp->dn_string,
2347 DT_IDENT_SCALAR, DT_IDFLG_DECL | DT_IDFLG_INLINE, 0,
2348 _dtrace_defattr, 0, &dt_idops_inline,
2349 pinp, dtp->dt_gen);
2350
2351 if (pidp == NULL) {
2352 free(pinp);
2353 longjmp(yypcb->pcb_jmpbuf, EDT_NOMEM);
2354 }
2355
2356 inp->din_argv[i] = pidp;
2357 bzero(pinp, sizeof (dt_idnode_t));
2358 dt_ident_type_assign(pidp, pnp->dn_ctfp, pnp->dn_type);
2359 }
2360
2361 dt_idstack_push(&yypcb->pcb_globals, inp->din_hash);
2362 }
2363
2364 /*
2365 * Unlike most constructors, we need to explicitly cook the right-hand
2366 * side of the inline definition immediately to prevent recursion. If
2367 * the right-hand side uses the inline itself, the cook will fail.
2368 */
2369 expr = dt_node_cook(expr, DT_IDFLG_REF);
2370
2371 if (ddp->dd_kind == CTF_K_ARRAY)
2372 dt_idstack_pop(&yypcb->pcb_globals, inp->din_hash);
2373
2374 /*
2375 * Set the type, attributes, and flags for the inline. If the right-
2376 * hand expression has an identifier, propagate its flags. Then cook
2377 * the identifier to fully initialize it: if we're declaring an inline
2378 * associative array this will construct a type signature from 'ddp'.
2379 */
2380 if (dt_node_is_dynamic(expr))
2381 rdp = dt_ident_resolve(expr->dn_ident);
2382 else if (expr->dn_kind == DT_NODE_VAR || expr->dn_kind == DT_NODE_SYM)
2383 rdp = expr->dn_ident;
2384 else
2385 rdp = NULL;
2386
2387 if (rdp != NULL) {
2388 idp->di_flags |= (rdp->di_flags &
2389 (DT_IDFLG_WRITE | DT_IDFLG_USER | DT_IDFLG_PRIM));
2390 }
2391
2392 idp->di_attr = dt_attr_min(_dtrace_defattr, expr->dn_attr);
2393 dt_ident_type_assign(idp, dtt.dtt_ctfp, dtt.dtt_type);
2394 (void) dt_ident_cook(dnp, idp, &ddp->dd_node);
2395
2396 /*
2397 * Store the parse tree nodes for 'expr' inside of idp->di_data ('inp')
2398 * so that they will be preserved with this identifier. Then pop the
2399 * inline declaration from the declaration stack and restore the lexer.
2400 */
2401 inp->din_list = yypcb->pcb_list;
2402 inp->din_root = expr;
2403
2404 dt_decl_free(dt_decl_pop());
2405 yybegin(YYS_CLAUSE);
2406
2407 /*
2408 * Finally, insert the inline identifier into dt_globals to make it
2409 * visible, and then cook 'dnp' to check its type against 'expr'.
2410 */
2411 dt_idhash_xinsert(dtp->dt_globals, idp);
2412 return (dt_node_cook(dnp, DT_IDFLG_REF));
2413 }
2414
2415 dt_node_t *
2416 dt_node_member(dt_decl_t *ddp, char *name, dt_node_t *expr)
2417 {
2418 dtrace_typeinfo_t dtt;
2419 dt_node_t *dnp;
2420 int err;
2421
2422 if (ddp != NULL) {
2423 err = dt_decl_type(ddp, &dtt);
2424 dt_decl_free(ddp);
2425
2426 if (err != 0)
2427 longjmp(yypcb->pcb_jmpbuf, EDT_COMPILER);
2428 }
2429
2430 dnp = dt_node_alloc(DT_NODE_MEMBER);
2431 dnp->dn_membname = name;
2432 dnp->dn_membexpr = expr;
2433
2434 if (ddp != NULL)
2435 dt_node_type_assign(dnp, dtt.dtt_ctfp, dtt.dtt_type,
2436 dtt.dtt_flags);
2437
2438 return (dnp);
2439 }
2440
2441 dt_node_t *
2442 dt_node_xlator(dt_decl_t *ddp, dt_decl_t *sdp, char *name, dt_node_t *members)
2443 {
2444 dtrace_hdl_t *dtp = yypcb->pcb_hdl;
2445 dtrace_typeinfo_t src, dst;
2446 dt_node_t sn, dn;
2447 dt_xlator_t *dxp;
2448 dt_node_t *dnp;
2449 int edst, esrc;
2450 uint_t kind;
2451
2452 char n1[DT_TYPE_NAMELEN];
2453 char n2[DT_TYPE_NAMELEN];
2454
2455 edst = dt_decl_type(ddp, &dst);
2456 dt_decl_free(ddp);
2457
2458 esrc = dt_decl_type(sdp, &src);
2459 dt_decl_free(sdp);
2460
2461 if (edst != 0 || esrc != 0) {
2462 free(name);
2463 longjmp(yypcb->pcb_jmpbuf, EDT_COMPILER);
2464 }
2465
2466 bzero(&sn, sizeof (sn));
2467 dt_node_type_assign(&sn, src.dtt_ctfp, src.dtt_type, B_FALSE);
2468
2469 bzero(&dn, sizeof (dn));
2470 dt_node_type_assign(&dn, dst.dtt_ctfp, dst.dtt_type, B_FALSE);
2471
2472 if (dt_xlator_lookup(dtp, &sn, &dn, DT_XLATE_EXACT) != NULL) {
2473 xyerror(D_XLATE_REDECL,
2474 "translator from %s to %s has already been declared\n",
2475 dt_node_type_name(&sn, n1, sizeof (n1)),
2476 dt_node_type_name(&dn, n2, sizeof (n2)));
2477 }
2478
2479 kind = ctf_type_kind(dst.dtt_ctfp,
2480 ctf_type_resolve(dst.dtt_ctfp, dst.dtt_type));
2481
2482 if (kind == CTF_K_FORWARD) {
2483 xyerror(D_XLATE_SOU, "incomplete struct/union/enum %s\n",
2484 dt_type_name(dst.dtt_ctfp, dst.dtt_type, n1, sizeof (n1)));
2485 }
2486
2487 if (kind != CTF_K_STRUCT && kind != CTF_K_UNION) {
2488 xyerror(D_XLATE_SOU,
2489 "translator output type must be a struct or union\n");
2490 }
2491
2492 dxp = dt_xlator_create(dtp, &src, &dst, name, members, yypcb->pcb_list);
2493 yybegin(YYS_CLAUSE);
2494 free(name);
2495
2496 if (dxp == NULL)
2497 longjmp(yypcb->pcb_jmpbuf, EDT_NOMEM);
2498
2499 dnp = dt_node_alloc(DT_NODE_XLATOR);
2500 dnp->dn_xlator = dxp;
2501 dnp->dn_members = members;
2502
2503 return (dt_node_cook(dnp, DT_IDFLG_REF));
2504 }
2505
2506 dt_node_t *
2507 dt_node_probe(char *s, int protoc, dt_node_t *nargs, dt_node_t *xargs)
2508 {
2509 dtrace_hdl_t *dtp = yypcb->pcb_hdl;
2510 int nargc, xargc;
2511 dt_node_t *dnp;
2512
2513 size_t len = strlen(s) + 3; /* +3 for :: and \0 */
2514 char *name = alloca(len);
2515
2516 (void) snprintf(name, len, "::%s", s);
2517 (void) strhyphenate(name);
2518 free(s);
2519
2520 if (strchr(name, '`') != NULL) {
2521 xyerror(D_PROV_BADNAME, "probe name may not "
2522 "contain scoping operator: %s\n", name);
2523 }
2524
2525 if (strlen(name) - 2 >= DTRACE_NAMELEN) {
2526 xyerror(D_PROV_BADNAME, "probe name may not exceed %d "
2527 "characters: %s\n", DTRACE_NAMELEN - 1, name);
2528 }
2529
2530 dnp = dt_node_alloc(DT_NODE_PROBE);
2531
2532 dnp->dn_ident = dt_ident_create(name, DT_IDENT_PROBE,
2533 DT_IDFLG_ORPHAN, DTRACE_IDNONE, _dtrace_defattr, 0,
2534 &dt_idops_probe, NULL, dtp->dt_gen);
2535
2536 nargc = dt_decl_prototype(nargs, nargs,
2537 "probe input", DT_DP_VOID | DT_DP_ANON);
2538
2539 xargc = dt_decl_prototype(xargs, nargs,
2540 "probe output", DT_DP_VOID);
2541
2542 if (nargc > UINT8_MAX) {
2543 xyerror(D_PROV_PRARGLEN, "probe %s input prototype exceeds %u "
2544 "parameters: %d params used\n", name, UINT8_MAX, nargc);
2545 }
2546
2547 if (xargc > UINT8_MAX) {
2548 xyerror(D_PROV_PRARGLEN, "probe %s output prototype exceeds %u "
2549 "parameters: %d params used\n", name, UINT8_MAX, xargc);
2550 }
2551
2552 if (dnp->dn_ident == NULL || dt_probe_create(dtp,
2553 dnp->dn_ident, protoc, nargs, nargc, xargs, xargc) == NULL)
2554 longjmp(yypcb->pcb_jmpbuf, EDT_NOMEM);
2555
2556 return (dnp);
2557 }
2558
2559 dt_node_t *
2560 dt_node_provider(char *name, dt_node_t *probes)
2561 {
2562 dtrace_hdl_t *dtp = yypcb->pcb_hdl;
2563 dt_node_t *dnp = dt_node_alloc(DT_NODE_PROVIDER);
2564 dt_node_t *lnp;
2565 size_t len;
2566
2567 dnp->dn_provname = name;
2568 dnp->dn_probes = probes;
2569
2570 if (strchr(name, '`') != NULL) {
2571 dnerror(dnp, D_PROV_BADNAME, "provider name may not "
2572 "contain scoping operator: %s\n", name);
2573 }
2574
2575 if ((len = strlen(name)) >= DTRACE_PROVNAMELEN) {
2576 dnerror(dnp, D_PROV_BADNAME, "provider name may not exceed %d "
2577 "characters: %s\n", DTRACE_PROVNAMELEN - 1, name);
2578 }
2579
2580 if (isdigit(name[len - 1])) {
2581 dnerror(dnp, D_PROV_BADNAME, "provider name may not "
2582 "end with a digit: %s\n", name);
2583 }
2584
2585 /*
2586 * Check to see if the provider is already defined or visible through
2587 * dtrace(7D). If so, set dn_provred to treat it as a re-declaration.
2588 * If not, create a new provider and set its interface-only flag. This
2589 * flag may be cleared later by calls made to dt_probe_declare().
2590 */
2591 if ((dnp->dn_provider = dt_provider_lookup(dtp, name)) != NULL)
2592 dnp->dn_provred = B_TRUE;
2593 else if ((dnp->dn_provider = dt_provider_create(dtp, name)) == NULL)
2594 longjmp(yypcb->pcb_jmpbuf, EDT_NOMEM);
2595 else
2596 dnp->dn_provider->pv_flags |= DT_PROVIDER_INTF;
2597
2598 /*
2599 * Store all parse nodes created since we consumed the DT_KEY_PROVIDER
2600 * token with the provider and then restore our lexing state to CLAUSE.
2601 * Note that if dnp->dn_provred is true, we may end up storing dups of
2602 * a provider's interface and implementation: we eat this space because
2603 * the implementation will likely need to redeclare probe members, and
2604 * therefore may result in those member nodes becoming persistent.
2605 */
2606 for (lnp = yypcb->pcb_list; lnp->dn_link != NULL; lnp = lnp->dn_link)
2607 continue; /* skip to end of allocation list */
2608
2609 lnp->dn_link = dnp->dn_provider->pv_nodes;
2610 dnp->dn_provider->pv_nodes = yypcb->pcb_list;
2611
2612 yybegin(YYS_CLAUSE);
2613 return (dnp);
2614 }
2615
2616 dt_node_t *
2617 dt_node_program(dt_node_t *lnp)
2618 {
2619 dt_node_t *dnp = dt_node_alloc(DT_NODE_PROG);
2620 dnp->dn_list = lnp;
2621 return (dnp);
2622 }
2623
2624 /*
2625 * This function provides the underlying implementation of cooking an
2626 * identifier given its node, a hash of dynamic identifiers, an identifier
2627 * kind, and a boolean flag indicating whether we are allowed to instantiate
2628 * a new identifier if the string is not found. This function is either
2629 * called from dt_cook_ident(), below, or directly by the various cooking
2630 * routines that are allowed to instantiate identifiers (e.g. op2 TOK_ASGN).
2631 */
2632 static void
2633 dt_xcook_ident(dt_node_t *dnp, dt_idhash_t *dhp, uint_t idkind, int create)
2634 {
2635 dtrace_hdl_t *dtp = yypcb->pcb_hdl;
2636 const char *sname = dt_idhash_name(dhp);
2637 int uref = 0;
2638
2639 dtrace_attribute_t attr = _dtrace_defattr;
2640 dt_ident_t *idp;
2641 dtrace_syminfo_t dts;
2642 GElf_Sym sym;
2643
2644 const char *scope, *mark;
2645 uchar_t dnkind;
2646 char *name;
2647
2648 /*
2649 * Look for scoping marks in the identifier. If one is found, set our
2650 * scope to either DTRACE_OBJ_KMODS or UMODS or to the first part of
2651 * the string that specifies the scope using an explicit module name.
2652 * If two marks in a row are found, set 'uref' (user symbol reference).
2653 * Otherwise we set scope to DTRACE_OBJ_EXEC, indicating that normal
2654 * scope is desired and we should search the specified idhash.
2655 */
2656 if ((name = strrchr(dnp->dn_string, '`')) != NULL) {
2657 if (name > dnp->dn_string && name[-1] == '`') {
2658 uref++;
2659 name[-1] = '\0';
2660 }
2661
2662 if (name == dnp->dn_string + uref)
2663 scope = uref ? DTRACE_OBJ_UMODS : DTRACE_OBJ_KMODS;
2664 else
2665 scope = dnp->dn_string;
2666
2667 *name++ = '\0'; /* leave name pointing after scoping mark */
2668 dnkind = DT_NODE_VAR;
2669
2670 } else if (idkind == DT_IDENT_AGG) {
2671 scope = DTRACE_OBJ_EXEC;
2672 name = dnp->dn_string + 1;
2673 dnkind = DT_NODE_AGG;
2674 } else {
2675 scope = DTRACE_OBJ_EXEC;
2676 name = dnp->dn_string;
2677 dnkind = DT_NODE_VAR;
2678 }
2679
2680 /*
2681 * If create is set to false, and we fail our idhash lookup, preset
2682 * the errno code to EDT_NOVAR for our final error message below.
2683 * If we end up calling dtrace_lookup_by_name(), it will reset the
2684 * errno appropriately and that error will be reported instead.
2685 */
2686 (void) dt_set_errno(dtp, EDT_NOVAR);
2687 mark = uref ? "``" : "`";
2688
2689 if (scope == DTRACE_OBJ_EXEC && (
2690 (dhp != dtp->dt_globals &&
2691 (idp = dt_idhash_lookup(dhp, name)) != NULL) ||
2692 (dhp == dtp->dt_globals &&
2693 (idp = dt_idstack_lookup(&yypcb->pcb_globals, name)) != NULL))) {
2694 /*
2695 * Check that we are referencing the ident in the manner that
2696 * matches its type if this is a global lookup. In the TLS or
2697 * local case, we don't know how the ident will be used until
2698 * the time operator -> is seen; more parsing is needed.
2699 */
2700 if (idp->di_kind != idkind && dhp == dtp->dt_globals) {
2701 xyerror(D_IDENT_BADREF, "%s '%s' may not be referenced "
2702 "as %s\n", dt_idkind_name(idp->di_kind),
2703 idp->di_name, dt_idkind_name(idkind));
2704 }
2705
2706 /*
2707 * Arrays and aggregations are not cooked individually. They
2708 * have dynamic types and must be referenced using operator [].
2709 * This is handled explicitly by the code for DT_TOK_LBRAC.
2710 */
2711 if (idp->di_kind != DT_IDENT_ARRAY &&
2712 idp->di_kind != DT_IDENT_AGG)
2713 attr = dt_ident_cook(dnp, idp, NULL);
2714 else {
2715 dt_node_type_assign(dnp,
2716 DT_DYN_CTFP(dtp), DT_DYN_TYPE(dtp), B_FALSE);
2717 attr = idp->di_attr;
2718 }
2719
2720 free(dnp->dn_string);
2721 dnp->dn_string = NULL;
2722 dnp->dn_kind = dnkind;
2723 dnp->dn_ident = idp;
2724 dnp->dn_flags |= DT_NF_LVALUE;
2725
2726 if (idp->di_flags & DT_IDFLG_WRITE)
2727 dnp->dn_flags |= DT_NF_WRITABLE;
2728
2729 dt_node_attr_assign(dnp, attr);
2730
2731 } else if (dhp == dtp->dt_globals && scope != DTRACE_OBJ_EXEC &&
2732 dtrace_lookup_by_name(dtp, scope, name, &sym, &dts) == 0) {
2733
2734 dt_module_t *mp = dt_module_lookup_by_name(dtp, dts.dts_object);
2735 int umod = (mp->dm_flags & DT_DM_KERNEL) == 0;
2736 static const char *const kunames[] = { "kernel", "user" };
2737
2738 dtrace_typeinfo_t dtt;
2739 dtrace_syminfo_t *sip;
2740
2741 if (uref ^ umod) {
2742 xyerror(D_SYM_BADREF, "%s module '%s' symbol '%s' may "
2743 "not be referenced as a %s symbol\n", kunames[umod],
2744 dts.dts_object, dts.dts_name, kunames[uref]);
2745 }
2746
2747 if (dtrace_symbol_type(dtp, &sym, &dts, &dtt) != 0) {
2748 /*
2749 * For now, we special-case EDT_DATAMODEL to clarify
2750 * that mixed data models are not currently supported.
2751 */
2752 if (dtp->dt_errno == EDT_DATAMODEL) {
2753 xyerror(D_SYM_MODEL, "cannot use %s symbol "
2754 "%s%s%s in a %s D program\n",
2755 dt_module_modelname(mp),
2756 dts.dts_object, mark, dts.dts_name,
2757 dt_module_modelname(dtp->dt_ddefs));
2758 }
2759
2760 xyerror(D_SYM_NOTYPES,
2761 "no symbolic type information is available for "
2762 "%s%s%s: %s\n", dts.dts_object, mark, dts.dts_name,
2763 dtrace_errmsg(dtp, dtrace_errno(dtp)));
2764 }
2765
2766 idp = dt_ident_create(name, DT_IDENT_SYMBOL, 0, 0,
2767 _dtrace_symattr, 0, &dt_idops_thaw, NULL, dtp->dt_gen);
2768
2769 if (idp == NULL)
2770 longjmp(yypcb->pcb_jmpbuf, EDT_NOMEM);
2771
2772 if (mp->dm_flags & DT_DM_PRIMARY)
2773 idp->di_flags |= DT_IDFLG_PRIM;
2774
2775 idp->di_next = dtp->dt_externs;
2776 dtp->dt_externs = idp;
2777
2778 if ((sip = malloc(sizeof (dtrace_syminfo_t))) == NULL)
2779 longjmp(yypcb->pcb_jmpbuf, EDT_NOMEM);
2780
2781 bcopy(&dts, sip, sizeof (dtrace_syminfo_t));
2782 idp->di_data = sip;
2783 idp->di_ctfp = dtt.dtt_ctfp;
2784 idp->di_type = dtt.dtt_type;
2785
2786 free(dnp->dn_string);
2787 dnp->dn_string = NULL;
2788 dnp->dn_kind = DT_NODE_SYM;
2789 dnp->dn_ident = idp;
2790 dnp->dn_flags |= DT_NF_LVALUE;
2791
2792 dt_node_type_assign(dnp, dtt.dtt_ctfp, dtt.dtt_type,
2793 dtt.dtt_flags);
2794 dt_node_attr_assign(dnp, _dtrace_symattr);
2795
2796 if (uref) {
2797 idp->di_flags |= DT_IDFLG_USER;
2798 dnp->dn_flags |= DT_NF_USERLAND;
2799 }
2800
2801 } else if (scope == DTRACE_OBJ_EXEC && create == B_TRUE) {
2802 uint_t flags = DT_IDFLG_WRITE;
2803 uint_t id;
2804
2805 if (dt_idhash_nextid(dhp, &id) == -1) {
2806 xyerror(D_ID_OFLOW, "cannot create %s: limit on number "
2807 "of %s variables exceeded\n", name, sname);
2808 }
2809
2810 if (dhp == yypcb->pcb_locals)
2811 flags |= DT_IDFLG_LOCAL;
2812 else if (dhp == dtp->dt_tls)
2813 flags |= DT_IDFLG_TLS;
2814
2815 dt_dprintf("create %s %s variable %s, id=%u\n",
2816 sname, dt_idkind_name(idkind), name, id);
2817
2818 if (idkind == DT_IDENT_ARRAY || idkind == DT_IDENT_AGG) {
2819 idp = dt_idhash_insert(dhp, name,
2820 idkind, flags, id, _dtrace_defattr, 0,
2821 &dt_idops_assc, NULL, dtp->dt_gen);
2822 } else {
2823 idp = dt_idhash_insert(dhp, name,
2824 idkind, flags, id, _dtrace_defattr, 0,
2825 &dt_idops_thaw, NULL, dtp->dt_gen);
2826 }
2827
2828 if (idp == NULL)
2829 longjmp(yypcb->pcb_jmpbuf, EDT_NOMEM);
2830
2831 /*
2832 * Arrays and aggregations are not cooked individually. They
2833 * have dynamic types and must be referenced using operator [].
2834 * This is handled explicitly by the code for DT_TOK_LBRAC.
2835 */
2836 if (idp->di_kind != DT_IDENT_ARRAY &&
2837 idp->di_kind != DT_IDENT_AGG)
2838 attr = dt_ident_cook(dnp, idp, NULL);
2839 else {
2840 dt_node_type_assign(dnp,
2841 DT_DYN_CTFP(dtp), DT_DYN_TYPE(dtp), B_FALSE);
2842 attr = idp->di_attr;
2843 }
2844
2845 free(dnp->dn_string);
2846 dnp->dn_string = NULL;
2847 dnp->dn_kind = dnkind;
2848 dnp->dn_ident = idp;
2849 dnp->dn_flags |= DT_NF_LVALUE | DT_NF_WRITABLE;
2850
2851 dt_node_attr_assign(dnp, attr);
2852
2853 } else if (scope != DTRACE_OBJ_EXEC) {
2854 xyerror(D_IDENT_UNDEF, "failed to resolve %s%s%s: %s\n",
2855 dnp->dn_string, mark, name,
2856 dtrace_errmsg(dtp, dtrace_errno(dtp)));
2857 } else {
2858 xyerror(D_IDENT_UNDEF, "failed to resolve %s: %s\n",
2859 dnp->dn_string, dtrace_errmsg(dtp, dtrace_errno(dtp)));
2860 }
2861 }
2862
2863 static dt_node_t *
2864 dt_cook_ident(dt_node_t *dnp, uint_t idflags)
2865 {
2866 dtrace_hdl_t *dtp = yypcb->pcb_hdl;
2867
2868 if (dnp->dn_op == DT_TOK_AGG)
2869 dt_xcook_ident(dnp, dtp->dt_aggs, DT_IDENT_AGG, B_FALSE);
2870 else
2871 dt_xcook_ident(dnp, dtp->dt_globals, DT_IDENT_SCALAR, B_FALSE);
2872
2873 return (dt_node_cook(dnp, idflags));
2874 }
2875
2876 /*
2877 * Since operators [ and -> can instantiate new variables before we know
2878 * whether the reference is for a read or a write, we need to check read
2879 * references to determine if the identifier is currently dt_ident_unref().
2880 * If so, we report that this first access was to an undefined variable.
2881 */
2882 static dt_node_t *
2883 dt_cook_var(dt_node_t *dnp, uint_t idflags)
2884 {
2885 dt_ident_t *idp = dnp->dn_ident;
2886
2887 if ((idflags & DT_IDFLG_REF) && dt_ident_unref(idp)) {
2888 dnerror(dnp, D_VAR_UNDEF,
2889 "%s%s has not yet been declared or assigned\n",
2890 (idp->di_flags & DT_IDFLG_LOCAL) ? "this->" :
2891 (idp->di_flags & DT_IDFLG_TLS) ? "self->" : "",
2892 idp->di_name);
2893 }
2894
2895 dt_node_attr_assign(dnp, dt_ident_cook(dnp, idp, &dnp->dn_args));
2896 return (dnp);
2897 }
2898
2899 /*ARGSUSED*/
2900 static dt_node_t *
2901 dt_cook_func(dt_node_t *dnp, uint_t idflags)
2902 {
2903 dt_node_attr_assign(dnp,
2904 dt_ident_cook(dnp, dnp->dn_ident, &dnp->dn_args));
2905
2906 return (dnp);
2907 }
2908
2909 static dt_node_t *
2910 dt_cook_op1(dt_node_t *dnp, uint_t idflags)
2911 {
2912 dtrace_hdl_t *dtp = yypcb->pcb_hdl;
2913 dt_node_t *cp = dnp->dn_child;
2914
2915 char n[DT_TYPE_NAMELEN];
2916 dtrace_typeinfo_t dtt;
2917 dt_ident_t *idp;
2918
2919 ctf_encoding_t e;
2920 ctf_arinfo_t r;
2921 ctf_id_t type, base;
2922 uint_t kind;
2923
2924 if (dnp->dn_op == DT_TOK_PREINC || dnp->dn_op == DT_TOK_POSTINC ||
2925 dnp->dn_op == DT_TOK_PREDEC || dnp->dn_op == DT_TOK_POSTDEC)
2926 idflags = DT_IDFLG_REF | DT_IDFLG_MOD;
2927 else
2928 idflags = DT_IDFLG_REF;
2929
2930 /*
2931 * We allow the unary ++ and -- operators to instantiate new scalar
2932 * variables if applied to an identifier; otherwise just cook as usual.
2933 */
2934 if (cp->dn_kind == DT_NODE_IDENT && (idflags & DT_IDFLG_MOD))
2935 dt_xcook_ident(cp, dtp->dt_globals, DT_IDENT_SCALAR, B_TRUE);
2936
2937 cp = dnp->dn_child = dt_node_cook(cp, 0); /* don't set idflags yet */
2938
2939 if (cp->dn_kind == DT_NODE_VAR && dt_ident_unref(cp->dn_ident)) {
2940 if (dt_type_lookup("int64_t", &dtt) != 0)
2941 xyerror(D_TYPE_ERR, "failed to lookup int64_t\n");
2942
2943 dt_ident_type_assign(cp->dn_ident, dtt.dtt_ctfp, dtt.dtt_type);
2944 dt_node_type_assign(cp, dtt.dtt_ctfp, dtt.dtt_type,
2945 dtt.dtt_flags);
2946 }
2947
2948 if (cp->dn_kind == DT_NODE_VAR)
2949 cp->dn_ident->di_flags |= idflags;
2950
2951 switch (dnp->dn_op) {
2952 case DT_TOK_DEREF:
2953 /*
2954 * If the deref operator is applied to a translated pointer,
2955 * we set our output type to the output of the translation.
2956 */
2957 if ((idp = dt_node_resolve(cp, DT_IDENT_XLPTR)) != NULL) {
2958 dt_xlator_t *dxp = idp->di_data;
2959
2960 dnp->dn_ident = &dxp->dx_souid;
2961 dt_node_type_assign(dnp,
2962 dnp->dn_ident->di_ctfp, dnp->dn_ident->di_type,
2963 cp->dn_flags & DT_NF_USERLAND);
2964 break;
2965 }
2966
2967 type = ctf_type_resolve(cp->dn_ctfp, cp->dn_type);
2968 kind = ctf_type_kind(cp->dn_ctfp, type);
2969
2970 if (kind == CTF_K_ARRAY) {
2971 if (ctf_array_info(cp->dn_ctfp, type, &r) != 0) {
2972 dtp->dt_ctferr = ctf_errno(cp->dn_ctfp);
2973 longjmp(yypcb->pcb_jmpbuf, EDT_CTF);
2974 } else
2975 type = r.ctr_contents;
2976 } else if (kind == CTF_K_POINTER) {
2977 type = ctf_type_reference(cp->dn_ctfp, type);
2978 } else {
2979 xyerror(D_DEREF_NONPTR,
2980 "cannot dereference non-pointer type\n");
2981 }
2982
2983 dt_node_type_assign(dnp, cp->dn_ctfp, type,
2984 cp->dn_flags & DT_NF_USERLAND);
2985 base = ctf_type_resolve(cp->dn_ctfp, type);
2986 kind = ctf_type_kind(cp->dn_ctfp, base);
2987
2988 if (kind == CTF_K_INTEGER && ctf_type_encoding(cp->dn_ctfp,
2989 base, &e) == 0 && IS_VOID(e)) {
2990 xyerror(D_DEREF_VOID,
2991 "cannot dereference pointer to void\n");
2992 }
2993
2994 if (kind == CTF_K_FUNCTION) {
2995 xyerror(D_DEREF_FUNC,
2996 "cannot dereference pointer to function\n");
2997 }
2998
2999 if (kind != CTF_K_ARRAY || dt_node_is_string(dnp))
3000 dnp->dn_flags |= DT_NF_LVALUE; /* see K&R[A7.4.3] */
3001
3002 /*
3003 * If we propagated the l-value bit and the child operand was
3004 * a writable D variable or a binary operation of the form
3005 * a + b where a is writable, then propagate the writable bit.
3006 * This is necessary to permit assignments to scalar arrays,
3007 * which are converted to expressions of the form *(a + i).
3008 */
3009 if ((cp->dn_flags & DT_NF_WRITABLE) ||
3010 (cp->dn_kind == DT_NODE_OP2 && cp->dn_op == DT_TOK_ADD &&
3011 (cp->dn_left->dn_flags & DT_NF_WRITABLE)))
3012 dnp->dn_flags |= DT_NF_WRITABLE;
3013
3014 if ((cp->dn_flags & DT_NF_USERLAND) &&
3015 (kind == CTF_K_POINTER || (dnp->dn_flags & DT_NF_REF)))
3016 dnp->dn_flags |= DT_NF_USERLAND;
3017 break;
3018
3019 case DT_TOK_IPOS:
3020 case DT_TOK_INEG:
3021 if (!dt_node_is_arith(cp)) {
3022 xyerror(D_OP_ARITH, "operator %s requires an operand "
3023 "of arithmetic type\n", opstr(dnp->dn_op));
3024 }
3025 dt_node_type_propagate(cp, dnp); /* see K&R[A7.4.4-6] */
3026 break;
3027
3028 case DT_TOK_BNEG:
3029 if (!dt_node_is_integer(cp)) {
3030 xyerror(D_OP_INT, "operator %s requires an operand of "
3031 "integral type\n", opstr(dnp->dn_op));
3032 }
3033 dt_node_type_propagate(cp, dnp); /* see K&R[A7.4.4-6] */
3034 break;
3035
3036 case DT_TOK_LNEG:
3037 if (!dt_node_is_scalar(cp)) {
3038 xyerror(D_OP_SCALAR, "operator %s requires an operand "
3039 "of scalar type\n", opstr(dnp->dn_op));
3040 }
3041 dt_node_type_assign(dnp, DT_INT_CTFP(dtp), DT_INT_TYPE(dtp),
3042 B_FALSE);
3043 break;
3044
3045 case DT_TOK_ADDROF:
3046 if (cp->dn_kind == DT_NODE_VAR || cp->dn_kind == DT_NODE_AGG) {
3047 xyerror(D_ADDROF_VAR,
3048 "cannot take address of dynamic variable\n");
3049 }
3050
3051 if (dt_node_is_dynamic(cp)) {
3052 xyerror(D_ADDROF_VAR,
3053 "cannot take address of dynamic object\n");
3054 }
3055
3056 if (!(cp->dn_flags & DT_NF_LVALUE)) {
3057 xyerror(D_ADDROF_LVAL, /* see K&R[A7.4.2] */
3058 "unacceptable operand for unary & operator\n");
3059 }
3060
3061 if (cp->dn_flags & DT_NF_BITFIELD) {
3062 xyerror(D_ADDROF_BITFIELD,
3063 "cannot take address of bit-field\n");
3064 }
3065
3066 dtt.dtt_object = NULL;
3067 dtt.dtt_ctfp = cp->dn_ctfp;
3068 dtt.dtt_type = cp->dn_type;
3069
3070 if (dt_type_pointer(&dtt) == -1) {
3071 xyerror(D_TYPE_ERR, "cannot find type for \"&\": %s*\n",
3072 dt_node_type_name(cp, n, sizeof (n)));
3073 }
3074
3075 dt_node_type_assign(dnp, dtt.dtt_ctfp, dtt.dtt_type,
3076 cp->dn_flags & DT_NF_USERLAND);
3077 break;
3078
3079 case DT_TOK_SIZEOF:
3080 if (cp->dn_flags & DT_NF_BITFIELD) {
3081 xyerror(D_SIZEOF_BITFIELD,
3082 "cannot apply sizeof to a bit-field\n");
3083 }
3084
3085 if (dt_node_sizeof(cp) == 0) {
3086 xyerror(D_SIZEOF_TYPE, "cannot apply sizeof to an "
3087 "operand of unknown size\n");
3088 }
3089
3090 dt_node_type_assign(dnp, dtp->dt_ddefs->dm_ctfp,
3091 ctf_lookup_by_name(dtp->dt_ddefs->dm_ctfp, "size_t"),
3092 B_FALSE);
3093 break;
3094
3095 case DT_TOK_STRINGOF:
3096 if (!dt_node_is_scalar(cp) && !dt_node_is_pointer(cp) &&
3097 !dt_node_is_strcompat(cp)) {
3098 xyerror(D_STRINGOF_TYPE,
3099 "cannot apply stringof to a value of type %s\n",
3100 dt_node_type_name(cp, n, sizeof (n)));
3101 }
3102 dt_node_type_assign(dnp, DT_STR_CTFP(dtp), DT_STR_TYPE(dtp),
3103 cp->dn_flags & DT_NF_USERLAND);
3104 break;
3105
3106 case DT_TOK_PREINC:
3107 case DT_TOK_POSTINC:
3108 case DT_TOK_PREDEC:
3109 case DT_TOK_POSTDEC:
3110 if (dt_node_is_scalar(cp) == 0) {
3111 xyerror(D_OP_SCALAR, "operator %s requires operand of "
3112 "scalar type\n", opstr(dnp->dn_op));
3113 }
3114
3115 if (dt_node_is_vfptr(cp)) {
3116 xyerror(D_OP_VFPTR, "operator %s requires an operand "
3117 "of known size\n", opstr(dnp->dn_op));
3118 }
3119
3120 if (!(cp->dn_flags & DT_NF_LVALUE)) {
3121 xyerror(D_OP_LVAL, "operator %s requires modifiable "
3122 "lvalue as an operand\n", opstr(dnp->dn_op));
3123 }
3124
3125 if (!(cp->dn_flags & DT_NF_WRITABLE)) {
3126 xyerror(D_OP_WRITE, "operator %s can only be applied "
3127 "to a writable variable\n", opstr(dnp->dn_op));
3128 }
3129
3130 dt_node_type_propagate(cp, dnp); /* see K&R[A7.4.1] */
3131 break;
3132
3133 default:
3134 xyerror(D_UNKNOWN, "invalid unary op %s\n", opstr(dnp->dn_op));
3135 }
3136
3137 dt_node_attr_assign(dnp, cp->dn_attr);
3138 return (dnp);
3139 }
3140
3141 static void
3142 dt_assign_common(dt_node_t *dnp)
3143 {
3144 dt_node_t *lp = dnp->dn_left;
3145 dt_node_t *rp = dnp->dn_right;
3146 int op = dnp->dn_op;
3147
3148 if (rp->dn_kind == DT_NODE_INT)
3149 dt_cast(lp, rp);
3150
3151 if (!(lp->dn_flags & DT_NF_LVALUE)) {
3152 xyerror(D_OP_LVAL, "operator %s requires modifiable "
3153 "lvalue as an operand\n", opstr(op));
3154 /* see K&R[A7.17] */
3155 }
3156
3157 if (!(lp->dn_flags & DT_NF_WRITABLE)) {
3158 xyerror(D_OP_WRITE, "operator %s can only be applied "
3159 "to a writable variable\n", opstr(op));
3160 }
3161
3162 dt_node_type_propagate(lp, dnp); /* see K&R[A7.17] */
3163 dt_node_attr_assign(dnp, dt_attr_min(lp->dn_attr, rp->dn_attr));
3164 }
3165
3166 static dt_node_t *
3167 dt_cook_op2(dt_node_t *dnp, uint_t idflags)
3168 {
3169 dtrace_hdl_t *dtp = yypcb->pcb_hdl;
3170 dt_node_t *lp = dnp->dn_left;
3171 dt_node_t *rp = dnp->dn_right;
3172 int op = dnp->dn_op;
3173
3174 ctf_membinfo_t m;
3175 ctf_file_t *ctfp;
3176 ctf_id_t type;
3177 int kind, val, uref;
3178 dt_ident_t *idp;
3179
3180 char n1[DT_TYPE_NAMELEN];
3181 char n2[DT_TYPE_NAMELEN];
3182
3183 /*
3184 * The expression E1[E2] is identical by definition to *((E1)+(E2)) so
3185 * we convert "[" to "+" and glue on "*" at the end (see K&R[A7.3.1])
3186 * unless the left-hand side is an untyped D scalar, associative array,
3187 * or aggregation. In these cases, we proceed to case DT_TOK_LBRAC and
3188 * handle associative array and aggregation references there.
3189 */
3190 if (op == DT_TOK_LBRAC) {
3191 if (lp->dn_kind == DT_NODE_IDENT) {
3192 dt_idhash_t *dhp;
3193 uint_t idkind;
3194
3195 if (lp->dn_op == DT_TOK_AGG) {
3196 dhp = dtp->dt_aggs;
3197 idp = dt_idhash_lookup(dhp, lp->dn_string + 1);
3198 idkind = DT_IDENT_AGG;
3199 } else {
3200 dhp = dtp->dt_globals;
3201 idp = dt_idstack_lookup(
3202 &yypcb->pcb_globals, lp->dn_string);
3203 idkind = DT_IDENT_ARRAY;
3204 }
3205
3206 if (idp == NULL || dt_ident_unref(idp))
3207 dt_xcook_ident(lp, dhp, idkind, B_TRUE);
3208 else
3209 dt_xcook_ident(lp, dhp, idp->di_kind, B_FALSE);
3210 } else {
3211 lp = dnp->dn_left = dt_node_cook(lp, 0);
3212 }
3213
3214 /*
3215 * Switch op to '+' for *(E1 + E2) array mode in these cases:
3216 * (a) lp is a DT_IDENT_ARRAY variable that has already been
3217 * referenced using [] notation (dn_args != NULL).
3218 * (b) lp is a non-ARRAY variable that has already been given
3219 * a type by assignment or declaration (!dt_ident_unref())
3220 * (c) lp is neither a variable nor an aggregation
3221 */
3222 if (lp->dn_kind == DT_NODE_VAR) {
3223 if (lp->dn_ident->di_kind == DT_IDENT_ARRAY) {
3224 if (lp->dn_args != NULL)
3225 op = DT_TOK_ADD;
3226 } else if (!dt_ident_unref(lp->dn_ident)) {
3227 op = DT_TOK_ADD;
3228 }
3229 } else if (lp->dn_kind != DT_NODE_AGG) {
3230 op = DT_TOK_ADD;
3231 }
3232 }
3233
3234 switch (op) {
3235 case DT_TOK_BAND:
3236 case DT_TOK_XOR:
3237 case DT_TOK_BOR:
3238 lp = dnp->dn_left = dt_node_cook(lp, DT_IDFLG_REF);
3239 rp = dnp->dn_right = dt_node_cook(rp, DT_IDFLG_REF);
3240
3241 if (!dt_node_is_integer(lp) || !dt_node_is_integer(rp)) {
3242 xyerror(D_OP_INT, "operator %s requires operands of "
3243 "integral type\n", opstr(op));
3244 }
3245
3246 dt_node_promote(lp, rp, dnp); /* see K&R[A7.11-13] */
3247 break;
3248
3249 case DT_TOK_LSH:
3250 case DT_TOK_RSH:
3251 lp = dnp->dn_left = dt_node_cook(lp, DT_IDFLG_REF);
3252 rp = dnp->dn_right = dt_node_cook(rp, DT_IDFLG_REF);
3253
3254 if (!dt_node_is_integer(lp) || !dt_node_is_integer(rp)) {
3255 xyerror(D_OP_INT, "operator %s requires operands of "
3256 "integral type\n", opstr(op));
3257 }
3258
3259 dt_node_type_propagate(lp, dnp); /* see K&R[A7.8] */
3260 dt_node_attr_assign(dnp, dt_attr_min(lp->dn_attr, rp->dn_attr));
3261 break;
3262
3263 case DT_TOK_MOD:
3264 lp = dnp->dn_left = dt_node_cook(lp, DT_IDFLG_REF);
3265 rp = dnp->dn_right = dt_node_cook(rp, DT_IDFLG_REF);
3266
3267 if (!dt_node_is_integer(lp) || !dt_node_is_integer(rp)) {
3268 xyerror(D_OP_INT, "operator %s requires operands of "
3269 "integral type\n", opstr(op));
3270 }
3271
3272 dt_node_promote(lp, rp, dnp); /* see K&R[A7.6] */
3273 break;
3274
3275 case DT_TOK_MUL:
3276 case DT_TOK_DIV:
3277 lp = dnp->dn_left = dt_node_cook(lp, DT_IDFLG_REF);
3278 rp = dnp->dn_right = dt_node_cook(rp, DT_IDFLG_REF);
3279
3280 if (!dt_node_is_arith(lp) || !dt_node_is_arith(rp)) {
3281 xyerror(D_OP_ARITH, "operator %s requires operands of "
3282 "arithmetic type\n", opstr(op));
3283 }
3284
3285 dt_node_promote(lp, rp, dnp); /* see K&R[A7.6] */
3286 break;
3287
3288 case DT_TOK_LAND:
3289 case DT_TOK_LXOR:
3290 case DT_TOK_LOR:
3291 lp = dnp->dn_left = dt_node_cook(lp, DT_IDFLG_REF);
3292 rp = dnp->dn_right = dt_node_cook(rp, DT_IDFLG_REF);
3293
3294 if (!dt_node_is_scalar(lp) || !dt_node_is_scalar(rp)) {
3295 xyerror(D_OP_SCALAR, "operator %s requires operands "
3296 "of scalar type\n", opstr(op));
3297 }
3298
3299 dt_node_type_assign(dnp, DT_INT_CTFP(dtp), DT_INT_TYPE(dtp),
3300 B_FALSE);
3301 dt_node_attr_assign(dnp, dt_attr_min(lp->dn_attr, rp->dn_attr));
3302 break;
3303
3304 case DT_TOK_LT:
3305 case DT_TOK_LE:
3306 case DT_TOK_GT:
3307 case DT_TOK_GE:
3308 case DT_TOK_EQU:
3309 case DT_TOK_NEQ:
3310 /*
3311 * The D comparison operators provide the ability to transform
3312 * a right-hand identifier into a corresponding enum tag value
3313 * if the left-hand side is an enum type. To do this, we cook
3314 * the left-hand side, and then see if the right-hand side is
3315 * an unscoped identifier defined in the enum. If so, we
3316 * convert into an integer constant node with the tag's value.
3317 */
3318 lp = dnp->dn_left = dt_node_cook(lp, DT_IDFLG_REF);
3319
3320 kind = ctf_type_kind(lp->dn_ctfp,
3321 ctf_type_resolve(lp->dn_ctfp, lp->dn_type));
3322
3323 if (kind == CTF_K_ENUM && rp->dn_kind == DT_NODE_IDENT &&
3324 strchr(rp->dn_string, '`') == NULL && ctf_enum_value(
3325 lp->dn_ctfp, lp->dn_type, rp->dn_string, &val) == 0) {
3326
3327 if ((idp = dt_idstack_lookup(&yypcb->pcb_globals,
3328 rp->dn_string)) != NULL) {
3329 xyerror(D_IDENT_AMBIG,
3330 "ambiguous use of operator %s: %s is "
3331 "both a %s enum tag and a global %s\n",
3332 opstr(op), rp->dn_string,
3333 dt_node_type_name(lp, n1, sizeof (n1)),
3334 dt_idkind_name(idp->di_kind));
3335 }
3336
3337 free(rp->dn_string);
3338 rp->dn_string = NULL;
3339 rp->dn_kind = DT_NODE_INT;
3340 rp->dn_flags |= DT_NF_COOKED;
3341 rp->dn_op = DT_TOK_INT;
3342 rp->dn_value = (intmax_t)val;
3343
3344 dt_node_type_assign(rp, lp->dn_ctfp, lp->dn_type,
3345 B_FALSE);
3346 dt_node_attr_assign(rp, _dtrace_symattr);
3347 }
3348
3349 rp = dnp->dn_right = dt_node_cook(rp, DT_IDFLG_REF);
3350
3351 /*
3352 * The rules for type checking for the relational operators are
3353 * described in the ANSI-C spec (see K&R[A7.9-10]). We perform
3354 * the various tests in order from least to most expensive. We
3355 * also allow derived strings to be compared as a first-class
3356 * type (resulting in a strcmp(3C)-style comparison), and we
3357 * slightly relax the A7.9 rules to permit void pointer
3358 * comparisons as in A7.10. Our users won't be confused by
3359 * this since they understand pointers are just numbers, and
3360 * relaxing this constraint simplifies the implementation.
3361 */
3362 if (ctf_type_compat(lp->dn_ctfp, lp->dn_type,
3363 rp->dn_ctfp, rp->dn_type))
3364 /*EMPTY*/;
3365 else if (dt_node_is_integer(lp) && dt_node_is_integer(rp))
3366 /*EMPTY*/;
3367 else if (dt_node_is_strcompat(lp) && dt_node_is_strcompat(rp) &&
3368 (dt_node_is_string(lp) || dt_node_is_string(rp)))
3369 /*EMPTY*/;
3370 else if (dt_node_is_ptrcompat(lp, rp, NULL, NULL) == 0) {
3371 xyerror(D_OP_INCOMPAT, "operands have "
3372 "incompatible types: \"%s\" %s \"%s\"\n",
3373 dt_node_type_name(lp, n1, sizeof (n1)), opstr(op),
3374 dt_node_type_name(rp, n2, sizeof (n2)));
3375 }
3376
3377 dt_node_type_assign(dnp, DT_INT_CTFP(dtp), DT_INT_TYPE(dtp),
3378 B_FALSE);
3379 dt_node_attr_assign(dnp, dt_attr_min(lp->dn_attr, rp->dn_attr));
3380 break;
3381
3382 case DT_TOK_ADD:
3383 case DT_TOK_SUB: {
3384 /*
3385 * The rules for type checking for the additive operators are
3386 * described in the ANSI-C spec (see K&R[A7.7]). Pointers and
3387 * integers may be manipulated according to specific rules. In
3388 * these cases D permits strings to be treated as pointers.
3389 */
3390 int lp_is_ptr, lp_is_int, rp_is_ptr, rp_is_int;
3391
3392 lp = dnp->dn_left = dt_node_cook(lp, DT_IDFLG_REF);
3393 rp = dnp->dn_right = dt_node_cook(rp, DT_IDFLG_REF);
3394
3395 lp_is_ptr = dt_node_is_string(lp) ||
3396 (dt_node_is_pointer(lp) && !dt_node_is_vfptr(lp));
3397 lp_is_int = dt_node_is_integer(lp);
3398
3399 rp_is_ptr = dt_node_is_string(rp) ||
3400 (dt_node_is_pointer(rp) && !dt_node_is_vfptr(rp));
3401 rp_is_int = dt_node_is_integer(rp);
3402
3403 if (lp_is_int && rp_is_int) {
3404 dt_type_promote(lp, rp, &ctfp, &type);
3405 uref = 0;
3406 } else if (lp_is_ptr && rp_is_int) {
3407 ctfp = lp->dn_ctfp;
3408 type = lp->dn_type;
3409 uref = lp->dn_flags & DT_NF_USERLAND;
3410 } else if (lp_is_int && rp_is_ptr && op == DT_TOK_ADD) {
3411 ctfp = rp->dn_ctfp;
3412 type = rp->dn_type;
3413 uref = rp->dn_flags & DT_NF_USERLAND;
3414 } else if (lp_is_ptr && rp_is_ptr && op == DT_TOK_SUB &&
3415 dt_node_is_ptrcompat(lp, rp, NULL, NULL)) {
3416 ctfp = dtp->dt_ddefs->dm_ctfp;
3417 type = ctf_lookup_by_name(ctfp, "ptrdiff_t");
3418 uref = 0;
3419 } else {
3420 xyerror(D_OP_INCOMPAT, "operands have incompatible "
3421 "types: \"%s\" %s \"%s\"\n",
3422 dt_node_type_name(lp, n1, sizeof (n1)), opstr(op),
3423 dt_node_type_name(rp, n2, sizeof (n2)));
3424 }
3425
3426 dt_node_type_assign(dnp, ctfp, type, B_FALSE);
3427 dt_node_attr_assign(dnp, dt_attr_min(lp->dn_attr, rp->dn_attr));
3428
3429 if (uref)
3430 dnp->dn_flags |= DT_NF_USERLAND;
3431 break;
3432 }
3433
3434 case DT_TOK_OR_EQ:
3435 case DT_TOK_XOR_EQ:
3436 case DT_TOK_AND_EQ:
3437 case DT_TOK_LSH_EQ:
3438 case DT_TOK_RSH_EQ:
3439 case DT_TOK_MOD_EQ:
3440 if (lp->dn_kind == DT_NODE_IDENT) {
3441 dt_xcook_ident(lp, dtp->dt_globals,
3442 DT_IDENT_SCALAR, B_TRUE);
3443 }
3444
3445 lp = dnp->dn_left =
3446 dt_node_cook(lp, DT_IDFLG_REF | DT_IDFLG_MOD);
3447
3448 rp = dnp->dn_right =
3449 dt_node_cook(rp, DT_IDFLG_REF | DT_IDFLG_MOD);
3450
3451 if (!dt_node_is_integer(lp) || !dt_node_is_integer(rp)) {
3452 xyerror(D_OP_INT, "operator %s requires operands of "
3453 "integral type\n", opstr(op));
3454 }
3455 goto asgn_common;
3456
3457 case DT_TOK_MUL_EQ:
3458 case DT_TOK_DIV_EQ:
3459 if (lp->dn_kind == DT_NODE_IDENT) {
3460 dt_xcook_ident(lp, dtp->dt_globals,
3461 DT_IDENT_SCALAR, B_TRUE);
3462 }
3463
3464 lp = dnp->dn_left =
3465 dt_node_cook(lp, DT_IDFLG_REF | DT_IDFLG_MOD);
3466
3467 rp = dnp->dn_right =
3468 dt_node_cook(rp, DT_IDFLG_REF | DT_IDFLG_MOD);
3469
3470 if (!dt_node_is_arith(lp) || !dt_node_is_arith(rp)) {
3471 xyerror(D_OP_ARITH, "operator %s requires operands of "
3472 "arithmetic type\n", opstr(op));
3473 }
3474 goto asgn_common;
3475
3476 case DT_TOK_ASGN:
3477 /*
3478 * If the left-hand side is an identifier, attempt to resolve
3479 * it as either an aggregation or scalar variable. We pass
3480 * B_TRUE to dt_xcook_ident to indicate that a new variable can
3481 * be created if no matching variable exists in the namespace.
3482 */
3483 if (lp->dn_kind == DT_NODE_IDENT) {
3484 if (lp->dn_op == DT_TOK_AGG) {
3485 dt_xcook_ident(lp, dtp->dt_aggs,
3486 DT_IDENT_AGG, B_TRUE);
3487 } else {
3488 dt_xcook_ident(lp, dtp->dt_globals,
3489 DT_IDENT_SCALAR, B_TRUE);
3490 }
3491 }
3492
3493 lp = dnp->dn_left = dt_node_cook(lp, 0); /* don't set mod yet */
3494 rp = dnp->dn_right = dt_node_cook(rp, DT_IDFLG_REF);
3495
3496 /*
3497 * If the left-hand side is an aggregation, verify that we are
3498 * assigning it the result of an aggregating function. Once
3499 * we've done so, hide the func node in the aggregation and
3500 * return the aggregation itself up to the parse tree parent.
3501 * This transformation is legal since the assigned function
3502 * cannot change identity across disjoint cooking passes and
3503 * the argument list subtree is retained for later cooking.
3504 */
3505 if (lp->dn_kind == DT_NODE_AGG) {
3506 const char *aname = lp->dn_ident->di_name;
3507 dt_ident_t *oid = lp->dn_ident->di_iarg;
3508
3509 if (rp->dn_kind != DT_NODE_FUNC ||
3510 rp->dn_ident->di_kind != DT_IDENT_AGGFUNC) {
3511 xyerror(D_AGG_FUNC,
3512 "@%s must be assigned the result of "
3513 "an aggregating function\n", aname);
3514 }
3515
3516 if (oid != NULL && oid != rp->dn_ident) {
3517 xyerror(D_AGG_REDEF,
3518 "aggregation redefined: @%s\n\t "
3519 "current: @%s = %s( )\n\tprevious: @%s = "
3520 "%s( ) : line %d\n", aname, aname,
3521 rp->dn_ident->di_name, aname, oid->di_name,
3522 lp->dn_ident->di_lineno);
3523 } else if (oid == NULL)
3524 lp->dn_ident->di_iarg = rp->dn_ident;
3525
3526 /*
3527 * Do not allow multiple aggregation assignments in a
3528 * single statement, e.g. (@a = count()) = count();
3529 * We produce a message as if the result of aggregating
3530 * function does not propagate DT_NF_LVALUE.
3531 */
3532 if (lp->dn_aggfun != NULL) {
3533 xyerror(D_OP_LVAL, "operator = requires "
3534 "modifiable lvalue as an operand\n");
3535 }
3536
3537 lp->dn_aggfun = rp;
3538 lp = dt_node_cook(lp, DT_IDFLG_MOD);
3539
3540 dnp->dn_left = dnp->dn_right = NULL;
3541 dt_node_free(dnp);
3542
3543 return (lp);
3544 }
3545
3546 /*
3547 * If the right-hand side is a dynamic variable that is the
3548 * output of a translator, our result is the translated type.
3549 */
3550 if ((idp = dt_node_resolve(rp, DT_IDENT_XLSOU)) != NULL) {
3551 ctfp = idp->di_ctfp;
3552 type = idp->di_type;
3553 uref = idp->di_flags & DT_IDFLG_USER;
3554 } else {
3555 ctfp = rp->dn_ctfp;
3556 type = rp->dn_type;
3557 uref = rp->dn_flags & DT_NF_USERLAND;
3558 }
3559
3560 /*
3561 * If the left-hand side of an assignment statement is a virgin
3562 * variable created by this compilation pass, reset the type of
3563 * this variable to the type of the right-hand side.
3564 */
3565 if (lp->dn_kind == DT_NODE_VAR &&
3566 dt_ident_unref(lp->dn_ident)) {
3567 dt_node_type_assign(lp, ctfp, type, B_FALSE);
3568 dt_ident_type_assign(lp->dn_ident, ctfp, type);
3569
3570 if (uref) {
3571 lp->dn_flags |= DT_NF_USERLAND;
3572 lp->dn_ident->di_flags |= DT_IDFLG_USER;
3573 }
3574 }
3575
3576 if (lp->dn_kind == DT_NODE_VAR)
3577 lp->dn_ident->di_flags |= DT_IDFLG_MOD;
3578
3579 /*
3580 * The rules for type checking for the assignment operators are
3581 * described in the ANSI-C spec (see K&R[A7.17]). We share
3582 * most of this code with the argument list checking code.
3583 */
3584 if (!dt_node_is_string(lp)) {
3585 kind = ctf_type_kind(lp->dn_ctfp,
3586 ctf_type_resolve(lp->dn_ctfp, lp->dn_type));
3587
3588 if (kind == CTF_K_ARRAY || kind == CTF_K_FUNCTION) {
3589 xyerror(D_OP_ARRFUN, "operator %s may not be "
3590 "applied to operand of type \"%s\"\n",
3591 opstr(op),
3592 dt_node_type_name(lp, n1, sizeof (n1)));
3593 }
3594 }
3595
3596 if (idp != NULL && idp->di_kind == DT_IDENT_XLSOU &&
3597 ctf_type_compat(lp->dn_ctfp, lp->dn_type, ctfp, type))
3598 goto asgn_common;
3599
3600 if (dt_node_is_argcompat(lp, rp))
3601 goto asgn_common;
3602
3603 xyerror(D_OP_INCOMPAT,
3604 "operands have incompatible types: \"%s\" %s \"%s\"\n",
3605 dt_node_type_name(lp, n1, sizeof (n1)), opstr(op),
3606 dt_node_type_name(rp, n2, sizeof (n2)));
3607 /*NOTREACHED*/
3608
3609 case DT_TOK_ADD_EQ:
3610 case DT_TOK_SUB_EQ:
3611 if (lp->dn_kind == DT_NODE_IDENT) {
3612 dt_xcook_ident(lp, dtp->dt_globals,
3613 DT_IDENT_SCALAR, B_TRUE);
3614 }
3615
3616 lp = dnp->dn_left =
3617 dt_node_cook(lp, DT_IDFLG_REF | DT_IDFLG_MOD);
3618
3619 rp = dnp->dn_right =
3620 dt_node_cook(rp, DT_IDFLG_REF | DT_IDFLG_MOD);
3621
3622 if (dt_node_is_string(lp) || dt_node_is_string(rp)) {
3623 xyerror(D_OP_INCOMPAT, "operands have "
3624 "incompatible types: \"%s\" %s \"%s\"\n",
3625 dt_node_type_name(lp, n1, sizeof (n1)), opstr(op),
3626 dt_node_type_name(rp, n2, sizeof (n2)));
3627 }
3628
3629 /*
3630 * The rules for type checking for the assignment operators are
3631 * described in the ANSI-C spec (see K&R[A7.17]). To these
3632 * rules we add that only writable D nodes can be modified.
3633 */
3634 if (dt_node_is_integer(lp) == 0 ||
3635 dt_node_is_integer(rp) == 0) {
3636 if (!dt_node_is_pointer(lp) || dt_node_is_vfptr(lp)) {
3637 xyerror(D_OP_VFPTR,
3638 "operator %s requires left-hand scalar "
3639 "operand of known size\n", opstr(op));
3640 } else if (dt_node_is_integer(rp) == 0 &&
3641 dt_node_is_ptrcompat(lp, rp, NULL, NULL) == 0) {
3642 xyerror(D_OP_INCOMPAT, "operands have "
3643 "incompatible types: \"%s\" %s \"%s\"\n",
3644 dt_node_type_name(lp, n1, sizeof (n1)),
3645 opstr(op),
3646 dt_node_type_name(rp, n2, sizeof (n2)));
3647 }
3648 }
3649 asgn_common:
3650 dt_assign_common(dnp);
3651 break;
3652
3653 case DT_TOK_PTR:
3654 /*
3655 * If the left-hand side of operator -> is one of the
3656 * scoping keywords, permit a local or thread
3657 * variable to be created or referenced.
3658 */
3659 if (lp->dn_kind == DT_NODE_IDENT) {
3660 dt_idhash_t *dhp = NULL;
3661
3662 if (strcmp(lp->dn_string, "self") == 0) {
3663 dhp = dtp->dt_tls;
3664 } else if (strcmp(lp->dn_string, "this") == 0) {
3665 dhp = yypcb->pcb_locals;
3666 }
3667 if (dhp != NULL) {
3668 if (rp->dn_kind != DT_NODE_VAR) {
3669 dt_xcook_ident(rp, dhp,
3670 DT_IDENT_SCALAR, B_TRUE);
3671 }
3672
3673 if (idflags != 0)
3674 rp = dt_node_cook(rp, idflags);
3675
3676 /* avoid freeing rp */
3677 dnp->dn_right = dnp->dn_left;
3678 dt_node_free(dnp);
3679 return (rp);
3680 }
3681 }
3682 /*FALLTHRU*/
3683 case DT_TOK_DOT:
3684 lp = dnp->dn_left = dt_node_cook(lp, DT_IDFLG_REF);
3685
3686 if (rp->dn_kind != DT_NODE_IDENT) {
3687 xyerror(D_OP_IDENT, "operator %s must be followed by "
3688 "an identifier\n", opstr(op));
3689 }
3690
3691 if ((idp = dt_node_resolve(lp, DT_IDENT_XLSOU)) != NULL ||
3692 (idp = dt_node_resolve(lp, DT_IDENT_XLPTR)) != NULL) {
3693 /*
3694 * If the left-hand side is a translated struct or ptr,
3695 * the type of the left is the translation output type.
3696 */
3697 dt_xlator_t *dxp = idp->di_data;
3698
3699 if (dt_xlator_member(dxp, rp->dn_string) == NULL) {
3700 xyerror(D_XLATE_NOCONV,
3701 "translator does not define conversion "
3702 "for member: %s\n", rp->dn_string);
3703 }
3704
3705 ctfp = idp->di_ctfp;
3706 type = ctf_type_resolve(ctfp, idp->di_type);
3707 uref = idp->di_flags & DT_IDFLG_USER;
3708 } else {
3709 ctfp = lp->dn_ctfp;
3710 type = ctf_type_resolve(ctfp, lp->dn_type);
3711 uref = lp->dn_flags & DT_NF_USERLAND;
3712 }
3713
3714 kind = ctf_type_kind(ctfp, type);
3715
3716 if (op == DT_TOK_PTR) {
3717 if (kind != CTF_K_POINTER) {
3718 xyerror(D_OP_PTR, "operator %s must be "
3719 "applied to a pointer\n", opstr(op));
3720 }
3721 type = ctf_type_reference(ctfp, type);
3722 type = ctf_type_resolve(ctfp, type);
3723 kind = ctf_type_kind(ctfp, type);
3724 }
3725
3726 /*
3727 * If we follow a reference to a forward declaration tag,
3728 * search the entire type space for the actual definition.
3729 */
3730 while (kind == CTF_K_FORWARD) {
3731 char *tag = ctf_type_name(ctfp, type, n1, sizeof (n1));
3732 dtrace_typeinfo_t dtt;
3733
3734 if (tag != NULL && dt_type_lookup(tag, &dtt) == 0 &&
3735 (dtt.dtt_ctfp != ctfp || dtt.dtt_type != type)) {
3736 ctfp = dtt.dtt_ctfp;
3737 type = ctf_type_resolve(ctfp, dtt.dtt_type);
3738 kind = ctf_type_kind(ctfp, type);
3739 } else {
3740 xyerror(D_OP_INCOMPLETE,
3741 "operator %s cannot be applied to a "
3742 "forward declaration: no %s definition "
3743 "is available\n", opstr(op), tag);
3744 }
3745 }
3746
3747 if (kind != CTF_K_STRUCT && kind != CTF_K_UNION) {
3748 if (op == DT_TOK_PTR) {
3749 xyerror(D_OP_SOU, "operator -> cannot be "
3750 "applied to pointer to type \"%s\"; must "
3751 "be applied to a struct or union pointer\n",
3752 ctf_type_name(ctfp, type, n1, sizeof (n1)));
3753 } else {
3754 xyerror(D_OP_SOU, "operator %s cannot be "
3755 "applied to type \"%s\"; must be applied "
3756 "to a struct or union\n", opstr(op),
3757 ctf_type_name(ctfp, type, n1, sizeof (n1)));
3758 }
3759 }
3760
3761 if (ctf_member_info(ctfp, type, rp->dn_string, &m) == CTF_ERR) {
3762 xyerror(D_TYPE_MEMBER,
3763 "%s is not a member of %s\n", rp->dn_string,
3764 ctf_type_name(ctfp, type, n1, sizeof (n1)));
3765 }
3766
3767 type = ctf_type_resolve(ctfp, m.ctm_type);
3768 kind = ctf_type_kind(ctfp, type);
3769
3770 dt_node_type_assign(dnp, ctfp, m.ctm_type, B_FALSE);
3771 dt_node_attr_assign(dnp, lp->dn_attr);
3772
3773 if (op == DT_TOK_PTR && (kind != CTF_K_ARRAY ||
3774 dt_node_is_string(dnp)))
3775 dnp->dn_flags |= DT_NF_LVALUE; /* see K&R[A7.3.3] */
3776
3777 if (op == DT_TOK_DOT && (lp->dn_flags & DT_NF_LVALUE) &&
3778 (kind != CTF_K_ARRAY || dt_node_is_string(dnp)))
3779 dnp->dn_flags |= DT_NF_LVALUE; /* see K&R[A7.3.3] */
3780
3781 if (lp->dn_flags & DT_NF_WRITABLE)
3782 dnp->dn_flags |= DT_NF_WRITABLE;
3783
3784 if (uref && (kind == CTF_K_POINTER ||
3785 (dnp->dn_flags & DT_NF_REF)))
3786 dnp->dn_flags |= DT_NF_USERLAND;
3787 break;
3788
3789 case DT_TOK_LBRAC: {
3790 /*
3791 * If op is DT_TOK_LBRAC, we know from the special-case code at
3792 * the top that lp is either a D variable or an aggregation.
3793 */
3794 dt_node_t *lnp;
3795
3796 /*
3797 * If the left-hand side is an aggregation, just set dn_aggtup
3798 * to the right-hand side and return the cooked aggregation.
3799 * This transformation is legal since we are just collapsing
3800 * nodes to simplify later processing, and the entire aggtup
3801 * parse subtree is retained for subsequent cooking passes.
3802 */
3803 if (lp->dn_kind == DT_NODE_AGG) {
3804 if (lp->dn_aggtup != NULL) {
3805 xyerror(D_AGG_MDIM, "improper attempt to "
3806 "reference @%s as a multi-dimensional "
3807 "array\n", lp->dn_ident->di_name);
3808 }
3809
3810 lp->dn_aggtup = rp;
3811 lp = dt_node_cook(lp, 0);
3812
3813 dnp->dn_left = dnp->dn_right = NULL;
3814 dt_node_free(dnp);
3815
3816 return (lp);
3817 }
3818
3819 assert(lp->dn_kind == DT_NODE_VAR);
3820 idp = lp->dn_ident;
3821
3822 /*
3823 * If the left-hand side is a non-global scalar that hasn't yet
3824 * been referenced or modified, it was just created by self->
3825 * or this-> and we can convert it from scalar to assoc array.
3826 */
3827 if (idp->di_kind == DT_IDENT_SCALAR && dt_ident_unref(idp) &&
3828 (idp->di_flags & (DT_IDFLG_LOCAL | DT_IDFLG_TLS)) != 0) {
3829
3830 if (idp->di_flags & DT_IDFLG_LOCAL) {
3831 xyerror(D_ARR_LOCAL,
3832 "local variables may not be used as "
3833 "associative arrays: %s\n", idp->di_name);
3834 }
3835
3836 dt_dprintf("morph variable %s (id %u) from scalar to "
3837 "array\n", idp->di_name, idp->di_id);
3838
3839 dt_ident_morph(idp, DT_IDENT_ARRAY,
3840 &dt_idops_assc, NULL);
3841 }
3842
3843 if (idp->di_kind != DT_IDENT_ARRAY) {
3844 xyerror(D_IDENT_BADREF, "%s '%s' may not be referenced "
3845 "as %s\n", dt_idkind_name(idp->di_kind),
3846 idp->di_name, dt_idkind_name(DT_IDENT_ARRAY));
3847 }
3848
3849 /*
3850 * Now that we've confirmed our left-hand side is a DT_NODE_VAR
3851 * of idkind DT_IDENT_ARRAY, we need to splice the [ node from
3852 * the parse tree and leave a cooked DT_NODE_VAR in its place
3853 * where dn_args for the VAR node is the right-hand 'rp' tree,
3854 * as shown in the parse tree diagram below:
3855 *
3856 * / /
3857 * [ OP2 "[" ]=dnp [ VAR ]=dnp
3858 * / \ => |
3859 * / \ +- dn_args -> [ ??? ]=rp
3860 * [ VAR ]=lp [ ??? ]=rp
3861 *
3862 * Since the final dt_node_cook(dnp) can fail using longjmp we
3863 * must perform the transformations as a group first by over-
3864 * writing 'dnp' to become the VAR node, so that the parse tree
3865 * is guaranteed to be in a consistent state if the cook fails.
3866 */
3867 assert(lp->dn_kind == DT_NODE_VAR);
3868 assert(lp->dn_args == NULL);
3869
3870 lnp = dnp->dn_link;
3871 bcopy(lp, dnp, sizeof (dt_node_t));
3872 dnp->dn_link = lnp;
3873
3874 dnp->dn_args = rp;
3875 dnp->dn_list = NULL;
3876
3877 dt_node_free(lp);
3878 return (dt_node_cook(dnp, idflags));
3879 }
3880
3881 case DT_TOK_XLATE: {
3882 dt_xlator_t *dxp;
3883
3884 assert(lp->dn_kind == DT_NODE_TYPE);
3885 rp = dnp->dn_right = dt_node_cook(rp, DT_IDFLG_REF);
3886 dxp = dt_xlator_lookup(dtp, rp, lp, DT_XLATE_FUZZY);
3887
3888 if (dxp == NULL) {
3889 xyerror(D_XLATE_NONE,
3890 "cannot translate from \"%s\" to \"%s\"\n",
3891 dt_node_type_name(rp, n1, sizeof (n1)),
3892 dt_node_type_name(lp, n2, sizeof (n2)));
3893 }
3894
3895 dnp->dn_ident = dt_xlator_ident(dxp, lp->dn_ctfp, lp->dn_type);
3896 dt_node_type_assign(dnp, DT_DYN_CTFP(dtp), DT_DYN_TYPE(dtp),
3897 B_FALSE);
3898 dt_node_attr_assign(dnp,
3899 dt_attr_min(rp->dn_attr, dnp->dn_ident->di_attr));
3900 break;
3901 }
3902
3903 case DT_TOK_LPAR: {
3904 ctf_id_t ltype, rtype;
3905 uint_t lkind, rkind;
3906
3907 assert(lp->dn_kind == DT_NODE_TYPE);
3908 rp = dnp->dn_right = dt_node_cook(rp, DT_IDFLG_REF);
3909
3910 ltype = ctf_type_resolve(lp->dn_ctfp, lp->dn_type);
3911 lkind = ctf_type_kind(lp->dn_ctfp, ltype);
3912
3913 rtype = ctf_type_resolve(rp->dn_ctfp, rp->dn_type);
3914 rkind = ctf_type_kind(rp->dn_ctfp, rtype);
3915
3916 /*
3917 * The rules for casting are loosely explained in K&R[A7.5]
3918 * and K&R[A6]. Basically, we can cast to the same type or
3919 * same base type, between any kind of scalar values, from
3920 * arrays to pointers, and we can cast anything to void.
3921 * To these rules D adds casts from scalars to strings.
3922 */
3923 if (ctf_type_compat(lp->dn_ctfp, lp->dn_type,
3924 rp->dn_ctfp, rp->dn_type))
3925 /*EMPTY*/;
3926 else if (dt_node_is_scalar(lp) &&
3927 (dt_node_is_scalar(rp) || rkind == CTF_K_FUNCTION))
3928 /*EMPTY*/;
3929 else if (dt_node_is_void(lp))
3930 /*EMPTY*/;
3931 else if (lkind == CTF_K_POINTER && dt_node_is_pointer(rp))
3932 /*EMPTY*/;
3933 else if (dt_node_is_string(lp) && (dt_node_is_scalar(rp) ||
3934 dt_node_is_pointer(rp) || dt_node_is_strcompat(rp)))
3935 /*EMPTY*/;
3936 else {
3937 xyerror(D_CAST_INVAL,
3938 "invalid cast expression: \"%s\" to \"%s\"\n",
3939 dt_node_type_name(rp, n1, sizeof (n1)),
3940 dt_node_type_name(lp, n2, sizeof (n2)));
3941 }
3942
3943 dt_node_type_propagate(lp, dnp); /* see K&R[A7.5] */
3944 dt_node_attr_assign(dnp, dt_attr_min(lp->dn_attr, rp->dn_attr));
3945
3946 /*
3947 * If it's a pointer then should be able to (attempt to)
3948 * assign to it.
3949 */
3950 if (lkind == CTF_K_POINTER)
3951 dnp->dn_flags |= DT_NF_WRITABLE;
3952
3953 break;
3954 }
3955
3956 case DT_TOK_COMMA:
3957 lp = dnp->dn_left = dt_node_cook(lp, DT_IDFLG_REF);
3958 rp = dnp->dn_right = dt_node_cook(rp, DT_IDFLG_REF);
3959
3960 if (dt_node_is_dynamic(lp) || dt_node_is_dynamic(rp)) {
3961 xyerror(D_OP_DYN, "operator %s operands "
3962 "cannot be of dynamic type\n", opstr(op));
3963 }
3964
3965 if (dt_node_is_actfunc(lp) || dt_node_is_actfunc(rp)) {
3966 xyerror(D_OP_ACT, "operator %s operands "
3967 "cannot be actions\n", opstr(op));
3968 }
3969
3970 dt_node_type_propagate(rp, dnp); /* see K&R[A7.18] */
3971 dt_node_attr_assign(dnp, dt_attr_min(lp->dn_attr, rp->dn_attr));
3972 break;
3973
3974 default:
3975 xyerror(D_UNKNOWN, "invalid binary op %s\n", opstr(op));
3976 }
3977
3978 /*
3979 * Complete the conversion of E1[E2] to *((E1)+(E2)) that we started
3980 * at the top of our switch() above (see K&R[A7.3.1]). Since E2 is
3981 * parsed as an argument_expression_list by dt_grammar.y, we can
3982 * end up with a comma-separated list inside of a non-associative
3983 * array reference. We check for this and report an appropriate error.
3984 */
3985 if (dnp->dn_op == DT_TOK_LBRAC && op == DT_TOK_ADD) {
3986 dt_node_t *pnp;
3987
3988 if (rp->dn_list != NULL) {
3989 xyerror(D_ARR_BADREF,
3990 "cannot access %s as an associative array\n",
3991 dt_node_name(lp, n1, sizeof (n1)));
3992 }
3993
3994 dnp->dn_op = DT_TOK_ADD;
3995 pnp = dt_node_op1(DT_TOK_DEREF, dnp);
3996
3997 /*
3998 * Cook callbacks are not typically permitted to allocate nodes.
3999 * When we do, we must insert them in the middle of an existing
4000 * allocation list rather than having them appended to the pcb
4001 * list because the sub-expression may be part of a definition.
4002 */
4003 assert(yypcb->pcb_list == pnp);
4004 yypcb->pcb_list = pnp->dn_link;
4005
4006 pnp->dn_link = dnp->dn_link;
4007 dnp->dn_link = pnp;
4008
4009 return (dt_node_cook(pnp, DT_IDFLG_REF));
4010 }
4011
4012 return (dnp);
4013 }
4014
4015 /*ARGSUSED*/
4016 static dt_node_t *
4017 dt_cook_op3(dt_node_t *dnp, uint_t idflags)
4018 {
4019 dt_node_t *lp, *rp;
4020 ctf_file_t *ctfp;
4021 ctf_id_t type;
4022
4023 dnp->dn_expr = dt_node_cook(dnp->dn_expr, DT_IDFLG_REF);
4024 lp = dnp->dn_left = dt_node_cook(dnp->dn_left, DT_IDFLG_REF);
4025 rp = dnp->dn_right = dt_node_cook(dnp->dn_right, DT_IDFLG_REF);
4026
4027 if (!dt_node_is_scalar(dnp->dn_expr)) {
4028 xyerror(D_OP_SCALAR,
4029 "operator ?: expression must be of scalar type\n");
4030 }
4031
4032 if (dt_node_is_dynamic(lp) || dt_node_is_dynamic(rp)) {
4033 xyerror(D_OP_DYN,
4034 "operator ?: operands cannot be of dynamic type\n");
4035 }
4036
4037 /*
4038 * The rules for type checking for the ternary operator are complex and
4039 * are described in the ANSI-C spec (see K&R[A7.16]). We implement
4040 * the various tests in order from least to most expensive.
4041 */
4042 if (ctf_type_compat(lp->dn_ctfp, lp->dn_type,
4043 rp->dn_ctfp, rp->dn_type)) {
4044 ctfp = lp->dn_ctfp;
4045 type = lp->dn_type;
4046 } else if (dt_node_is_integer(lp) && dt_node_is_integer(rp)) {
4047 dt_type_promote(lp, rp, &ctfp, &type);
4048 } else if (dt_node_is_strcompat(lp) && dt_node_is_strcompat(rp) &&
4049 (dt_node_is_string(lp) || dt_node_is_string(rp))) {
4050 ctfp = DT_STR_CTFP(yypcb->pcb_hdl);
4051 type = DT_STR_TYPE(yypcb->pcb_hdl);
4052 } else if (dt_node_is_ptrcompat(lp, rp, &ctfp, &type) == 0) {
4053 xyerror(D_OP_INCOMPAT,
4054 "operator ?: operands must have compatible types\n");
4055 }
4056
4057 if (dt_node_is_actfunc(lp) || dt_node_is_actfunc(rp)) {
4058 xyerror(D_OP_ACT, "action cannot be "
4059 "used in a conditional context\n");
4060 }
4061
4062 dt_node_type_assign(dnp, ctfp, type, B_FALSE);
4063 dt_node_attr_assign(dnp, dt_attr_min(dnp->dn_expr->dn_attr,
4064 dt_attr_min(lp->dn_attr, rp->dn_attr)));
4065
4066 return (dnp);
4067 }
4068
4069 static dt_node_t *
4070 dt_cook_statement(dt_node_t *dnp, uint_t idflags)
4071 {
4072 dnp->dn_expr = dt_node_cook(dnp->dn_expr, idflags);
4073 dt_node_attr_assign(dnp, dnp->dn_expr->dn_attr);
4074
4075 return (dnp);
4076 }
4077
4078 /*
4079 * If dn_aggfun is set, this node is a collapsed aggregation assignment (see
4080 * the special case code for DT_TOK_ASGN in dt_cook_op2() above), in which
4081 * case we cook both the tuple and the function call. If dn_aggfun is NULL,
4082 * this node is just a reference to the aggregation's type and attributes.
4083 */
4084 /*ARGSUSED*/
4085 static dt_node_t *
4086 dt_cook_aggregation(dt_node_t *dnp, uint_t idflags)
4087 {
4088 dtrace_hdl_t *dtp = yypcb->pcb_hdl;
4089
4090 if (dnp->dn_aggfun != NULL) {
4091 dnp->dn_aggfun = dt_node_cook(dnp->dn_aggfun, DT_IDFLG_REF);
4092 dt_node_attr_assign(dnp, dt_ident_cook(dnp,
4093 dnp->dn_ident, &dnp->dn_aggtup));
4094 } else {
4095 dt_node_type_assign(dnp, DT_DYN_CTFP(dtp), DT_DYN_TYPE(dtp),
4096 B_FALSE);
4097 dt_node_attr_assign(dnp, dnp->dn_ident->di_attr);
4098 }
4099
4100 return (dnp);
4101 }
4102
4103 /*
4104 * Since D permits new variable identifiers to be instantiated in any program
4105 * expression, we may need to cook a clause's predicate either before or after
4106 * the action list depending on the program code in question. Consider:
4107 *
4108 * probe-description-list probe-description-list
4109 * /x++/ /x == 0/
4110 * { {
4111 * trace(x); trace(x++);
4112 * } }
4113 *
4114 * In the left-hand example, the predicate uses operator ++ to instantiate 'x'
4115 * as a variable of type int64_t. The predicate must be cooked first because
4116 * otherwise the statement trace(x) refers to an unknown identifier. In the
4117 * right-hand example, the action list uses ++ to instantiate 'x'; the action
4118 * list must be cooked first because otherwise the predicate x == 0 refers to
4119 * an unknown identifier. In order to simplify programming, we support both.
4120 *
4121 * When cooking a clause, we cook the action statements before the predicate by
4122 * default, since it seems more common to create or modify identifiers in the
4123 * action list. If cooking fails due to an unknown identifier, we attempt to
4124 * cook the predicate (i.e. do it first) and then go back and cook the actions.
4125 * If this, too, fails (or if we get an error other than D_IDENT_UNDEF) we give
4126 * up and report failure back to the user. There are five possible paths:
4127 *
4128 * cook actions = OK, cook predicate = OK -> OK
4129 * cook actions = OK, cook predicate = ERR -> ERR
4130 * cook actions = ERR, cook predicate = ERR -> ERR
4131 * cook actions = ERR, cook predicate = OK, cook actions = OK -> OK
4132 * cook actions = ERR, cook predicate = OK, cook actions = ERR -> ERR
4133 *
4134 * The programmer can still defeat our scheme by creating circular definition
4135 * dependencies between predicates and actions, as in this example clause:
4136 *
4137 * probe-description-list
4138 * /x++ && y == 0/
4139 * {
4140 * trace(x + y++);
4141 * }
4142 *
4143 * but it doesn't seem worth the complexity to handle such rare cases. The
4144 * user can simply use the D variable declaration syntax to work around them.
4145 */
4146 static dt_node_t *
4147 dt_cook_clause(dt_node_t *dnp, uint_t idflags)
4148 {
4149 volatile int err, tries;
4150 jmp_buf ojb;
4151
4152 /*
4153 * Before assigning dn_ctxattr, temporarily assign the probe attribute
4154 * to 'dnp' itself to force an attribute check and minimum violation.
4155 */
4156 dt_node_attr_assign(dnp, yypcb->pcb_pinfo.dtp_attr);
4157 dnp->dn_ctxattr = yypcb->pcb_pinfo.dtp_attr;
4158
4159 bcopy(yypcb->pcb_jmpbuf, ojb, sizeof (jmp_buf));
4160 tries = 0;
4161
4162 if (dnp->dn_pred != NULL && (err = setjmp(yypcb->pcb_jmpbuf)) != 0) {
4163 bcopy(ojb, yypcb->pcb_jmpbuf, sizeof (jmp_buf));
4164 if (tries++ != 0 || err != EDT_COMPILER || (
4165 yypcb->pcb_hdl->dt_errtag != dt_errtag(D_IDENT_UNDEF) &&
4166 yypcb->pcb_hdl->dt_errtag != dt_errtag(D_VAR_UNDEF)))
4167 longjmp(yypcb->pcb_jmpbuf, err);
4168 }
4169
4170 if (tries == 0) {
4171 yylabel("action list");
4172
4173 dt_node_attr_assign(dnp,
4174 dt_node_list_cook(&dnp->dn_acts, idflags));
4175
4176 bcopy(ojb, yypcb->pcb_jmpbuf, sizeof (jmp_buf));
4177 yylabel(NULL);
4178 }
4179
4180 if (dnp->dn_pred != NULL) {
4181 yylabel("predicate");
4182
4183 dnp->dn_pred = dt_node_cook(dnp->dn_pred, idflags);
4184 dt_node_attr_assign(dnp,
4185 dt_attr_min(dnp->dn_attr, dnp->dn_pred->dn_attr));
4186
4187 if (!dt_node_is_scalar(dnp->dn_pred)) {
4188 xyerror(D_PRED_SCALAR,
4189 "predicate result must be of scalar type\n");
4190 }
4191
4192 yylabel(NULL);
4193 }
4194
4195 if (tries != 0) {
4196 yylabel("action list");
4197
4198 dt_node_attr_assign(dnp,
4199 dt_node_list_cook(&dnp->dn_acts, idflags));
4200
4201 yylabel(NULL);
4202 }
4203
4204 return (dnp);
4205 }
4206
4207 /*ARGSUSED*/
4208 static dt_node_t *
4209 dt_cook_inline(dt_node_t *dnp, uint_t idflags)
4210 {
4211 dt_idnode_t *inp = dnp->dn_ident->di_iarg;
4212 dt_ident_t *rdp;
4213
4214 char n1[DT_TYPE_NAMELEN];
4215 char n2[DT_TYPE_NAMELEN];
4216
4217 assert(dnp->dn_ident->di_flags & DT_IDFLG_INLINE);
4218 assert(inp->din_root->dn_flags & DT_NF_COOKED);
4219
4220 /*
4221 * If we are inlining a translation, verify that the inline declaration
4222 * type exactly matches the type that is returned by the translation.
4223 * Otherwise just use dt_node_is_argcompat() to check the types.
4224 */
4225 if ((rdp = dt_node_resolve(inp->din_root, DT_IDENT_XLSOU)) != NULL ||
4226 (rdp = dt_node_resolve(inp->din_root, DT_IDENT_XLPTR)) != NULL) {
4227
4228 ctf_file_t *lctfp = dnp->dn_ctfp;
4229 ctf_id_t ltype = ctf_type_resolve(lctfp, dnp->dn_type);
4230
4231 dt_xlator_t *dxp = rdp->di_data;
4232 ctf_file_t *rctfp = dxp->dx_dst_ctfp;
4233 ctf_id_t rtype = dxp->dx_dst_base;
4234
4235 if (ctf_type_kind(lctfp, ltype) == CTF_K_POINTER) {
4236 ltype = ctf_type_reference(lctfp, ltype);
4237 ltype = ctf_type_resolve(lctfp, ltype);
4238 }
4239
4240 if (ctf_type_compat(lctfp, ltype, rctfp, rtype) == 0) {
4241 dnerror(dnp, D_OP_INCOMPAT,
4242 "inline %s definition uses incompatible types: "
4243 "\"%s\" = \"%s\"\n", dnp->dn_ident->di_name,
4244 dt_type_name(lctfp, ltype, n1, sizeof (n1)),
4245 dt_type_name(rctfp, rtype, n2, sizeof (n2)));
4246 }
4247
4248 } else if (dt_node_is_argcompat(dnp, inp->din_root) == 0) {
4249 dnerror(dnp, D_OP_INCOMPAT,
4250 "inline %s definition uses incompatible types: "
4251 "\"%s\" = \"%s\"\n", dnp->dn_ident->di_name,
4252 dt_node_type_name(dnp, n1, sizeof (n1)),
4253 dt_node_type_name(inp->din_root, n2, sizeof (n2)));
4254 }
4255
4256 return (dnp);
4257 }
4258
4259 static dt_node_t *
4260 dt_cook_member(dt_node_t *dnp, uint_t idflags)
4261 {
4262 dnp->dn_membexpr = dt_node_cook(dnp->dn_membexpr, idflags);
4263 dt_node_attr_assign(dnp, dnp->dn_membexpr->dn_attr);
4264 return (dnp);
4265 }
4266
4267 /*ARGSUSED*/
4268 static dt_node_t *
4269 dt_cook_xlator(dt_node_t *dnp, uint_t idflags)
4270 {
4271 dtrace_hdl_t *dtp = yypcb->pcb_hdl;
4272 dt_xlator_t *dxp = dnp->dn_xlator;
4273 dt_node_t *mnp;
4274
4275 char n1[DT_TYPE_NAMELEN];
4276 char n2[DT_TYPE_NAMELEN];
4277
4278 dtrace_attribute_t attr = _dtrace_maxattr;
4279 ctf_membinfo_t ctm;
4280
4281 /*
4282 * Before cooking each translator member, we push a reference to the
4283 * hash containing translator-local identifiers on to pcb_globals to
4284 * temporarily interpose these identifiers in front of other globals.
4285 */
4286 dt_idstack_push(&yypcb->pcb_globals, dxp->dx_locals);
4287
4288 for (mnp = dnp->dn_members; mnp != NULL; mnp = mnp->dn_list) {
4289 if (ctf_member_info(dxp->dx_dst_ctfp, dxp->dx_dst_type,
4290 mnp->dn_membname, &ctm) == CTF_ERR) {
4291 xyerror(D_XLATE_MEMB,
4292 "translator member %s is not a member of %s\n",
4293 mnp->dn_membname, ctf_type_name(dxp->dx_dst_ctfp,
4294 dxp->dx_dst_type, n1, sizeof (n1)));
4295 }
4296
4297 (void) dt_node_cook(mnp, DT_IDFLG_REF);
4298 dt_node_type_assign(mnp, dxp->dx_dst_ctfp, ctm.ctm_type,
4299 B_FALSE);
4300 attr = dt_attr_min(attr, mnp->dn_attr);
4301
4302 if (dt_node_is_argcompat(mnp, mnp->dn_membexpr) == 0) {
4303 xyerror(D_XLATE_INCOMPAT,
4304 "translator member %s definition uses "
4305 "incompatible types: \"%s\" = \"%s\"\n",
4306 mnp->dn_membname,
4307 dt_node_type_name(mnp, n1, sizeof (n1)),
4308 dt_node_type_name(mnp->dn_membexpr,
4309 n2, sizeof (n2)));
4310 }
4311 }
4312
4313 dt_idstack_pop(&yypcb->pcb_globals, dxp->dx_locals);
4314
4315 dxp->dx_souid.di_attr = attr;
4316 dxp->dx_ptrid.di_attr = attr;
4317
4318 dt_node_type_assign(dnp, DT_DYN_CTFP(dtp), DT_DYN_TYPE(dtp), B_FALSE);
4319 dt_node_attr_assign(dnp, _dtrace_defattr);
4320
4321 return (dnp);
4322 }
4323
4324 static void
4325 dt_node_provider_cmp_argv(dt_provider_t *pvp, dt_node_t *pnp, const char *kind,
4326 uint_t old_argc, dt_node_t *old_argv, uint_t new_argc, dt_node_t *new_argv)
4327 {
4328 dt_probe_t *prp = pnp->dn_ident->di_data;
4329 uint_t i;
4330
4331 char n1[DT_TYPE_NAMELEN];
4332 char n2[DT_TYPE_NAMELEN];
4333
4334 if (old_argc != new_argc) {
4335 dnerror(pnp, D_PROV_INCOMPAT,
4336 "probe %s:%s %s prototype mismatch:\n"
4337 "\t current: %u arg%s\n\tprevious: %u arg%s\n",
4338 pvp->pv_desc.dtvd_name, prp->pr_ident->di_name, kind,
4339 new_argc, new_argc != 1 ? "s" : "",
4340 old_argc, old_argc != 1 ? "s" : "");
4341 }
4342
4343 for (i = 0; i < old_argc; i++,
4344 old_argv = old_argv->dn_list, new_argv = new_argv->dn_list) {
4345 if (ctf_type_cmp(old_argv->dn_ctfp, old_argv->dn_type,
4346 new_argv->dn_ctfp, new_argv->dn_type) == 0)
4347 continue;
4348
4349 dnerror(pnp, D_PROV_INCOMPAT,
4350 "probe %s:%s %s prototype argument #%u mismatch:\n"
4351 "\t current: %s\n\tprevious: %s\n",
4352 pvp->pv_desc.dtvd_name, prp->pr_ident->di_name, kind, i + 1,
4353 dt_node_type_name(new_argv, n1, sizeof (n1)),
4354 dt_node_type_name(old_argv, n2, sizeof (n2)));
4355 }
4356 }
4357
4358 /*
4359 * Compare a new probe declaration with an existing probe definition (either
4360 * from a previous declaration or cached from the kernel). If the existing
4361 * definition and declaration both have an input and output parameter list,
4362 * compare both lists. Otherwise compare only the output parameter lists.
4363 */
4364 static void
4365 dt_node_provider_cmp(dt_provider_t *pvp, dt_node_t *pnp,
4366 dt_probe_t *old, dt_probe_t *new)
4367 {
4368 dt_node_provider_cmp_argv(pvp, pnp, "output",
4369 old->pr_xargc, old->pr_xargs, new->pr_xargc, new->pr_xargs);
4370
4371 if (old->pr_nargs != old->pr_xargs && new->pr_nargs != new->pr_xargs) {
4372 dt_node_provider_cmp_argv(pvp, pnp, "input",
4373 old->pr_nargc, old->pr_nargs, new->pr_nargc, new->pr_nargs);
4374 }
4375
4376 if (old->pr_nargs == old->pr_xargs && new->pr_nargs != new->pr_xargs) {
4377 if (pvp->pv_flags & DT_PROVIDER_IMPL) {
4378 dnerror(pnp, D_PROV_INCOMPAT,
4379 "provider interface mismatch: %s\n"
4380 "\t current: probe %s:%s has an output prototype\n"
4381 "\tprevious: probe %s:%s has no output prototype\n",
4382 pvp->pv_desc.dtvd_name, pvp->pv_desc.dtvd_name,
4383 new->pr_ident->di_name, pvp->pv_desc.dtvd_name,
4384 old->pr_ident->di_name);
4385 }
4386
4387 if (old->pr_ident->di_gen == yypcb->pcb_hdl->dt_gen)
4388 old->pr_ident->di_flags |= DT_IDFLG_ORPHAN;
4389
4390 dt_idhash_delete(pvp->pv_probes, old->pr_ident);
4391 dt_probe_declare(pvp, new);
4392 }
4393 }
4394
4395 static void
4396 dt_cook_probe(dt_node_t *dnp, dt_provider_t *pvp)
4397 {
4398 dtrace_hdl_t *dtp = yypcb->pcb_hdl;
4399 dt_probe_t *prp = dnp->dn_ident->di_data;
4400
4401 dt_xlator_t *dxp;
4402 uint_t i;
4403
4404 char n1[DT_TYPE_NAMELEN];
4405 char n2[DT_TYPE_NAMELEN];
4406
4407 if (prp->pr_nargs == prp->pr_xargs)
4408 return;
4409
4410 for (i = 0; i < prp->pr_xargc; i++) {
4411 dt_node_t *xnp = prp->pr_xargv[i];
4412 dt_node_t *nnp = prp->pr_nargv[prp->pr_mapping[i]];
4413
4414 if ((dxp = dt_xlator_lookup(dtp,
4415 nnp, xnp, DT_XLATE_FUZZY)) != NULL) {
4416 if (dt_provider_xref(dtp, pvp, dxp->dx_id) != 0)
4417 longjmp(yypcb->pcb_jmpbuf, EDT_NOMEM);
4418 continue;
4419 }
4420
4421 if (dt_node_is_argcompat(nnp, xnp))
4422 continue; /* no translator defined and none required */
4423
4424 dnerror(dnp, D_PROV_PRXLATOR, "translator for %s:%s output "
4425 "argument #%u from %s to %s is not defined\n",
4426 pvp->pv_desc.dtvd_name, dnp->dn_ident->di_name, i + 1,
4427 dt_node_type_name(nnp, n1, sizeof (n1)),
4428 dt_node_type_name(xnp, n2, sizeof (n2)));
4429 }
4430 }
4431
4432 /*ARGSUSED*/
4433 static dt_node_t *
4434 dt_cook_provider(dt_node_t *dnp, uint_t idflags)
4435 {
4436 dt_provider_t *pvp = dnp->dn_provider;
4437 dt_node_t *pnp;
4438
4439 /*
4440 * If we're declaring a provider for the first time and it is unknown
4441 * to dtrace(7D), insert the probe definitions into the provider's hash.
4442 * If we're redeclaring a known provider, verify the interface matches.
4443 */
4444 for (pnp = dnp->dn_probes; pnp != NULL; pnp = pnp->dn_list) {
4445 const char *probename = pnp->dn_ident->di_name;
4446 dt_probe_t *prp = dt_probe_lookup(pvp, probename);
4447
4448 assert(pnp->dn_kind == DT_NODE_PROBE);
4449
4450 if (prp != NULL && dnp->dn_provred) {
4451 dt_node_provider_cmp(pvp, pnp,
4452 prp, pnp->dn_ident->di_data);
4453 } else if (prp == NULL && dnp->dn_provred) {
4454 dnerror(pnp, D_PROV_INCOMPAT,
4455 "provider interface mismatch: %s\n"
4456 "\t current: probe %s:%s defined\n"
4457 "\tprevious: probe %s:%s not defined\n",
4458 dnp->dn_provname, dnp->dn_provname,
4459 probename, dnp->dn_provname, probename);
4460 } else if (prp != NULL) {
4461 dnerror(pnp, D_PROV_PRDUP, "probe redeclared: %s:%s\n",
4462 dnp->dn_provname, probename);
4463 } else
4464 dt_probe_declare(pvp, pnp->dn_ident->di_data);
4465
4466 dt_cook_probe(pnp, pvp);
4467 }
4468
4469 return (dnp);
4470 }
4471
4472 /*ARGSUSED*/
4473 static dt_node_t *
4474 dt_cook_none(dt_node_t *dnp, uint_t idflags)
4475 {
4476 return (dnp);
4477 }
4478
4479 static dt_node_t *(*dt_cook_funcs[])(dt_node_t *, uint_t) = {
4480 dt_cook_none, /* DT_NODE_FREE */
4481 dt_cook_none, /* DT_NODE_INT */
4482 dt_cook_none, /* DT_NODE_STRING */
4483 dt_cook_ident, /* DT_NODE_IDENT */
4484 dt_cook_var, /* DT_NODE_VAR */
4485 dt_cook_none, /* DT_NODE_SYM */
4486 dt_cook_none, /* DT_NODE_TYPE */
4487 dt_cook_func, /* DT_NODE_FUNC */
4488 dt_cook_op1, /* DT_NODE_OP1 */
4489 dt_cook_op2, /* DT_NODE_OP2 */
4490 dt_cook_op3, /* DT_NODE_OP3 */
4491 dt_cook_statement, /* DT_NODE_DEXPR */
4492 dt_cook_statement, /* DT_NODE_DFUNC */
4493 dt_cook_aggregation, /* DT_NODE_AGG */
4494 dt_cook_none, /* DT_NODE_PDESC */
4495 dt_cook_clause, /* DT_NODE_CLAUSE */
4496 dt_cook_inline, /* DT_NODE_INLINE */
4497 dt_cook_member, /* DT_NODE_MEMBER */
4498 dt_cook_xlator, /* DT_NODE_XLATOR */
4499 dt_cook_none, /* DT_NODE_PROBE */
4500 dt_cook_provider, /* DT_NODE_PROVIDER */
4501 dt_cook_none, /* DT_NODE_PROG */
4502 dt_cook_none, /* DT_NODE_IF */
4503 };
4504
4505 /*
4506 * Recursively cook the parse tree starting at the specified node. The idflags
4507 * parameter is used to indicate the type of reference (r/w) and is applied to
4508 * the resulting identifier if it is a D variable or D aggregation.
4509 */
4510 dt_node_t *
4511 dt_node_cook(dt_node_t *dnp, uint_t idflags)
4512 {
4513 int oldlineno = yylineno;
4514
4515 yylineno = dnp->dn_line;
4516
4517 assert(dnp->dn_kind <
4518 sizeof (dt_cook_funcs) / sizeof (dt_cook_funcs[0]));
4519 dnp = dt_cook_funcs[dnp->dn_kind](dnp, idflags);
4520 dnp->dn_flags |= DT_NF_COOKED;
4521
4522 if (dnp->dn_kind == DT_NODE_VAR || dnp->dn_kind == DT_NODE_AGG)
4523 dnp->dn_ident->di_flags |= idflags;
4524
4525 yylineno = oldlineno;
4526 return (dnp);
4527 }
4528
4529 dtrace_attribute_t
4530 dt_node_list_cook(dt_node_t **pnp, uint_t idflags)
4531 {
4532 dtrace_attribute_t attr = _dtrace_defattr;
4533 dt_node_t *dnp, *nnp;
4534
4535 for (dnp = (pnp != NULL ? *pnp : NULL); dnp != NULL; dnp = nnp) {
4536 nnp = dnp->dn_list;
4537 dnp = *pnp = dt_node_cook(dnp, idflags);
4538 attr = dt_attr_min(attr, dnp->dn_attr);
4539 dnp->dn_list = nnp;
4540 pnp = &dnp->dn_list;
4541 }
4542
4543 return (attr);
4544 }
4545
4546 void
4547 dt_node_list_free(dt_node_t **pnp)
4548 {
4549 dt_node_t *dnp, *nnp;
4550
4551 for (dnp = (pnp != NULL ? *pnp : NULL); dnp != NULL; dnp = nnp) {
4552 nnp = dnp->dn_list;
4553 dt_node_free(dnp);
4554 }
4555
4556 if (pnp != NULL)
4557 *pnp = NULL;
4558 }
4559
4560 void
4561 dt_node_link_free(dt_node_t **pnp)
4562 {
4563 dt_node_t *dnp, *nnp;
4564
4565 for (dnp = (pnp != NULL ? *pnp : NULL); dnp != NULL; dnp = nnp) {
4566 nnp = dnp->dn_link;
4567 dt_node_free(dnp);
4568 }
4569
4570 for (dnp = (pnp != NULL ? *pnp : NULL); dnp != NULL; dnp = nnp) {
4571 nnp = dnp->dn_link;
4572 free(dnp);
4573 }
4574
4575 if (pnp != NULL)
4576 *pnp = NULL;
4577 }
4578
4579 dt_node_t *
4580 dt_node_link(dt_node_t *lp, dt_node_t *rp)
4581 {
4582 dt_node_t *dnp;
4583
4584 if (lp == NULL)
4585 return (rp);
4586 else if (rp == NULL)
4587 return (lp);
4588
4589 for (dnp = lp; dnp->dn_list != NULL; dnp = dnp->dn_list)
4590 continue;
4591
4592 dnp->dn_list = rp;
4593 return (lp);
4594 }
4595
4596 /*
4597 * Compute the DOF dtrace_diftype_t representation of a node's type. This is
4598 * called from a variety of places in the library so it cannot assume yypcb
4599 * is valid: any references to handle-specific data must be made through 'dtp'.
4600 */
4601 void
4602 dt_node_diftype(dtrace_hdl_t *dtp, const dt_node_t *dnp, dtrace_diftype_t *tp)
4603 {
4604 if (dnp->dn_ctfp == DT_STR_CTFP(dtp) &&
4605 dnp->dn_type == DT_STR_TYPE(dtp)) {
4606 tp->dtdt_kind = DIF_TYPE_STRING;
4607 tp->dtdt_ckind = CTF_K_UNKNOWN;
4608 } else {
4609 tp->dtdt_kind = DIF_TYPE_CTF;
4610 tp->dtdt_ckind = ctf_type_kind(dnp->dn_ctfp,
4611 ctf_type_resolve(dnp->dn_ctfp, dnp->dn_type));
4612 }
4613
4614 tp->dtdt_flags = (dnp->dn_flags & DT_NF_REF) ?
4615 (dnp->dn_flags & DT_NF_USERLAND) ? DIF_TF_BYUREF :
4616 DIF_TF_BYREF : 0;
4617 tp->dtdt_pad = 0;
4618 tp->dtdt_size = ctf_type_size(dnp->dn_ctfp, dnp->dn_type);
4619 }
4620
4621 /*
4622 * Output the parse tree as D. The "-xtree=8" argument will call this
4623 * function to print out the program after any syntactic sugar
4624 * transformations have been applied (e.g. to implement "if"). The
4625 * resulting output can be used to understand the transformations
4626 * applied by these features, or to run such a script on a system that
4627 * does not support these features
4628 *
4629 * Note that the output does not express precisely the same program as
4630 * the input. In particular:
4631 * - Only the clauses are output. #pragma options, variable
4632 * declarations, etc. are excluded.
4633 * - Command argument substitution has already been done, so the output
4634 * will not contain e.g. $$1, but rather the substituted string.
4635 */
4636 void
4637 dt_printd(dt_node_t *dnp, FILE *fp, int depth)
4638 {
4639 dt_node_t *arg;
4640
4641 switch (dnp->dn_kind) {
4642 case DT_NODE_INT:
4643 (void) fprintf(fp, "0x%llx", (u_longlong_t)dnp->dn_value);
4644 if (!(dnp->dn_flags & DT_NF_SIGNED))
4645 (void) fprintf(fp, "u");
4646 break;
4647
4648 case DT_NODE_STRING: {
4649 char *escd = strchr2esc(dnp->dn_string, strlen(dnp->dn_string));
4650 (void) fprintf(fp, "\"%s\"", escd);
4651 free(escd);
4652 break;
4653 }
4654
4655 case DT_NODE_IDENT:
4656 (void) fprintf(fp, "%s", dnp->dn_string);
4657 break;
4658
4659 case DT_NODE_VAR:
4660 (void) fprintf(fp, "%s%s",
4661 (dnp->dn_ident->di_flags & DT_IDFLG_LOCAL) ? "this->" :
4662 (dnp->dn_ident->di_flags & DT_IDFLG_TLS) ? "self->" : "",
4663 dnp->dn_ident->di_name);
4664
4665 if (dnp->dn_args != NULL) {
4666 (void) fprintf(fp, "[");
4667
4668 for (arg = dnp->dn_args; arg != NULL;
4669 arg = arg->dn_list) {
4670 dt_printd(arg, fp, 0);
4671 if (arg->dn_list != NULL)
4672 (void) fprintf(fp, ", ");
4673 }
4674
4675 (void) fprintf(fp, "]");
4676 }
4677 break;
4678
4679 case DT_NODE_SYM: {
4680 const dtrace_syminfo_t *dts = dnp->dn_ident->di_data;
4681 (void) fprintf(fp, "%s`%s", dts->dts_object, dts->dts_name);
4682 break;
4683 }
4684 case DT_NODE_FUNC:
4685 (void) fprintf(fp, "%s(", dnp->dn_ident->di_name);
4686
4687 for (arg = dnp->dn_args; arg != NULL; arg = arg->dn_list) {
4688 dt_printd(arg, fp, 0);
4689 if (arg->dn_list != NULL)
4690 (void) fprintf(fp, ", ");
4691 }
4692 (void) fprintf(fp, ")");
4693 break;
4694
4695 case DT_NODE_OP1:
4696 (void) fprintf(fp, "%s(", opstr(dnp->dn_op));
4697 dt_printd(dnp->dn_child, fp, 0);
4698 (void) fprintf(fp, ")");
4699 break;
4700
4701 case DT_NODE_OP2:
4702 (void) fprintf(fp, "(");
4703 dt_printd(dnp->dn_left, fp, 0);
4704 if (dnp->dn_op == DT_TOK_LPAR) {
4705 (void) fprintf(fp, ")");
4706 dt_printd(dnp->dn_right, fp, 0);
4707 break;
4708 }
4709 if (dnp->dn_op == DT_TOK_PTR || dnp->dn_op == DT_TOK_DOT ||
4710 dnp->dn_op == DT_TOK_LBRAC)
4711 (void) fprintf(fp, "%s", opstr(dnp->dn_op));
4712 else
4713 (void) fprintf(fp, " %s ", opstr(dnp->dn_op));
4714 dt_printd(dnp->dn_right, fp, 0);
4715 if (dnp->dn_op == DT_TOK_LBRAC) {
4716 dt_node_t *ln = dnp->dn_right;
4717 while (ln->dn_list != NULL) {
4718 (void) fprintf(fp, ", ");
4719 dt_printd(ln->dn_list, fp, depth);
4720 ln = ln->dn_list;
4721 }
4722 (void) fprintf(fp, "]");
4723 }
4724 (void) fprintf(fp, ")");
4725 break;
4726
4727 case DT_NODE_OP3:
4728 (void) fprintf(fp, "(");
4729 dt_printd(dnp->dn_expr, fp, 0);
4730 (void) fprintf(fp, " ? ");
4731 dt_printd(dnp->dn_left, fp, 0);
4732 (void) fprintf(fp, " : ");
4733 dt_printd(dnp->dn_right, fp, 0);
4734 (void) fprintf(fp, ")");
4735 break;
4736
4737 case DT_NODE_DEXPR:
4738 case DT_NODE_DFUNC:
4739 (void) fprintf(fp, "%*s", depth * 8, "");
4740 dt_printd(dnp->dn_expr, fp, depth + 1);
4741 (void) fprintf(fp, ";\n");
4742 break;
4743
4744 case DT_NODE_PDESC:
4745 (void) fprintf(fp, "%s:%s:%s:%s",
4746 dnp->dn_desc->dtpd_provider, dnp->dn_desc->dtpd_mod,
4747 dnp->dn_desc->dtpd_func, dnp->dn_desc->dtpd_name);
4748 break;
4749
4750 case DT_NODE_CLAUSE:
4751 for (arg = dnp->dn_pdescs; arg != NULL; arg = arg->dn_list) {
4752 dt_printd(arg, fp, 0);
4753 if (arg->dn_list != NULL)
4754 (void) fprintf(fp, ",");
4755 (void) fprintf(fp, "\n");
4756 }
4757
4758 if (dnp->dn_pred != NULL) {
4759 (void) fprintf(fp, "/");
4760 dt_printd(dnp->dn_pred, fp, 0);
4761 (void) fprintf(fp, "/\n");
4762 }
4763 (void) fprintf(fp, "{\n");
4764
4765 for (arg = dnp->dn_acts; arg != NULL; arg = arg->dn_list)
4766 dt_printd(arg, fp, depth + 1);
4767 (void) fprintf(fp, "}\n");
4768 (void) fprintf(fp, "\n");
4769 break;
4770
4771 case DT_NODE_IF:
4772 (void) fprintf(fp, "%*sif (", depth * 8, "");
4773 dt_printd(dnp->dn_conditional, fp, 0);
4774 (void) fprintf(fp, ") {\n");
4775
4776 for (arg = dnp->dn_body; arg != NULL; arg = arg->dn_list)
4777 dt_printd(arg, fp, depth + 1);
4778 if (dnp->dn_alternate_body == NULL) {
4779 (void) fprintf(fp, "%*s}\n", depth * 8, "");
4780 } else {
4781 (void) fprintf(fp, "%*s} else {\n", depth * 8, "");
4782 for (arg = dnp->dn_alternate_body; arg != NULL;
4783 arg = arg->dn_list)
4784 dt_printd(arg, fp, depth + 1);
4785 (void) fprintf(fp, "%*s}\n", depth * 8, "");
4786 }
4787
4788 break;
4789
4790 default:
4791 (void) fprintf(fp, "/* bad node %p, kind %d */\n",
4792 (void *)dnp, dnp->dn_kind);
4793 }
4794 }
4795
4796 void
4797 dt_node_printr(dt_node_t *dnp, FILE *fp, int depth)
4798 {
4799 char n[DT_TYPE_NAMELEN], buf[BUFSIZ], a[8];
4800 const dtrace_syminfo_t *dts;
4801 const dt_idnode_t *inp;
4802 dt_node_t *arg;
4803
4804 (void) fprintf(fp, "%*s", depth * 2, "");
4805 (void) dt_attr_str(dnp->dn_attr, a, sizeof (a));
4806
4807 if (dnp->dn_ctfp != NULL && dnp->dn_type != CTF_ERR &&
4808 ctf_type_name(dnp->dn_ctfp, dnp->dn_type, n, sizeof (n)) != NULL) {
4809 (void) snprintf(buf, BUFSIZ, "type=<%s> attr=%s flags=", n, a);
4810 } else {
4811 (void) snprintf(buf, BUFSIZ, "type=<%ld> attr=%s flags=",
4812 dnp->dn_type, a);
4813 }
4814
4815 if (dnp->dn_flags != 0) {
4816 n[0] = '\0';
4817 if (dnp->dn_flags & DT_NF_SIGNED)
4818 (void) strcat(n, ",SIGN");
4819 if (dnp->dn_flags & DT_NF_COOKED)
4820 (void) strcat(n, ",COOK");
4821 if (dnp->dn_flags & DT_NF_REF)
4822 (void) strcat(n, ",REF");
4823 if (dnp->dn_flags & DT_NF_LVALUE)
4824 (void) strcat(n, ",LVAL");
4825 if (dnp->dn_flags & DT_NF_WRITABLE)
4826 (void) strcat(n, ",WRITE");
4827 if (dnp->dn_flags & DT_NF_BITFIELD)
4828 (void) strcat(n, ",BITF");
4829 if (dnp->dn_flags & DT_NF_USERLAND)
4830 (void) strcat(n, ",USER");
4831 (void) strcat(buf, n + 1);
4832 } else
4833 (void) strcat(buf, "0");
4834
4835 switch (dnp->dn_kind) {
4836 case DT_NODE_FREE:
4837 (void) fprintf(fp, "FREE <node %p>\n", (void *)dnp);
4838 break;
4839
4840 case DT_NODE_INT:
4841 (void) fprintf(fp, "INT 0x%llx (%s)\n",
4842 (u_longlong_t)dnp->dn_value, buf);
4843 break;
4844
4845 case DT_NODE_STRING:
4846 (void) fprintf(fp, "STRING \"%s\" (%s)\n", dnp->dn_string, buf);
4847 break;
4848
4849 case DT_NODE_IDENT:
4850 (void) fprintf(fp, "IDENT %s (%s)\n", dnp->dn_string, buf);
4851 break;
4852
4853 case DT_NODE_VAR:
4854 (void) fprintf(fp, "VARIABLE %s%s (%s)\n",
4855 (dnp->dn_ident->di_flags & DT_IDFLG_LOCAL) ? "this->" :
4856 (dnp->dn_ident->di_flags & DT_IDFLG_TLS) ? "self->" : "",
4857 dnp->dn_ident->di_name, buf);
4858
4859 if (dnp->dn_args != NULL)
4860 (void) fprintf(fp, "%*s[\n", depth * 2, "");
4861
4862 for (arg = dnp->dn_args; arg != NULL; arg = arg->dn_list) {
4863 dt_node_printr(arg, fp, depth + 1);
4864 if (arg->dn_list != NULL)
4865 (void) fprintf(fp, "%*s,\n", depth * 2, "");
4866 }
4867
4868 if (dnp->dn_args != NULL)
4869 (void) fprintf(fp, "%*s]\n", depth * 2, "");
4870 break;
4871
4872 case DT_NODE_SYM:
4873 dts = dnp->dn_ident->di_data;
4874 (void) fprintf(fp, "SYMBOL %s`%s (%s)\n",
4875 dts->dts_object, dts->dts_name, buf);
4876 break;
4877
4878 case DT_NODE_TYPE:
4879 if (dnp->dn_string != NULL) {
4880 (void) fprintf(fp, "TYPE (%s) %s\n",
4881 buf, dnp->dn_string);
4882 } else
4883 (void) fprintf(fp, "TYPE (%s)\n", buf);
4884 break;
4885
4886 case DT_NODE_FUNC:
4887 (void) fprintf(fp, "FUNC %s (%s)\n",
4888 dnp->dn_ident->di_name, buf);
4889
4890 for (arg = dnp->dn_args; arg != NULL; arg = arg->dn_list) {
4891 dt_node_printr(arg, fp, depth + 1);
4892 if (arg->dn_list != NULL)
4893 (void) fprintf(fp, "%*s,\n", depth * 2, "");
4894 }
4895 break;
4896
4897 case DT_NODE_OP1:
4898 (void) fprintf(fp, "OP1 %s (%s)\n", opstr(dnp->dn_op), buf);
4899 dt_node_printr(dnp->dn_child, fp, depth + 1);
4900 break;
4901
4902 case DT_NODE_OP2:
4903 (void) fprintf(fp, "OP2 %s (%s)\n", opstr(dnp->dn_op), buf);
4904 dt_node_printr(dnp->dn_left, fp, depth + 1);
4905 dt_node_printr(dnp->dn_right, fp, depth + 1);
4906 if (dnp->dn_op == DT_TOK_LBRAC) {
4907 dt_node_t *ln = dnp->dn_right;
4908 while (ln->dn_list != NULL) {
4909 dt_node_printr(ln->dn_list, fp, depth + 1);
4910 ln = ln->dn_list;
4911 }
4912 }
4913 break;
4914
4915 case DT_NODE_OP3:
4916 (void) fprintf(fp, "OP3 (%s)\n", buf);
4917 dt_node_printr(dnp->dn_expr, fp, depth + 1);
4918 (void) fprintf(fp, "%*s?\n", depth * 2, "");
4919 dt_node_printr(dnp->dn_left, fp, depth + 1);
4920 (void) fprintf(fp, "%*s:\n", depth * 2, "");
4921 dt_node_printr(dnp->dn_right, fp, depth + 1);
4922 break;
4923
4924 case DT_NODE_DEXPR:
4925 case DT_NODE_DFUNC:
4926 (void) fprintf(fp, "D EXPRESSION attr=%s\n", a);
4927 dt_node_printr(dnp->dn_expr, fp, depth + 1);
4928 break;
4929
4930 case DT_NODE_AGG:
4931 (void) fprintf(fp, "AGGREGATE @%s attr=%s [\n",
4932 dnp->dn_ident->di_name, a);
4933
4934 for (arg = dnp->dn_aggtup; arg != NULL; arg = arg->dn_list) {
4935 dt_node_printr(arg, fp, depth + 1);
4936 if (arg->dn_list != NULL)
4937 (void) fprintf(fp, "%*s,\n", depth * 2, "");
4938 }
4939
4940 if (dnp->dn_aggfun) {
4941 (void) fprintf(fp, "%*s] = ", depth * 2, "");
4942 dt_node_printr(dnp->dn_aggfun, fp, depth + 1);
4943 } else
4944 (void) fprintf(fp, "%*s]\n", depth * 2, "");
4945
4946 if (dnp->dn_aggfun)
4947 (void) fprintf(fp, "%*s)\n", depth * 2, "");
4948 break;
4949
4950 case DT_NODE_PDESC:
4951 (void) fprintf(fp, "PDESC %s:%s:%s:%s [%u]\n",
4952 dnp->dn_desc->dtpd_provider, dnp->dn_desc->dtpd_mod,
4953 dnp->dn_desc->dtpd_func, dnp->dn_desc->dtpd_name,
4954 dnp->dn_desc->dtpd_id);
4955 break;
4956
4957 case DT_NODE_CLAUSE:
4958 (void) fprintf(fp, "CLAUSE attr=%s\n", a);
4959
4960 for (arg = dnp->dn_pdescs; arg != NULL; arg = arg->dn_list)
4961 dt_node_printr(arg, fp, depth + 1);
4962
4963 (void) fprintf(fp, "%*sCTXATTR %s\n", depth * 2, "",
4964 dt_attr_str(dnp->dn_ctxattr, a, sizeof (a)));
4965
4966 if (dnp->dn_pred != NULL) {
4967 (void) fprintf(fp, "%*sPREDICATE /\n", depth * 2, "");
4968 dt_node_printr(dnp->dn_pred, fp, depth + 1);
4969 (void) fprintf(fp, "%*s/\n", depth * 2, "");
4970 }
4971
4972 for (arg = dnp->dn_acts; arg != NULL; arg = arg->dn_list)
4973 dt_node_printr(arg, fp, depth + 1);
4974 (void) fprintf(fp, "\n");
4975 break;
4976
4977 case DT_NODE_INLINE:
4978 inp = dnp->dn_ident->di_iarg;
4979
4980 (void) fprintf(fp, "INLINE %s (%s)\n",
4981 dnp->dn_ident->di_name, buf);
4982 dt_node_printr(inp->din_root, fp, depth + 1);
4983 break;
4984
4985 case DT_NODE_MEMBER:
4986 (void) fprintf(fp, "MEMBER %s (%s)\n", dnp->dn_membname, buf);
4987 if (dnp->dn_membexpr)
4988 dt_node_printr(dnp->dn_membexpr, fp, depth + 1);
4989 break;
4990
4991 case DT_NODE_XLATOR:
4992 (void) fprintf(fp, "XLATOR (%s)", buf);
4993
4994 if (ctf_type_name(dnp->dn_xlator->dx_src_ctfp,
4995 dnp->dn_xlator->dx_src_type, n, sizeof (n)) != NULL)
4996 (void) fprintf(fp, " from <%s>", n);
4997
4998 if (ctf_type_name(dnp->dn_xlator->dx_dst_ctfp,
4999 dnp->dn_xlator->dx_dst_type, n, sizeof (n)) != NULL)
5000 (void) fprintf(fp, " to <%s>", n);
5001
5002 (void) fprintf(fp, "\n");
5003
5004 for (arg = dnp->dn_members; arg != NULL; arg = arg->dn_list)
5005 dt_node_printr(arg, fp, depth + 1);
5006 break;
5007
5008 case DT_NODE_PROBE:
5009 (void) fprintf(fp, "PROBE %s\n", dnp->dn_ident->di_name);
5010 break;
5011
5012 case DT_NODE_PROVIDER:
5013 (void) fprintf(fp, "PROVIDER %s (%s)\n",
5014 dnp->dn_provname, dnp->dn_provred ? "redecl" : "decl");
5015 for (arg = dnp->dn_probes; arg != NULL; arg = arg->dn_list)
5016 dt_node_printr(arg, fp, depth + 1);
5017 break;
5018
5019 case DT_NODE_PROG:
5020 (void) fprintf(fp, "PROGRAM attr=%s\n", a);
5021 for (arg = dnp->dn_list; arg != NULL; arg = arg->dn_list)
5022 dt_node_printr(arg, fp, depth + 1);
5023 break;
5024
5025 case DT_NODE_IF:
5026 (void) fprintf(fp, "IF attr=%s CONDITION:\n", a);
5027
5028 dt_node_printr(dnp->dn_conditional, fp, depth + 1);
5029
5030 (void) fprintf(fp, "%*sIF BODY: \n", depth * 2, "");
5031 for (arg = dnp->dn_body; arg != NULL; arg = arg->dn_list)
5032 dt_node_printr(arg, fp, depth + 1);
5033
5034 if (dnp->dn_alternate_body != NULL) {
5035 (void) fprintf(fp, "%*sIF ELSE: \n", depth * 2, "");
5036 for (arg = dnp->dn_alternate_body; arg != NULL;
5037 arg = arg->dn_list)
5038 dt_node_printr(arg, fp, depth + 1);
5039 }
5040
5041 break;
5042
5043 default:
5044 (void) fprintf(fp, "<bad node %p, kind %d>\n",
5045 (void *)dnp, dnp->dn_kind);
5046 }
5047 }
5048
5049 int
5050 dt_node_root(dt_node_t *dnp)
5051 {
5052 yypcb->pcb_root = dnp;
5053 return (0);
5054 }
5055
5056 /*PRINTFLIKE3*/
5057 void
5058 dnerror(const dt_node_t *dnp, dt_errtag_t tag, const char *format, ...)
5059 {
5060 int oldlineno = yylineno;
5061 va_list ap;
5062
5063 yylineno = dnp->dn_line;
5064
5065 va_start(ap, format);
5066 xyvwarn(tag, format, ap);
5067 va_end(ap);
5068
5069 yylineno = oldlineno;
5070 longjmp(yypcb->pcb_jmpbuf, EDT_COMPILER);
5071 }
5072
5073 /*PRINTFLIKE3*/
5074 void
5075 dnwarn(const dt_node_t *dnp, dt_errtag_t tag, const char *format, ...)
5076 {
5077 int oldlineno = yylineno;
5078 va_list ap;
5079
5080 yylineno = dnp->dn_line;
5081
5082 va_start(ap, format);
5083 xyvwarn(tag, format, ap);
5084 va_end(ap);
5085
5086 yylineno = oldlineno;
5087 }
5088
5089 /*PRINTFLIKE2*/
5090 void
5091 xyerror(dt_errtag_t tag, const char *format, ...)
5092 {
5093 va_list ap;
5094
5095 va_start(ap, format);
5096 xyvwarn(tag, format, ap);
5097 va_end(ap);
5098
5099 longjmp(yypcb->pcb_jmpbuf, EDT_COMPILER);
5100 }
5101
5102 /*PRINTFLIKE2*/
5103 void
5104 xywarn(dt_errtag_t tag, const char *format, ...)
5105 {
5106 va_list ap;
5107
5108 va_start(ap, format);
5109 xyvwarn(tag, format, ap);
5110 va_end(ap);
5111 }
5112
5113 void
5114 xyvwarn(dt_errtag_t tag, const char *format, va_list ap)
5115 {
5116 if (yypcb == NULL)
5117 return; /* compiler is not currently active: act as a no-op */
5118
5119 dt_set_errmsg(yypcb->pcb_hdl, dt_errtag(tag), yypcb->pcb_region,
5120 yypcb->pcb_filetag, yypcb->pcb_fileptr ? yylineno : 0, format, ap);
5121 }
5122
5123 /*PRINTFLIKE1*/
5124 void
5125 yyerror(const char *format, ...)
5126 {
5127 va_list ap;
5128
5129 va_start(ap, format);
5130 yyvwarn(format, ap);
5131 va_end(ap);
5132
5133 longjmp(yypcb->pcb_jmpbuf, EDT_COMPILER);
5134 }
5135
5136 /*PRINTFLIKE1*/
5137 void
5138 yywarn(const char *format, ...)
5139 {
5140 va_list ap;
5141
5142 va_start(ap, format);
5143 yyvwarn(format, ap);
5144 va_end(ap);
5145 }
5146
5147 void
5148 yyvwarn(const char *format, va_list ap)
5149 {
5150 if (yypcb == NULL)
5151 return; /* compiler is not currently active: act as a no-op */
5152
5153 dt_set_errmsg(yypcb->pcb_hdl, dt_errtag(D_SYNTAX), yypcb->pcb_region,
5154 yypcb->pcb_filetag, yypcb->pcb_fileptr ? yylineno : 0, format, ap);
5155
5156 if (strchr(format, '\n') == NULL) {
5157 dtrace_hdl_t *dtp = yypcb->pcb_hdl;
5158 size_t len = strlen(dtp->dt_errmsg);
5159 char *p, *s = dtp->dt_errmsg + len;
5160 size_t n = sizeof (dtp->dt_errmsg) - len;
5161
5162 if (yytext[0] == '\0')
5163 (void) snprintf(s, n, " near end of input");
5164 else if (yytext[0] == '\n')
5165 (void) snprintf(s, n, " near end of line");
5166 else {
5167 if ((p = strchr(yytext, '\n')) != NULL)
5168 *p = '\0'; /* crop at newline */
5169 (void) snprintf(s, n, " near \"%s\"", yytext);
5170 }
5171 }
5172 }
5173
5174 void
5175 yylabel(const char *label)
5176 {
5177 dt_dprintf("set label to <%s>\n", label ? label : "NULL");
5178 yypcb->pcb_region = label;
5179 }
5180
5181 int
5182 yywrap(void)
5183 {
5184 return (1); /* indicate that lex should return a zero token for EOF */
5185 }