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