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