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