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