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