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 */
25
26 #include <sys/sysmacros.h>
27 #include <strings.h>
28 #include <stdlib.h>
29 #include <alloca.h>
30 #include <assert.h>
31 #include <errno.h>
32 #include <ctype.h>
33 #include <sys/procfs_isa.h>
34 #include <limits.h>
35
36 #include <dt_ident.h>
37 #include <dt_parser.h>
38 #include <dt_provider.h>
39 #include <dt_strtab.h>
40 #include <dt_impl.h>
41
42 /*
43 * Common code for cooking an identifier that uses a typed signature list (we
44 * use this for associative arrays and functions). If the argument list is
45 * of the same length and types, then return the return type. Otherwise
46 * print an appropriate compiler error message and abort the compile.
47 */
48 static void
49 dt_idcook_sign(dt_node_t *dnp, dt_ident_t *idp,
50 int argc, dt_node_t *args, const char *prefix, const char *suffix)
51 {
52 dt_idsig_t *isp = idp->di_data;
53 int i, compat, mismatch, arglimit, iskey;
54
55 char n1[DT_TYPE_NAMELEN];
56 char n2[DT_TYPE_NAMELEN];
57
58 iskey = idp->di_kind == DT_IDENT_ARRAY || idp->di_kind == DT_IDENT_AGG;
59
60 if (isp->dis_varargs >= 0) {
61 mismatch = argc < isp->dis_varargs;
62 arglimit = isp->dis_varargs;
63 } else if (isp->dis_optargs >= 0) {
64 mismatch = (argc < isp->dis_optargs || argc > isp->dis_argc);
65 arglimit = argc;
66 } else {
67 mismatch = argc != isp->dis_argc;
68 arglimit = isp->dis_argc;
69 }
70
71 if (mismatch) {
72 xyerror(D_PROTO_LEN, "%s%s%s prototype mismatch: %d %s%s"
73 "passed, %s%d expected\n", prefix, idp->di_name, suffix,
74 argc, iskey ? "key" : "arg", argc == 1 ? " " : "s ",
75 isp->dis_optargs >= 0 ? "at least " : "",
76 isp->dis_optargs >= 0 ? isp->dis_optargs : arglimit);
77 }
78
79 for (i = 0; i < arglimit; i++, args = args->dn_list) {
80 if (isp->dis_args[i].dn_ctfp != NULL)
81 compat = dt_node_is_argcompat(&isp->dis_args[i], args);
82 else
83 compat = 1; /* "@" matches any type */
84
85 if (!compat) {
86 xyerror(D_PROTO_ARG,
87 "%s%s%s %s #%d is incompatible with "
88 "prototype:\n\tprototype: %s\n\t%9s: %s\n",
89 prefix, idp->di_name, suffix,
90 iskey ? "key" : "argument", i + 1,
91 dt_node_type_name(&isp->dis_args[i], n1,
92 sizeof (n1)),
93 iskey ? "key" : "argument",
94 dt_node_type_name(args, n2, sizeof (n2)));
95 }
96 }
97
98 dt_node_type_assign(dnp, idp->di_ctfp, idp->di_type);
99 }
100
101 /*
102 * Cook an associative array identifier. If this is the first time we are
103 * cooking this array, create its signature based on the argument list.
104 * Otherwise validate the argument list against the existing signature.
105 */
106 static void
107 dt_idcook_assc(dt_node_t *dnp, dt_ident_t *idp, int argc, dt_node_t *args)
108 {
109 if (idp->di_data == NULL) {
110 dt_idsig_t *isp = idp->di_data = malloc(sizeof (dt_idsig_t));
111 char n[DT_TYPE_NAMELEN];
112 int i;
113
114 if (isp == NULL)
115 longjmp(yypcb->pcb_jmpbuf, EDT_NOMEM);
116
117 isp->dis_varargs = -1;
118 isp->dis_optargs = -1;
119 isp->dis_argc = argc;
120 isp->dis_args = NULL;
121 isp->dis_auxinfo = 0;
122
123 if (argc != 0 && (isp->dis_args = calloc(argc,
124 sizeof (dt_node_t))) == NULL) {
125 idp->di_data = NULL;
126 free(isp);
127 longjmp(yypcb->pcb_jmpbuf, EDT_NOMEM);
128 }
129
130 /*
131 * If this identifier has not been explicitly declared earlier,
132 * set the identifier's base type to be our special type <DYN>.
133 * If this ident is an aggregation, it will remain as is. If
134 * this ident is an associative array, it will be reassigned
135 * based on the result type of the first assignment statement.
136 */
137 if (!(idp->di_flags & DT_IDFLG_DECL)) {
138 idp->di_ctfp = DT_DYN_CTFP(yypcb->pcb_hdl);
139 idp->di_type = DT_DYN_TYPE(yypcb->pcb_hdl);
140 }
141
142 for (i = 0; i < argc; i++, args = args->dn_list) {
143 if (dt_node_is_dynamic(args) || dt_node_is_void(args)) {
144 xyerror(D_KEY_TYPE, "%s expression may not be "
145 "used as %s index: key #%d\n",
146 dt_node_type_name(args, n, sizeof (n)),
147 dt_idkind_name(idp->di_kind), i + 1);
148 }
149
150 dt_node_type_propagate(args, &isp->dis_args[i]);
151 isp->dis_args[i].dn_list = &isp->dis_args[i + 1];
152 }
153
154 if (argc != 0)
155 isp->dis_args[argc - 1].dn_list = NULL;
156
157 dt_node_type_assign(dnp, idp->di_ctfp, idp->di_type);
158
159 } else {
160 dt_idcook_sign(dnp, idp, argc, args,
161 idp->di_kind == DT_IDENT_AGG ? "@" : "", "[ ]");
162 }
163 }
164
165 /*
166 * Cook a function call. If this is the first time we are cooking this
167 * identifier, create its type signature based on predefined prototype stored
168 * in di_iarg. We then validate the argument list against this signature.
169 */
170 static void
171 dt_idcook_func(dt_node_t *dnp, dt_ident_t *idp, int argc, dt_node_t *args)
172 {
173 if (idp->di_data == NULL) {
174 dtrace_hdl_t *dtp = yypcb->pcb_hdl;
175 dtrace_typeinfo_t dtt;
176 dt_idsig_t *isp;
177 char *s, *p1, *p2;
178 int i = 0;
179
180 assert(idp->di_iarg != NULL);
181 s = strdupa(idp->di_iarg);
182
183 if ((p2 = strrchr(s, ')')) != NULL)
184 *p2 = '\0'; /* mark end of parameter list string */
185
186 if ((p1 = strchr(s, '(')) != NULL)
187 *p1++ = '\0'; /* mark end of return type string */
188
189 if (p1 == NULL || p2 == NULL) {
190 xyerror(D_UNKNOWN, "internal error: malformed entry "
191 "for built-in function %s\n", idp->di_name);
192 }
193
194 for (p2 = p1; *p2 != '\0'; p2++) {
195 if (!isspace(*p2)) {
196 i++;
197 break;
198 }
199 }
200
201 for (p2 = strchr(p2, ','); p2++ != NULL; i++)
202 p2 = strchr(p2, ',');
203
204 /*
205 * We first allocate a new ident signature structure with the
206 * appropriate number of argument entries, and then look up
207 * the return type and store its CTF data in di_ctfp/type.
208 */
209 if ((isp = idp->di_data = malloc(sizeof (dt_idsig_t))) == NULL)
210 longjmp(yypcb->pcb_jmpbuf, EDT_NOMEM);
211
212 isp->dis_varargs = -1;
213 isp->dis_optargs = -1;
214 isp->dis_argc = i;
215 isp->dis_args = NULL;
216 isp->dis_auxinfo = 0;
217
218 if (i != 0 && (isp->dis_args = calloc(i,
219 sizeof (dt_node_t))) == NULL) {
220 idp->di_data = NULL;
221 free(isp);
222 longjmp(yypcb->pcb_jmpbuf, EDT_NOMEM);
223 }
224
225 if (dt_type_lookup(s, &dtt) == -1) {
226 xyerror(D_UNKNOWN, "failed to resolve type of %s (%s):"
227 " %s\n", idp->di_name, s,
228 dtrace_errmsg(dtp, dtrace_errno(dtp)));
229 }
230
231 if (idp->di_kind == DT_IDENT_AGGFUNC) {
232 idp->di_ctfp = DT_DYN_CTFP(dtp);
233 idp->di_type = DT_DYN_TYPE(dtp);
234 } else {
235 idp->di_ctfp = dtt.dtt_ctfp;
236 idp->di_type = dtt.dtt_type;
237 }
238
239 /*
240 * For each comma-delimited parameter in the prototype string,
241 * we look up the corresponding type and store its CTF data in
242 * the corresponding location in dis_args[]. We also recognize
243 * the special type string "@" to indicate that the specified
244 * parameter may be a D expression of *any* type (represented
245 * as a dis_args[] element with ctfp = NULL, type == CTF_ERR).
246 * If a varargs "..." is present, we record the argument index
247 * in dis_varargs for the benefit of dt_idcook_sign(), above.
248 * If the type of an argument is enclosed in square brackets
249 * (e.g. "[int]"), the argument is considered optional: the
250 * argument may be absent, but if it is present, it must be of
251 * the specified type. Note that varargs may not optional,
252 * optional arguments may not follow varargs, and non-optional
253 * arguments may not follow optional arguments.
254 */
255 for (i = 0; i < isp->dis_argc; i++, p1 = p2) {
256 while (isspace(*p1))
257 p1++; /* skip leading whitespace */
258
259 if ((p2 = strchr(p1, ',')) == NULL)
260 p2 = p1 + strlen(p1);
261 else
262 *p2++ = '\0';
263
264 if (strcmp(p1, "@") == 0 || strcmp(p1, "...") == 0) {
265 isp->dis_args[i].dn_ctfp = NULL;
266 isp->dis_args[i].dn_type = CTF_ERR;
267 if (*p1 == '.')
268 isp->dis_varargs = i;
269 continue;
270 }
271
272 if (*p1 == '[' && p1[strlen(p1) - 1] == ']') {
273 if (isp->dis_varargs != -1) {
274 xyerror(D_UNKNOWN, "optional arg#%d "
275 "may not follow variable arg#%d\n",
276 i + 1, isp->dis_varargs + 1);
277 }
278
279 if (isp->dis_optargs == -1)
280 isp->dis_optargs = i;
281
282 p1[strlen(p1) - 1] = '\0';
283 p1++;
284 } else if (isp->dis_optargs != -1) {
285 xyerror(D_UNKNOWN, "required arg#%d may not "
286 "follow optional arg#%d\n", i + 1,
287 isp->dis_optargs + 1);
288 }
289
290 if (dt_type_lookup(p1, &dtt) == -1) {
291 xyerror(D_UNKNOWN, "failed to resolve type of "
292 "%s arg#%d (%s): %s\n", idp->di_name, i + 1,
293 p1, dtrace_errmsg(dtp, dtrace_errno(dtp)));
294 }
295
296 dt_node_type_assign(&isp->dis_args[i],
297 dtt.dtt_ctfp, dtt.dtt_type);
298 }
299 }
300
301 dt_idcook_sign(dnp, idp, argc, args, "", "( )");
302 }
303
304 /*
305 * Cook a reference to the dynamically typed args[] array. We verify that the
306 * reference is using a single integer constant, and then construct a new ident
307 * representing the appropriate type or translation specifically for this node.
308 */
309 static void
310 dt_idcook_args(dt_node_t *dnp, dt_ident_t *idp, int argc, dt_node_t *ap)
311 {
312 dtrace_hdl_t *dtp = yypcb->pcb_hdl;
313 dt_probe_t *prp = yypcb->pcb_probe;
314
315 dt_node_t tag, *nnp, *xnp;
316 dt_xlator_t *dxp;
317 dt_ident_t *xidp;
318
319 char n1[DT_TYPE_NAMELEN];
320 char n2[DT_TYPE_NAMELEN];
321
322 if (argc != 1) {
323 xyerror(D_PROTO_LEN, "%s[ ] prototype mismatch: %d arg%s"
324 "passed, 1 expected\n", idp->di_name, argc,
325 argc == 1 ? " " : "s ");
326 }
327
328 if (ap->dn_kind != DT_NODE_INT) {
329 xyerror(D_PROTO_ARG, "%s[ ] argument #1 is incompatible with "
330 "prototype:\n\tprototype: %s\n\t argument: %s\n",
331 idp->di_name, "integer constant",
332 dt_type_name(ap->dn_ctfp, ap->dn_type, n1, sizeof (n1)));
333 }
334
335 if (yypcb->pcb_pdesc == NULL) {
336 xyerror(D_ARGS_NONE, "%s[ ] may not be referenced outside "
337 "of a probe clause\n", idp->di_name);
338 }
339
340 if (prp == NULL) {
341 xyerror(D_ARGS_MULTI,
342 "%s[ ] may not be referenced because probe description %s "
343 "matches an unstable set of probes\n", idp->di_name,
344 dtrace_desc2str(yypcb->pcb_pdesc, n1, sizeof (n1)));
345 }
346
347 if (ap->dn_value >= prp->pr_argc) {
348 xyerror(D_ARGS_IDX, "index %lld is out of range for %s %s[ ]\n",
349 (longlong_t)ap->dn_value, dtrace_desc2str(yypcb->pcb_pdesc,
350 n1, sizeof (n1)), idp->di_name);
351 }
352
353 /*
354 * Look up the native and translated argument types for the probe.
355 * If no translation is needed, these will be the same underlying node.
356 * If translation is needed, look up the appropriate translator. Once
357 * we have the appropriate node, create a new dt_ident_t for this node,
358 * assign it the appropriate attributes, and set the type of 'dnp'.
359 */
360 xnp = prp->pr_xargv[ap->dn_value];
361 nnp = prp->pr_nargv[prp->pr_mapping[ap->dn_value]];
362
363 if (xnp->dn_type == CTF_ERR) {
364 xyerror(D_ARGS_TYPE, "failed to resolve translated type for "
365 "%s[%lld]\n", idp->di_name, (longlong_t)ap->dn_value);
366 }
367
368 if (nnp->dn_type == CTF_ERR) {
369 xyerror(D_ARGS_TYPE, "failed to resolve native type for "
370 "%s[%lld]\n", idp->di_name, (longlong_t)ap->dn_value);
371 }
372
373 if (dtp->dt_xlatemode == DT_XL_STATIC && (
374 nnp == xnp || dt_node_is_argcompat(nnp, xnp))) {
375 dnp->dn_ident = dt_ident_create(idp->di_name, idp->di_kind,
376 idp->di_flags | DT_IDFLG_ORPHAN, idp->di_id, idp->di_attr,
377 idp->di_vers, idp->di_ops, idp->di_iarg, idp->di_gen);
378
379 if (dnp->dn_ident == NULL)
380 longjmp(yypcb->pcb_jmpbuf, EDT_NOMEM);
381
382 dt_node_type_assign(dnp,
383 prp->pr_argv[ap->dn_value].dtt_ctfp,
384 prp->pr_argv[ap->dn_value].dtt_type);
385
386 } else if ((dxp = dt_xlator_lookup(dtp,
387 nnp, xnp, DT_XLATE_FUZZY)) != NULL || (
388 dxp = dt_xlator_lookup(dtp, dt_probe_tag(prp, ap->dn_value, &tag),
389 xnp, DT_XLATE_EXACT | DT_XLATE_EXTERN)) != NULL) {
390
391 xidp = dt_xlator_ident(dxp, xnp->dn_ctfp, xnp->dn_type);
392
393 dnp->dn_ident = dt_ident_create(idp->di_name, xidp->di_kind,
394 xidp->di_flags | DT_IDFLG_ORPHAN, idp->di_id, idp->di_attr,
395 idp->di_vers, idp->di_ops, idp->di_iarg, idp->di_gen);
396
397 if (dnp->dn_ident == NULL)
398 longjmp(yypcb->pcb_jmpbuf, EDT_NOMEM);
399
400 if (dt_xlator_dynamic(dxp))
401 dxp->dx_arg = (int)ap->dn_value;
402
403 /*
404 * Propagate relevant members from the translator's internal
405 * dt_ident_t. This code must be kept in sync with the state
406 * that is initialized for idents in dt_xlator_create().
407 */
408 dnp->dn_ident->di_data = xidp->di_data;
409 dnp->dn_ident->di_ctfp = xidp->di_ctfp;
410 dnp->dn_ident->di_type = xidp->di_type;
411
412 dt_node_type_assign(dnp, DT_DYN_CTFP(dtp), DT_DYN_TYPE(dtp));
413
414 } else {
415 xyerror(D_ARGS_XLATOR, "translator for %s[%lld] from %s to %s "
416 "is not defined\n", idp->di_name, (longlong_t)ap->dn_value,
417 dt_node_type_name(nnp, n1, sizeof (n1)),
418 dt_node_type_name(xnp, n2, sizeof (n2)));
419 }
420
421 assert(dnp->dn_ident->di_flags & DT_IDFLG_ORPHAN);
422 assert(dnp->dn_ident->di_id == idp->di_id);
423 }
424
425 static void
426 dt_idcook_regs(dt_node_t *dnp, dt_ident_t *idp, int argc, dt_node_t *ap)
427 {
428 dtrace_typeinfo_t dtt;
429 dtrace_hdl_t *dtp = yypcb->pcb_hdl;
430 char n[DT_TYPE_NAMELEN];
431
432 if (argc != 1) {
433 xyerror(D_PROTO_LEN, "%s[ ] prototype mismatch: %d arg%s"
434 "passed, 1 expected\n", idp->di_name,
435 argc, argc == 1 ? " " : "s ");
436 }
437
438 if (ap->dn_kind != DT_NODE_INT) {
439 xyerror(D_PROTO_ARG, "%s[ ] argument #1 is incompatible with "
440 "prototype:\n\tprototype: %s\n\t argument: %s\n",
441 idp->di_name, "integer constant",
442 dt_type_name(ap->dn_ctfp, ap->dn_type, n, sizeof (n)));
443 }
444
445 if ((ap->dn_flags & DT_NF_SIGNED) && (int64_t)ap->dn_value < 0) {
446 xyerror(D_REGS_IDX, "index %lld is out of range for array %s\n",
447 (longlong_t)ap->dn_value, idp->di_name);
448 }
449
450 if (dt_type_lookup("uint64_t", &dtt) == -1) {
451 xyerror(D_UNKNOWN, "failed to resolve type of %s: %s\n",
452 idp->di_name, dtrace_errmsg(dtp, dtrace_errno(dtp)));
453 }
454
455 idp->di_ctfp = dtt.dtt_ctfp;
456 idp->di_type = dtt.dtt_type;
457
458 dt_node_type_assign(dnp, idp->di_ctfp, idp->di_type);
459 }
460
461 /*ARGSUSED*/
462 static void
463 dt_idcook_type(dt_node_t *dnp, dt_ident_t *idp, int argc, dt_node_t *args)
464 {
465 if (idp->di_type == CTF_ERR) {
466 dtrace_hdl_t *dtp = yypcb->pcb_hdl;
467 dtrace_typeinfo_t dtt;
468
469 if (dt_type_lookup(idp->di_iarg, &dtt) == -1) {
470 xyerror(D_UNKNOWN,
471 "failed to resolve type %s for identifier %s: %s\n",
472 (const char *)idp->di_iarg, idp->di_name,
473 dtrace_errmsg(dtp, dtrace_errno(dtp)));
474 }
475
476 idp->di_ctfp = dtt.dtt_ctfp;
477 idp->di_type = dtt.dtt_type;
478 }
479
480 dt_node_type_assign(dnp, idp->di_ctfp, idp->di_type);
481 }
482
483 /*ARGSUSED*/
484 static void
485 dt_idcook_thaw(dt_node_t *dnp, dt_ident_t *idp, int argc, dt_node_t *args)
486 {
487 if (idp->di_ctfp != NULL && idp->di_type != CTF_ERR)
488 dt_node_type_assign(dnp, idp->di_ctfp, idp->di_type);
489 }
490
491 static void
492 dt_idcook_inline(dt_node_t *dnp, dt_ident_t *idp, int argc, dt_node_t *args)
493 {
494 if (idp->di_kind == DT_IDENT_ARRAY)
495 dt_idcook_assc(dnp, idp, argc, args);
496 else
497 dt_idcook_thaw(dnp, idp, argc, args);
498 }
499
500 static void
501 dt_iddtor_sign(dt_ident_t *idp)
502 {
503 if (idp->di_data != NULL)
504 free(((dt_idsig_t *)idp->di_data)->dis_args);
505 free(idp->di_data);
506 }
507
508 static void
509 dt_iddtor_free(dt_ident_t *idp)
510 {
511 free(idp->di_data);
512 }
513
514 static void
515 dt_iddtor_inline(dt_ident_t *idp)
516 {
517 dt_idnode_t *inp = idp->di_iarg;
518
519 if (inp != NULL) {
520 dt_node_link_free(&inp->din_list);
521
522 if (inp->din_hash != NULL)
523 dt_idhash_destroy(inp->din_hash);
524
525 free(inp->din_argv);
526 free(inp);
527 }
528
529 if (idp->di_kind == DT_IDENT_ARRAY)
530 dt_iddtor_sign(idp);
531 else
532 dt_iddtor_free(idp);
533 }
534
535 /*ARGSUSED*/
536 static void
537 dt_iddtor_none(dt_ident_t *idp)
538 {
539 /* do nothing */
540 }
541
542 static void
543 dt_iddtor_probe(dt_ident_t *idp)
544 {
545 if (idp->di_data != NULL)
546 dt_probe_destroy(idp->di_data);
547 }
548
549 static size_t
550 dt_idsize_type(dt_ident_t *idp)
551 {
552 return (ctf_type_size(idp->di_ctfp, idp->di_type));
553 }
554
555 /*ARGSUSED*/
556 static size_t
557 dt_idsize_none(dt_ident_t *idp)
558 {
559 return (0);
560 }
561
562 const dt_idops_t dt_idops_assc = {
563 dt_idcook_assc,
564 dt_iddtor_sign,
565 dt_idsize_none,
566 };
567
568 const dt_idops_t dt_idops_func = {
569 dt_idcook_func,
570 dt_iddtor_sign,
571 dt_idsize_none,
572 };
573
574 const dt_idops_t dt_idops_args = {
575 dt_idcook_args,
576 dt_iddtor_none,
577 dt_idsize_none,
578 };
579
580 const dt_idops_t dt_idops_regs = {
581 dt_idcook_regs,
582 dt_iddtor_free,
583 dt_idsize_none,
584 };
585
586 const dt_idops_t dt_idops_type = {
587 dt_idcook_type,
588 dt_iddtor_free,
589 dt_idsize_type,
590 };
591
592 const dt_idops_t dt_idops_thaw = {
593 dt_idcook_thaw,
594 dt_iddtor_free,
595 dt_idsize_type,
596 };
597
598 const dt_idops_t dt_idops_inline = {
599 dt_idcook_inline,
600 dt_iddtor_inline,
601 dt_idsize_type,
602 };
603
604 const dt_idops_t dt_idops_probe = {
605 dt_idcook_thaw,
606 dt_iddtor_probe,
607 dt_idsize_none,
608 };
609
610 static void
611 dt_idhash_populate(dt_idhash_t *dhp)
612 {
613 const dt_ident_t *idp = dhp->dh_tmpl;
614
615 dhp->dh_tmpl = NULL; /* clear dh_tmpl first to avoid recursion */
616 dt_dprintf("populating %s idhash from %p\n", dhp->dh_name, (void *)idp);
617
618 for (; idp->di_name != NULL; idp++) {
619 if (dt_idhash_insert(dhp, idp->di_name,
620 idp->di_kind, idp->di_flags, idp->di_id, idp->di_attr,
621 idp->di_vers, idp->di_ops ? idp->di_ops : &dt_idops_thaw,
622 idp->di_iarg, 0) == NULL)
623 longjmp(yypcb->pcb_jmpbuf, EDT_NOMEM);
624 }
625 }
626
627 dt_idhash_t *
628 dt_idhash_create(const char *name, const dt_ident_t *tmpl,
629 uint_t min, uint_t max)
630 {
631 dt_idhash_t *dhp;
632 size_t size;
633
634 assert(min <= max);
635
636 size = sizeof (dt_idhash_t) +
637 sizeof (dt_ident_t *) * (_dtrace_strbuckets - 1);
638
639 if ((dhp = malloc(size)) == NULL)
640 return (NULL);
641
642 bzero(dhp, size);
643 dhp->dh_name = name;
644 dhp->dh_tmpl = tmpl;
645 dhp->dh_nextid = min;
646 dhp->dh_minid = min;
647 dhp->dh_maxid = max;
648 dhp->dh_hashsz = _dtrace_strbuckets;
649
650 return (dhp);
651 }
652
653 /*
654 * Destroy an entire identifier hash. This must be done using two passes with
655 * an inlined version of dt_ident_destroy() to avoid referencing freed memory.
656 * In the first pass di_dtor() is called for all identifiers; then the second
657 * pass frees the actual dt_ident_t's. These must be done separately because
658 * a di_dtor() may operate on data structures which contain references to other
659 * identifiers inside of this hash itself (e.g. a global inline definition
660 * which contains a parse tree that refers to another global variable).
661 */
662 void
663 dt_idhash_destroy(dt_idhash_t *dhp)
664 {
665 dt_ident_t *idp, *next;
666 ulong_t i;
667
668 for (i = 0; i < dhp->dh_hashsz; i++) {
669 for (idp = dhp->dh_hash[i]; idp != NULL; idp = next) {
670 next = idp->di_next;
671 idp->di_ops->di_dtor(idp);
672 }
673 }
674
675 for (i = 0; i < dhp->dh_hashsz; i++) {
676 for (idp = dhp->dh_hash[i]; idp != NULL; idp = next) {
677 next = idp->di_next;
678 free(idp->di_name);
679 free(idp);
680 }
681 }
682
683 free(dhp);
684 }
685
686 void
687 dt_idhash_update(dt_idhash_t *dhp)
688 {
689 uint_t nextid = dhp->dh_minid;
690 dt_ident_t *idp;
691 ulong_t i;
692
693 for (i = 0; i < dhp->dh_hashsz; i++) {
694 for (idp = dhp->dh_hash[i]; idp != NULL; idp = idp->di_next) {
695 /*
696 * Right now we're hard coding which types need to be
697 * reset, but ideally this would be done dynamically.
698 */
699 if (idp->di_kind == DT_IDENT_ARRAY ||
700 idp->di_kind == DT_IDENT_SCALAR ||
701 idp->di_kind == DT_IDENT_AGG)
702 nextid = MAX(nextid, idp->di_id + 1);
703 }
704 }
705
706 dhp->dh_nextid = nextid;
707 }
708
709 dt_ident_t *
710 dt_idhash_lookup(dt_idhash_t *dhp, const char *name)
711 {
712 size_t len;
713 ulong_t h = dt_strtab_hash(name, &len) % dhp->dh_hashsz;
714 dt_ident_t *idp;
715
716 if (dhp->dh_tmpl != NULL)
717 dt_idhash_populate(dhp); /* fill hash w/ initial population */
718
719 for (idp = dhp->dh_hash[h]; idp != NULL; idp = idp->di_next) {
720 if (strcmp(idp->di_name, name) == 0)
721 return (idp);
722 }
723
724 return (NULL);
725 }
726
727 int
728 dt_idhash_nextid(dt_idhash_t *dhp, uint_t *p)
729 {
730 if (dhp->dh_nextid >= dhp->dh_maxid)
731 return (-1); /* no more id's are free to allocate */
732
733 *p = dhp->dh_nextid++;
734 return (0);
735 }
736
737 ulong_t
738 dt_idhash_size(const dt_idhash_t *dhp)
739 {
740 return (dhp->dh_nelems);
741 }
742
743 const char *
744 dt_idhash_name(const dt_idhash_t *dhp)
745 {
746 return (dhp->dh_name);
747 }
748
749 dt_ident_t *
750 dt_idhash_insert(dt_idhash_t *dhp, const char *name, ushort_t kind,
751 ushort_t flags, uint_t id, dtrace_attribute_t attr, uint_t vers,
752 const dt_idops_t *ops, void *iarg, ulong_t gen)
753 {
754 dt_ident_t *idp;
755 ulong_t h;
756
757 if (dhp->dh_tmpl != NULL)
758 dt_idhash_populate(dhp); /* fill hash w/ initial population */
759
760 idp = dt_ident_create(name, kind, flags, id,
761 attr, vers, ops, iarg, gen);
762
763 if (idp == NULL)
764 return (NULL);
765
766 h = dt_strtab_hash(name, NULL) % dhp->dh_hashsz;
767 idp->di_next = dhp->dh_hash[h];
768
769 dhp->dh_hash[h] = idp;
770 dhp->dh_nelems++;
771
772 if (dhp->dh_defer != NULL)
773 dhp->dh_defer(dhp, idp);
774
775 return (idp);
776 }
777
778 void
779 dt_idhash_xinsert(dt_idhash_t *dhp, dt_ident_t *idp)
780 {
781 ulong_t h;
782
783 if (dhp->dh_tmpl != NULL)
784 dt_idhash_populate(dhp); /* fill hash w/ initial population */
785
786 h = dt_strtab_hash(idp->di_name, NULL) % dhp->dh_hashsz;
787 idp->di_next = dhp->dh_hash[h];
788 idp->di_flags &= ~DT_IDFLG_ORPHAN;
789
790 dhp->dh_hash[h] = idp;
791 dhp->dh_nelems++;
792
793 if (dhp->dh_defer != NULL)
794 dhp->dh_defer(dhp, idp);
795 }
796
797 void
798 dt_idhash_delete(dt_idhash_t *dhp, dt_ident_t *key)
799 {
800 size_t len;
801 ulong_t h = dt_strtab_hash(key->di_name, &len) % dhp->dh_hashsz;
802 dt_ident_t **pp = &dhp->dh_hash[h];
803 dt_ident_t *idp;
804
805 for (idp = dhp->dh_hash[h]; idp != NULL; idp = idp->di_next) {
806 if (idp == key)
807 break;
808 else
809 pp = &idp->di_next;
810 }
811
812 assert(idp == key);
813 *pp = idp->di_next;
814
815 assert(dhp->dh_nelems != 0);
816 dhp->dh_nelems--;
817
818 if (!(idp->di_flags & DT_IDFLG_ORPHAN))
819 dt_ident_destroy(idp);
820 }
821
822 static int
823 dt_idhash_comp(const void *lp, const void *rp)
824 {
825 const dt_ident_t *lhs = *((const dt_ident_t **)lp);
826 const dt_ident_t *rhs = *((const dt_ident_t **)rp);
827
828 if (lhs->di_id != rhs->di_id)
829 return ((int)(lhs->di_id - rhs->di_id));
830 else
831 return (strcmp(lhs->di_name, rhs->di_name));
832 }
833
834 int
835 dt_idhash_iter(dt_idhash_t *dhp, dt_idhash_f *func, void *data)
836 {
837 dt_ident_t **ids;
838 dt_ident_t *idp;
839 ulong_t i, j, n;
840 int rv;
841
842 if (dhp->dh_tmpl != NULL)
843 dt_idhash_populate(dhp); /* fill hash w/ initial population */
844
845 n = dhp->dh_nelems;
846 ids = alloca(sizeof (dt_ident_t *) * n);
847
848 for (i = 0, j = 0; i < dhp->dh_hashsz; i++) {
849 for (idp = dhp->dh_hash[i]; idp != NULL; idp = idp->di_next)
850 ids[j++] = idp;
851 }
852
853 qsort(ids, dhp->dh_nelems, sizeof (dt_ident_t *), dt_idhash_comp);
854
855 for (i = 0; i < n; i++) {
856 if ((rv = func(dhp, ids[i], data)) != 0)
857 return (rv);
858 }
859
860 return (0);
861 }
862
863 dt_ident_t *
864 dt_idstack_lookup(dt_idstack_t *sp, const char *name)
865 {
866 dt_idhash_t *dhp;
867 dt_ident_t *idp;
868
869 for (dhp = dt_list_prev(&sp->dids_list);
870 dhp != NULL; dhp = dt_list_prev(dhp)) {
871 if ((idp = dt_idhash_lookup(dhp, name)) != NULL)
872 return (idp);
873 }
874
875 return (NULL);
876 }
877
878 void
879 dt_idstack_push(dt_idstack_t *sp, dt_idhash_t *dhp)
880 {
881 dt_list_append(&sp->dids_list, dhp);
882 }
883
884 void
885 dt_idstack_pop(dt_idstack_t *sp, dt_idhash_t *dhp)
886 {
887 assert(dt_list_prev(&sp->dids_list) == dhp);
888 dt_list_delete(&sp->dids_list, dhp);
889 }
890
891 dt_ident_t *
892 dt_ident_create(const char *name, ushort_t kind, ushort_t flags, uint_t id,
893 dtrace_attribute_t attr, uint_t vers,
894 const dt_idops_t *ops, void *iarg, ulong_t gen)
895 {
896 dt_ident_t *idp;
897 char *s = NULL;
898
899 if ((name != NULL && (s = strdup(name)) == NULL) ||
900 (idp = malloc(sizeof (dt_ident_t))) == NULL) {
901 free(s);
902 return (NULL);
903 }
904
905 idp->di_name = s;
906 idp->di_kind = kind;
907 idp->di_flags = flags;
908 idp->di_id = id;
909 idp->di_attr = attr;
910 idp->di_vers = vers;
911 idp->di_ops = ops;
912 idp->di_iarg = iarg;
913 idp->di_data = NULL;
914 idp->di_ctfp = NULL;
915 idp->di_type = CTF_ERR;
916 idp->di_next = NULL;
917 idp->di_gen = gen;
918 idp->di_lineno = yylineno;
919
920 return (idp);
921 }
922
923 /*
924 * Destroy an individual identifier. This code must be kept in sync with the
925 * dt_idhash_destroy() function below, which separates out the call to di_dtor.
926 */
927 void
928 dt_ident_destroy(dt_ident_t *idp)
929 {
930 idp->di_ops->di_dtor(idp);
931 free(idp->di_name);
932 free(idp);
933 }
934
935 void
936 dt_ident_morph(dt_ident_t *idp, ushort_t kind,
937 const dt_idops_t *ops, void *iarg)
938 {
939 idp->di_ops->di_dtor(idp);
940 idp->di_kind = kind;
941 idp->di_ops = ops;
942 idp->di_iarg = iarg;
943 idp->di_data = NULL;
944 }
945
946 dtrace_attribute_t
947 dt_ident_cook(dt_node_t *dnp, dt_ident_t *idp, dt_node_t **pargp)
948 {
949 dtrace_attribute_t attr;
950 dt_node_t *args, *argp;
951 int argc = 0;
952
953 attr = dt_node_list_cook(pargp, DT_IDFLG_REF);
954 args = pargp ? *pargp : NULL;
955
956 for (argp = args; argp != NULL; argp = argp->dn_list)
957 argc++;
958
959 idp->di_ops->di_cook(dnp, idp, argc, args);
960
961 if (idp->di_flags & DT_IDFLG_USER)
962 dnp->dn_flags |= DT_NF_USERLAND;
963
964 return (dt_attr_min(attr, idp->di_attr));
965 }
966
967 void
968 dt_ident_type_assign(dt_ident_t *idp, ctf_file_t *fp, ctf_id_t type)
969 {
970 idp->di_ctfp = fp;
971 idp->di_type = type;
972 }
973
974 dt_ident_t *
975 dt_ident_resolve(dt_ident_t *idp)
976 {
977 while (idp->di_flags & DT_IDFLG_INLINE) {
978 const dt_node_t *dnp = ((dt_idnode_t *)idp->di_iarg)->din_root;
979
980 if (dnp == NULL)
981 break; /* can't resolve any further yet */
982
983 switch (dnp->dn_kind) {
984 case DT_NODE_VAR:
985 case DT_NODE_SYM:
986 case DT_NODE_FUNC:
987 case DT_NODE_AGG:
988 case DT_NODE_INLINE:
989 case DT_NODE_PROBE:
990 idp = dnp->dn_ident;
991 continue;
992 }
993
994 if (dt_node_is_dynamic(dnp))
995 idp = dnp->dn_ident;
996 else
997 break;
998 }
999
1000 return (idp);
1001 }
1002
1003 size_t
1004 dt_ident_size(dt_ident_t *idp)
1005 {
1006 idp = dt_ident_resolve(idp);
1007 return (idp->di_ops->di_size(idp));
1008 }
1009
1010 int
1011 dt_ident_unref(const dt_ident_t *idp)
1012 {
1013 return (idp->di_gen == yypcb->pcb_hdl->dt_gen &&
1014 (idp->di_flags & (DT_IDFLG_REF|DT_IDFLG_MOD|DT_IDFLG_DECL)) == 0);
1015 }
1016
1017 const char *
1018 dt_idkind_name(uint_t kind)
1019 {
1020 switch (kind) {
1021 case DT_IDENT_ARRAY: return ("associative array");
1022 case DT_IDENT_SCALAR: return ("scalar");
1023 case DT_IDENT_PTR: return ("pointer");
1024 case DT_IDENT_FUNC: return ("function");
1025 case DT_IDENT_AGG: return ("aggregation");
1026 case DT_IDENT_AGGFUNC: return ("aggregating function");
1027 case DT_IDENT_ACTFUNC: return ("tracing function");
1028 case DT_IDENT_XLSOU: return ("translated data");
1029 case DT_IDENT_XLPTR: return ("pointer to translated data");
1030 case DT_IDENT_SYMBOL: return ("external symbol reference");
1031 case DT_IDENT_ENUM: return ("enumerator");
1032 case DT_IDENT_PRAGAT: return ("#pragma attributes");
1033 case DT_IDENT_PRAGBN: return ("#pragma binding");
1034 case DT_IDENT_PROBE: return ("probe definition");
1035 default: return ("<?>");
1036 }
1037 }