xref: /titanic_52/usr/src/lib/libdtrace/common/dt_decl.c (revision 3c112a2b34403220c06c3e2fcac403358cfba168)
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, Version 1.0 only
6  * (the "License").  You may not use this file except in compliance
7  * with the License.
8  *
9  * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE
10  * or http://www.opensolaris.org/os/licensing.
11  * See the License for the specific language governing permissions
12  * and limitations under the License.
13  *
14  * When distributing Covered Code, include this CDDL HEADER in each
15  * file and include the License file at usr/src/OPENSOLARIS.LICENSE.
16  * If applicable, add the following below this CDDL HEADER, with the
17  * fields enclosed by brackets "[]" replaced with your own identifying
18  * information: Portions Copyright [yyyy] [name of copyright owner]
19  *
20  * CDDL HEADER END
21  */
22 /*
23  * Copyright 2005 Sun Microsystems, Inc.  All rights reserved.
24  * Use is subject to license terms.
25  */
26 
27 #pragma ident	"%Z%%M%	%I%	%E% SMI"
28 
29 #include <strings.h>
30 #include <stdlib.h>
31 #include <limits.h>
32 #include <alloca.h>
33 #include <assert.h>
34 
35 #include <dt_decl.h>
36 #include <dt_parser.h>
37 #include <dt_module.h>
38 #include <dt_impl.h>
39 
40 static dt_decl_t *
41 dt_decl_check(dt_decl_t *ddp)
42 {
43 	if (ddp->dd_kind == CTF_K_UNKNOWN)
44 		return (ddp); /* nothing to check if the type is not yet set */
45 
46 	if (ddp->dd_name != NULL && strcmp(ddp->dd_name, "char") == 0 &&
47 	    (ddp->dd_attr & (DT_DA_SHORT | DT_DA_LONG | DT_DA_LONGLONG))) {
48 		xyerror(D_DECL_CHARATTR, "invalid type declaration: short and "
49 		    "long may not be used with char type\n");
50 	}
51 
52 	if (ddp->dd_name != NULL && strcmp(ddp->dd_name, "void") == 0 &&
53 	    (ddp->dd_attr & (DT_DA_SHORT | DT_DA_LONG | DT_DA_LONGLONG |
54 	    (DT_DA_SIGNED | DT_DA_UNSIGNED)))) {
55 		xyerror(D_DECL_VOIDATTR, "invalid type declaration: attributes "
56 		    "may not be used with void type\n");
57 	}
58 
59 	if (ddp->dd_kind != CTF_K_INTEGER &&
60 	    (ddp->dd_attr & (DT_DA_SIGNED | DT_DA_UNSIGNED))) {
61 		xyerror(D_DECL_SIGNINT, "invalid type declaration: signed and "
62 		    "unsigned may only be used with integer type\n");
63 	}
64 
65 	if (ddp->dd_kind != CTF_K_INTEGER && ddp->dd_kind != CTF_K_FLOAT &&
66 	    (ddp->dd_attr & (DT_DA_LONG | DT_DA_LONGLONG))) {
67 		xyerror(D_DECL_LONGINT, "invalid type declaration: long and "
68 		    "long long may only be used with integer or "
69 		    "floating-point type\n");
70 	}
71 
72 	return (ddp);
73 }
74 
75 dt_decl_t *
76 dt_decl_alloc(ushort_t kind, char *name)
77 {
78 	dt_decl_t *ddp = malloc(sizeof (dt_decl_t));
79 
80 	if (ddp == NULL)
81 		longjmp(yypcb->pcb_jmpbuf, EDT_NOMEM);
82 
83 	ddp->dd_kind = kind;
84 	ddp->dd_attr = 0;
85 	ddp->dd_ctfp = NULL;
86 	ddp->dd_type = CTF_ERR;
87 	ddp->dd_name = name;
88 	ddp->dd_node = NULL;
89 	ddp->dd_next = NULL;
90 
91 	return (ddp);
92 }
93 
94 void
95 dt_decl_free(dt_decl_t *ddp)
96 {
97 	dt_decl_t *ndp;
98 
99 	for (; ddp != NULL; ddp = ndp) {
100 		ndp = ddp->dd_next;
101 		free(ddp->dd_name);
102 		dt_node_list_free(&ddp->dd_node);
103 		free(ddp);
104 	}
105 }
106 
107 void
108 dt_decl_reset(void)
109 {
110 	dt_scope_t *dsp = &yypcb->pcb_dstack;
111 	dt_decl_t *ddp = dsp->ds_decl;
112 
113 	while (ddp->dd_next != NULL) {
114 		dsp->ds_decl = ddp->dd_next;
115 		ddp->dd_next = NULL;
116 		dt_decl_free(ddp);
117 		ddp = dsp->ds_decl;
118 	}
119 }
120 
121 dt_decl_t *
122 dt_decl_push(dt_decl_t *ddp)
123 {
124 	dt_scope_t *dsp = &yypcb->pcb_dstack;
125 	dt_decl_t *top = dsp->ds_decl;
126 
127 	if (top != NULL &&
128 	    top->dd_kind == CTF_K_UNKNOWN && top->dd_name == NULL) {
129 		top->dd_kind = CTF_K_INTEGER;
130 		(void) dt_decl_check(top);
131 	}
132 
133 	assert(ddp->dd_next == NULL);
134 	ddp->dd_next = top;
135 	dsp->ds_decl = ddp;
136 
137 	return (ddp);
138 }
139 
140 dt_decl_t *
141 dt_decl_pop(void)
142 {
143 	dt_scope_t *dsp = &yypcb->pcb_dstack;
144 	dt_decl_t *ddp = dt_decl_top();
145 
146 	dsp->ds_decl = NULL;
147 	free(dsp->ds_ident);
148 	dsp->ds_ident = NULL;
149 	dsp->ds_ctfp = NULL;
150 	dsp->ds_type = CTF_ERR;
151 	dsp->ds_class = DT_DC_DEFAULT;
152 	dsp->ds_enumval = -1;
153 
154 	return (ddp);
155 }
156 
157 dt_decl_t *
158 dt_decl_pop_param(char **idp)
159 {
160 	dt_scope_t *dsp = &yypcb->pcb_dstack;
161 
162 	if (dsp->ds_class != DT_DC_DEFAULT && dsp->ds_class != DT_DC_REGISTER) {
163 		xyerror(D_DECL_PARMCLASS, "inappropriate storage class "
164 		    "for function or associative array parameter\n");
165 	}
166 
167 	if (idp != NULL && dt_decl_top() != NULL) {
168 		*idp = dsp->ds_ident;
169 		dsp->ds_ident = NULL;
170 	}
171 
172 	return (dt_decl_pop());
173 }
174 
175 dt_decl_t *
176 dt_decl_top(void)
177 {
178 	dt_decl_t *ddp = yypcb->pcb_dstack.ds_decl;
179 
180 	if (ddp == NULL)
181 		longjmp(yypcb->pcb_jmpbuf, EDT_NODECL);
182 
183 	if (ddp->dd_kind == CTF_K_UNKNOWN && ddp->dd_name == NULL) {
184 		ddp->dd_kind = CTF_K_INTEGER;
185 		(void) dt_decl_check(ddp);
186 	}
187 
188 	return (ddp);
189 }
190 
191 dt_decl_t *
192 dt_decl_ident(char *name)
193 {
194 	dt_scope_t *dsp = &yypcb->pcb_dstack;
195 	dt_decl_t *ddp = dsp->ds_decl;
196 
197 	if (dsp->ds_ident != NULL) {
198 		free(name);
199 		xyerror(D_DECL_IDENT, "old-style declaration or "
200 		    "incorrect type specified\n");
201 	}
202 
203 	dsp->ds_ident = name;
204 
205 	if (ddp == NULL)
206 		ddp = dt_decl_push(dt_decl_alloc(CTF_K_UNKNOWN, NULL));
207 
208 	return (ddp);
209 }
210 
211 void
212 dt_decl_class(dt_dclass_t class)
213 {
214 	dt_scope_t *dsp = &yypcb->pcb_dstack;
215 
216 	if (dsp->ds_class != DT_DC_DEFAULT) {
217 		xyerror(D_DECL_CLASS, "only one storage class allowed "
218 		    "in a declaration\n");
219 	}
220 
221 	dsp->ds_class = class;
222 }
223 
224 /*
225  * Set the kind and name of the current declaration.  If none is allocated,
226  * make a new decl and push it on to the top of our stack.  If the name or kind
227  * is already set for the current decl, then we need to fail this declaration.
228  * This can occur because too many types were given (e.g. "int int"), etc.
229  */
230 dt_decl_t *
231 dt_decl_spec(ushort_t kind, char *name)
232 {
233 	dt_decl_t *ddp = yypcb->pcb_dstack.ds_decl;
234 
235 	if (ddp == NULL)
236 		return (dt_decl_push(dt_decl_alloc(kind, name)));
237 
238 	/*
239 	 * If we already have a type name specified and we see another type
240 	 * name, this is an error if the declaration is a typedef.  If the
241 	 * declaration is not a typedef, then the user may be trying to declare
242 	 * a variable whose name has been returned by lex as a TNAME token:
243 	 * call dt_decl_ident() as if the grammar's IDENT rule was matched.
244 	 */
245 	if (ddp->dd_name != NULL && kind == CTF_K_TYPEDEF) {
246 		if (yypcb->pcb_dstack.ds_class != DT_DC_TYPEDEF)
247 			return (dt_decl_ident(name));
248 		xyerror(D_DECL_IDRED, "identifier redeclared: %s\n", name);
249 	}
250 
251 	if (ddp->dd_name != NULL || ddp->dd_kind != CTF_K_UNKNOWN)
252 		xyerror(D_DECL_COMBO, "invalid type combination\n");
253 
254 	ddp->dd_kind = kind;
255 	ddp->dd_name = name;
256 
257 	if (name != NULL && strchr(name, '`') != NULL) {
258 		xyerror(D_DECL_SCOPE, "D scoping operator may not be used "
259 		    "in a type name\n");
260 	}
261 
262 	return (dt_decl_check(ddp));
263 }
264 
265 dt_decl_t *
266 dt_decl_attr(ushort_t attr)
267 {
268 	dt_decl_t *ddp = yypcb->pcb_dstack.ds_decl;
269 
270 	if (ddp == NULL) {
271 		ddp = dt_decl_push(dt_decl_alloc(CTF_K_UNKNOWN, NULL));
272 		ddp->dd_attr = attr;
273 		return (ddp);
274 	}
275 
276 	if (attr == DT_DA_LONG && (ddp->dd_attr & DT_DA_LONG)) {
277 		ddp->dd_attr &= ~DT_DA_LONG;
278 		attr = DT_DA_LONGLONG;
279 	}
280 
281 	ddp->dd_attr |= attr;
282 	return (dt_decl_check(ddp));
283 }
284 
285 /*
286  * Examine the list of formal parameters 'flist' and determine if the formal
287  * name fnp->dn_string is defined in this list (B_TRUE) or not (B_FALSE).
288  * If 'fnp' is in 'flist', do not search beyond 'fnp' itself in 'flist'.
289  */
290 static int
291 dt_decl_protoform(dt_node_t *fnp, dt_node_t *flist)
292 {
293 	dt_node_t *dnp;
294 
295 	for (dnp = flist; dnp != fnp && dnp != NULL; dnp = dnp->dn_list) {
296 		if (dnp->dn_string != NULL &&
297 		    strcmp(dnp->dn_string, fnp->dn_string) == 0)
298 			return (B_TRUE);
299 	}
300 
301 	return (B_FALSE);
302 }
303 
304 /*
305  * Common code for parsing array, function, and probe definition prototypes.
306  * The prototype node list is specified as 'plist'.  The formal prototype
307  * against which to compare the prototype is specified as 'flist'.  If plist
308  * and flist are the same, we require that named parameters are unique.  If
309  * plist and flist are different, we require that named parameters in plist
310  * match a name that is present in flist.
311  */
312 int
313 dt_decl_prototype(dt_node_t *plist,
314     dt_node_t *flist, const char *kind, uint_t flags)
315 {
316 	char n[DT_TYPE_NAMELEN];
317 	int is_void, v = 0, i = 1;
318 	int form = plist != flist;
319 	dt_node_t *dnp;
320 
321 	for (dnp = plist; dnp != NULL; dnp = dnp->dn_list, i++) {
322 
323 		if (dnp->dn_type == CTF_ERR && !(flags & DT_DP_VARARGS)) {
324 			dnerror(dnp, D_DECL_PROTO_VARARGS, "%s prototype may "
325 			    "not use a variable-length argument list\n", kind);
326 		}
327 
328 		if (dt_node_is_dynamic(dnp) && !(flags & DT_DP_DYNAMIC)) {
329 			dnerror(dnp, D_DECL_PROTO_TYPE, "%s prototype may not "
330 			    "use parameter of type %s: %s, parameter #%d\n",
331 			    kind, dt_node_type_name(dnp, n, sizeof (n)),
332 			    dnp->dn_string ? dnp->dn_string : "(anonymous)", i);
333 		}
334 
335 		is_void = dt_node_is_void(dnp);
336 		v += is_void;
337 
338 		if (is_void && !(flags & DT_DP_VOID)) {
339 			dnerror(dnp, D_DECL_PROTO_TYPE, "%s prototype may not "
340 			    "use parameter of type %s: %s, parameter #%d\n",
341 			    kind, dt_node_type_name(dnp, n, sizeof (n)),
342 			    dnp->dn_string ? dnp->dn_string : "(anonymous)", i);
343 		}
344 
345 		if (is_void && dnp->dn_string != NULL) {
346 			dnerror(dnp, D_DECL_PROTO_NAME, "void parameter may "
347 			    "not have a name: %s\n", dnp->dn_string);
348 		}
349 
350 		if (dnp->dn_string != NULL &&
351 		    dt_decl_protoform(dnp, flist) != form) {
352 			dnerror(dnp, D_DECL_PROTO_FORM, "parameter is "
353 			    "%s declared in %s prototype: %s, parameter #%d\n",
354 			    form ? "not" : "already", kind, dnp->dn_string, i);
355 		}
356 
357 		if (dnp->dn_string == NULL &&
358 		    !is_void && !(flags & DT_DP_ANON)) {
359 			dnerror(dnp, D_DECL_PROTO_NAME, "parameter declaration "
360 			    "requires a name: parameter #%d\n", i);
361 		}
362 	}
363 
364 	if (v != 0 && plist->dn_list != NULL)
365 		xyerror(D_DECL_PROTO_VOID, "void must be sole parameter\n");
366 
367 	return (v ? 0 : i - 1); /* return zero if sole parameter is 'void' */
368 }
369 
370 dt_decl_t *
371 dt_decl_array(dt_node_t *dnp)
372 {
373 	dt_decl_t *ddp = dt_decl_push(dt_decl_alloc(CTF_K_ARRAY, NULL));
374 	dt_scope_t *dsp = &yypcb->pcb_dstack;
375 	dt_decl_t *ndp = ddp;
376 
377 	/*
378 	 * After pushing the array on to the decl stack, scan ahead for multi-
379 	 * dimensional array declarations and push the current decl to the
380 	 * bottom to match the resulting CTF type tree and data layout.  Refer
381 	 * to the comments in dt_decl_type() and ISO C 6.5.2.1 for more info.
382 	 */
383 	while (ndp->dd_next != NULL && ndp->dd_next->dd_kind == CTF_K_ARRAY)
384 		ndp = ndp->dd_next; /* skip to bottom-most array declaration */
385 
386 	if (ndp != ddp) {
387 		if (dnp != NULL && dnp->dn_kind == DT_NODE_TYPE) {
388 			xyerror(D_DECL_DYNOBJ,
389 			    "cannot declare array of associative arrays\n");
390 		}
391 		dsp->ds_decl = ddp->dd_next;
392 		ddp->dd_next = ndp->dd_next;
393 		ndp->dd_next = ddp;
394 	}
395 
396 	if (ddp->dd_next->dd_name != NULL &&
397 	    strcmp(ddp->dd_next->dd_name, "void") == 0)
398 		xyerror(D_DECL_VOIDOBJ, "cannot declare array of void\n");
399 
400 	if (dnp != NULL && dnp->dn_kind != DT_NODE_TYPE) {
401 		dnp = ddp->dd_node = dt_node_cook(dnp, DT_IDFLG_REF);
402 
403 		if (dt_node_is_posconst(dnp) == 0) {
404 			xyerror(D_DECL_ARRSUB, "positive integral constant "
405 			    "expression or tuple signature expected as "
406 			    "array declaration subscript\n");
407 		}
408 
409 		if (dnp->dn_value > UINT_MAX)
410 			xyerror(D_DECL_ARRBIG, "array dimension too big\n");
411 
412 	} else if (dnp != NULL) {
413 		ddp->dd_node = dnp;
414 		(void) dt_decl_prototype(dnp, dnp, "array", DT_DP_ANON);
415 	}
416 
417 	return (ddp);
418 }
419 
420 /*
421  * When a function is declared, we need to fudge the decl stack a bit if the
422  * declaration uses the function pointer (*)() syntax.  In this case, the
423  * dt_decl_func() call occurs *after* the dt_decl_ptr() call, even though the
424  * resulting type is "pointer to function".  To make the pointer land on top,
425  * we check to see if 'pdp' is non-NULL and a pointer.  If it is, we search
426  * backward for a decl tagged with DT_DA_PAREN, and if one is found, the func
427  * decl is inserted behind this node in the decl list instead of at the top.
428  * In all cases, the func decl's dd_next pointer is set to the decl chain
429  * for the function's return type and the function parameter list is discarded.
430  */
431 dt_decl_t *
432 dt_decl_func(dt_decl_t *pdp, dt_node_t *dnp)
433 {
434 	dt_decl_t *ddp = dt_decl_alloc(CTF_K_FUNCTION, NULL);
435 
436 	ddp->dd_node = dnp;
437 
438 	(void) dt_decl_prototype(dnp, dnp, "function",
439 	    DT_DP_VARARGS | DT_DP_VOID | DT_DP_ANON);
440 
441 	if (pdp == NULL || pdp->dd_kind != CTF_K_POINTER)
442 		return (dt_decl_push(ddp));
443 
444 	while (pdp->dd_next != NULL && !(pdp->dd_next->dd_attr & DT_DA_PAREN))
445 		pdp = pdp->dd_next;
446 
447 	if (pdp->dd_next == NULL)
448 		return (dt_decl_push(ddp));
449 
450 	ddp->dd_next = pdp->dd_next;
451 	pdp->dd_next = ddp;
452 
453 	return (pdp);
454 }
455 
456 dt_decl_t *
457 dt_decl_ptr(void)
458 {
459 	return (dt_decl_push(dt_decl_alloc(CTF_K_POINTER, NULL)));
460 }
461 
462 dt_decl_t *
463 dt_decl_sou(uint_t kind, char *name)
464 {
465 	dt_decl_t *ddp = dt_decl_spec(kind, name);
466 	char n[DT_TYPE_NAMELEN];
467 	ctf_file_t *ctfp;
468 	ctf_id_t type;
469 	uint_t flag;
470 
471 	if (yypcb->pcb_idepth != 0)
472 		ctfp = yypcb->pcb_hdl->dt_cdefs->dm_ctfp;
473 	else
474 		ctfp = yypcb->pcb_hdl->dt_ddefs->dm_ctfp;
475 
476 	if (yypcb->pcb_dstack.ds_next != NULL)
477 		flag = CTF_ADD_NONROOT;
478 	else
479 		flag = CTF_ADD_ROOT;
480 
481 	(void) snprintf(n, sizeof (n), "%s %s",
482 	    kind == CTF_K_STRUCT ? "struct" : "union",
483 	    name == NULL ? "(anon)" : name);
484 
485 	if (name != NULL && (type = ctf_lookup_by_name(ctfp, n)) != CTF_ERR &&
486 	    ctf_type_kind(ctfp, type) != CTF_K_FORWARD)
487 		xyerror(D_DECL_TYPERED, "type redeclared: %s\n", n);
488 
489 	if (kind == CTF_K_STRUCT)
490 		type = ctf_add_struct(ctfp, flag, name);
491 	else
492 		type = ctf_add_union(ctfp, flag, name);
493 
494 	if (type == CTF_ERR || ctf_update(ctfp) == CTF_ERR) {
495 		xyerror(D_UNKNOWN, "failed to define %s: %s\n",
496 		    n, ctf_errmsg(ctf_errno(ctfp)));
497 	}
498 
499 	ddp->dd_ctfp = ctfp;
500 	ddp->dd_type = type;
501 
502 	dt_scope_push(ctfp, type);
503 	return (ddp);
504 }
505 
506 void
507 dt_decl_member(dt_node_t *dnp)
508 {
509 	dt_scope_t *dsp = yypcb->pcb_dstack.ds_next;
510 	dt_decl_t *ddp = yypcb->pcb_dstack.ds_decl;
511 	char *ident = yypcb->pcb_dstack.ds_ident;
512 
513 	const char *idname = ident ? ident : "(anon)";
514 	char n[DT_TYPE_NAMELEN];
515 
516 	dtrace_typeinfo_t dtt;
517 	ctf_encoding_t cte;
518 	ctf_id_t base;
519 	uint_t kind;
520 	ssize_t size;
521 
522 	if (dsp == NULL)
523 		longjmp(yypcb->pcb_jmpbuf, EDT_NOSCOPE);
524 
525 	if (ddp == NULL)
526 		longjmp(yypcb->pcb_jmpbuf, EDT_NODECL);
527 
528 	if (dnp == NULL && ident == NULL)
529 		xyerror(D_DECL_MNAME, "member declaration requires a name\n");
530 
531 	if (ddp->dd_kind == CTF_K_UNKNOWN && ddp->dd_name == NULL) {
532 		ddp->dd_kind = CTF_K_INTEGER;
533 		(void) dt_decl_check(ddp);
534 	}
535 
536 	if (dt_decl_type(ddp, &dtt) != 0)
537 		longjmp(yypcb->pcb_jmpbuf, EDT_COMPILER);
538 
539 	if (ident != NULL && strchr(ident, '`') != NULL) {
540 		xyerror(D_DECL_SCOPE, "D scoping operator may not be used "
541 		    "in a member name (%s)\n", ident);
542 	}
543 
544 	if (dtt.dtt_ctfp == DT_DYN_CTFP(yypcb->pcb_hdl) &&
545 	    dtt.dtt_type == DT_DYN_TYPE(yypcb->pcb_hdl)) {
546 		xyerror(D_DECL_DYNOBJ,
547 		    "cannot have dynamic member: %s\n", ident);
548 	}
549 
550 	base = ctf_type_resolve(dtt.dtt_ctfp, dtt.dtt_type);
551 	kind = ctf_type_kind(dtt.dtt_ctfp, base);
552 	size = ctf_type_size(dtt.dtt_ctfp, base);
553 
554 	if (kind == CTF_K_FORWARD || ((kind == CTF_K_STRUCT ||
555 	    kind == CTF_K_UNION) && size == 0)) {
556 		xyerror(D_DECL_INCOMPLETE, "incomplete struct/union/enum %s: "
557 		    "%s\n", dt_type_name(dtt.dtt_ctfp, dtt.dtt_type,
558 		    n, sizeof (n)), ident);
559 	}
560 
561 	if (size == 0)
562 		xyerror(D_DECL_VOIDOBJ, "cannot have void member: %s\n", ident);
563 
564 	/*
565 	 * If a bit-field qualifier was part of the member declaration, create
566 	 * a new integer type of the same name and attributes as the base type
567 	 * and size equal to the specified number of bits.  We reset 'dtt' to
568 	 * refer to this new bit-field type and continue on to add the member.
569 	 */
570 	if (dnp != NULL) {
571 		dnp = dt_node_cook(dnp, DT_IDFLG_REF);
572 
573 		/*
574 		 * A bit-field member with no declarator is permitted to have
575 		 * size zero and indicates that no more fields are to be packed
576 		 * into the current storage unit.  We ignore these directives
577 		 * as the underlying ctf code currently does so for all fields.
578 		 */
579 		if (ident == NULL && dnp->dn_kind == DT_NODE_INT &&
580 		    dnp->dn_value == 0) {
581 			dt_node_free(dnp);
582 			goto done;
583 		}
584 
585 		if (dt_node_is_posconst(dnp) == 0) {
586 			xyerror(D_DECL_BFCONST, "positive integral constant "
587 			    "expression expected as bit-field size\n");
588 		}
589 
590 		if (ctf_type_kind(dtt.dtt_ctfp, base) != CTF_K_INTEGER ||
591 		    ctf_type_encoding(dtt.dtt_ctfp, base, &cte) == CTF_ERR ||
592 		    IS_VOID(cte)) {
593 			xyerror(D_DECL_BFTYPE, "invalid type for "
594 			    "bit-field: %s\n", idname);
595 		}
596 
597 		if (dnp->dn_value > cte.cte_bits) {
598 			xyerror(D_DECL_BFSIZE, "bit-field too big "
599 			    "for type: %s\n", idname);
600 		}
601 
602 		cte.cte_offset = 0;
603 		cte.cte_bits = (uint_t)dnp->dn_value;
604 
605 		dtt.dtt_type = ctf_add_integer(dsp->ds_ctfp,
606 		    CTF_ADD_NONROOT, ctf_type_name(dtt.dtt_ctfp,
607 		    dtt.dtt_type, n, sizeof (n)), &cte);
608 
609 		if (dtt.dtt_type == CTF_ERR ||
610 		    ctf_update(dsp->ds_ctfp) == CTF_ERR) {
611 			xyerror(D_UNKNOWN, "failed to create type for "
612 			    "member '%s': %s\n", idname,
613 			    ctf_errmsg(ctf_errno(dsp->ds_ctfp)));
614 		}
615 
616 		dtt.dtt_ctfp = dsp->ds_ctfp;
617 		dt_node_free(dnp);
618 	}
619 
620 	/*
621 	 * If the member type is not defined in the same CTF container as the
622 	 * one associated with the current scope (i.e. the container for the
623 	 * struct or union itself) or its parent, copy the member type into
624 	 * this container and reset dtt to refer to the copied type.
625 	 */
626 	if (dtt.dtt_ctfp != dsp->ds_ctfp &&
627 	    dtt.dtt_ctfp != ctf_parent_file(dsp->ds_ctfp)) {
628 
629 		dtt.dtt_type = ctf_add_type(dsp->ds_ctfp,
630 		    dtt.dtt_ctfp, dtt.dtt_type);
631 		dtt.dtt_ctfp = dsp->ds_ctfp;
632 
633 		if (dtt.dtt_type == CTF_ERR ||
634 		    ctf_update(dtt.dtt_ctfp) == CTF_ERR) {
635 			xyerror(D_UNKNOWN, "failed to copy type of '%s': %s\n",
636 			    idname, ctf_errmsg(ctf_errno(dtt.dtt_ctfp)));
637 		}
638 	}
639 
640 	if (ctf_add_member(dsp->ds_ctfp, dsp->ds_type,
641 	    ident, dtt.dtt_type) == CTF_ERR) {
642 		xyerror(D_UNKNOWN, "failed to define member '%s': %s\n",
643 		    idname, ctf_errmsg(ctf_errno(dsp->ds_ctfp)));
644 	}
645 
646 done:
647 	free(ident);
648 	yypcb->pcb_dstack.ds_ident = NULL;
649 	dt_decl_reset();
650 }
651 
652 /*ARGSUSED*/
653 static int
654 dt_decl_hasmembers(const char *name, int value, void *private)
655 {
656 	return (1); /* abort search and return true if a member exists */
657 }
658 
659 dt_decl_t *
660 dt_decl_enum(char *name)
661 {
662 	dt_decl_t *ddp = dt_decl_spec(CTF_K_ENUM, name);
663 	char n[DT_TYPE_NAMELEN];
664 	ctf_file_t *ctfp;
665 	ctf_id_t type;
666 	uint_t flag;
667 
668 	if (yypcb->pcb_idepth != 0)
669 		ctfp = yypcb->pcb_hdl->dt_cdefs->dm_ctfp;
670 	else
671 		ctfp = yypcb->pcb_hdl->dt_ddefs->dm_ctfp;
672 
673 	if (yypcb->pcb_dstack.ds_next != NULL)
674 		flag = CTF_ADD_NONROOT;
675 	else
676 		flag = CTF_ADD_ROOT;
677 
678 	(void) snprintf(n, sizeof (n), "enum %s", name ? name : "(anon)");
679 
680 	if (name != NULL && (type = ctf_lookup_by_name(ctfp, n)) != CTF_ERR) {
681 		if (ctf_enum_iter(ctfp, type, dt_decl_hasmembers, NULL))
682 			xyerror(D_DECL_TYPERED, "type redeclared: %s\n", n);
683 	} else if ((type = ctf_add_enum(ctfp, flag, name)) == CTF_ERR) {
684 		xyerror(D_UNKNOWN, "failed to define %s: %s\n",
685 		    n, ctf_errmsg(ctf_errno(ctfp)));
686 	}
687 
688 	ddp->dd_ctfp = ctfp;
689 	ddp->dd_type = type;
690 
691 	dt_scope_push(ctfp, type);
692 	return (ddp);
693 }
694 
695 void
696 dt_decl_enumerator(char *s, dt_node_t *dnp)
697 {
698 	dt_scope_t *dsp = yypcb->pcb_dstack.ds_next;
699 	dtrace_hdl_t *dtp = yypcb->pcb_hdl;
700 
701 	dt_idnode_t *inp;
702 	dt_ident_t *idp;
703 	char *name;
704 	int value;
705 
706 	name = alloca(strlen(s) + 1);
707 	(void) strcpy(name, s);
708 	free(s);
709 
710 	if (dsp == NULL)
711 		longjmp(yypcb->pcb_jmpbuf, EDT_NOSCOPE);
712 
713 	assert(dsp->ds_decl->dd_kind == CTF_K_ENUM);
714 	value = dsp->ds_enumval + 1; /* default is previous value plus one */
715 
716 	if (strchr(name, '`') != NULL) {
717 		xyerror(D_DECL_SCOPE, "D scoping operator may not be used in "
718 		    "an enumerator name (%s)\n", name);
719 	}
720 
721 	/*
722 	 * If the enumerator is being assigned a value, cook and check the node
723 	 * and then free it after we get the value.  We also permit references
724 	 * to identifiers which are previously defined enumerators in the type.
725 	 */
726 	if (dnp != NULL) {
727 		if (dnp->dn_kind != DT_NODE_IDENT || ctf_enum_value(
728 		    dsp->ds_ctfp, dsp->ds_type, dnp->dn_string, &value) != 0) {
729 			dnp = dt_node_cook(dnp, DT_IDFLG_REF);
730 
731 			if (dnp->dn_kind != DT_NODE_INT) {
732 				xyerror(D_DECL_ENCONST, "enumerator '%s' must "
733 				    "be assigned to an integral constant "
734 				    "expression\n", name);
735 			}
736 
737 			if ((intmax_t)dnp->dn_value > INT_MAX ||
738 			    (intmax_t)dnp->dn_value < INT_MIN) {
739 				xyerror(D_DECL_ENOFLOW, "enumerator '%s' value "
740 				    "overflows INT_MAX (%d)\n", name, INT_MAX);
741 			}
742 
743 			value = (int)dnp->dn_value;
744 		}
745 		dt_node_free(dnp);
746 	}
747 
748 	if (ctf_add_enumerator(dsp->ds_ctfp, dsp->ds_type,
749 	    name, value) == CTF_ERR || ctf_update(dsp->ds_ctfp) == CTF_ERR) {
750 		xyerror(D_UNKNOWN, "failed to define enumerator '%s': %s\n",
751 		    name, ctf_errmsg(ctf_errno(dsp->ds_ctfp)));
752 	}
753 
754 	dsp->ds_enumval = value; /* save most recent value */
755 
756 	/*
757 	 * If the enumerator name matches an identifier in the global scope,
758 	 * flag this as an error.  We only do this for "D" enumerators to
759 	 * prevent "C" header file enumerators from conflicting with the ever-
760 	 * growing list of D built-in global variables and inlines.  If a "C"
761 	 * enumerator conflicts with a global identifier, we add the enumerator
762 	 * but do not insert a corresponding inline (i.e. the D variable wins).
763 	 */
764 	if (dt_idstack_lookup(&yypcb->pcb_globals, name) != NULL) {
765 		if (dsp->ds_ctfp == dtp->dt_ddefs->dm_ctfp) {
766 			xyerror(D_DECL_IDRED,
767 			    "identifier redeclared: %s\n", name);
768 		} else
769 			return;
770 	}
771 
772 	dt_dprintf("add global enumerator %s = %d\n", name, value);
773 
774 	idp = dt_idhash_insert(dtp->dt_globals, name, DT_IDENT_ENUM,
775 	    DT_IDFLG_INLINE | DT_IDFLG_REF, 0, _dtrace_defattr, 0,
776 	    &dt_idops_inline, NULL, dtp->dt_gen);
777 
778 	if (idp == NULL)
779 		longjmp(yypcb->pcb_jmpbuf, EDT_NOMEM);
780 
781 	yyintprefix = 0;
782 	yyintsuffix[0] = '\0';
783 	yyintdecimal = 0;
784 
785 	dnp = dt_node_int(value);
786 	dt_node_type_assign(dnp, dsp->ds_ctfp, dsp->ds_type);
787 
788 	if ((inp = malloc(sizeof (dt_idnode_t))) == NULL)
789 		longjmp(yypcb->pcb_jmpbuf, EDT_NOMEM);
790 
791 	/*
792 	 * Remove the INT node from the node allocation list and store it in
793 	 * din_list and din_root so it persists with and is freed by the ident.
794 	 */
795 	assert(yypcb->pcb_list == dnp);
796 	yypcb->pcb_list = dnp->dn_link;
797 	dnp->dn_link = NULL;
798 
799 	bzero(inp, sizeof (dt_idnode_t));
800 	inp->din_list = dnp;
801 	inp->din_root = dnp;
802 
803 	idp->di_iarg = inp;
804 	idp->di_ctfp = dsp->ds_ctfp;
805 	idp->di_type = dsp->ds_type;
806 }
807 
808 /*
809  * Look up the type corresponding to the specified decl stack.  The scoping of
810  * the underlying type names is handled by dt_type_lookup().  We build up the
811  * name from the specified string and prefixes and then lookup the type.  If
812  * we fail, an errmsg is saved and the caller must abort with EDT_COMPILER.
813  */
814 int
815 dt_decl_type(dt_decl_t *ddp, dtrace_typeinfo_t *tip)
816 {
817 	dtrace_hdl_t *dtp = yypcb->pcb_hdl;
818 
819 	dt_module_t *dmp;
820 	ctf_arinfo_t r;
821 	ctf_id_t type;
822 
823 	char n[DT_TYPE_NAMELEN];
824 	uint_t flag;
825 	char *name;
826 	int rv;
827 
828 	/*
829 	 * Based on our current #include depth and decl stack depth, determine
830 	 * which dynamic CTF module and scope to use when adding any new types.
831 	 */
832 	dmp = yypcb->pcb_idepth ? dtp->dt_cdefs : dtp->dt_ddefs;
833 	flag = yypcb->pcb_dstack.ds_next ? CTF_ADD_NONROOT : CTF_ADD_ROOT;
834 
835 	/*
836 	 * If we have already cached a CTF type for this decl, then we just
837 	 * return the type information for the cached type.
838 	 */
839 	if (ddp->dd_ctfp != NULL &&
840 	    (dmp = dt_module_lookup_by_ctf(dtp, ddp->dd_ctfp)) != NULL) {
841 		tip->dtt_object = dmp->dm_name;
842 		tip->dtt_ctfp = ddp->dd_ctfp;
843 		tip->dtt_type = ddp->dd_type;
844 		return (0);
845 	}
846 
847 	/*
848 	 * Currently CTF treats all function pointers identically.  We cache a
849 	 * representative ID of kind CTF_K_FUNCTION and just return that type.
850 	 * If we want to support full function declarations, dd_next refers to
851 	 * the declaration of the function return type, and the parameter list
852 	 * should be parsed and hung off a new pointer inside of this decl.
853 	 */
854 	if (ddp->dd_kind == CTF_K_FUNCTION) {
855 		tip->dtt_object = dtp->dt_ddefs->dm_name;
856 		tip->dtt_ctfp = DT_FUNC_CTFP(dtp);
857 		tip->dtt_type = DT_FUNC_TYPE(dtp);
858 		return (0);
859 	}
860 
861 	/*
862 	 * If the decl is a pointer, resolve the rest of the stack by calling
863 	 * dt_decl_type() recursively and then compute a pointer to the result.
864 	 * Similar to the code above, we return a cached id for function ptrs.
865 	 */
866 	if (ddp->dd_kind == CTF_K_POINTER) {
867 		if (ddp->dd_next->dd_kind == CTF_K_FUNCTION) {
868 			tip->dtt_object = dtp->dt_ddefs->dm_name;
869 			tip->dtt_ctfp = DT_FPTR_CTFP(dtp);
870 			tip->dtt_type = DT_FPTR_TYPE(dtp);
871 			return (0);
872 		}
873 
874 		if ((rv = dt_decl_type(ddp->dd_next, tip)) == 0 &&
875 		    (rv = dt_type_pointer(tip)) != 0) {
876 			xywarn(D_UNKNOWN, "cannot find type: %s*: %s\n",
877 			    dt_type_name(tip->dtt_ctfp, tip->dtt_type,
878 			    n, sizeof (n)), ctf_errmsg(dtp->dt_ctferr));
879 		}
880 
881 		return (rv);
882 	}
883 
884 	/*
885 	 * If the decl is an array, we must find the base type and then call
886 	 * dt_decl_type() recursively and then build an array of the result.
887 	 * The C and D multi-dimensional array syntax requires that consecutive
888 	 * array declarations be processed from right-to-left (i.e. top-down
889 	 * from the perspective of the declaration stack).  For example, an
890 	 * array declaration such as int x[3][5] is stored on the stack as:
891 	 *
892 	 * (bottom) NULL <- ( INT "int" ) <- ( ARR [3] ) <- ( ARR [5] ) (top)
893 	 *
894 	 * but means that x is declared to be an array of 3 objects each of
895 	 * which is an array of 5 integers, or in CTF representation:
896 	 *
897 	 * type T1:( content=int, nelems=5 ) type T2:( content=T1, nelems=3 )
898 	 *
899 	 * For more details, refer to K&R[5.7] and ISO C 6.5.2.1.  Rather than
900 	 * overcomplicate the implementation of dt_decl_type(), we push array
901 	 * declarations down into the stack in dt_decl_array(), above, so that
902 	 * by the time dt_decl_type() is called, the decl stack looks like:
903 	 *
904 	 * (bottom) NULL <- ( INT "int" ) <- ( ARR [5] ) <- ( ARR [3] ) (top)
905 	 *
906 	 * which permits a straightforward recursive descent of the decl stack
907 	 * to build the corresponding CTF type tree in the appropriate order.
908 	 */
909 	if (ddp->dd_kind == CTF_K_ARRAY) {
910 		/*
911 		 * If the array decl has a parameter list associated with it,
912 		 * this is an associative array declaration: return <DYN>.
913 		 */
914 		if (ddp->dd_node != NULL &&
915 		    ddp->dd_node->dn_kind == DT_NODE_TYPE) {
916 			tip->dtt_object = dtp->dt_ddefs->dm_name;
917 			tip->dtt_ctfp = DT_DYN_CTFP(dtp);
918 			tip->dtt_type = DT_DYN_TYPE(dtp);
919 			return (0);
920 		}
921 
922 		if ((rv = dt_decl_type(ddp->dd_next, tip)) != 0)
923 			return (rv);
924 
925 		/*
926 		 * If the array base type is not defined in the target
927 		 * container or its parent, copy the type to the target
928 		 * container and reset dtt_ctfp and dtt_type to the copy.
929 		 */
930 		if (tip->dtt_ctfp != dmp->dm_ctfp &&
931 		    tip->dtt_ctfp != ctf_parent_file(dmp->dm_ctfp)) {
932 
933 			tip->dtt_type = ctf_add_type(dmp->dm_ctfp,
934 			    tip->dtt_ctfp, tip->dtt_type);
935 			tip->dtt_ctfp = dmp->dm_ctfp;
936 
937 			if (tip->dtt_type == CTF_ERR ||
938 			    ctf_update(tip->dtt_ctfp) == CTF_ERR) {
939 				xywarn(D_UNKNOWN, "failed to copy type: %s\n",
940 				    ctf_errmsg(ctf_errno(tip->dtt_ctfp)));
941 				return (-1);
942 			}
943 		}
944 
945 		/*
946 		 * The array index type is irrelevant in C and D: just set it
947 		 * to "long" for all array types that we create on-the-fly.
948 		 */
949 		r.ctr_contents = tip->dtt_type;
950 		r.ctr_index = ctf_lookup_by_name(tip->dtt_ctfp, "long");
951 		r.ctr_nelems = ddp->dd_node ?
952 		    (uint_t)ddp->dd_node->dn_value : 0;
953 
954 		tip->dtt_object = dmp->dm_name;
955 		tip->dtt_ctfp = dmp->dm_ctfp;
956 		tip->dtt_type = ctf_add_array(dmp->dm_ctfp, CTF_ADD_ROOT, &r);
957 
958 		if (tip->dtt_type == CTF_ERR ||
959 		    ctf_update(tip->dtt_ctfp) == CTF_ERR) {
960 			xywarn(D_UNKNOWN, "failed to create array type: %s\n",
961 			    ctf_errmsg(ctf_errno(tip->dtt_ctfp)));
962 			return (-1);
963 		}
964 
965 		return (0);
966 	}
967 
968 	/*
969 	 * Allocate space for the type name and enough space for the maximum
970 	 * additional text ("unsigned long long \0" requires 20 more bytes).
971 	 */
972 	name = alloca(ddp->dd_name ? strlen(ddp->dd_name) + 20 : 20);
973 	name[0] = '\0';
974 
975 	switch (ddp->dd_kind) {
976 	case CTF_K_INTEGER:
977 	case CTF_K_FLOAT:
978 		if (ddp->dd_attr & DT_DA_SIGNED)
979 			(void) strcat(name, "signed ");
980 		if (ddp->dd_attr & DT_DA_UNSIGNED)
981 			(void) strcat(name, "unsigned ");
982 		if (ddp->dd_attr & DT_DA_SHORT)
983 			(void) strcat(name, "short ");
984 		if (ddp->dd_attr & DT_DA_LONG)
985 			(void) strcat(name, "long ");
986 		if (ddp->dd_attr & DT_DA_LONGLONG)
987 			(void) strcat(name, "long long ");
988 		if (ddp->dd_attr == 0 && ddp->dd_name == NULL)
989 			(void) strcat(name, "int");
990 		break;
991 	case CTF_K_STRUCT:
992 		(void) strcpy(name, "struct ");
993 		break;
994 	case CTF_K_UNION:
995 		(void) strcpy(name, "union ");
996 		break;
997 	case CTF_K_ENUM:
998 		(void) strcpy(name, "enum ");
999 		break;
1000 	case CTF_K_TYPEDEF:
1001 		break;
1002 	default:
1003 		xywarn(D_UNKNOWN, "internal error -- "
1004 		    "bad decl kind %u\n", ddp->dd_kind);
1005 		return (-1);
1006 	}
1007 
1008 	/*
1009 	 * Add dd_name unless a short, long, or long long is explicitly
1010 	 * suffixed by int.  We use the C/CTF canonical names for integers.
1011 	 */
1012 	if (ddp->dd_name != NULL && (ddp->dd_kind != CTF_K_INTEGER ||
1013 	    (ddp->dd_attr & (DT_DA_SHORT | DT_DA_LONG | DT_DA_LONGLONG)) == 0))
1014 		(void) strcat(name, ddp->dd_name);
1015 
1016 	/*
1017 	 * Lookup the type.  If we find it, we're done.  Otherwise create a
1018 	 * forward tag for the type if it is a struct, union, or enum.  If
1019 	 * we can't find it and we can't create a tag, return failure.
1020 	 */
1021 	if ((rv = dt_type_lookup(name, tip)) == 0)
1022 		return (rv);
1023 
1024 	switch (ddp->dd_kind) {
1025 	case CTF_K_STRUCT:
1026 	case CTF_K_UNION:
1027 	case CTF_K_ENUM:
1028 		type = ctf_add_forward(dmp->dm_ctfp, flag,
1029 		    ddp->dd_name, ddp->dd_kind);
1030 		break;
1031 	default:
1032 		xywarn(D_UNKNOWN, "failed to resolve type %s: %s\n", name,
1033 		    dtrace_errmsg(dtp, dtrace_errno(dtp)));
1034 		return (rv);
1035 	}
1036 
1037 	if (type == CTF_ERR || ctf_update(dmp->dm_ctfp) == CTF_ERR) {
1038 		xywarn(D_UNKNOWN, "failed to add forward tag for %s: %s\n",
1039 		    name, ctf_errmsg(ctf_errno(dmp->dm_ctfp)));
1040 		return (-1);
1041 	}
1042 
1043 	ddp->dd_ctfp = dmp->dm_ctfp;
1044 	ddp->dd_type = type;
1045 
1046 	tip->dtt_object = dmp->dm_name;
1047 	tip->dtt_ctfp = dmp->dm_ctfp;
1048 	tip->dtt_type = type;
1049 
1050 	return (0);
1051 }
1052 
1053 void
1054 dt_scope_create(dt_scope_t *dsp)
1055 {
1056 	dsp->ds_decl = NULL;
1057 	dsp->ds_next = NULL;
1058 	dsp->ds_ident = NULL;
1059 	dsp->ds_ctfp = NULL;
1060 	dsp->ds_type = CTF_ERR;
1061 	dsp->ds_class = DT_DC_DEFAULT;
1062 	dsp->ds_enumval = -1;
1063 }
1064 
1065 void
1066 dt_scope_destroy(dt_scope_t *dsp)
1067 {
1068 	dt_scope_t *nsp;
1069 
1070 	for (; dsp != NULL; dsp = nsp) {
1071 		dt_decl_free(dsp->ds_decl);
1072 		free(dsp->ds_ident);
1073 		nsp = dsp->ds_next;
1074 		if (dsp != &yypcb->pcb_dstack)
1075 			free(dsp);
1076 	}
1077 }
1078 
1079 void
1080 dt_scope_push(ctf_file_t *ctfp, ctf_id_t type)
1081 {
1082 	dt_scope_t *rsp = &yypcb->pcb_dstack;
1083 	dt_scope_t *dsp = malloc(sizeof (dt_scope_t));
1084 
1085 	if (dsp == NULL)
1086 		longjmp(yypcb->pcb_jmpbuf, EDT_NOMEM);
1087 
1088 	dsp->ds_decl = rsp->ds_decl;
1089 	dsp->ds_next = rsp->ds_next;
1090 	dsp->ds_ident = rsp->ds_ident;
1091 	dsp->ds_ctfp = ctfp;
1092 	dsp->ds_type = type;
1093 	dsp->ds_class = rsp->ds_class;
1094 	dsp->ds_enumval = rsp->ds_enumval;
1095 
1096 	dt_scope_create(rsp);
1097 	rsp->ds_next = dsp;
1098 }
1099 
1100 dt_decl_t *
1101 dt_scope_pop(void)
1102 {
1103 	dt_scope_t *rsp = &yypcb->pcb_dstack;
1104 	dt_scope_t *dsp = rsp->ds_next;
1105 
1106 	if (dsp == NULL)
1107 		longjmp(yypcb->pcb_jmpbuf, EDT_NOSCOPE);
1108 
1109 	if (dsp->ds_ctfp != NULL && ctf_update(dsp->ds_ctfp) == CTF_ERR) {
1110 		xyerror(D_UNKNOWN, "failed to update type definitions: %s\n",
1111 		    ctf_errmsg(ctf_errno(dsp->ds_ctfp)));
1112 	}
1113 
1114 	dt_decl_free(rsp->ds_decl);
1115 	free(rsp->ds_ident);
1116 
1117 	rsp->ds_decl = dsp->ds_decl;
1118 	rsp->ds_next = dsp->ds_next;
1119 	rsp->ds_ident = dsp->ds_ident;
1120 	rsp->ds_ctfp = dsp->ds_ctfp;
1121 	rsp->ds_type = dsp->ds_type;
1122 	rsp->ds_class = dsp->ds_class;
1123 	rsp->ds_enumval = dsp->ds_enumval;
1124 
1125 	free(dsp);
1126 	return (rsp->ds_decl);
1127 }
1128