xref: /netbsd-src/usr.bin/xlint/lint1/decl.c (revision 3d6a50253cd682dca85a66a49baee893251dac65)
1 /* $NetBSD: decl.c,v 1.412 2025/01/03 03:14:47 rillig Exp $ */
2 
3 /*
4  * Copyright (c) 1996 Christopher G. Demetriou.  All Rights Reserved.
5  * Copyright (c) 1994, 1995 Jochen Pohl
6  * All Rights Reserved.
7  *
8  * Redistribution and use in source and binary forms, with or without
9  * modification, are permitted provided that the following conditions
10  * are met:
11  * 1. Redistributions of source code must retain the above copyright
12  *    notice, this list of conditions and the following disclaimer.
13  * 2. Redistributions in binary form must reproduce the above copyright
14  *    notice, this list of conditions and the following disclaimer in the
15  *    documentation and/or other materials provided with the distribution.
16  * 3. All advertising materials mentioning features or use of this software
17  *    must display the following acknowledgement:
18  *	This product includes software developed by Jochen Pohl for
19  *	The NetBSD Project.
20  * 4. The name of the author may not be used to endorse or promote products
21  *    derived from this software without specific prior written permission.
22  *
23  * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
24  * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
25  * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
26  * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
27  * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
28  * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
29  * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
30  * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
31  * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
32  * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
33  */
34 
35 #if HAVE_NBTOOL_CONFIG_H
36 #include "nbtool_config.h"
37 #endif
38 
39 #include <sys/cdefs.h>
40 #if defined(__RCSID)
41 __RCSID("$NetBSD: decl.c,v 1.412 2025/01/03 03:14:47 rillig Exp $");
42 #endif
43 
44 #include <sys/param.h>
45 #include <limits.h>
46 #include <stdlib.h>
47 #include <string.h>
48 
49 #include "lint1.h"
50 
51 const char unnamed[] = "<unnamed>";
52 
53 /* shared type structures for arithmetic types and void */
54 static type_t typetab[NTSPEC];
55 
56 /* value of next enumerator during declaration of enum types */
57 int enumval;
58 
59 /*
60  * Points to the innermost element of a stack that contains information about
61  * nested declarations, such as struct declarations, function prototypes,
62  * local variables.
63  */
64 decl_level *dcs;
65 
66 #ifdef DEBUG
67 static inline void
68 debug_func_dcs(const char *func)
69 {
70 	debug_printf("%s: ", func);
71 	debug_dcs();
72 }
73 #else
74 #define debug_func_dcs(func) debug_noop()
75 #endif
76 
77 void
78 init_decl(void)
79 {
80 	dcs = xcalloc(1, sizeof(*dcs));
81 	dcs->d_kind = DLK_EXTERN;
82 	dcs->d_last_dlsym = &dcs->d_first_dlsym;
83 
84 	if (!pflag) {
85 		for (size_t i = 0; i < NTSPEC; i++) {
86 			if (ttab[i].tt_rank_kind != RK_NONE)
87 				ttab[i].tt_rank_value =
88 				    ttab[i].tt_size_in_bits;
89 		}
90 		ttab[BOOL].tt_rank_value = 1;
91 	}
92 
93 	if (Tflag) {
94 		ttab[BOOL].tt_is_integer = false;
95 		ttab[BOOL].tt_is_uinteger = false;
96 		ttab[BOOL].tt_is_arithmetic = false;
97 	}
98 
99 	/* struct, union, enum, ptr, array and func are not shared. */
100 	for (int i = (int)SIGNED; i < (int)STRUCT; i++)
101 		typetab[i].t_tspec = (tspec_t)i;
102 }
103 
104 /*
105  * Returns a shared type structure for arithmetic types and void.  The returned
106  * type must not be modified; use block_dup_type or expr_dup_type if necessary.
107  */
108 type_t *
109 gettyp(tspec_t t)
110 {
111 
112 	lint_assert((int)t < (int)STRUCT);
113 	/* TODO: make the return type 'const' */
114 	return &typetab[t];
115 }
116 
117 type_t *
118 block_dup_type(const type_t *tp)
119 {
120 	type_t *ntp = block_zero_alloc(sizeof(*ntp), "type");
121 	// Keep referring to the same subtype, struct, union, enum, params.
122 	*ntp = *tp;
123 	debug_step("%s '%s'", __func__, type_name(ntp));
124 	return ntp;
125 }
126 
127 /* Duplicate a type, free the allocated memory after the expression. */
128 type_t *
129 expr_dup_type(const type_t *tp)
130 {
131 	type_t *ntp = expr_zero_alloc(sizeof(*ntp), "type");
132 	// Keep referring to the same subtype, struct, union, enum, params.
133 	*ntp = *tp;
134 	debug_step("%s: '%s'", __func__, type_name(ntp));
135 	return ntp;
136 }
137 
138 /*
139  * Return the unqualified version of the type.  The returned type is freed at
140  * the end of the current expression.
141  *
142  * See C99 6.2.5p25.
143  */
144 type_t *
145 expr_unqualified_type(const type_t *tp)
146 {
147 	type_t *ntp = expr_zero_alloc(sizeof(*ntp), "type");
148 	// Keep referring to the same subtype, struct, union, enum, params.
149 	*ntp = *tp;
150 	ntp->t_const = false;
151 	ntp->t_volatile = false;
152 
153 	/*
154 	 * In case of a struct or union type, the members should lose their
155 	 * qualifiers as well, but that would require a deep copy of the struct
156 	 * or union type.  This in turn would defeat the type comparison in
157 	 * types_compatible, which simply tests whether 'tp1->u.sou ==
158 	 * tp2->u.sou'.
159 	 */
160 
161 	debug_step("%s: '%s'", __func__, type_name(ntp));
162 	return ntp;
163 }
164 
165 /*
166  * Returns whether the type is 'void' or an incomplete array, struct, union
167  * or enum.
168  */
169 bool
170 is_incomplete(const type_t *tp)
171 {
172 	tspec_t t = tp->t_tspec;
173 
174 	if (t == VOID)
175 		return true;
176 	if (t == ARRAY)
177 		return tp->t_incomplete_array;
178 	if (is_struct_or_union(t))
179 		return tp->u.sou->sou_incomplete;
180 	if (t == ENUM)
181 		return tp->u.enumer->en_incomplete;
182 	return false;
183 }
184 
185 void
186 dcs_add_function_specifier(function_specifier fs)
187 {
188 	if (fs == FS_INLINE) {
189 		if (dcs->d_inline)
190 			/* duplicate '%s' */
191 			warning(10, "inline");
192 		dcs->d_inline = true;
193 	}
194 	if (fs == FS_NORETURN)
195 		dcs->d_noreturn = true;
196 	debug_func_dcs(__func__);
197 }
198 
199 void
200 dcs_add_storage_class(scl_t sc)
201 {
202 
203 	if (dcs->d_type != NULL || dcs->d_abstract_type != NO_TSPEC ||
204 	    dcs->d_sign_mod != NO_TSPEC || dcs->d_rank_mod != NO_TSPEC)
205 		/* storage class after type is obsolescent */
206 		warning(83);
207 
208 	if (dcs->d_scl == NO_SCL)
209 		dcs->d_scl = sc;
210 	else if ((dcs->d_scl == EXTERN && sc == THREAD_LOCAL)
211 	    || (dcs->d_scl == THREAD_LOCAL && sc == EXTERN))
212 		dcs->d_scl = EXTERN;	/* ignore thread_local */
213 	else if ((dcs->d_scl == STATIC && sc == THREAD_LOCAL)
214 	    || (dcs->d_scl == THREAD_LOCAL && sc == STATIC))
215 		dcs->d_scl = STATIC;	/* ignore thread_local */
216 	else
217 		dcs->d_multiple_storage_classes = true;
218 	debug_func_dcs(__func__);
219 }
220 
221 /* Merge the signedness into the abstract type. */
222 static tspec_t
223 merge_signedness(tspec_t t, tspec_t s)
224 {
225 
226 	if (s == SIGNED)
227 		return t == CHAR ? SCHAR : t;
228 	if (s != UNSIGN)
229 		return t;
230 	return t == CHAR ? UCHAR
231 	    : t == SHORT ? USHORT
232 	    : t == INT ? UINT
233 	    : t == LONG ? ULONG
234 	    : t == LLONG ? ULLONG
235 	    : t;
236 }
237 
238 /*
239  * Called if a list of declaration specifiers contains a typedef name
240  * and other specifiers (except struct, union, enum, typedef name).
241  */
242 static type_t *
243 typedef_error(type_t *td, tspec_t t)
244 {
245 	tspec_t t2 = td->t_tspec;
246 
247 	if ((t == SIGNED || t == UNSIGN) &&
248 	    (t2 == CHAR || t2 == SHORT || t2 == INT ||
249 	     t2 == LONG || t2 == LLONG)) {
250 		if (allow_c90)
251 			/* modifying typedef with '%s'; only qualifiers... */
252 			warning(5, tspec_name(t));
253 		td = block_dup_type(gettyp(merge_signedness(t2, t)));
254 		td->t_typedef = true;
255 		return td;
256 	}
257 
258 	if (t == SHORT && (t2 == INT || t2 == UINT)) {
259 		/* modifying typedef with '%s'; only qualifiers allowed */
260 		warning(5, "short");
261 		td = block_dup_type(gettyp(t2 == INT ? SHORT : USHORT));
262 		td->t_typedef = true;
263 		return td;
264 	}
265 
266 	if (t != LONG)
267 		goto invalid;
268 
269 	tspec_t lt;
270 	if (t2 == INT)
271 		lt = LONG;
272 	else if (t2 == UINT)
273 		lt = ULONG;
274 	else if (t2 == LONG)
275 		lt = LLONG;
276 	else if (t2 == ULONG)
277 		lt = ULLONG;
278 	else if (t2 == FLOAT)
279 		lt = DOUBLE;
280 	else if (t2 == DOUBLE)
281 		lt = LDOUBLE;
282 	else if (t2 == DCOMPLEX)
283 		lt = LCOMPLEX;
284 	else
285 		goto invalid;
286 
287 	/* modifying typedef with '%s'; only qualifiers allowed */
288 	warning(5, "long");
289 	td = block_dup_type(gettyp(lt));
290 	td->t_typedef = true;
291 	return td;
292 
293 invalid:
294 	dcs->d_invalid_type_combination = true;
295 	debug_func_dcs(__func__);
296 	return td;
297 }
298 
299 /*
300  * Remember the type, modifier or typedef name returned by the parser in the
301  * top element of the declaration stack. This information is used in
302  * dcs_end_type to build the type used for all declarators in this declaration.
303  *
304  * If tp->t_typedef is true, the type comes from a previously defined typename.
305  * Otherwise, it comes from a type specifier (int, long, ...) or a
306  * struct/union/enum tag.
307  */
308 void
309 dcs_add_type(type_t *tp)
310 {
311 
312 	if (tp->t_typedef) {
313 		/*-
314 		 * something like "typedef int a; int a b;"
315 		 * This should not happen with current grammar.
316 		 */
317 		lint_assert(dcs->d_type == NULL);
318 		lint_assert(dcs->d_abstract_type == NO_TSPEC);
319 		lint_assert(dcs->d_sign_mod == NO_TSPEC);
320 		lint_assert(dcs->d_rank_mod == NO_TSPEC);
321 
322 		dcs->d_type = tp;
323 		debug_func_dcs(__func__);
324 		return;
325 	}
326 
327 	tspec_t t = tp->t_tspec;
328 	if (t == STRUCT || t == UNION || t == ENUM) {
329 		/* something like "int struct a ..." */
330 		if (dcs->d_type != NULL || dcs->d_abstract_type != NO_TSPEC ||
331 		    dcs->d_rank_mod != NO_TSPEC || dcs->d_sign_mod != NO_TSPEC) {
332 			dcs->d_invalid_type_combination = true;
333 			dcs->d_abstract_type = NO_TSPEC;
334 			dcs->d_sign_mod = NO_TSPEC;
335 			dcs->d_rank_mod = NO_TSPEC;
336 		}
337 		dcs->d_type = tp;
338 		debug_func_dcs(__func__);
339 		return;
340 	}
341 
342 	if (dcs->d_type != NULL && !dcs->d_type->t_typedef) {
343 		/* something like "struct a int" */
344 		dcs->d_invalid_type_combination = true;
345 		debug_func_dcs(__func__);
346 		return;
347 	}
348 
349 	if (t == COMPLEX) {
350 		if (dcs->d_complex_mod == FLOAT)
351 			t = FCOMPLEX;
352 		else if (dcs->d_complex_mod == DOUBLE)
353 			t = DCOMPLEX;
354 		else {
355 			/* invalid type for _Complex */
356 			error(308);
357 			t = DCOMPLEX;	/* just as a fallback */
358 		}
359 		dcs->d_complex_mod = NO_TSPEC;
360 	}
361 
362 	if (t == LONG && dcs->d_rank_mod == LONG) {
363 		/* "long long" or "long ... long" */
364 		t = LLONG;
365 		dcs->d_rank_mod = NO_TSPEC;
366 		if (!suppress_longlong)
367 			/* %s does not support 'long long' */
368 			c99ism(265, allow_c90 ? "C90" : "traditional C");
369 	}
370 
371 	if (dcs->d_type != NULL && dcs->d_type->t_typedef) {
372 		/* something like "typedef int a; a long ..." */
373 		dcs->d_type = typedef_error(dcs->d_type, t);
374 		return;
375 	}
376 
377 	/* now it can be only a combination of arithmetic types and void */
378 	if (t == SIGNED || t == UNSIGN) {
379 		if (dcs->d_sign_mod != NO_TSPEC)
380 			dcs->d_invalid_type_combination = true;
381 		dcs->d_sign_mod = t;
382 	} else if (t == SHORT || t == LONG || t == LLONG) {
383 		if (dcs->d_rank_mod != NO_TSPEC)
384 			dcs->d_invalid_type_combination = true;
385 		dcs->d_rank_mod = t;
386 	} else if (t == FLOAT || t == DOUBLE) {
387 		if (dcs->d_rank_mod == NO_TSPEC || dcs->d_rank_mod == LONG) {
388 			if (dcs->d_complex_mod != NO_TSPEC
389 			    || (t == FLOAT && dcs->d_rank_mod == LONG))
390 				dcs->d_invalid_type_combination = true;
391 			dcs->d_complex_mod = t;
392 		} else {
393 			if (dcs->d_abstract_type != NO_TSPEC)
394 				dcs->d_invalid_type_combination = true;
395 			dcs->d_abstract_type = t;
396 		}
397 	} else if (t == PTR) {
398 		dcs->d_type = tp;
399 	} else {
400 		if (dcs->d_abstract_type != NO_TSPEC)
401 			dcs->d_invalid_type_combination = true;
402 		dcs->d_abstract_type = t;
403 	}
404 	debug_func_dcs(__func__);
405 }
406 
407 static void
408 set_first_typedef(type_t *tp, sym_t *sym)
409 {
410 
411 	tspec_t t = tp->t_tspec;
412 	if (is_struct_or_union(t) && tp->u.sou->sou_first_typedef == NULL)
413 		tp->u.sou->sou_first_typedef = sym;
414 	if (t == ENUM && tp->u.enumer->en_first_typedef == NULL)
415 		tp->u.enumer->en_first_typedef = sym;
416 	debug_printf("%s: ", __func__);
417 	debug_type(tp);
418 }
419 
420 static unsigned int
421 bit_fields_width(const sym_t **mem, bool *named)
422 {
423 	unsigned int width = 0;
424 	unsigned int align = 0;
425 	while (*mem != NULL && (*mem)->s_type->t_bitfield) {
426 		if ((*mem)->s_name != unnamed)
427 			*named = true;
428 		width += (*mem)->s_type->t_bit_field_width;
429 		unsigned mem_align = alignment((*mem)->s_type);
430 		if (mem_align > align)
431 			align = mem_align;
432 		*mem = (*mem)->s_next;
433 	}
434 	unsigned align_in_bits = align * CHAR_BIT;
435 	return (width + align_in_bits - 1) & -align_in_bits;
436 }
437 
438 static void
439 pack_struct_or_union(type_t *tp)
440 {
441 
442 	if (!is_struct_or_union(tp->t_tspec)) {
443 		/* attribute '%s' ignored for '%s' */
444 		warning(326, "packed", type_name(tp));
445 		return;
446 	}
447 
448 	unsigned int bits = 0;
449 	bool named = false;
450 	for (const sym_t *mem = tp->u.sou->sou_first_member;
451 	    mem != NULL; mem = mem->s_next) {
452 		// TODO: Maybe update mem->u.s_member.sm_offset_in_bits.
453 		if (mem->s_type->t_bitfield) {
454 			bits += bit_fields_width(&mem, &named);
455 			if (mem == NULL)
456 				break;
457 		}
458 		unsigned int mem_bits = type_size_in_bits(mem->s_type);
459 		if (tp->t_tspec == STRUCT)
460 			bits += mem_bits;
461 		else if (mem_bits > bits)
462 			bits = mem_bits;
463 	}
464 	tp->u.sou->sou_size_in_bits = bits;
465 }
466 
467 void
468 dcs_add_alignas(tnode_t *tn)
469 {
470 	dcs->d_mem_align = to_int_constant(tn, true);
471 	if (dcs->d_type != NULL && is_struct_or_union(dcs->d_type->t_tspec))
472 		// FIXME: The type must not be modified.
473 		dcs->d_type->u.sou->sou_align = dcs->d_mem_align;
474 	debug_func_dcs(__func__);
475 }
476 
477 void
478 dcs_add_packed(void)
479 {
480 	if (dcs->d_type == NULL)
481 		dcs->d_packed = true;
482 	else
483 		pack_struct_or_union(dcs->d_type);
484 	debug_func_dcs(__func__);
485 }
486 
487 void
488 dcs_set_used(void)
489 {
490 	dcs->d_used = true;
491 	debug_func_dcs(__func__);
492 }
493 
494 /*
495  * Remember a qualifier that is part of the declaration specifiers (and not the
496  * declarator). The remembered qualifier is used by dcs_end_type for all
497  * declarators.
498  */
499 void
500 dcs_add_qualifiers(type_qualifiers qs)
501 {
502 	add_type_qualifiers(&dcs->d_qual, qs);
503 	debug_func_dcs(__func__);
504 }
505 
506 void
507 begin_declaration_level(decl_level_kind kind)
508 {
509 
510 	decl_level *dl = xcalloc(1, sizeof(*dl));
511 	dl->d_enclosing = dcs;
512 	dl->d_kind = kind;
513 	dl->d_last_dlsym = &dl->d_first_dlsym;
514 	dcs = dl;
515 	debug_enter();
516 	debug_dcs_all();
517 }
518 
519 void
520 end_declaration_level(void)
521 {
522 
523 	debug_dcs_all();
524 
525 	decl_level *dl = dcs;
526 	dcs = dl->d_enclosing;
527 	lint_assert(dcs != NULL);
528 
529 	switch (dl->d_kind) {
530 	case DLK_STRUCT:
531 	case DLK_UNION:
532 	case DLK_ENUM:
533 		/*
534 		 * Symbols declared in (nested) structs or enums are part of
535 		 * the next level (they are removed from the symbol table if
536 		 * the symbols of the outer level are removed).
537 		 */
538 		if ((*dcs->d_last_dlsym = dl->d_first_dlsym) != NULL)
539 			dcs->d_last_dlsym = dl->d_last_dlsym;
540 		break;
541 	case DLK_OLD_STYLE_PARAMS:
542 		/*
543 		 * All symbols in dcs->d_first_dlsym are introduced in
544 		 * old-style parameter declarations (it's not clean, but
545 		 * possible). They are appended to the list of symbols declared
546 		 * in an old-style parameter identifier list or a new-style
547 		 * parameter type list.
548 		 */
549 		if (dl->d_first_dlsym != NULL) {
550 			*dl->d_last_dlsym = dcs->d_func_proto_syms;
551 			dcs->d_func_proto_syms = dl->d_first_dlsym;
552 		}
553 		break;
554 	case DLK_ABSTRACT:
555 		/*
556 		 * Append all symbols declared in the abstract declaration to
557 		 * the list of symbols declared in the surrounding declaration
558 		 * or block.
559 		 *
560 		 * XXX I'm not sure whether they should be removed from the
561 		 * symbol table now or later.
562 		 */
563 		if ((*dcs->d_last_dlsym = dl->d_first_dlsym) != NULL)
564 			dcs->d_last_dlsym = dl->d_last_dlsym;
565 		break;
566 	case DLK_AUTO:
567 		check_usage(dl);
568 		/* FALLTHROUGH */
569 	case DLK_PROTO_PARAMS:
570 		/* usage of parameters will be checked by end_function() */
571 		symtab_remove_level(dl->d_first_dlsym);
572 		break;
573 	case DLK_EXTERN:
574 		/* there is nothing around an external declaration */
575 		/* FALLTHROUGH */
576 	default:
577 		lint_assert(/*CONSTCOND*/false);
578 	}
579 	free(dl);
580 	debug_leave();
581 }
582 
583 /*
584  * Set flag d_asm in all declaration stack elements up to the outermost one.
585  *
586  * This is used to mark compound statements which have, possibly in nested
587  * compound statements, asm statements. For these compound statements, no
588  * warnings about unused or uninitialized variables are printed.
589  *
590  * There is no need to clear d_asm in decl_level structs with context AUTO, as
591  * these structs are freed at the end of the compound statement. But it must be
592  * cleared in the outermost decl_level struct, which has context EXTERN. This
593  * could be done in dcs_begin_type and would work for C90, but not for C99 or
594  * C++ (due to mixed statements and declarations). Thus, we clear it in
595  * global_clean_up_decl.
596  */
597 void
598 dcs_set_asm(void)
599 {
600 
601 	for (decl_level *dl = dcs; dl != NULL; dl = dl->d_enclosing)
602 		dl->d_asm = true;
603 	debug_step("%s", __func__);
604 	debug_dcs_all();
605 }
606 
607 void
608 dcs_begin_type(void)
609 {
610 
611 	debug_enter();
612 
613 	// keep d_kind
614 	dcs->d_abstract_type = NO_TSPEC;
615 	dcs->d_complex_mod = NO_TSPEC;
616 	dcs->d_sign_mod = NO_TSPEC;
617 	dcs->d_rank_mod = NO_TSPEC;
618 	dcs->d_scl = NO_SCL;
619 	dcs->d_type = NULL;
620 	dcs->d_redeclared_symbol = NULL;
621 	// keep d_sou_size_in_bits
622 	// keep d_sou_align
623 	dcs->d_mem_align = 0;
624 	dcs->d_qual = (type_qualifiers) { .tq_const = false };
625 	dcs->d_inline = false;
626 	dcs->d_multiple_storage_classes = false;
627 	dcs->d_invalid_type_combination = false;
628 	dcs->d_nonempty_decl = false;
629 	dcs->d_no_type_specifier = false;
630 	// keep d_asm
631 	dcs->d_packed = false;
632 	dcs->d_used = false;
633 	dcs->d_noreturn = false;
634 	// keep d_tag_type
635 	dcs->d_func_params = NULL;
636 	dcs->d_func_def_pos = (pos_t){ NULL, 0, 0 };
637 	// keep d_first_dlsym
638 	// keep d_last_dlsym
639 	dcs->d_func_proto_syms = NULL;
640 	// keep d_enclosing
641 
642 	debug_func_dcs(__func__);
643 }
644 
645 static void
646 dcs_adjust_storage_class(void)
647 {
648 	if (dcs->d_kind == DLK_EXTERN) {
649 		if (dcs->d_scl == REG || dcs->d_scl == AUTO) {
650 			/* illegal storage class */
651 			error(8);
652 			dcs->d_scl = NO_SCL;
653 		}
654 	} else if (dcs->d_kind == DLK_OLD_STYLE_PARAMS ||
655 	    dcs->d_kind == DLK_PROTO_PARAMS) {
656 		if (dcs->d_scl != NO_SCL && dcs->d_scl != REG) {
657 			/* only 'register' is valid as storage class ... */
658 			error(9);
659 			dcs->d_scl = NO_SCL;
660 		}
661 	}
662 }
663 
664 /*
665  * Merge the declaration specifiers from dcs into dcs->d_type.
666  *
667  * See C99 6.7.2 "Type specifiers".
668  */
669 static void
670 dcs_merge_declaration_specifiers(void)
671 {
672 	tspec_t t = dcs->d_abstract_type;
673 	tspec_t c = dcs->d_complex_mod;
674 	tspec_t s = dcs->d_sign_mod;
675 	tspec_t l = dcs->d_rank_mod;
676 	type_t *tp = dcs->d_type;
677 
678 	if (tp != NULL) {
679 		lint_assert(t == NO_TSPEC);
680 		lint_assert(s == NO_TSPEC);
681 		lint_assert(l == NO_TSPEC);
682 		return;
683 	}
684 
685 	if (t == NO_TSPEC && s == NO_TSPEC && l == NO_TSPEC && c == NO_TSPEC)
686 		dcs->d_no_type_specifier = true;
687 	if (t == NO_TSPEC && s == NO_TSPEC && (l == NO_TSPEC || l == LONG))
688 		t = c;
689 
690 	if (t == NO_TSPEC)
691 		t = INT;
692 	if (s == NO_TSPEC && t == INT)
693 		s = SIGNED;
694 	if (l != NO_TSPEC && t == CHAR) {
695 		dcs->d_invalid_type_combination = true;
696 		l = NO_TSPEC;
697 	}
698 	if (l == LONG && t == FLOAT) {
699 		l = NO_TSPEC;
700 		t = DOUBLE;
701 		if (allow_c90)
702 			/* use 'double' instead of 'long float' */
703 			warning(6);
704 	}
705 	if ((l == LONG && t == DOUBLE) || t == LDOUBLE) {
706 		l = NO_TSPEC;
707 		t = LDOUBLE;
708 	}
709 	if (t == LDOUBLE && !allow_c90)
710 		/* 'long double' is illegal in traditional C */
711 		warning(266);
712 	if (l == LONG && t == DCOMPLEX) {
713 		l = NO_TSPEC;
714 		t = LCOMPLEX;
715 	}
716 
717 	if (t != INT && t != CHAR && (s != NO_TSPEC || l != NO_TSPEC)) {
718 		dcs->d_invalid_type_combination = true;
719 		l = s = NO_TSPEC;
720 	}
721 	if (l != NO_TSPEC)
722 		t = l;
723 	dcs->d_type = gettyp(merge_signedness(t, s));
724 	debug_func_dcs(__func__);
725 }
726 
727 static void dcs_align(unsigned int, unsigned int);
728 
729 /* Create a type in 'dcs->d_type' from the information gathered in 'dcs'. */
730 void
731 dcs_end_type(void)
732 {
733 
734 	dcs_merge_declaration_specifiers();
735 
736 	if (dcs->d_multiple_storage_classes)
737 		/* only one storage class allowed */
738 		error(7);
739 	if (dcs->d_invalid_type_combination)
740 		/* illegal type combination */
741 		error(4);
742 
743 	dcs_adjust_storage_class();
744 
745 	if (dcs->d_qual.tq_const && dcs->d_type->t_const
746 	    && !dcs->d_type->t_typeof) {
747 		lint_assert(dcs->d_type->t_typedef);
748 		/* typedef already qualified with '%s' */
749 		warning(68, "const");
750 	}
751 	if (dcs->d_qual.tq_volatile && dcs->d_type->t_volatile &&
752 	    !dcs->d_type->t_typeof) {
753 		lint_assert(dcs->d_type->t_typedef);
754 		/* typedef already qualified with '%s' */
755 		warning(68, "volatile");
756 	}
757 
758 	if (dcs->d_qual.tq_const || dcs->d_qual.tq_volatile) {
759 		dcs->d_type = block_dup_type(dcs->d_type);
760 		dcs->d_type->t_const |= dcs->d_qual.tq_const;
761 		dcs->d_type->t_volatile |= dcs->d_qual.tq_volatile;
762 	}
763 	unsigned align = dcs->d_mem_align;
764 	if (align > 0 && dcs->d_type->t_tspec == STRUCT) {
765 		dcs_align(align, 0);
766 		dcs->d_type->u.sou->sou_align = align;
767 		unsigned align_in_bits = align * CHAR_SIZE;
768 		dcs->d_type->u.sou->sou_size_in_bits =
769 		    (dcs->d_type->u.sou->sou_size_in_bits + align_in_bits - 1)
770 		    & -align_in_bits;
771 	}
772 
773 	debug_dcs();
774 	debug_leave();
775 }
776 
777 /*
778  * Return the length of a type in bits. For bit-fields, return the length of
779  * the underlying storage type.
780  *
781  * Printing a message if the outermost dimension of an array is 0 must
782  * be done by the caller. All other problems are reported by this function
783  * if name is not NULL.
784  */
785 int
786 length_in_bits(const type_t *tp, const char *name)
787 {
788 
789 	if (tp == NULL)
790 		return -1;
791 
792 	unsigned int elem = 1;
793 	while (tp->t_tspec == ARRAY) {
794 		elem *= tp->u.dimension;
795 		tp = tp->t_subt;
796 	}
797 
798 	if (is_struct_or_union(tp->t_tspec)) {
799 		if (is_incomplete(tp) && name != NULL)
800 			/* '%s' has incomplete type '%s' */
801 			error(31, name, type_name(tp));
802 		return (int)(elem * tp->u.sou->sou_size_in_bits);
803 	}
804 
805 	if (tp->t_tspec == ENUM && is_incomplete(tp) && name != NULL)
806 		/* incomplete enum type '%s' */
807 		warning(13, name);
808 
809 	lint_assert(tp->t_tspec != FUNC);
810 
811 	unsigned int elsz = size_in_bits(tp->t_tspec);
812 	/*
813 	 * Workaround until the type parser (see add_function, add_array,
814 	 * add_pointer) does not construct the invalid intermediate declaration
815 	 * 'void b[4]' for the legitimate declaration 'void *b[4]'.
816 	 */
817 	if (sytxerr > 0 && elsz == 0)
818 		elsz = CHAR_SIZE;
819 	lint_assert(elsz > 0);
820 	return (int)(elem * elsz);
821 }
822 
823 unsigned int
824 alignment(const type_t *tp)
825 {
826 
827 	/* Super conservative so that it works for most systems. */
828 	unsigned worst_align = 2 * LONG_SIZE / CHAR_SIZE;
829 
830 	while (tp->t_tspec == ARRAY)
831 		tp = tp->t_subt;
832 
833 	tspec_t t = tp->t_tspec;
834 	unsigned a;
835 	if (is_struct_or_union(t))
836 		a = tp->u.sou->sou_align;
837 	else {
838 		lint_assert(t != FUNC);
839 		if ((a = size_in_bits(t) / CHAR_SIZE) == 0)
840 			a = 1;
841 		else if (a > worst_align)
842 			a = worst_align;
843 	}
844 	lint_assert(a >= 1);
845 	return a;
846 }
847 
848 /*
849  * Concatenate two lists of symbols by s_next. Used by declarations of
850  * struct/union/enum elements and parameters.
851  */
852 sym_t *
853 concat_symbols(sym_t *l1, sym_t *l2)
854 {
855 
856 	if (l1 == NULL)
857 		return l2;
858 	sym_t *l = l1;
859 	while (l->s_next != NULL)
860 		l = l->s_next;
861 	l->s_next = l2;
862 	return l1;
863 }
864 
865 /*
866  * Check if the type of the given symbol is valid.
867  *
868  * Invalid types are:
869  * - arrays of incomplete types or functions
870  * - functions returning arrays or functions
871  * - void types other than type of function or pointer
872  */
873 void
874 check_type(sym_t *sym)
875 {
876 
877 	type_t **tpp = &sym->s_type;
878 	tspec_t to = NO_TSPEC;
879 	while (*tpp != NULL) {
880 		type_t *tp = *tpp;
881 		tspec_t t = tp->t_tspec;
882 		/*
883 		 * If this is the type of an old-style function definition, a
884 		 * better warning is printed in begin_function().
885 		 */
886 		if (t == FUNC && !tp->t_proto &&
887 		    !(to == NO_TSPEC && sym->s_osdef)) {
888 			/* TODO: Make this an error in C99 mode as well. */
889 			if (!allow_trad && !allow_c99 && hflag)
890 				/* function declaration is not a prototype */
891 				warning(287);
892 		}
893 		if (to == FUNC) {
894 			if (t == FUNC || t == ARRAY) {
895 				/* function returns illegal type '%s' */
896 				error(15, type_name(tp));
897 				*tpp = block_derive_type(
898 				    t == FUNC ? *tpp : (*tpp)->t_subt, PTR);
899 				return;
900 			}
901 			if (tp->t_const || tp->t_volatile) {
902 				/* TODO: Make this a warning in C99 mode as well. */
903 				if (!allow_trad && !allow_c99) {	/* XXX or better allow_c90? */
904 					/* function cannot return const... */
905 					warning(228);
906 				}
907 			}
908 		} else if (to == ARRAY) {
909 			if (t == FUNC) {
910 				/* array of function is illegal */
911 				error(16);
912 				*tpp = gettyp(INT);
913 				return;
914 			}
915 			if (t == ARRAY && tp->u.dimension == 0) {
916 				/* null dimension */
917 				error(17);
918 				return;
919 			}
920 			if (t == VOID) {
921 				/* illegal use of 'void' */
922 				error(18);
923 				*tpp = gettyp(INT);
924 			}
925 			/*
926 			 * No need to check for incomplete types here as
927 			 * length_in_bits already does this.
928 			 */
929 		} else if (to == NO_TSPEC && t == VOID) {
930 			if (dcs->d_kind == DLK_PROTO_PARAMS) {
931 				if (sym->s_scl != ABSTRACT) {
932 					lint_assert(sym->s_name != unnamed);
933 					/* void parameter '%s' cannot ... */
934 					error(61, sym->s_name);
935 					*tpp = gettyp(INT);
936 				}
937 			} else if (dcs->d_kind == DLK_ABSTRACT) {
938 				/* ok */
939 			} else if (sym->s_scl != TYPEDEF) {
940 				/* void type for '%s' */
941 				error(19, sym->s_name);
942 				*tpp = gettyp(INT);
943 			}
944 		}
945 		if (t == VOID && to != PTR) {
946 			if (tp->t_const || tp->t_volatile) {
947 				/* inappropriate qualifiers with 'void' */
948 				warning(69);
949 				tp->t_const = tp->t_volatile = false;
950 			}
951 		}
952 		tpp = &tp->t_subt;
953 		to = t;
954 	}
955 }
956 
957 /*
958  * In traditional C, the only portable type for bit-fields is unsigned int.
959  *
960  * In C90, the only allowed types for bit-fields are int, signed int and
961  * unsigned int (3.5.2.1).  There is no mention of implementation-defined
962  * types.
963  *
964  * In C99, the only portable types for bit-fields are _Bool, signed int and
965  * unsigned int (6.7.2.1p4).  In addition, C99 allows "or some other
966  * implementation-defined type".
967  */
968 static void
969 check_bit_field_type(sym_t *dsym, type_t **inout_tp, tspec_t *inout_t)
970 {
971 	type_t *tp = *inout_tp;
972 	tspec_t t = *inout_t;
973 
974 	if (t == CHAR || t == UCHAR || t == SCHAR ||
975 	    t == SHORT || t == USHORT || t == ENUM) {
976 		if (!suppress_bitfieldtype) {
977 			/* TODO: Make this an error in C99 mode as well. */
978 			if (!allow_trad && !allow_c99) {
979 				type_t *btp = block_dup_type(tp);
980 				btp->t_bitfield = false;
981 				/* bit-field type '%s' invalid in C90 or ... */
982 				warning(273, type_name(btp));
983 			} else if (pflag) {
984 				type_t *btp = block_dup_type(tp);
985 				btp->t_bitfield = false;
986 				/* nonportable bit-field type '%s' */
987 				warning(34, type_name(btp));
988 			}
989 		}
990 	} else if (t == INT && dcs->d_sign_mod == NO_TSPEC) {
991 		if (pflag && !suppress_bitfieldtype) {
992 			/* bit-field of type plain 'int' has ... */
993 			warning(344);
994 		}
995 	} else if (!(t == INT || t == UINT || t == BOOL
996 		|| (is_integer(t) && (suppress_bitfieldtype || allow_gcc)))) {
997 
998 		type_t *btp = block_dup_type(tp);
999 		btp->t_bitfield = false;
1000 		/* illegal bit-field type '%s' */
1001 		warning(35, type_name(btp));
1002 
1003 		unsigned int width = tp->t_bit_field_width;
1004 		dsym->s_type = tp = block_dup_type(gettyp(t = INT));
1005 		if ((tp->t_bit_field_width = width) > size_in_bits(t))
1006 			tp->t_bit_field_width = size_in_bits(t);
1007 		*inout_t = t;
1008 		*inout_tp = tp;
1009 	}
1010 }
1011 
1012 static void
1013 check_bit_field(sym_t *dsym, tspec_t *inout_t, type_t **inout_tp)
1014 {
1015 
1016 	check_bit_field_type(dsym, inout_tp, inout_t);
1017 
1018 	type_t *tp = *inout_tp;
1019 	tspec_t t = *inout_t;
1020 	unsigned int t_width = size_in_bits(t);
1021 	if (tp->t_bit_field_width > t_width) {
1022 		/* illegal bit-field size: %d */
1023 		error(36, (int)tp->t_bit_field_width);
1024 		tp->t_bit_field_width = t_width;
1025 	} else if (tp->t_bit_field_width == 0 && dsym->s_name != unnamed) {
1026 		/* zero size bit-field */
1027 		error(37);
1028 		tp->t_bit_field_width = t_width;
1029 	}
1030 	if (dsym->s_scl == UNION_MEMBER) {
1031 		/* bit-field in union is very unusual */
1032 		warning(41);
1033 		dsym->s_type->t_bitfield = false;
1034 		dsym->s_bitfield = false;
1035 	}
1036 }
1037 
1038 /* Aligns the next structure member as required. */
1039 static void
1040 dcs_align(unsigned int member_alignment, unsigned int bit_field_width)
1041 {
1042 
1043 	if (member_alignment > dcs->d_sou_align)
1044 		dcs->d_sou_align = member_alignment;
1045 
1046 	unsigned align_in_bits = member_alignment * CHAR_SIZE;
1047 	unsigned offset = (dcs->d_sou_size_in_bits + align_in_bits - 1)
1048 	    & -align_in_bits;
1049 	if (bit_field_width == 0
1050 	    || dcs->d_sou_size_in_bits + bit_field_width > offset)
1051 		dcs->d_sou_size_in_bits = offset;
1052 	debug_func_dcs(__func__);
1053 }
1054 
1055 /* Add a member to the struct or union type that is being built in 'dcs'. */
1056 static void
1057 dcs_add_member(sym_t *mem)
1058 {
1059 	type_t *tp = mem->s_type;
1060 
1061 	unsigned int union_size = 0;
1062 	if (dcs->d_kind == DLK_UNION) {
1063 		union_size = dcs->d_sou_size_in_bits;
1064 		dcs->d_sou_size_in_bits = 0;
1065 	}
1066 
1067 	if (mem->s_bitfield) {
1068 		dcs_align(alignment(tp), tp->t_bit_field_width);
1069 		// XXX: Why round down?
1070 		mem->u.s_member.sm_offset_in_bits = dcs->d_sou_size_in_bits
1071 		    - dcs->d_sou_size_in_bits % size_in_bits(tp->t_tspec);
1072 		tp->t_bit_field_offset = dcs->d_sou_size_in_bits
1073 		    - mem->u.s_member.sm_offset_in_bits;
1074 		dcs->d_sou_size_in_bits += tp->t_bit_field_width;
1075 	} else {
1076 		unsigned int align = dcs->d_mem_align > 0
1077 		    ? dcs->d_mem_align : alignment(tp);
1078 		dcs_align(align, 0);
1079 		mem->u.s_member.sm_offset_in_bits = dcs->d_sou_size_in_bits;
1080 		dcs->d_sou_size_in_bits += type_size_in_bits(tp);
1081 	}
1082 
1083 	if (union_size > dcs->d_sou_size_in_bits)
1084 		dcs->d_sou_size_in_bits = union_size;
1085 
1086 	debug_func_dcs(__func__);
1087 }
1088 
1089 sym_t *
1090 declare_unnamed_member(void)
1091 {
1092 
1093 	sym_t *mem = block_zero_alloc(sizeof(*mem), "sym");
1094 	mem->s_name = unnamed;
1095 	mem->s_kind = SK_MEMBER;
1096 	mem->s_scl = dcs->d_kind == DLK_STRUCT ? STRUCT_MEMBER : UNION_MEMBER;
1097 	mem->s_block_level = -1;
1098 	mem->s_type = dcs->d_type;
1099 	mem->u.s_member.sm_containing_type = dcs->d_tag_type->u.sou;
1100 
1101 	dcs_add_member(mem);
1102 	suppress_bitfieldtype = false;
1103 	return mem;
1104 }
1105 
1106 sym_t *
1107 declare_member(sym_t *dsym)
1108 {
1109 
1110 	lint_assert(is_member(dsym));
1111 
1112 	sym_t *rdsym = dcs->d_redeclared_symbol;
1113 	if (rdsym != NULL) {
1114 		debug_sym("rdsym: ", rdsym, "\n");
1115 		lint_assert(is_member(rdsym));
1116 
1117 		if (dsym->u.s_member.sm_containing_type ==
1118 		    rdsym->u.s_member.sm_containing_type) {
1119 			/* duplicate member name '%s' */
1120 			error(33, dsym->s_name);
1121 			symtab_remove_forever(rdsym);
1122 		}
1123 	}
1124 
1125 	check_type(dsym);
1126 
1127 	type_t *tp = dsym->s_type;
1128 	tspec_t t = tp->t_tspec;
1129 	if (dsym->s_bitfield)
1130 		check_bit_field(dsym, &t, &tp);
1131 	else if (t == FUNC) {
1132 		/* function illegal in structure or union */
1133 		error(38);
1134 		dsym->s_type = tp = block_derive_type(tp, t = PTR);
1135 	}
1136 
1137 	/*
1138 	 * bit-fields of length 0 are not warned about because length_in_bits
1139 	 * does not return the length of the bit-field but the length of the
1140 	 * type the bit-field is packed in (it's ok)
1141 	 */
1142 	int sz = length_in_bits(dsym->s_type, dsym->s_name);
1143 	if (sz == 0 && t == ARRAY && dsym->s_type->u.dimension == 0)
1144 		/* zero-sized array '%s' in struct requires C99 or later */
1145 		c99ism(39, dsym->s_name);
1146 
1147 	dcs_add_member(dsym);
1148 
1149 	check_function_definition(dsym, false);
1150 
1151 	suppress_bitfieldtype = false;
1152 
1153 	return dsym;
1154 }
1155 
1156 sym_t *
1157 set_bit_field_width(sym_t *dsym, int bit_field_width)
1158 {
1159 
1160 	if (dsym == NULL) {
1161 		dsym = block_zero_alloc(sizeof(*dsym), "sym");
1162 		dsym->s_name = unnamed;
1163 		dsym->s_kind = SK_MEMBER;
1164 		dsym->s_scl = STRUCT_MEMBER;
1165 		dsym->s_type = gettyp(UINT);
1166 		dsym->s_block_level = -1;
1167 		lint_assert(dcs->d_tag_type->u.sou != NULL);
1168 		dsym->u.s_member.sm_containing_type = dcs->d_tag_type->u.sou;
1169 	}
1170 	dsym->s_type = block_dup_type(dsym->s_type);
1171 	dsym->s_type->t_bitfield = true;
1172 	dsym->s_type->t_bit_field_width = bit_field_width;
1173 	dsym->s_bitfield = true;
1174 	debug_sym("set_bit_field_width: ", dsym, "\n");
1175 	return dsym;
1176 }
1177 
1178 void
1179 add_type_qualifiers(type_qualifiers *dst, type_qualifiers src)
1180 {
1181 
1182 	if (src.tq_const && dst->tq_const)
1183 		/* duplicate '%s' */
1184 		warning(10, "const");
1185 	if (src.tq_volatile && dst->tq_volatile)
1186 		/* duplicate '%s' */
1187 		warning(10, "volatile");
1188 
1189 	dst->tq_const = dst->tq_const | src.tq_const;
1190 	dst->tq_restrict = dst->tq_restrict | src.tq_restrict;
1191 	dst->tq_volatile = dst->tq_volatile | src.tq_volatile;
1192 	dst->tq_atomic = dst->tq_atomic | src.tq_atomic;
1193 	debug_step("%s: '%s'", __func__, type_qualifiers_string(*dst));
1194 }
1195 
1196 qual_ptr *
1197 append_qualified_pointer(qual_ptr *p1, qual_ptr *p2)
1198 {
1199 
1200 	qual_ptr *tail = p2;
1201 	while (tail->p_next != NULL)
1202 		tail = tail->p_next;
1203 	tail->p_next = p1;
1204 	return p2;
1205 }
1206 
1207 static type_t *
1208 block_derive_pointer(type_t *stp, bool is_const, bool is_volatile)
1209 {
1210 
1211 	type_t *tp = block_derive_type(stp, PTR);
1212 	tp->t_const = is_const;
1213 	tp->t_volatile = is_volatile;
1214 	debug_step("%s: '%s'", __func__, type_name(tp));
1215 	return tp;
1216 }
1217 
1218 sym_t *
1219 add_pointer(sym_t *decl, qual_ptr *p)
1220 {
1221 
1222 	debug_dcs();
1223 
1224 	type_t **tpp = &decl->s_type;
1225 	lint_assert(*tpp != NULL);
1226 	while (*tpp != dcs->d_type) {
1227 		tpp = &(*tpp)->t_subt;
1228 		lint_assert(*tpp != NULL);
1229 	}
1230 
1231 	while (p != NULL) {
1232 		*tpp = block_derive_pointer(dcs->d_type,
1233 		    p->qualifiers.tq_const, p->qualifiers.tq_volatile);
1234 
1235 		tpp = &(*tpp)->t_subt;
1236 
1237 		qual_ptr *next = p->p_next;
1238 		free(p);
1239 		p = next;
1240 	}
1241 	debug_step("%s: '%s'", __func__, type_name(decl->s_type));
1242 	return decl;
1243 }
1244 
1245 static type_t *
1246 block_derive_array(type_t *stp, bool has_dim, int dim)
1247 {
1248 
1249 	type_t *tp = block_derive_type(stp, ARRAY);
1250 	tp->u.dimension = dim;
1251 
1252 #if 0
1253 	/*
1254 	 * When the type of the declaration 'void *b[4]' is constructed (see
1255 	 * add_function, add_array, add_pointer), the intermediate type
1256 	 * 'void[4]' is invalid and only later gets the '*' inserted in the
1257 	 * middle of the type.  Due to the invalid intermediate type, this
1258 	 * check cannot be enabled yet.
1259 	 */
1260 	if (stp->t_tspec == VOID) {
1261 		/* array of incomplete type */
1262 		error(301);
1263 		tp->t_subt = gettyp(CHAR);
1264 	}
1265 #endif
1266 	if (dim < 0)
1267 		/* negative array dimension (%d) */
1268 		error(20, dim);
1269 	else if (dim == 0 && has_dim)
1270 		/* zero sized array requires C99 or later */
1271 		c99ism(322);
1272 	else if (dim == 0 && !has_dim)
1273 		tp->t_incomplete_array = true;
1274 
1275 	debug_step("%s: '%s'", __func__, type_name(tp));
1276 	return tp;
1277 }
1278 
1279 sym_t *
1280 add_array(sym_t *decl, bool has_dim, int dim)
1281 {
1282 
1283 	debug_dcs();
1284 
1285 	type_t **tpp = &decl->s_type;
1286 	lint_assert(*tpp != NULL);
1287 	while (*tpp != dcs->d_type) {
1288 		tpp = &(*tpp)->t_subt;
1289 		lint_assert(*tpp != NULL);
1290 	}
1291 
1292 	*tpp = block_derive_array(dcs->d_type, has_dim, dim);
1293 
1294 	debug_step("%s: '%s'", __func__, type_name(decl->s_type));
1295 	return decl;
1296 }
1297 
1298 static type_t *
1299 block_derive_function(type_t *ret, bool proto, sym_t *params, bool vararg,
1300     bool noreturn)
1301 {
1302 
1303 	type_t *tp = block_derive_type(ret, FUNC);
1304 	tp->t_proto = proto;
1305 	if (proto)
1306 		tp->u.params = params;
1307 	tp->t_noreturn = noreturn;
1308 	tp->t_vararg = vararg;
1309 	debug_step("%s: '%s'", __func__, type_name(tp));
1310 	return tp;
1311 }
1312 
1313 static const char *
1314 tag_name(scl_t sc)
1315 {
1316 	return sc == STRUCT_TAG ? "struct"
1317 	    : sc == UNION_TAG ? "union"
1318 	    : "enum";
1319 }
1320 
1321 static void
1322 check_prototype_parameters(sym_t *args)
1323 {
1324 
1325 	for (sym_t *sym = dcs->d_first_dlsym;
1326 	    sym != NULL; sym = sym->s_level_next) {
1327 		scl_t sc = sym->s_scl;
1328 		if (sc == STRUCT_TAG || sc == UNION_TAG || sc == ENUM_TAG)
1329 			/* dubious tag declaration '%s %s' */
1330 			warning(85, tag_name(sc), sym->s_name);
1331 	}
1332 
1333 	for (sym_t *arg = args; arg != NULL; arg = arg->s_next) {
1334 		if (arg->s_type->t_tspec == VOID &&
1335 		    !(arg == args && arg->s_next == NULL)) {
1336 			/* void must be sole parameter */
1337 			error(60);
1338 			arg->s_type = gettyp(INT);
1339 		}
1340 	}
1341 }
1342 
1343 static void
1344 old_style_function(sym_t *decl, sym_t *params)
1345 {
1346 
1347 	/*
1348 	 * Remember the list of parameters only if this really seems to be a
1349 	 * function definition.
1350 	 */
1351 	if (dcs->d_enclosing->d_kind == DLK_EXTERN &&
1352 	    decl->s_type == dcs->d_enclosing->d_type) {
1353 		/*
1354 		 * Assume that this becomes a function definition. If not, it
1355 		 * will be corrected in check_function_definition.
1356 		 */
1357 		if (params != NULL) {
1358 			decl->s_osdef = true;
1359 			decl->u.s_old_style_params = params;
1360 		}
1361 	} else {
1362 		if (params != NULL)
1363 			/* function prototype parameters must have types */
1364 			warning(62);
1365 	}
1366 }
1367 
1368 sym_t *
1369 add_function(sym_t *decl, parameter_list params)
1370 {
1371 
1372 	debug_enter();
1373 	debug_dcs_all();
1374 	debug_sym("decl: ", decl, "\n");
1375 #ifdef DEBUG
1376 	for (const sym_t *p = params.first; p != NULL; p = p->s_next)
1377 		debug_sym("param: ", p, "\n");
1378 #endif
1379 
1380 	if (params.identifier && allow_c23)
1381 		/* function definition for '%s' with identifier list is ... */
1382 		error_at(384, &decl->s_def_pos, decl->s_name);
1383 	else if (params.identifier && allow_c99)
1384 		/* function definition for '%s' with identifier list is ... */
1385 		warning_at(384, &decl->s_def_pos, decl->s_name);
1386 
1387 	if (params.prototype) {
1388 		if (!allow_c90)
1389 			/* function prototypes are illegal in traditional C */
1390 			warning(270);
1391 		check_prototype_parameters(params.first);
1392 		if (params.first != NULL
1393 		    && params.first->s_type->t_tspec == VOID)
1394 			params.first = NULL;
1395 	} else
1396 		old_style_function(decl, params.first);
1397 	if (params.used)
1398 		decl->s_used = true;
1399 
1400 	/*
1401 	 * The symbols are removed from the symbol table by
1402 	 * end_declaration_level after add_function. To be able to restore them
1403 	 * if this is a function definition, a pointer to the list of all
1404 	 * symbols is stored in dcs->d_enclosing->d_func_proto_syms. Also, a
1405 	 * list of the parameters (concatenated by s_next) is stored in
1406 	 * dcs->d_enclosing->d_func_params. (dcs->d_enclosing must be used
1407 	 * because *dcs is the declaration stack element created for the list
1408 	 * of params and is removed after add_function.)
1409 	 */
1410 	if (dcs->d_enclosing->d_kind == DLK_EXTERN &&
1411 	    decl->s_type == dcs->d_enclosing->d_type) {
1412 		dcs->d_enclosing->d_func_proto_syms = dcs->d_first_dlsym;
1413 		dcs->d_enclosing->d_func_params = params.first;
1414 		debug_dcs_all();
1415 	}
1416 
1417 	type_t **tpp = &decl->s_type;
1418 	lint_assert(*tpp != NULL);
1419 	while (*tpp != dcs->d_enclosing->d_type) {
1420 		tpp = &(*tpp)->t_subt;
1421 		lint_assert(*tpp != NULL);
1422 	}
1423 
1424 	*tpp = block_derive_function(dcs->d_enclosing->d_type,
1425 	    params.prototype, params.first, params.vararg,
1426 	    params.noreturn || dcs->d_enclosing->d_noreturn);
1427 
1428 	debug_step("add_function: '%s'", type_name(decl->s_type));
1429 	debug_dcs_all();
1430 	debug_leave();
1431 	return decl;
1432 }
1433 
1434 /*
1435  * In a function declaration, a list of identifiers (as opposed to a list of
1436  * types) is allowed only if it's also a function definition.
1437  */
1438 void
1439 check_function_definition(sym_t *sym, bool msg)
1440 {
1441 
1442 	if (sym->s_osdef) {
1443 		if (msg)
1444 			/* incomplete or misplaced function definition */
1445 			error(22);
1446 		sym->s_osdef = false;
1447 		sym->u.s_old_style_params = NULL;
1448 	}
1449 }
1450 
1451 /* The symbol gets a storage class and a definedness. */
1452 sym_t *
1453 declarator_name(sym_t *sym)
1454 {
1455 	scl_t sc = NO_SCL;
1456 
1457 	if (sym->s_scl == NO_SCL)
1458 		dcs->d_redeclared_symbol = NULL;
1459 	else if (sym->s_defparam) {
1460 		sym->s_defparam = false;
1461 		dcs->d_redeclared_symbol = NULL;
1462 	} else {
1463 		dcs->d_redeclared_symbol = sym;
1464 		if (is_query_enabled[16]
1465 		    && sym->s_scl == STATIC && dcs->d_scl != STATIC) {
1466 			/* '%s' was declared 'static', now non-'static' */
1467 			query_message(16, sym->s_name);
1468 			print_previous_declaration(sym);
1469 		}
1470 		sym = pushdown(sym);
1471 	}
1472 
1473 	switch (dcs->d_kind) {
1474 	case DLK_STRUCT:
1475 	case DLK_UNION:
1476 		sym->u.s_member.sm_containing_type = dcs->d_tag_type->u.sou;
1477 		sym->s_def = DEF;
1478 		sc = dcs->d_kind == DLK_STRUCT ? STRUCT_MEMBER : UNION_MEMBER;
1479 		break;
1480 	case DLK_EXTERN:
1481 		/*
1482 		 * Symbols that are 'static' or without any storage class are
1483 		 * tentatively defined. Symbols that are tentatively defined or
1484 		 * declared may later become defined if an initializer is seen
1485 		 * or this is a function definition.
1486 		 */
1487 		sc = dcs->d_scl;
1488 		if (sc == NO_SCL || sc == THREAD_LOCAL) {
1489 			sc = EXTERN;
1490 			sym->s_def = TDEF;
1491 		} else if (sc == STATIC)
1492 			sym->s_def = TDEF;
1493 		else if (sc == TYPEDEF)
1494 			sym->s_def = DEF;
1495 		else {
1496 			lint_assert(sc == EXTERN);
1497 			sym->s_def = DECL;
1498 		}
1499 		break;
1500 	case DLK_PROTO_PARAMS:
1501 		sym->s_param = true;
1502 		/* FALLTHROUGH */
1503 	case DLK_OLD_STYLE_PARAMS:
1504 		lint_assert(dcs->d_scl == NO_SCL || dcs->d_scl == REG);
1505 		sym->s_register = dcs->d_scl == REG;
1506 		sc = AUTO;
1507 		sym->s_def = DEF;
1508 		break;
1509 	case DLK_AUTO:
1510 		if ((sc = dcs->d_scl) == NO_SCL) {
1511 			/*
1512 			 * XXX somewhat ugly because we don't know whether this
1513 			 * is AUTO or EXTERN (functions). If we are wrong, it
1514 			 * must be corrected in declare_local, when the
1515 			 * necessary type information is available.
1516 			 */
1517 			sc = AUTO;
1518 			sym->s_def = DEF;
1519 		} else if (sc == AUTO || sc == STATIC || sc == TYPEDEF
1520 		    || sc == THREAD_LOCAL)
1521 			sym->s_def = DEF;
1522 		else if (sc == REG) {
1523 			sym->s_register = true;
1524 			sc = AUTO;
1525 			sym->s_def = DEF;
1526 		} else {
1527 			lint_assert(sc == EXTERN);
1528 			sym->s_def = DECL;
1529 		}
1530 		break;
1531 	default:
1532 		lint_assert(dcs->d_kind == DLK_ABSTRACT);
1533 		/* try to continue after syntax errors */
1534 		sc = NO_SCL;
1535 	}
1536 	sym->s_scl = sc;
1537 
1538 	sym->s_type = dcs->d_type;
1539 	if (dcs->d_used)
1540 		sym->s_used = true;
1541 
1542 	dcs->d_func_proto_syms = NULL;
1543 
1544 	debug_sym("declarator_name: ", sym, "\n");
1545 	debug_func_dcs(__func__);
1546 	return sym;
1547 }
1548 
1549 sym_t *
1550 old_style_function_parameter_name(sym_t *sym)
1551 {
1552 
1553 	if (sym->s_scl != NO_SCL) {
1554 		if (block_level == sym->s_block_level) {
1555 			/* redeclaration of formal parameter '%s' */
1556 			error(21, sym->s_name);
1557 			lint_assert(sym->s_defparam);
1558 		}
1559 		sym = pushdown(sym);
1560 	}
1561 	sym->s_type = gettyp(INT);
1562 	sym->s_scl = AUTO;
1563 	sym->s_def = DEF;
1564 	sym->s_defparam = true;
1565 	sym->s_param = true;
1566 	debug_sym("old_style_function_parameter_name: ", sym, "\n");
1567 	return sym;
1568 }
1569 
1570 /*-
1571  * Checks all possible cases of tag redeclarations.
1572  *
1573  * decl		whether T_LBRACE follows
1574  * semi		whether T_SEMI follows
1575  */
1576 static sym_t *
1577 new_tag(sym_t *tag, scl_t scl, bool decl, bool semi)
1578 {
1579 
1580 	if (tag->s_block_level < block_level) {
1581 		if (semi) {
1582 			/* "struct a;" */
1583 			if (allow_c90) {
1584 				/* XXX: Why is this warning suppressed in C90 mode? */
1585 				if (allow_trad || allow_c99)
1586 					/* declaration of '%s %s' intro... */
1587 					warning(44, tag_name(scl),
1588 					    tag->s_name);
1589 				tag = pushdown(tag);
1590 			} else if (tag->s_scl != scl)
1591 				/* base type is really '%s %s' */
1592 				warning(45, tag_name(tag->s_scl), tag->s_name);
1593 			dcs->d_enclosing->d_nonempty_decl = true;
1594 		} else if (decl) {
1595 			/* "struct a { ... } " */
1596 			if (hflag)
1597 				/* redefinition of '%s' hides earlier one */
1598 				warning(43, tag->s_name);
1599 			tag = pushdown(tag);
1600 			dcs->d_enclosing->d_nonempty_decl = true;
1601 		} else if (tag->s_scl != scl) {
1602 			/* base type is really '%s %s' */
1603 			warning(45, tag_name(tag->s_scl), tag->s_name);
1604 			/* XXX: Why is this warning suppressed in C90 mode? */
1605 			if (allow_trad || allow_c99)
1606 				/* declaration of '%s %s' introduces ... */
1607 				warning(44, tag_name(scl), tag->s_name);
1608 			tag = pushdown(tag);
1609 			dcs->d_enclosing->d_nonempty_decl = true;
1610 		}
1611 	} else {
1612 		if (tag->s_scl != scl ||
1613 		    (decl && !is_incomplete(tag->s_type))) {
1614 			/* %s tag '%s' redeclared as %s */
1615 			error(46, tag_name(tag->s_scl),
1616 			    tag->s_name, tag_name(scl));
1617 			print_previous_declaration(tag);
1618 			tag = pushdown(tag);
1619 			dcs->d_enclosing->d_nonempty_decl = true;
1620 		} else if (semi || decl)
1621 			dcs->d_enclosing->d_nonempty_decl = true;
1622 	}
1623 	debug_sym("new_tag: ", tag, "\n");
1624 	debug_dcs_all();
1625 	return tag;
1626 }
1627 
1628 /*-
1629  * tag		the symbol table entry of the tag
1630  * kind		the kind of the tag (STRUCT/UNION/ENUM)
1631  * decl		whether the tag type will be completed in this declaration
1632  *		(when the following token is T_LBRACE)
1633  * semi		whether the following token is T_SEMI
1634  */
1635 type_t *
1636 make_tag_type(sym_t *tag, tspec_t kind, bool decl, bool semi)
1637 {
1638 	scl_t scl;
1639 	type_t *tp;
1640 
1641 	if (kind == STRUCT)
1642 		scl = STRUCT_TAG;
1643 	else if (kind == UNION)
1644 		scl = UNION_TAG;
1645 	else {
1646 		lint_assert(kind == ENUM);
1647 		scl = ENUM_TAG;
1648 	}
1649 
1650 	if (tag != NULL) {
1651 		if (tag->s_scl != NO_SCL)
1652 			tag = new_tag(tag, scl, decl, semi);
1653 		else {
1654 			/* a new tag, no empty declaration */
1655 			dcs->d_enclosing->d_nonempty_decl = true;
1656 			if (scl == ENUM_TAG && !decl) {
1657 				/* TODO: Make this an error in C99 mode as well. */
1658 				if (allow_c90 &&
1659 				    ((!allow_trad && !allow_c99) || pflag))
1660 					/* forward reference to enum type */
1661 					warning(42);
1662 			}
1663 		}
1664 		if (tag->s_scl == NO_SCL) {
1665 			tag->s_scl = scl;
1666 			tag->s_type = tp =
1667 			    block_zero_alloc(sizeof(*tp), "type");
1668 			tp->t_packed = dcs->d_packed;
1669 		} else
1670 			tp = tag->s_type;
1671 
1672 	} else {
1673 		tag = block_zero_alloc(sizeof(*tag), "sym");
1674 		tag->s_name = unnamed;
1675 		tag->s_def_pos = unique_curr_pos();
1676 		tag->s_kind = SK_TAG;
1677 		tag->s_scl = scl;
1678 		tag->s_block_level = -1;
1679 		tag->s_type = tp = block_zero_alloc(sizeof(*tp), "type");
1680 		tp->t_packed = dcs->d_packed;
1681 		dcs->d_enclosing->d_nonempty_decl = true;
1682 	}
1683 
1684 	if (tp->t_tspec == NO_TSPEC) {
1685 		tp->t_tspec = kind;
1686 		if (kind != ENUM) {
1687 			tp->u.sou = block_zero_alloc(sizeof(*tp->u.sou),
1688 			    "struct_or_union");
1689 			tp->u.sou->sou_align = 1;
1690 			tp->u.sou->sou_tag = tag;
1691 			tp->u.sou->sou_incomplete = true;
1692 		} else {
1693 			tp->t_is_enum = true;
1694 			tp->u.enumer = block_zero_alloc(
1695 			    sizeof(*tp->u.enumer), "enumeration");
1696 			tp->u.enumer->en_tag = tag;
1697 			tp->u.enumer->en_incomplete = true;
1698 		}
1699 	}
1700 	debug_printf("%s: '%s'", __func__, type_name(tp));
1701 	debug_sym(" ", tag, "\n");
1702 	debug_dcs_all();
1703 	return tp;
1704 }
1705 
1706 static bool
1707 has_named_member(const struct_or_union *sou)
1708 {
1709 	for (const sym_t *mem = sou->sou_first_member;
1710 	    mem != NULL; mem = mem->s_next) {
1711 		if (mem->s_name != unnamed)
1712 			return true;
1713 		if (is_struct_or_union(mem->s_type->t_tspec)
1714 		    && has_named_member(mem->s_type->u.sou))
1715 			return true;
1716 	}
1717 	return false;
1718 }
1719 
1720 type_t *
1721 complete_struct_or_union(sym_t *first_member)
1722 {
1723 
1724 	type_t *tp = dcs->d_tag_type;
1725 	if (tp == NULL)		/* in case of syntax errors */
1726 		return gettyp(INT);
1727 
1728 	dcs_align(dcs->d_sou_align, 0);
1729 
1730 	struct_or_union *sou = tp->u.sou;
1731 	sou->sou_align = dcs->d_sou_align;
1732 	sou->sou_incomplete = false;
1733 	sou->sou_first_member = first_member;
1734 	if (tp->t_packed)
1735 		pack_struct_or_union(tp);
1736 	else
1737 		sou->sou_size_in_bits = dcs->d_sou_size_in_bits;
1738 
1739 	if (sou->sou_size_in_bits == 0)
1740 		/* zero sized %s is a C99 feature */
1741 		c99ism(47, tspec_name(tp->t_tspec));
1742 	else if (!has_named_member(sou))
1743 		/* '%s' has no named members */
1744 		warning(65, type_name(tp));
1745 	debug_step("%s: '%s'", __func__, type_name(tp));
1746 	debug_dcs_all();
1747 	return tp;
1748 }
1749 
1750 type_t *
1751 complete_enum(sym_t *first_enumerator)
1752 {
1753 
1754 	type_t *tp = dcs->d_tag_type;
1755 	tp->u.enumer->en_incomplete = false;
1756 	tp->u.enumer->en_first_enumerator = first_enumerator;
1757 	debug_step("%s: '%s'", __func__, type_name(tp));
1758 	debug_func_dcs(__func__);
1759 	return tp;
1760 }
1761 
1762 sym_t *
1763 enumeration_constant(sym_t *sym, int val, bool implicit)
1764 {
1765 
1766 	if (sym->s_scl != NO_SCL) {
1767 		if (sym->s_block_level == block_level) {
1768 			/* no hflag, because this is illegal */
1769 			if (sym->s_param)
1770 				/* enumeration constant '%s' hides parameter */
1771 				warning(57, sym->s_name);
1772 			else {
1773 				/* redeclaration of '%s' */
1774 				error(27, sym->s_name);
1775 				/*
1776 				 * Inside blocks, it should not be too
1777 				 * complicated to find the position of the
1778 				 * previous declaration
1779 				 */
1780 				if (block_level == 0)
1781 					print_previous_declaration(sym);
1782 			}
1783 		} else {
1784 			if (hflag)
1785 				/* redefinition of '%s' hides earlier one */
1786 				warning(43, sym->s_name);
1787 		}
1788 		sym = pushdown(sym);
1789 	}
1790 
1791 	sym->s_scl = ENUM_CONST;
1792 	sym->s_type = dcs->d_tag_type;
1793 	sym->u.s_enum_constant = val;
1794 
1795 	if (implicit && val == TARG_INT_MIN)
1796 		/* enumeration value '%s' overflows */
1797 		warning(48, sym->s_name);
1798 
1799 	enumval = val == TARG_INT_MAX ? TARG_INT_MIN : val + 1;
1800 	debug_sym("enumeration_constant: ", sym, "\n");
1801 	return sym;
1802 }
1803 
1804 static bool
1805 str_ends_with(const char *s, const char *suffix)
1806 {
1807 	size_t s_len = strlen(s);
1808 	size_t suffix_len = strlen(suffix);
1809 	return s_len >= suffix_len &&
1810 	    memcmp(s + s_len - suffix_len, suffix, suffix_len) == 0;
1811 }
1812 
1813 void
1814 check_extern_declaration(const sym_t *sym)
1815 {
1816 
1817 	if (sym->s_scl == EXTERN &&
1818 	    dcs->d_redeclared_symbol == NULL &&
1819 	    str_ends_with(curr_pos.p_file, ".c") &&
1820 	    allow_c90 &&
1821 	    !ch_isdigit(sym->s_name[0]) &&	/* see mktempsym */
1822 	    strcmp(sym->s_name, "main") != 0) {
1823 		/* missing%s header declaration for '%s' */
1824 		warning(351, sym->s_type->t_tspec == FUNC ? "" : " 'extern'",
1825 		    sym->s_name);
1826 	}
1827 	if (sym->s_type->t_tspec == FUNC &&
1828 	    sym->s_scl == EXTERN &&
1829 	    sym->s_def == DECL &&
1830 	    !in_system_header)
1831 		/* redundant 'extern' in function declaration of '%s' */
1832 		query_message(13, sym->s_name);
1833 }
1834 
1835 /*
1836  * Check whether the symbol cannot be initialized due to type/storage class.
1837  * Return whether an error has been detected.
1838  */
1839 static bool
1840 check_init(const sym_t *sym)
1841 {
1842 
1843 	if (sym->s_type->t_tspec == FUNC) {
1844 		/* cannot initialize function '%s' */
1845 		error(24, sym->s_name);
1846 		return true;
1847 	}
1848 	if (sym->s_scl == TYPEDEF) {
1849 		/* cannot initialize typedef '%s' */
1850 		error(25, sym->s_name);
1851 		return true;
1852 	}
1853 	if (sym->s_scl == EXTERN && sym->s_def == DECL) {
1854 		if (dcs->d_kind == DLK_EXTERN)
1855 			/* cannot initialize extern declaration '%s' */
1856 			warning(26, sym->s_name);
1857 		else {
1858 			/* cannot initialize extern declaration '%s' */
1859 			error(26, sym->s_name);
1860 			return true;
1861 		}
1862 	}
1863 
1864 	return false;
1865 }
1866 
1867 /*
1868  * Compares a prototype declaration with the remembered parameters of a
1869  * previous old-style function definition.
1870  */
1871 static bool
1872 check_old_style_definition(const sym_t *rdsym, const sym_t *dsym)
1873 {
1874 
1875 	const sym_t *old_params = rdsym->u.s_old_style_params;
1876 	const sym_t *proto_params = dsym->s_type->u.params;
1877 
1878 	bool msg = false;
1879 
1880 	int old_n = 0;
1881 	for (const sym_t *p = old_params; p != NULL; p = p->s_next)
1882 		old_n++;
1883 	int proto_n = 0;
1884 	for (const sym_t *p = proto_params; p != NULL; p = p->s_next)
1885 		proto_n++;
1886 	if (old_n != proto_n) {
1887 		/* prototype does not match old-style definition */
1888 		error(63);
1889 		msg = true;
1890 		goto end;
1891 	}
1892 
1893 	const sym_t *arg = old_params;
1894 	const sym_t *parg = proto_params;
1895 	int n = 1;
1896 	while (old_n-- > 0) {
1897 		bool dowarn = false;
1898 		if (!types_compatible(arg->s_type, parg->s_type,
1899 		    true, true, &dowarn) ||
1900 		    dowarn) {
1901 			/* prototype does not match old-style ... */
1902 			error(299, n);
1903 			msg = true;
1904 		}
1905 		arg = arg->s_next;
1906 		parg = parg->s_next;
1907 		n++;
1908 	}
1909 
1910 end:
1911 	if (msg && rflag)
1912 		/* old-style definition */
1913 		message_at(300, &rdsym->s_def_pos);
1914 	return msg;
1915 }
1916 
1917 /* Process a single external or 'static' declarator. */
1918 static void
1919 declare_extern(sym_t *dsym, bool has_initializer, const sbuf_t *renaming)
1920 {
1921 
1922 	if (renaming != NULL) {
1923 		lint_assert(dsym->s_rename == NULL);
1924 
1925 		char *s = level_zero_alloc(1, renaming->sb_len + 1, "string");
1926 		(void)memcpy(s, renaming->sb_name, renaming->sb_len + 1);
1927 		dsym->s_rename = s;
1928 	}
1929 
1930 	check_extern_declaration(dsym);
1931 
1932 	check_function_definition(dsym, true);
1933 
1934 	check_type(dsym);
1935 
1936 	if (has_initializer && !check_init(dsym))
1937 		dsym->s_def = DEF;
1938 
1939 	/*
1940 	 * Declarations of functions are marked as "tentative" in
1941 	 * declarator_name(). This is wrong because there are no tentative
1942 	 * function definitions.
1943 	 */
1944 	if (dsym->s_type->t_tspec == FUNC && dsym->s_def == TDEF)
1945 		dsym->s_def = DECL;
1946 
1947 	if (dcs->d_inline) {
1948 		if (dsym->s_type->t_tspec == FUNC) {
1949 			dsym->s_inline = true;
1950 		} else {
1951 			/* variable '%s' declared inline */
1952 			warning(268, dsym->s_name);
1953 		}
1954 	}
1955 
1956 	/* Write the declaration into the output file */
1957 	if (plibflg && llibflg &&
1958 	    dsym->s_type->t_tspec == FUNC && dsym->s_type->t_proto) {
1959 		/*
1960 		 * With both LINTLIBRARY and PROTOLIB the prototype is written
1961 		 * as a function definition to the output file.
1962 		 */
1963 		bool rval = dsym->s_type->t_subt->t_tspec != VOID;
1964 		outfdef(dsym, &dsym->s_def_pos, rval, false, NULL);
1965 	} else if (!is_compiler_builtin(dsym->s_name)
1966 	    && !(has_initializer && dsym->s_type->t_incomplete_array)) {
1967 		outsym(dsym, dsym->s_scl, dsym->s_def);
1968 	}
1969 
1970 	sym_t *rdsym = dcs->d_redeclared_symbol;
1971 	if (rdsym != NULL) {
1972 
1973 		/*
1974 		 * If the old symbol stems from an old-style function
1975 		 * definition, we have remembered the params in
1976 		 * rdsym->s_old_style_params and compare them with the params
1977 		 * of the prototype.
1978 		 */
1979 		bool redec = rdsym->s_osdef && dsym->s_type->t_proto &&
1980 		    check_old_style_definition(rdsym, dsym);
1981 
1982 		bool dowarn = false;
1983 		if (!redec && !check_redeclaration(dsym, &dowarn)) {
1984 			if (dowarn) {
1985 				/* TODO: Make this an error in C99 mode as well. */
1986 				if (!allow_trad && !allow_c99)
1987 					/* redeclaration of '%s' */
1988 					error(27, dsym->s_name);
1989 				else
1990 					/* redeclaration of '%s' */
1991 					warning(27, dsym->s_name);
1992 				print_previous_declaration(rdsym);
1993 			}
1994 
1995 			/*
1996 			 * Take over the remembered params if the new symbol is
1997 			 * not a prototype.
1998 			 */
1999 			if (rdsym->s_osdef && !dsym->s_type->t_proto) {
2000 				dsym->s_osdef = rdsym->s_osdef;
2001 				dsym->u.s_old_style_params =
2002 				    rdsym->u.s_old_style_params;
2003 				dsym->s_def_pos = rdsym->s_def_pos;
2004 			}
2005 
2006 			if (rdsym->s_type->t_proto && !dsym->s_type->t_proto)
2007 				dsym->s_def_pos = rdsym->s_def_pos;
2008 			else if (rdsym->s_def == DEF && dsym->s_def != DEF)
2009 				dsym->s_def_pos = rdsym->s_def_pos;
2010 
2011 			copy_usage_info(dsym, rdsym);
2012 
2013 			/* Once a name is defined, it remains defined. */
2014 			if (rdsym->s_def == DEF)
2015 				dsym->s_def = DEF;
2016 
2017 			/* once a function is inline, it remains inline */
2018 			if (rdsym->s_inline)
2019 				dsym->s_inline = true;
2020 
2021 			complete_type(dsym, rdsym);
2022 		}
2023 
2024 		symtab_remove_forever(rdsym);
2025 	}
2026 
2027 	if (dsym->s_scl == TYPEDEF) {
2028 		dsym->s_type = block_dup_type(dsym->s_type);
2029 		dsym->s_type->t_typedef = true;
2030 		set_first_typedef(dsym->s_type, dsym);
2031 		if (dsym->s_type->t_tspec == STRUCT)
2032 			/* typedef '%s' of struct type '%s' */
2033 			query_message(21, dsym->s_name,
2034 			    type_name(dsym->s_type));
2035 		else if (dsym->s_type->t_tspec == UNION)
2036 			/* typedef '%s' of union type '%s' */
2037 			query_message(22, dsym->s_name,
2038 			    type_name(dsym->s_type));
2039 		else if (dsym->s_type->t_tspec == PTR
2040 		    && dsym->s_type->t_subt->t_tspec == STRUCT)
2041 			/* typedef '%s' of pointer to struct type '%s' */
2042 			query_message(23, dsym->s_name,
2043 			    type_name(dsym->s_type));
2044 		else if (dsym->s_type->t_tspec == PTR
2045 		    && dsym->s_type->t_subt->t_tspec == UNION)
2046 			/* typedef '%s' of pointer to union type '%s' */
2047 			query_message(24, dsym->s_name,
2048 			    type_name(dsym->s_type));
2049 	}
2050 	debug_printf("%s: ", __func__);
2051 	debug_sym("", dsym, "\n");
2052 }
2053 
2054 void
2055 declare(sym_t *decl, bool has_initializer, sbuf_t *renaming)
2056 {
2057 
2058 	if (dcs->d_kind == DLK_EXTERN)
2059 		declare_extern(decl, has_initializer, renaming);
2060 	else if (dcs->d_kind == DLK_OLD_STYLE_PARAMS ||
2061 	    dcs->d_kind == DLK_PROTO_PARAMS) {
2062 		if (renaming != NULL)
2063 			/* symbol renaming can't be used on function ... */
2064 			error(310);
2065 		else
2066 			(void)declare_parameter(decl, has_initializer);
2067 	} else {
2068 		lint_assert(dcs->d_kind == DLK_AUTO);
2069 		if (renaming != NULL)
2070 			/* symbol renaming can't be used on automatic ... */
2071 			error(311);
2072 		else
2073 			declare_local(decl, has_initializer);
2074 	}
2075 	debug_printf("%s: ", __func__);
2076 	debug_sym("", decl, "\n");
2077 }
2078 
2079 /*
2080  * Copies information about usage into a new symbol table entry of
2081  * the same symbol.
2082  */
2083 void
2084 copy_usage_info(sym_t *sym, const sym_t *rdsym)
2085 {
2086 
2087 	sym->s_set_pos = rdsym->s_set_pos;
2088 	sym->s_use_pos = rdsym->s_use_pos;
2089 	sym->s_set = rdsym->s_set;
2090 	sym->s_used = rdsym->s_used;
2091 }
2092 
2093 /*
2094  * Prints an error and returns true if a symbol is redeclared/redefined.
2095  * Otherwise, returns false and, in some cases of minor problems, prints
2096  * a warning.
2097  */
2098 bool
2099 check_redeclaration(sym_t *dsym, bool *dowarn)
2100 {
2101 
2102 	sym_t *rdsym = dcs->d_redeclared_symbol;
2103 	if (rdsym->s_scl == ENUM_CONST) {
2104 		/* redeclaration of '%s' */
2105 		error(27, dsym->s_name);
2106 		print_previous_declaration(rdsym);
2107 		return true;
2108 	}
2109 	if (rdsym->s_scl == TYPEDEF) {
2110 		/* typedef '%s' redeclared */
2111 		error(89, dsym->s_name);
2112 		print_previous_declaration(rdsym);
2113 		return true;
2114 	}
2115 	if (dsym->s_scl == TYPEDEF) {
2116 		/* redeclaration of '%s' */
2117 		error(27, dsym->s_name);
2118 		print_previous_declaration(rdsym);
2119 		return true;
2120 	}
2121 	if (rdsym->s_def == DEF && dsym->s_def == DEF) {
2122 		/* redefinition of '%s' */
2123 		error(28, dsym->s_name);
2124 		print_previous_declaration(rdsym);
2125 		return true;
2126 	}
2127 	if (!types_compatible(rdsym->s_type, dsym->s_type,
2128 	    false, false, dowarn)) {
2129 		/* redeclaration of '%s' with type '%s', expected '%s' */
2130 		error(347, dsym->s_name,
2131 		    type_name(dsym->s_type), type_name(rdsym->s_type));
2132 		print_previous_declaration(rdsym);
2133 		return true;
2134 	}
2135 	if (rdsym->s_scl == EXTERN && dsym->s_scl == EXTERN)
2136 		return false;
2137 	if (rdsym->s_scl == STATIC && dsym->s_scl == STATIC)
2138 		return false;
2139 	if (rdsym->s_scl == STATIC && dsym->s_def == DECL)
2140 		return false;
2141 	if (rdsym->s_scl == EXTERN && rdsym->s_def == DEF) {
2142 		/*
2143 		 * All cases except "int a = 1; static int a;" are caught above
2144 		 * with or without a warning
2145 		 */
2146 		/* redeclaration of '%s' */
2147 		error(27, dsym->s_name);
2148 		print_previous_declaration(rdsym);
2149 		return true;
2150 	}
2151 	if (rdsym->s_scl == EXTERN) {
2152 		/* '%s' was previously declared extern, becomes static */
2153 		warning(29, dsym->s_name);
2154 		print_previous_declaration(rdsym);
2155 		return false;
2156 	}
2157 	/*-
2158 	 * Now it's one of:
2159 	 * "static a; int a;"
2160 	 * "static a; int a = 1;"
2161 	 * "static a = 1; int a;"
2162 	 */
2163 	/* TODO: Make this an error in C99 mode as well. */
2164 	if (!allow_trad && !allow_c99) {
2165 		/* redeclaration of '%s'; C90 or later require static */
2166 		warning(30, dsym->s_name);
2167 		print_previous_declaration(rdsym);
2168 	}
2169 	dsym->s_scl = STATIC;
2170 	return false;
2171 }
2172 
2173 static bool
2174 qualifiers_correspond(const type_t *tp1, const type_t *tp2, bool ignqual)
2175 {
2176 
2177 	if (tp1->t_const != tp2->t_const && !ignqual && allow_c90)
2178 		return false;
2179 	if (tp1->t_volatile != tp2->t_volatile && !ignqual && allow_c90)
2180 		return false;
2181 	return true;
2182 }
2183 
2184 bool
2185 pointer_types_are_compatible(const type_t *tp1, const type_t *tp2, bool ignqual)
2186 {
2187 
2188 	return tp1->t_tspec == VOID || tp2->t_tspec == VOID ||
2189 	    qualifiers_correspond(tp1, tp2, ignqual);
2190 }
2191 
2192 static bool
2193 prototypes_compatible(const type_t *tp1, const type_t *tp2, bool *dowarn)
2194 {
2195 
2196 	if (tp1->t_vararg != tp2->t_vararg)
2197 		return false;
2198 
2199 	const sym_t *p1 = tp1->u.params;
2200 	const sym_t *p2 = tp2->u.params;
2201 
2202 	for (; p1 != NULL && p2 != NULL; p1 = p1->s_next, p2 = p2->s_next) {
2203 		if (!types_compatible(p1->s_type, p2->s_type,
2204 		    true, false, dowarn))
2205 			return false;
2206 	}
2207 	return p1 == p2;
2208 }
2209 
2210 /*
2211  * Returns whether all parameters of a prototype are compatible with an
2212  * old-style function declaration.
2213  */
2214 static bool
2215 is_old_style_compat(const type_t *tp)
2216 {
2217 
2218 	if (tp->t_vararg)
2219 		return false;
2220 	for (const sym_t *p = tp->u.params; p != NULL; p = p->s_next) {
2221 		tspec_t t = p->s_type->t_tspec;
2222 		if (t == FLOAT ||
2223 		    t == CHAR || t == SCHAR || t == UCHAR ||
2224 		    t == SHORT || t == USHORT)
2225 			return false;
2226 	}
2227 	return true;
2228 }
2229 
2230 /*-
2231  * ignqual	ignore type qualifiers; used for function parameters
2232  * promot	promote the left type; used for comparison of parameters of
2233  *		old-style function definitions with parameters of prototypes.
2234  * *dowarn	is set to true if an old-style function declaration is not
2235  *		compatible with a prototype
2236  */
2237 bool
2238 types_compatible(const type_t *tp1, const type_t *tp2,
2239 		     bool ignqual, bool promot, bool *dowarn)
2240 {
2241 
2242 	while (tp1 != NULL && tp2 != NULL) {
2243 		tspec_t t = tp1->t_tspec;
2244 		if (promot) {
2245 			if (t == FLOAT)
2246 				t = DOUBLE;
2247 			else if (t == CHAR || t == SCHAR)
2248 				t = INT;
2249 			else if (t == UCHAR)
2250 				t = allow_c90 ? INT : UINT;
2251 			else if (t == SHORT)
2252 				t = INT;
2253 			else if (t == USHORT) {
2254 				/* CONSTCOND */
2255 				t = TARG_INT_MAX < TARG_USHRT_MAX || !allow_c90
2256 				    ? UINT : INT;
2257 			}
2258 		}
2259 
2260 		if (t != tp2->t_tspec)
2261 			return false;
2262 
2263 		if (!qualifiers_correspond(tp1, tp2, ignqual))
2264 			return false;
2265 
2266 		if (is_struct_or_union(t))
2267 			return tp1->u.sou == tp2->u.sou;
2268 
2269 		if (t == ENUM && eflag)
2270 			return tp1->u.enumer == tp2->u.enumer;
2271 
2272 		if (t == ARRAY && tp1->u.dimension != tp2->u.dimension) {
2273 			if (tp1->u.dimension != 0 && tp2->u.dimension != 0)
2274 				return false;
2275 		}
2276 
2277 		if (t == FUNC && allow_c90) {
2278 			if (tp1->t_proto && tp2->t_proto) {
2279 				if (!prototypes_compatible(tp1, tp2, dowarn))
2280 					return false;
2281 			} else if ((tp1->t_proto || tp2->t_proto)
2282 			    && dowarn != NULL
2283 			    && !is_old_style_compat(tp1->t_proto ? tp1 : tp2))
2284 				*dowarn = true;
2285 		}
2286 
2287 		tp1 = tp1->t_subt;
2288 		tp2 = tp2->t_subt;
2289 		ignqual = promot = false;
2290 	}
2291 
2292 	return tp1 == tp2;
2293 }
2294 
2295 /*
2296  * Completes a type by copying the dimension and prototype information from a
2297  * second compatible type.
2298  *
2299  * Following lines are legal:
2300  *  "typedef a[]; a b; a b[10]; a c; a c[20];"
2301  *  "typedef ft(); ft f; f(int); ft g; g(long);"
2302  * This means that, if a type is completed, the type structure must be
2303  * duplicated.
2304  */
2305 void
2306 complete_type(sym_t *dsym, const sym_t *ssym)
2307 {
2308 	type_t **dstp = &dsym->s_type;
2309 	type_t *src = ssym->s_type;
2310 
2311 	while (*dstp != NULL) {
2312 		type_t *dst = *dstp;
2313 		lint_assert(src != NULL);
2314 		lint_assert(dst->t_tspec == src->t_tspec);
2315 		if (dst->t_tspec == ARRAY) {
2316 			if (dst->u.dimension == 0 && src->u.dimension != 0) {
2317 				*dstp = dst = block_dup_type(dst);
2318 				dst->u.dimension = src->u.dimension;
2319 				dst->t_incomplete_array = false;
2320 			}
2321 		} else if (dst->t_tspec == FUNC) {
2322 			if (!dst->t_proto && src->t_proto) {
2323 				*dstp = dst = block_dup_type(dst);
2324 				dst->t_proto = true;
2325 				dst->u.params = src->u.params;
2326 			}
2327 		}
2328 		dstp = &dst->t_subt;
2329 		src = src->t_subt;
2330 	}
2331 	debug_printf("%s: ", __func__);
2332 	debug_sym("dsym: ", dsym, "");
2333 	debug_sym("ssym: ", ssym, "\n");
2334 }
2335 
2336 sym_t *
2337 declare_parameter(sym_t *sym, bool has_initializer)
2338 {
2339 
2340 	check_function_definition(sym, true);
2341 
2342 	check_type(sym);
2343 
2344 	if (dcs->d_redeclared_symbol != NULL &&
2345 	    dcs->d_redeclared_symbol->s_block_level == block_level) {
2346 		/* redeclaration of formal parameter '%s' */
2347 		error(237, sym->s_name);
2348 		symtab_remove_forever(dcs->d_redeclared_symbol);
2349 		sym->s_param = true;
2350 	}
2351 
2352 	if (!sym->s_param) {
2353 		/* declared parameter '%s' is missing */
2354 		error(53, sym->s_name);
2355 		sym->s_param = true;
2356 	}
2357 
2358 	if (has_initializer)
2359 		/* cannot initialize parameter '%s' */
2360 		error(52, sym->s_name);
2361 
2362 	if (sym->s_type == NULL)	/* for c(void()) */
2363 		sym->s_type = gettyp(VOID);
2364 
2365 	tspec_t t = sym->s_type->t_tspec;
2366 	if (t == ARRAY)
2367 		sym->s_type = block_derive_type(sym->s_type->t_subt, PTR);
2368 	if (t == FUNC) {
2369 		if (!allow_c90)
2370 			/* parameter '%s' has function type, should be ... */
2371 			warning(50, sym->s_name);
2372 		sym->s_type = block_derive_type(sym->s_type, PTR);
2373 	}
2374 	if (t == FLOAT && !allow_c90)
2375 		sym->s_type = gettyp(DOUBLE);
2376 
2377 	if (dcs->d_inline)
2378 		/* parameter '%s' declared inline */
2379 		warning(269, sym->s_name);
2380 
2381 	if (sym->s_type->t_const
2382 	    && (sym->s_scl == AUTO || sym->s_scl == REG)) {
2383 		/* const automatic variable '%s' */
2384 		query_message(18, sym->s_name);
2385 	}
2386 
2387 	/*
2388 	 * Arguments must have complete types. length_in_bits prints the needed
2389 	 * error messages (null dimension is impossible because arrays are
2390 	 * converted to pointers).
2391 	 */
2392 	if (sym->s_type->t_tspec != VOID)
2393 		(void)length_in_bits(sym->s_type, sym->s_name);
2394 
2395 	sym->s_used = dcs->d_used;
2396 	mark_as_set(sym);
2397 
2398 	debug_printf("%s: ", __func__);
2399 	debug_sym("", sym, "\n");
2400 	return sym;
2401 }
2402 
2403 static bool
2404 is_character_pointer(const type_t *tp)
2405 {
2406 	tspec_t st;
2407 
2408 	return tp->t_tspec == PTR &&
2409 	    (st = tp->t_subt->t_tspec,
2410 		st == CHAR || st == SCHAR || st == UCHAR);
2411 }
2412 
2413 void
2414 check_func_lint_directives(void)
2415 {
2416 
2417 	/* check for illegal combinations of lint directives */
2418 	if (printflike_argnum != -1 && scanflike_argnum != -1) {
2419 		/* ** PRINTFLIKE ** and ** SCANFLIKE ** cannot be combined */
2420 		warning(289);
2421 		printflike_argnum = scanflike_argnum = -1;
2422 	}
2423 	if (nvararg != -1 &&
2424 	    (printflike_argnum != -1 || scanflike_argnum != -1)) {
2425 		/* dubious use of ** VARARGS ** with ** %s ** */
2426 		warning(288,
2427 		    printflike_argnum != -1 ? "PRINTFLIKE" : "SCANFLIKE");
2428 		nvararg = -1;
2429 	}
2430 
2431 	/*
2432 	 * check if the numeric argument of a lint directive is compatible with
2433 	 * the number of parameters of the function.
2434 	 */
2435 	int narg = 0;
2436 	for (const sym_t *p = dcs->d_func_params; p != NULL; p = p->s_next)
2437 		narg++;
2438 	if (nargusg > narg) {
2439 		/* parameter number mismatch in comment ** %s ** */
2440 		warning(283, "ARGSUSED");
2441 		nargusg = 0;
2442 	}
2443 	if (nvararg > narg) {
2444 		/* parameter number mismatch in comment ** %s ** */
2445 		warning(283, "VARARGS");
2446 		nvararg = 0;
2447 	}
2448 	if (printflike_argnum > narg) {
2449 		/* parameter number mismatch in comment ** %s ** */
2450 		warning(283, "PRINTFLIKE");
2451 		printflike_argnum = -1;
2452 	} else if (printflike_argnum == 0) {
2453 		printflike_argnum = -1;
2454 	}
2455 	if (scanflike_argnum > narg) {
2456 		/* parameter number mismatch in comment ** %s ** */
2457 		warning(283, "SCANFLIKE");
2458 		scanflike_argnum = -1;
2459 	} else if (scanflike_argnum == 0) {
2460 		scanflike_argnum = -1;
2461 	}
2462 	if (printflike_argnum != -1 || scanflike_argnum != -1) {
2463 		narg = printflike_argnum != -1
2464 		    ? printflike_argnum : scanflike_argnum;
2465 		const sym_t *param = dcs->d_func_params;
2466 		for (int n = 1; n < narg; n++)
2467 			param = param->s_next;
2468 		if (!is_character_pointer(param->s_type)) {
2469 			/* parameter %d must be 'char *' for PRINTFLIKE/... */
2470 			warning(293, narg);
2471 			printflike_argnum = scanflike_argnum = -1;
2472 		}
2473 	}
2474 }
2475 
2476 /*
2477  * Checks compatibility of an old-style function definition with a previous
2478  * prototype declaration.
2479  * Returns true if the position of the previous declaration should be reported.
2480  */
2481 static bool
2482 check_prototype_declaration(const sym_t *old_param, const sym_t *proto_param)
2483 {
2484 	type_t *old_tp = old_param->s_type;
2485 	type_t *proto_tp = proto_param->s_type;
2486 	bool dowarn = false;
2487 
2488 	if (!types_compatible(old_tp, proto_tp, true, true, &dowarn)) {
2489 		if (types_compatible(old_tp, proto_tp, true, false, &dowarn)) {
2490 			/* type of '%s' does not match prototype */
2491 			return gnuism(58, old_param->s_name);
2492 		} else {
2493 			/* type of '%s' does not match prototype */
2494 			error(58, old_param->s_name);
2495 			return true;
2496 		}
2497 	}
2498 	if (dowarn) {
2499 		/* TODO: Make this an error in C99 mode as well. */
2500 		if (!allow_trad && !allow_c99)
2501 			/* type of '%s' does not match prototype */
2502 			error(58, old_param->s_name);
2503 		else
2504 			/* type of '%s' does not match prototype */
2505 			warning(58, old_param->s_name);
2506 		return true;
2507 	}
2508 
2509 	return false;
2510 }
2511 
2512 /*
2513  * Warn about parameters in old-style function definitions that default to int.
2514  * Check that an old-style function definition is compatible to a previous
2515  * prototype.
2516  */
2517 void
2518 check_func_old_style_parameters(void)
2519 {
2520 	sym_t *old_params = funcsym->u.s_old_style_params;
2521 	sym_t *proto_params = funcsym->s_type->u.params;
2522 
2523 	for (sym_t *arg = old_params; arg != NULL; arg = arg->s_next) {
2524 		if (arg->s_defparam) {
2525 			/* type of parameter '%s' defaults to 'int' */
2526 			warning(32, arg->s_name);
2527 			arg->s_defparam = false;
2528 			mark_as_set(arg);
2529 		}
2530 	}
2531 
2532 	/*
2533 	 * If this is an old-style function definition and a prototype exists,
2534 	 * compare the types of parameters.
2535 	 */
2536 	if (funcsym->s_osdef && funcsym->s_type->t_proto) {
2537 		/*
2538 		 * If the number of parameters does not match, we need not
2539 		 * continue.
2540 		 */
2541 		int old_n = 0, proto_n = 0;
2542 		bool msg = false;
2543 		for (const sym_t *p = proto_params; p != NULL; p = p->s_next)
2544 			proto_n++;
2545 		for (const sym_t *p = old_params; p != NULL; p = p->s_next)
2546 			old_n++;
2547 		if (old_n != proto_n) {
2548 			/* parameter mismatch: %d declared, %d defined */
2549 			error(51, proto_n, old_n);
2550 			msg = true;
2551 		} else {
2552 			const sym_t *proto_param = proto_params;
2553 			const sym_t *old_param = old_params;
2554 			while (old_n-- > 0) {
2555 				msg |= check_prototype_declaration(old_param, proto_param);
2556 				proto_param = proto_param->s_next;
2557 				old_param = old_param->s_next;
2558 			}
2559 		}
2560 		if (msg && rflag)
2561 			/* prototype declaration */
2562 			message_at(285, &dcs->d_redeclared_symbol->s_def_pos);
2563 
2564 		/* from now on the prototype is valid */
2565 		funcsym->s_osdef = false;
2566 		funcsym->u.s_old_style_params = NULL;
2567 	}
2568 }
2569 
2570 static void
2571 check_local_hiding(const sym_t *dsym, const sym_t *rdsym)
2572 {
2573 	switch (dsym->s_scl) {
2574 	case AUTO:
2575 		/* automatic '%s' hides external declaration with type '%s' */
2576 		warning(86, dsym->s_name, type_name(rdsym->s_type));
2577 		break;
2578 	case STATIC:
2579 		/* static '%s' hides external declaration with type '%s' */
2580 		warning(87, dsym->s_name, type_name(rdsym->s_type));
2581 		break;
2582 	case TYPEDEF:
2583 		/* typedef '%s' hides external declaration with type '%s' */
2584 		warning(88, dsym->s_name, type_name(rdsym->s_type));
2585 		break;
2586 	case EXTERN:
2587 		/* Already checked in declare_external_in_block. */
2588 		break;
2589 	default:
2590 		lint_assert(/*CONSTCOND*/false);
2591 	}
2592 }
2593 
2594 static void
2595 check_local_redeclaration(const sym_t *dsym, sym_t *rdsym)
2596 {
2597 	if (rdsym->s_block_level == 0) {
2598 		if (hflag)
2599 			check_local_hiding(dsym, rdsym);
2600 
2601 	} else if (rdsym->s_block_level == block_level) {
2602 
2603 		/* no hflag, because it's illegal! */
2604 		if (rdsym->s_param) {
2605 			/*
2606 			 * if allow_c90, a "redeclaration of '%s'" error is
2607 			 * produced below
2608 			 */
2609 			if (!allow_c90) {
2610 				if (hflag)
2611 					/* declaration of '%s' hides ... */
2612 					warning(91, dsym->s_name);
2613 				symtab_remove_forever(rdsym);
2614 			}
2615 		}
2616 
2617 	} else if (rdsym->s_block_level < block_level && hflag)
2618 		/* declaration of '%s' hides earlier one */
2619 		warning(95, dsym->s_name);
2620 
2621 	if (rdsym->s_block_level == block_level) {
2622 		/* redeclaration of '%s' */
2623 		error(27, dsym->s_name);
2624 		symtab_remove_forever(rdsym);
2625 	}
2626 }
2627 
2628 /* Processes (re)declarations of external symbols inside blocks. */
2629 static void
2630 declare_external_in_block(sym_t *dsym)
2631 {
2632 
2633 	/* look for a symbol with the same name */
2634 	sym_t *esym = dcs->d_redeclared_symbol;
2635 	while (esym != NULL && esym->s_block_level != 0) {
2636 		while ((esym = esym->s_symtab_next) != NULL) {
2637 			if (esym->s_kind != SK_VCFT)
2638 				continue;
2639 			if (strcmp(dsym->s_name, esym->s_name) == 0)
2640 				break;
2641 		}
2642 	}
2643 	if (esym == NULL)
2644 		return;
2645 	if (esym->s_scl != EXTERN && esym->s_scl != STATIC) {
2646 		/* gcc accepts this without a warning, pcc prints an error. */
2647 		/* redeclaration of '%s' */
2648 		warning(27, dsym->s_name);
2649 		print_previous_declaration(esym);
2650 		return;
2651 	}
2652 
2653 	bool dowarn = false;
2654 	bool compatible = types_compatible(esym->s_type, dsym->s_type,
2655 	    false, false, &dowarn);
2656 
2657 	if (!compatible || dowarn) {
2658 		if (esym->s_scl == EXTERN) {
2659 			/* inconsistent redeclaration of extern '%s' */
2660 			warning(90, dsym->s_name);
2661 			print_previous_declaration(esym);
2662 		} else {
2663 			/* inconsistent redeclaration of static '%s' */
2664 			warning(92, dsym->s_name);
2665 			print_previous_declaration(esym);
2666 		}
2667 	}
2668 
2669 	if (compatible) {
2670 		/*
2671 		 * Remember the external symbol, so we can update usage
2672 		 * information at the end of the block.
2673 		 */
2674 		dsym->s_ext_sym = esym;
2675 	}
2676 }
2677 
2678 /*
2679  * Completes a single local declaration/definition.
2680  */
2681 void
2682 declare_local(sym_t *dsym, bool has_initializer)
2683 {
2684 
2685 	/* Correct a mistake done in declarator_name(). */
2686 	if (dsym->s_type->t_tspec == FUNC) {
2687 		dsym->s_def = DECL;
2688 		if (dcs->d_scl == NO_SCL)
2689 			dsym->s_scl = EXTERN;
2690 	}
2691 
2692 	if (dsym->s_scl == EXTERN)
2693 		/* nested 'extern' declaration of '%s' */
2694 		warning(352, dsym->s_name);
2695 
2696 	if (dsym->s_type->t_tspec == FUNC) {
2697 		if (dsym->s_scl == STATIC) {
2698 			/* dubious static function '%s' at block level */
2699 			warning(93, dsym->s_name);
2700 			dsym->s_scl = EXTERN;
2701 		} else if (dsym->s_scl != EXTERN && dsym->s_scl != TYPEDEF) {
2702 			/* function '%s' has illegal storage class */
2703 			error(94, dsym->s_name);
2704 			dsym->s_scl = EXTERN;
2705 		}
2706 	}
2707 
2708 	/*
2709 	 * functions may be declared inline at local scope, although this has
2710 	 * no effect for a later definition of the same function.
2711 	 *
2712 	 * XXX it should have an effect if !allow_c90 is set. this would also
2713 	 * be the way gcc behaves.
2714 	 */
2715 	if (dcs->d_inline) {
2716 		if (dsym->s_type->t_tspec == FUNC)
2717 			dsym->s_inline = true;
2718 		else {
2719 			/* variable '%s' declared inline */
2720 			warning(268, dsym->s_name);
2721 		}
2722 	}
2723 
2724 	if (dsym->s_type->t_const
2725 	    && (dsym->s_scl == AUTO || dsym->s_scl == REG)) {
2726 		/* const automatic variable '%s' */
2727 		query_message(18, dsym->s_name);
2728 	}
2729 
2730 	check_function_definition(dsym, true);
2731 
2732 	check_type(dsym);
2733 
2734 	if (dcs->d_redeclared_symbol != NULL && dsym->s_scl == EXTERN)
2735 		declare_external_in_block(dsym);
2736 
2737 	if (dsym->s_scl == EXTERN) {
2738 		/*
2739 		 * XXX if the static variable at level 0 is only defined later,
2740 		 * checking will be possible.
2741 		 */
2742 		if (dsym->s_ext_sym == NULL)
2743 			outsym(dsym, EXTERN, dsym->s_def);
2744 		else
2745 			outsym(dsym, dsym->s_ext_sym->s_scl, dsym->s_def);
2746 	}
2747 
2748 	if (dcs->d_redeclared_symbol != NULL)
2749 		check_local_redeclaration(dsym, dcs->d_redeclared_symbol);
2750 
2751 	if (has_initializer && !check_init(dsym)) {
2752 		dsym->s_def = DEF;
2753 		mark_as_set(dsym);
2754 	}
2755 
2756 	if (dsym->s_scl == TYPEDEF) {
2757 		dsym->s_type = block_dup_type(dsym->s_type);
2758 		dsym->s_type->t_typedef = true;
2759 		set_first_typedef(dsym->s_type, dsym);
2760 	}
2761 
2762 	if (dsym->s_scl == STATIC)
2763 		/* static variable '%s' in function */
2764 		query_message(11, dsym->s_name);
2765 
2766 	debug_printf("%s: ", __func__);
2767 	debug_sym("", dsym, "\n");
2768 }
2769 
2770 /* Create a symbol for an abstract declaration. */
2771 static sym_t *
2772 abstract_name_level(bool enclosing)
2773 {
2774 
2775 	lint_assert(dcs->d_kind == DLK_ABSTRACT
2776 	    || dcs->d_kind == DLK_PROTO_PARAMS);
2777 
2778 	sym_t *sym = block_zero_alloc(sizeof(*sym), "sym");
2779 	sym->s_name = unnamed;
2780 	sym->s_def = DEF;
2781 	sym->s_scl = ABSTRACT;
2782 	sym->s_block_level = -1;
2783 	sym->s_param = dcs->d_kind == DLK_PROTO_PARAMS;
2784 
2785 	/*
2786 	 * At this point, dcs->d_type contains only the basic type.  That type
2787 	 * will be updated later, adding pointers, arrays and functions as
2788 	 * necessary.
2789 	 */
2790 	sym->s_type = enclosing ? dcs->d_enclosing->d_type : dcs->d_type;
2791 	dcs->d_redeclared_symbol = NULL;
2792 
2793 	debug_printf("%s: ", __func__);
2794 	debug_sym("", sym, "\n");
2795 	debug_func_dcs(__func__);
2796 	return sym;
2797 }
2798 
2799 sym_t *
2800 abstract_name(void)
2801 {
2802 	return abstract_name_level(false);
2803 }
2804 
2805 sym_t *
2806 abstract_enclosing_name(void)
2807 {
2808 	return abstract_name_level(true);
2809 }
2810 
2811 /* Removes anything which has nothing to do on global level. */
2812 void
2813 global_clean_up(void)
2814 {
2815 
2816 	while (dcs->d_enclosing != NULL)
2817 		end_declaration_level();
2818 
2819 	clean_up_after_error();
2820 	block_level = 0;
2821 	mem_block_level = 0;
2822 	debug_step("%s: mem_block_level = %zu", __func__, mem_block_level);
2823 	global_clean_up_decl(true);
2824 }
2825 
2826 sym_t *
2827 declare_abstract_type(sym_t *sym)
2828 {
2829 
2830 	check_function_definition(sym, true);
2831 	check_type(sym);
2832 	return sym;
2833 }
2834 
2835 /* Checks size after declarations of variables and their initialization. */
2836 void
2837 check_size(const sym_t *dsym)
2838 {
2839 
2840 	if (dsym->s_def == DEF &&
2841 	    dsym->s_scl != TYPEDEF &&
2842 	    dsym->s_type->t_tspec != FUNC &&
2843 	    length_in_bits(dsym->s_type, dsym->s_name) == 0 &&
2844 	    dsym->s_type->t_tspec == ARRAY &&
2845 	    dsym->s_type->u.dimension == 0) {
2846 		if (!allow_c90)
2847 			/* empty array declaration for '%s' */
2848 			warning(190, dsym->s_name);
2849 		else
2850 			/* empty array declaration for '%s' */
2851 			error(190, dsym->s_name);
2852 	}
2853 }
2854 
2855 /* Mark an object as set if it is not already. */
2856 void
2857 mark_as_set(sym_t *sym)
2858 {
2859 
2860 	if (!sym->s_set) {
2861 		sym->s_set = true;
2862 		sym->s_set_pos = unique_curr_pos();
2863 	}
2864 }
2865 
2866 /* Mark an object as used if it is not already. */
2867 void
2868 mark_as_used(sym_t *sym, bool fcall, bool szof)
2869 {
2870 
2871 	if (!sym->s_used) {
2872 		sym->s_used = true;
2873 		sym->s_use_pos = unique_curr_pos();
2874 	}
2875 	/*
2876 	 * For function calls, another record is written.
2877 	 *
2878 	 * XXX: Should symbols used in sizeof() be treated as used or not?
2879 	 * Probably not, because there is no point in declaring an external
2880 	 * variable only to get its size.
2881 	 */
2882 	if (!fcall && !szof && sym->s_kind == SK_VCFT && sym->s_scl == EXTERN)
2883 		outusg(sym);
2884 }
2885 
2886 /* Warns about variables and labels that are not used or only set. */
2887 void
2888 check_usage(const decl_level *dl)
2889 {
2890 	/* for this warning LINTED has no effect */
2891 	int saved_lwarn = lwarn;
2892 	lwarn = LWARN_ALL;
2893 
2894 	debug_step("begin lwarn %d", lwarn);
2895 	for (sym_t *sym = dl->d_first_dlsym;
2896 	    sym != NULL; sym = sym->s_level_next)
2897 		check_usage_sym(dl->d_asm, sym);
2898 	lwarn = saved_lwarn;
2899 	debug_step("end lwarn %d", lwarn);
2900 }
2901 
2902 static void
2903 check_parameter_usage(bool novar, const sym_t *arg)
2904 {
2905 
2906 	lint_assert(arg->s_set);
2907 
2908 	if (novar)
2909 		return;
2910 
2911 	if (!arg->s_used && !vflag)
2912 		/* parameter '%s' unused in function '%s' */
2913 		warning_at(231, &arg->s_def_pos, arg->s_name, funcsym->s_name);
2914 }
2915 
2916 static void
2917 check_variable_usage(bool novar, const sym_t *sym)
2918 {
2919 
2920 	lint_assert(block_level != 0);
2921 
2922 	/* example at file scope: int c = ({ return 3; }); */
2923 	if (sym->s_block_level == 0 && ch_isdigit(sym->s_name[0]))
2924 		return;
2925 
2926 	/* errors in expressions easily cause lots of these warnings */
2927 	if (seen_error)
2928 		return;
2929 
2930 	/*
2931 	 * XXX Only variables are checked, although types should probably also
2932 	 * be checked
2933 	 */
2934 	scl_t sc = sym->s_scl;
2935 	if (sc != EXTERN && sc != STATIC && sc != AUTO && sc != REG)
2936 		return;
2937 
2938 	if (novar)
2939 		return;
2940 
2941 	if (sc == EXTERN) {
2942 		if (!sym->s_used && !sym->s_set) {
2943 			/* '%s' unused in function '%s' */
2944 			warning_at(192, &sym->s_def_pos,
2945 			    sym->s_name, funcsym->s_name);
2946 		}
2947 	} else {
2948 		if (sym->s_set && !sym->s_used) {
2949 			/* '%s' set but not used in function '%s' */
2950 			warning_at(191, &sym->s_set_pos,
2951 			    sym->s_name, funcsym->s_name);
2952 		} else if (!sym->s_used) {
2953 			/* '%s' unused in function '%s' */
2954 			warning_at(192, &sym->s_def_pos,
2955 			    sym->s_name, funcsym->s_name);
2956 		}
2957 	}
2958 
2959 	if (sc == EXTERN) {
2960 		/*
2961 		 * information about usage is taken over into the symbol table
2962 		 * entry at level 0 if the symbol was locally declared as an
2963 		 * external symbol.
2964 		 *
2965 		 * XXX This is wrong for symbols declared static at level 0 if
2966 		 * the usage information stems from sizeof(). This is because
2967 		 * symbols at level 0 only used in sizeof() are considered to
2968 		 * not be used.
2969 		 */
2970 		sym_t *xsym = sym->s_ext_sym;
2971 		if (xsym != NULL) {
2972 			if (sym->s_used && !xsym->s_used) {
2973 				xsym->s_used = true;
2974 				xsym->s_use_pos = sym->s_use_pos;
2975 			}
2976 			if (sym->s_set && !xsym->s_set) {
2977 				xsym->s_set = true;
2978 				xsym->s_set_pos = sym->s_set_pos;
2979 			}
2980 		}
2981 	}
2982 }
2983 
2984 static void
2985 check_label_usage(const sym_t *lab)
2986 {
2987 
2988 	lint_assert(block_level == 1);
2989 	lint_assert(lab->s_block_level == 1);
2990 
2991 	if (funcsym == NULL)
2992 		/* syntax error '%s' */
2993 		error(249, "labels are only valid inside a function");
2994 	else if (lab->s_set && !lab->s_used)
2995 		/* label '%s' unused in function '%s' */
2996 		warning_at(232, &lab->s_set_pos, lab->s_name, funcsym->s_name);
2997 	else if (!lab->s_set)
2998 		/* undefined label '%s' */
2999 		warning_at(23, &lab->s_use_pos, lab->s_name);
3000 }
3001 
3002 static void
3003 check_tag_usage(const sym_t *sym)
3004 {
3005 
3006 	if (!is_incomplete(sym->s_type))
3007 		return;
3008 
3009 	/* always complain about incomplete tags declared inside blocks */
3010 	if (zflag || dcs->d_kind != DLK_EXTERN)
3011 		return;
3012 
3013 	switch (sym->s_type->t_tspec) {
3014 	case STRUCT:
3015 		/* struct '%s' never defined */
3016 		warning_at(233, &sym->s_def_pos, sym->s_name);
3017 		break;
3018 	case UNION:
3019 		/* union '%s' never defined */
3020 		warning_at(234, &sym->s_def_pos, sym->s_name);
3021 		break;
3022 	default:
3023 		lint_assert(sym->s_type->t_tspec == ENUM);
3024 		/* enum '%s' never defined */
3025 		warning_at(235, &sym->s_def_pos, sym->s_name);
3026 		break;
3027 	}
3028 }
3029 
3030 /* Warns about a variable or a label that is not used or only set. */
3031 void
3032 check_usage_sym(bool novar, const sym_t *sym)
3033 {
3034 
3035 	if (sym->s_block_level == -1)
3036 		return;
3037 
3038 	if (sym->s_kind == SK_VCFT && sym->s_param)
3039 		check_parameter_usage(novar, sym);
3040 	else if (sym->s_kind == SK_VCFT)
3041 		check_variable_usage(novar, sym);
3042 	else if (sym->s_kind == SK_LABEL)
3043 		check_label_usage(sym);
3044 	else if (sym->s_kind == SK_TAG)
3045 		check_tag_usage(sym);
3046 }
3047 
3048 static void
3049 check_global_variable_size(const sym_t *sym)
3050 {
3051 
3052 	if (sym->s_def != TDEF)
3053 		return;
3054 	if (sym->s_type->t_tspec == FUNC)
3055 		/* Maybe a syntax error after a function declaration. */
3056 		return;
3057 	if (sym->s_def == TDEF && sym->s_type->t_tspec == VOID)
3058 		/* Prevent an internal error in length_in_bits below. */
3059 		return;
3060 
3061 	pos_t cpos = curr_pos;
3062 	curr_pos = sym->s_def_pos;
3063 	int len_in_bits = length_in_bits(sym->s_type, sym->s_name);
3064 	curr_pos = cpos;
3065 
3066 	if (len_in_bits == 0 &&
3067 	    sym->s_type->t_tspec == ARRAY && sym->s_type->u.dimension == 0) {
3068 		/* TODO: C99 6.7.5.2p1 defines this as an error as well. */
3069 		if (!allow_c90 ||
3070 		    (sym->s_scl == EXTERN && (allow_trad || allow_c99))) {
3071 			/* empty array declaration for '%s' */
3072 			warning_at(190, &sym->s_def_pos, sym->s_name);
3073 		} else {
3074 			/* empty array declaration for '%s' */
3075 			error_at(190, &sym->s_def_pos, sym->s_name);
3076 		}
3077 	}
3078 }
3079 
3080 static void
3081 check_unused_static_global_variable(const sym_t *sym)
3082 {
3083 	if (sym->s_type->t_tspec == FUNC) {
3084 		if (sym->s_def == DEF) {
3085 			if (!sym->s_inline)
3086 				/* static function '%s' unused */
3087 				warning_at(236, &sym->s_def_pos, sym->s_name);
3088 		} else
3089 			/* static function '%s' declared but not defined */
3090 			warning_at(290, &sym->s_def_pos, sym->s_name);
3091 	} else if (!sym->s_set)
3092 		/* static variable '%s' unused */
3093 		warning_at(226, &sym->s_def_pos, sym->s_name);
3094 	else
3095 		/* static variable '%s' set but not used */
3096 		warning_at(307, &sym->s_def_pos, sym->s_name);
3097 }
3098 
3099 static void
3100 check_static_global_variable(const sym_t *sym)
3101 {
3102 	if (sym->s_type->t_tspec == FUNC && sym->s_used && sym->s_def != DEF)
3103 		/* static function '%s' called but not defined */
3104 		error_at(225, &sym->s_use_pos, sym->s_name);
3105 
3106 	if (!sym->s_used)
3107 		check_unused_static_global_variable(sym);
3108 
3109 	if (allow_c90 && sym->s_def == TDEF && sym->s_type->t_const)
3110 		/* const object '%s' should have initializer */
3111 		warning_at(227, &sym->s_def_pos, sym->s_name);
3112 }
3113 
3114 static void
3115 check_global_variable(const sym_t *sym)
3116 {
3117 	scl_t scl = sym->s_scl;
3118 
3119 	if (scl == TYPEDEF || scl == BOOL_CONST || scl == ENUM_CONST)
3120 		return;
3121 
3122 	if (scl == NO_SCL)
3123 		return;		/* May be caused by a syntax error. */
3124 
3125 	lint_assert(scl == EXTERN || scl == STATIC);
3126 
3127 	check_global_variable_size(sym);
3128 
3129 	if (scl == STATIC)
3130 		check_static_global_variable(sym);
3131 }
3132 
3133 void
3134 end_translation_unit(void)
3135 {
3136 
3137 	if (block_level != 0 || dcs->d_enclosing != NULL)
3138 		norecover();
3139 
3140 	for (const sym_t *sym = dcs->d_first_dlsym;
3141 	    sym != NULL; sym = sym->s_level_next) {
3142 		if (sym->s_block_level == -1)
3143 			continue;
3144 		if (sym->s_kind == SK_VCFT)
3145 			check_global_variable(sym);
3146 		else if (sym->s_kind == SK_TAG)
3147 			check_tag_usage(sym);
3148 		else
3149 			lint_assert(sym->s_kind == SK_MEMBER);
3150 	}
3151 }
3152 
3153 /*
3154  * Prints information about location of previous definition/declaration.
3155  */
3156 void
3157 print_previous_declaration(const sym_t *psym)
3158 {
3159 
3160 	if (!rflag)
3161 		return;
3162 
3163 	if (psym->s_def == DEF || psym->s_def == TDEF)
3164 		/* previous definition of '%s' */
3165 		message_at(261, &psym->s_def_pos, psym->s_name);
3166 	else
3167 		/* previous declaration of '%s' */
3168 		message_at(260, &psym->s_def_pos, psym->s_name);
3169 }
3170 
3171 /*
3172  * Gets a node for a constant and returns the value of this constant
3173  * as integer.
3174  *
3175  * If the node is not constant or too large for int or of type float,
3176  * a warning will be printed.
3177  *
3178  * to_int_constant() should be used only inside declarations. If it is used in
3179  * expressions, it frees the memory used for the expression.
3180  */
3181 int
3182 to_int_constant(tnode_t *tn, bool required)
3183 {
3184 
3185 	if (tn == NULL)
3186 		return 1;
3187 
3188 	val_t *v = integer_constant(tn, required);
3189 	bool is_unsigned = is_uinteger(v->v_tspec);
3190 	int64_t val = v->u.integer;
3191 	free(v);
3192 
3193 	/*
3194 	 * Abstract declarations are used inside expression. To free the memory
3195 	 * would be a fatal error. We don't free blocks that are inside casts
3196 	 * because these will be used later to match types.
3197 	 */
3198 	if (tn->tn_op != CON && dcs->d_kind != DLK_ABSTRACT)
3199 		expr_free_all();
3200 
3201 	bool out_of_bounds = is_unsigned
3202 	    ? (uint64_t)val > (uint64_t)TARG_INT_MAX
3203 	    : val > (int64_t)TARG_INT_MAX || val < (int64_t)TARG_INT_MIN;
3204 	if (out_of_bounds) {
3205 		char buf[256];
3206 		unsigned long long abs_val = is_unsigned || val >= 0
3207 		    ? (unsigned long long)val
3208 		    : -(unsigned long long)val;
3209 		snprintf(buf, sizeof(buf), "%s%#llx",
3210 		    is_unsigned || val >= 0 ? "" : "-",	abs_val);
3211 		/* constant %s too large for 'int' */
3212 		warning(56, buf);
3213 	}
3214 	return (int)val;
3215 }
3216