tree.c revision 1.386
1 /* $NetBSD: tree.c,v 1.386 2021/10/30 22:04:42 rillig Exp $ */ 2 3 /* 4 * Copyright (c) 1994, 1995 Jochen Pohl 5 * All Rights Reserved. 6 * 7 * Redistribution and use in source and binary forms, with or without 8 * modification, are permitted provided that the following conditions 9 * are met: 10 * 1. Redistributions of source code must retain the above copyright 11 * notice, this list of conditions and the following disclaimer. 12 * 2. Redistributions in binary form must reproduce the above copyright 13 * notice, this list of conditions and the following disclaimer in the 14 * documentation and/or other materials provided with the distribution. 15 * 3. All advertising materials mentioning features or use of this software 16 * must display the following acknowledgement: 17 * This product includes software developed by Jochen Pohl for 18 * The NetBSD Project. 19 * 4. The name of the author may not be used to endorse or promote products 20 * derived from this software without specific prior written permission. 21 * 22 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR 23 * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES 24 * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. 25 * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, 26 * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT 27 * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, 28 * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY 29 * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT 30 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF 31 * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. 32 */ 33 34 #if HAVE_NBTOOL_CONFIG_H 35 #include "nbtool_config.h" 36 #endif 37 38 #include <sys/cdefs.h> 39 #if defined(__RCSID) && !defined(lint) 40 __RCSID("$NetBSD: tree.c,v 1.386 2021/10/30 22:04:42 rillig Exp $"); 41 #endif 42 43 #include <float.h> 44 #include <limits.h> 45 #include <math.h> 46 #include <signal.h> 47 #include <stdlib.h> 48 #include <string.h> 49 50 #include "lint1.h" 51 #include "cgram.h" 52 53 static tnode_t *build_integer_constant(tspec_t, int64_t); 54 static void check_pointer_comparison(op_t, 55 const tnode_t *, const tnode_t *); 56 static bool check_assign_types_compatible(op_t, int, 57 const tnode_t *, const tnode_t *); 58 static void check_bad_enum_operation(op_t, 59 const tnode_t *, const tnode_t *); 60 static void check_enum_type_mismatch(op_t, int, 61 const tnode_t *, const tnode_t *); 62 static void check_enum_int_mismatch(op_t, int, 63 const tnode_t *, const tnode_t *); 64 static tnode_t *new_tnode(op_t, type_t *, tnode_t *, tnode_t *); 65 static void balance(op_t, tnode_t **, tnode_t **); 66 static void warn_incompatible_types(op_t, const type_t *, tspec_t, 67 const type_t *, tspec_t); 68 static void warn_incompatible_pointers(const mod_t *, 69 const type_t *, const type_t *); 70 static bool has_constant_member(const type_t *); 71 static void check_prototype_conversion(int, tspec_t, tspec_t, type_t *, 72 tnode_t *); 73 static void check_integer_conversion(op_t, int, tspec_t, tspec_t, type_t *, 74 tnode_t *); 75 static void check_pointer_integer_conversion(op_t, tspec_t, type_t *, 76 tnode_t *); 77 static void check_pointer_conversion(tnode_t *, type_t *); 78 static tnode_t *build_struct_access(op_t, tnode_t *, tnode_t *); 79 static tnode_t *build_prepost_incdec(op_t, tnode_t *); 80 static tnode_t *build_real_imag(op_t, tnode_t *); 81 static tnode_t *build_address(tnode_t *, bool); 82 static tnode_t *build_plus_minus(op_t, tnode_t *, tnode_t *); 83 static tnode_t *build_bit_shift(op_t, tnode_t *, tnode_t *); 84 static tnode_t *build_colon(tnode_t *, tnode_t *); 85 static tnode_t *build_assignment(op_t, tnode_t *, tnode_t *); 86 static tnode_t *plength(type_t *); 87 static tnode_t *fold(tnode_t *); 88 static tnode_t *fold_test(tnode_t *); 89 static tnode_t *fold_float(tnode_t *); 90 static tnode_t *check_function_arguments(type_t *, tnode_t *); 91 static tnode_t *check_prototype_argument(int, type_t *, tnode_t *); 92 static void check_null_effect(const tnode_t *); 93 static void check_array_index(tnode_t *, bool); 94 static void check_integer_comparison(op_t, tnode_t *, tnode_t *); 95 static void check_precedence_confusion(tnode_t *); 96 97 extern sig_atomic_t fpe; 98 99 static const char * 100 op_name(op_t op) 101 { 102 return modtab[op].m_name; 103 } 104 105 /* Build 'pointer to tp', 'array of tp' or 'function returning tp'. */ 106 type_t * 107 derive_type(type_t *tp, tspec_t t) 108 { 109 type_t *tp2; 110 111 tp2 = getblk(sizeof(*tp2)); 112 tp2->t_tspec = t; 113 tp2->t_subt = tp; 114 return tp2; 115 } 116 117 /* 118 * Derive 'pointer to tp' or 'function returning tp'. 119 * The memory is freed at the end of the current expression. 120 */ 121 type_t * 122 expr_derive_type(type_t *tp, tspec_t t) 123 { 124 type_t *tp2; 125 126 tp2 = expr_zalloc(sizeof(*tp2)); 127 tp2->t_tspec = t; 128 tp2->t_subt = tp; 129 return tp2; 130 } 131 132 /* 133 * Create a node for a constant. 134 */ 135 tnode_t * 136 build_constant(type_t *tp, val_t *v) 137 { 138 tnode_t *n; 139 140 n = expr_zalloc_tnode(); 141 n->tn_op = CON; 142 n->tn_type = tp; 143 n->tn_val = expr_zalloc(sizeof(*n->tn_val)); 144 n->tn_val->v_tspec = tp->t_tspec; 145 n->tn_val->v_unsigned_since_c90 = v->v_unsigned_since_c90; 146 n->tn_val->v_u = v->v_u; 147 free(v); 148 return n; 149 } 150 151 static tnode_t * 152 build_integer_constant(tspec_t t, int64_t q) 153 { 154 tnode_t *n; 155 156 n = expr_zalloc_tnode(); 157 n->tn_op = CON; 158 n->tn_type = gettyp(t); 159 n->tn_val = expr_zalloc(sizeof(*n->tn_val)); 160 n->tn_val->v_tspec = t; 161 n->tn_val->v_quad = q; 162 return n; 163 } 164 165 static void 166 fallback_symbol(sym_t *sym) 167 { 168 169 if (fallback_symbol_strict_bool(sym)) 170 return; 171 172 if (block_level > 0 && (strcmp(sym->s_name, "__FUNCTION__") == 0 || 173 strcmp(sym->s_name, "__PRETTY_FUNCTION__") == 0)) { 174 /* __FUNCTION__/__PRETTY_FUNCTION__ is a GCC extension */ 175 gnuism(316); 176 sym->s_type = derive_type(gettyp(CHAR), PTR); 177 sym->s_type->t_const = true; 178 return; 179 } 180 181 if (block_level > 0 && strcmp(sym->s_name, "__func__") == 0) { 182 if (!Sflag) 183 /* __func__ is a C9X feature */ 184 warning(317); 185 sym->s_type = derive_type(gettyp(CHAR), PTR); 186 sym->s_type->t_const = true; 187 return; 188 } 189 190 /* '%s' undefined */ 191 error(99, sym->s_name); 192 } 193 194 /* 195 * Functions that are predeclared by GCC or other compilers can be called 196 * with arbitrary arguments. Since lint usually runs after a successful 197 * compilation, it's the compiler's job to catch any errors. 198 */ 199 bool 200 is_compiler_builtin(const char *name) 201 { 202 /* https://gcc.gnu.org/onlinedocs/gcc/C-Extensions.html */ 203 if (gflag) { 204 if (strncmp(name, "__atomic_", 9) == 0 || 205 strncmp(name, "__builtin_", 10) == 0 || 206 /* obsolete but still in use, as of 2021 */ 207 strncmp(name, "__sync_", 7) == 0) 208 return true; 209 } 210 211 /* https://software.intel.com/sites/landingpage/IntrinsicsGuide/ */ 212 if (strncmp(name, "_mm_", 4) == 0) 213 return true; 214 215 return false; 216 } 217 218 static bool 219 str_endswith(const char *haystack, const char *needle) 220 { 221 size_t hlen = strlen(haystack); 222 size_t nlen = strlen(needle); 223 224 return nlen <= hlen && 225 memcmp(haystack + hlen - nlen, needle, nlen) == 0; 226 } 227 228 /* https://gcc.gnu.org/onlinedocs/gcc/Integer-Overflow-Builtins.html */ 229 static bool 230 is_gcc_bool_builtin(const char *name) 231 { 232 return strncmp(name, "__builtin_", 10) == 0 && 233 (str_endswith(name, "_overflow") || 234 str_endswith(name, "_overflow_p")); 235 } 236 237 static void 238 build_name_call(sym_t *sym) 239 { 240 241 if (is_compiler_builtin(sym->s_name)) { 242 /* 243 * Do not warn about these, just assume that 244 * they are regular functions compatible with 245 * non-prototype calling conventions. 246 */ 247 248 if (is_gcc_bool_builtin(sym->s_name)) 249 sym->s_type = gettyp(BOOL); 250 251 } else if (Sflag) { 252 /* function '%s' implicitly declared to return int */ 253 error(215, sym->s_name); 254 } else if (sflag) { 255 /* function '%s' implicitly declared to return int */ 256 warning(215, sym->s_name); 257 } 258 259 /* XXX if tflag is set, the symbol should be exported to level 0 */ 260 sym->s_type = derive_type(sym->s_type, FUNC); 261 } 262 263 /* 264 * Create a node for a name (symbol table entry). 265 * follow_token is the token which follows the name. 266 */ 267 tnode_t * 268 build_name(sym_t *sym, int follow_token) 269 { 270 tnode_t *n; 271 272 if (sym->s_scl == NOSCL) { 273 sym->s_scl = EXTERN; 274 sym->s_def = DECL; 275 if (follow_token == T_LPAREN) { 276 build_name_call(sym); 277 } else { 278 fallback_symbol(sym); 279 } 280 } 281 282 lint_assert(sym->s_kind == FVFT || sym->s_kind == FMEMBER); 283 284 n = expr_zalloc_tnode(); 285 n->tn_type = sym->s_type; 286 if (sym->s_scl != CTCONST) { 287 n->tn_op = NAME; 288 n->tn_sym = sym; 289 if (sym->s_kind == FVFT && sym->s_type->t_tspec != FUNC) 290 n->tn_lvalue = true; 291 } else { 292 n->tn_op = CON; 293 n->tn_val = expr_zalloc(sizeof(*n->tn_val)); 294 *n->tn_val = sym->s_value; 295 } 296 297 return n; 298 } 299 300 tnode_t * 301 build_string(strg_t *strg) 302 { 303 size_t len; 304 tnode_t *n; 305 type_t *tp; 306 307 len = strg->st_len; 308 309 n = expr_zalloc_tnode(); 310 311 tp = expr_zalloc(sizeof(*tp)); 312 tp->t_tspec = ARRAY; 313 tp->t_subt = gettyp(strg->st_tspec); 314 tp->t_dim = (int)(len + 1); 315 316 n->tn_op = STRING; 317 n->tn_type = tp; 318 n->tn_lvalue = true; 319 320 n->tn_string = expr_zalloc(sizeof(*n->tn_string)); 321 n->tn_string->st_tspec = strg->st_tspec; 322 n->tn_string->st_len = len; 323 324 if (strg->st_tspec == CHAR) { 325 n->tn_string->st_cp = expr_zalloc(len + 1); 326 (void)memcpy(n->tn_string->st_cp, strg->st_cp, len + 1); 327 free(strg->st_cp); 328 } else { 329 size_t size = (len + 1) * sizeof(*n->tn_string->st_wcp); 330 n->tn_string->st_wcp = expr_zalloc(size); 331 (void)memcpy(n->tn_string->st_wcp, strg->st_wcp, size); 332 free(strg->st_wcp); 333 } 334 free(strg); 335 336 return n; 337 } 338 339 /* 340 * Returns a symbol which has the same name as the msym argument and is a 341 * member of the struct or union specified by the tn argument. 342 */ 343 sym_t * 344 struct_or_union_member(tnode_t *tn, op_t op, sym_t *msym) 345 { 346 struct_or_union *str; 347 type_t *tp; 348 sym_t *sym, *csym; 349 bool eq; 350 tspec_t t; 351 352 /* 353 * Remove the member if it was unknown until now, which means 354 * that no defined struct or union has a member with the same name. 355 */ 356 if (msym->s_scl == NOSCL) { 357 /* type '%s' does not have member '%s' */ 358 error(101, type_name(tn->tn_type), msym->s_name); 359 rmsym(msym); 360 msym->s_kind = FMEMBER; 361 msym->s_scl = MOS; 362 msym->s_styp = expr_zalloc(sizeof(*msym->s_styp)); 363 msym->s_styp->sou_tag = expr_zalloc( 364 sizeof(*msym->s_styp->sou_tag)); 365 msym->s_styp->sou_tag->s_name = unnamed; 366 msym->s_value.v_tspec = INT; 367 return msym; 368 } 369 370 /* Set str to the tag of which msym is expected to be a member. */ 371 str = NULL; 372 t = (tp = tn->tn_type)->t_tspec; 373 if (op == POINT) { 374 if (t == STRUCT || t == UNION) 375 str = tp->t_str; 376 } else if (op == ARROW && t == PTR) { 377 t = (tp = tp->t_subt)->t_tspec; 378 if (t == STRUCT || t == UNION) 379 str = tp->t_str; 380 } 381 382 /* 383 * If this struct/union has a member with the name of msym, return it. 384 */ 385 if (str != NULL) { 386 for (sym = msym; sym != NULL; sym = sym->s_link) { 387 if (sym->s_scl != MOS && sym->s_scl != MOU) 388 continue; 389 if (sym->s_styp != str) 390 continue; 391 if (strcmp(sym->s_name, msym->s_name) != 0) 392 continue; 393 return sym; 394 } 395 } 396 397 /* 398 * Set eq to false if there are struct/union members with the same 399 * name and different types and/or offsets. 400 */ 401 eq = true; 402 for (csym = msym; csym != NULL; csym = csym->s_link) { 403 if (csym->s_scl != MOS && csym->s_scl != MOU) 404 continue; 405 if (strcmp(msym->s_name, csym->s_name) != 0) 406 continue; 407 for (sym = csym->s_link; sym != NULL; sym = sym->s_link) { 408 bool w; 409 410 if (sym->s_scl != MOS && sym->s_scl != MOU) 411 continue; 412 if (strcmp(csym->s_name, sym->s_name) != 0) 413 continue; 414 if (csym->s_value.v_quad != sym->s_value.v_quad) { 415 eq = false; 416 break; 417 } 418 w = false; 419 eq = eqtype(csym->s_type, sym->s_type, 420 false, false, &w) && !w; 421 if (!eq) 422 break; 423 if (csym->s_bitfield != sym->s_bitfield) { 424 eq = false; 425 break; 426 } 427 if (csym->s_bitfield) { 428 type_t *tp1, *tp2; 429 430 tp1 = csym->s_type; 431 tp2 = sym->s_type; 432 if (tp1->t_flen != tp2->t_flen) { 433 eq = false; 434 break; 435 } 436 if (tp1->t_foffs != tp2->t_foffs) { 437 eq = false; 438 break; 439 } 440 } 441 } 442 if (!eq) 443 break; 444 } 445 446 /* 447 * Now handle the case in which the left operand refers really 448 * to a struct/union, but the right operand is not member of it. 449 */ 450 if (str != NULL) { 451 if (eq && tflag) { 452 /* illegal member use: %s */ 453 warning(102, msym->s_name); 454 } else { 455 /* illegal member use: %s */ 456 error(102, msym->s_name); 457 } 458 return msym; 459 } 460 461 /* 462 * Now the left operand of ARROW does not point to a struct/union 463 * or the left operand of POINT is no struct/union. 464 */ 465 if (eq) { 466 if (op == POINT) { 467 if (tflag) { 468 /* left operand of '.' must be struct ... */ 469 warning(103, type_name(tn->tn_type)); 470 } else { 471 /* left operand of '.' must be struct ... */ 472 error(103, type_name(tn->tn_type)); 473 } 474 } else { 475 if (tflag && tn->tn_type->t_tspec == PTR) { 476 /* left operand of '->' must be pointer ... */ 477 warning(104, type_name(tn->tn_type)); 478 } else { 479 /* left operand of '->' must be pointer ... */ 480 error(104, type_name(tn->tn_type)); 481 } 482 } 483 } else { 484 if (tflag) { 485 /* non-unique member requires struct/union %s */ 486 error(105, op == POINT ? "object" : "pointer"); 487 } else { 488 /* unacceptable operand of '%s' */ 489 error(111, op_name(op)); 490 } 491 } 492 493 return msym; 494 } 495 496 tnode_t * 497 build_generic_selection(const tnode_t *expr, 498 struct generic_association *sel) 499 { 500 tnode_t *default_result = NULL; 501 502 for (; sel != NULL; sel = sel->ga_prev) 503 if (expr != NULL && 504 eqtype(sel->ga_arg, expr->tn_type, false, false, NULL)) 505 return sel->ga_result; 506 else if (sel->ga_arg == NULL) 507 default_result = sel->ga_result; 508 return default_result; 509 } 510 511 /* 512 * Create a tree node. Called for most operands except function calls, 513 * sizeof and casts. 514 * 515 * op operator 516 * ln left operand 517 * rn if not NULL, right operand 518 */ 519 tnode_t * 520 build_binary(tnode_t *ln, op_t op, tnode_t *rn) 521 { 522 const mod_t *mp; 523 tnode_t *ntn; 524 type_t *rettp; 525 526 mp = &modtab[op]; 527 528 /* If there was an error in one of the operands, return. */ 529 if (ln == NULL || (mp->m_binary && rn == NULL)) 530 return NULL; 531 532 /* 533 * Apply class conversions to the left operand, but only if its 534 * value is needed or it is compared with null. 535 */ 536 if (mp->m_left_value_context || mp->m_left_test_context) 537 ln = cconv(ln); 538 /* 539 * The right operand is almost always in a test or value context, 540 * except if it is a struct or union member. 541 */ 542 if (mp->m_binary && op != ARROW && op != POINT) 543 rn = cconv(rn); 544 545 /* 546 * Print some warnings for comparisons of unsigned values with 547 * constants lower than or equal to null. This must be done 548 * before promote() because otherwise unsigned char and unsigned 549 * short would be promoted to int. Also types are tested to be 550 * CHAR, which would also become int. 551 */ 552 if (mp->m_comparison) 553 check_integer_comparison(op, ln, rn); 554 555 /* 556 * Promote the left operand if it is in a test or value context 557 */ 558 if (mp->m_left_value_context || mp->m_left_test_context) 559 ln = promote(op, false, ln); 560 /* 561 * Promote the right operand, but only if it is no struct or 562 * union member, or if it is not to be assigned to the left operand 563 */ 564 if (mp->m_binary && op != ARROW && op != POINT && 565 op != ASSIGN && op != RETURN && op != INIT) { 566 rn = promote(op, false, rn); 567 } 568 569 /* 570 * If the result of the operation is different for signed or 571 * unsigned operands and one of the operands is signed only in 572 * ANSI C, print a warning. 573 */ 574 if (mp->m_warn_if_left_unsigned_in_c90 && 575 ln->tn_op == CON && ln->tn_val->v_unsigned_since_c90) { 576 /* ANSI C treats constant as unsigned, op %s */ 577 warning(218, mp->m_name); 578 ln->tn_val->v_unsigned_since_c90 = false; 579 } 580 if (mp->m_warn_if_right_unsigned_in_c90 && 581 rn->tn_op == CON && rn->tn_val->v_unsigned_since_c90) { 582 /* ANSI C treats constant as unsigned, op %s */ 583 warning(218, mp->m_name); 584 rn->tn_val->v_unsigned_since_c90 = false; 585 } 586 587 /* Make sure both operands are of the same type */ 588 if (mp->m_balance_operands || (tflag && (op == SHL || op == SHR))) 589 balance(op, &ln, &rn); 590 591 /* 592 * Check types for compatibility with the operation and mutual 593 * compatibility. Return if there are serious problems. 594 */ 595 if (!typeok(op, 0, ln, rn)) 596 return NULL; 597 598 /* And now create the node. */ 599 switch (op) { 600 case POINT: 601 case ARROW: 602 ntn = build_struct_access(op, ln, rn); 603 break; 604 case INCAFT: 605 case DECAFT: 606 case INCBEF: 607 case DECBEF: 608 ntn = build_prepost_incdec(op, ln); 609 break; 610 case ADDR: 611 ntn = build_address(ln, false); 612 break; 613 case INDIR: 614 ntn = new_tnode(INDIR, ln->tn_type->t_subt, ln, NULL); 615 break; 616 case PLUS: 617 case MINUS: 618 ntn = build_plus_minus(op, ln, rn); 619 break; 620 case SHL: 621 case SHR: 622 ntn = build_bit_shift(op, ln, rn); 623 break; 624 case COLON: 625 ntn = build_colon(ln, rn); 626 break; 627 case ASSIGN: 628 case MULASS: 629 case DIVASS: 630 case MODASS: 631 case ADDASS: 632 case SUBASS: 633 case SHLASS: 634 case SHRASS: 635 case ANDASS: 636 case XORASS: 637 case ORASS: 638 case RETURN: 639 case INIT: 640 ntn = build_assignment(op, ln, rn); 641 break; 642 case COMMA: 643 case QUEST: 644 ntn = new_tnode(op, rn->tn_type, ln, rn); 645 break; 646 case REAL: 647 case IMAG: 648 ntn = build_real_imag(op, ln); 649 break; 650 default: 651 rettp = mp->m_returns_bool 652 ? gettyp(Tflag ? BOOL : INT) : ln->tn_type; 653 lint_assert(mp->m_binary || rn == NULL); 654 ntn = new_tnode(op, rettp, ln, rn); 655 break; 656 } 657 658 /* Return if an error occurred. */ 659 if (ntn == NULL) 660 return NULL; 661 662 /* Print a warning if precedence confusion is possible */ 663 if (mp->m_possible_precedence_confusion) 664 check_precedence_confusion(ntn); 665 666 /* 667 * Print a warning if one of the operands is in a context where 668 * it is compared with null and if this operand is a constant. 669 */ 670 if (mp->m_left_test_context) { 671 if (ln->tn_op == CON || 672 ((mp->m_binary && op != QUEST) && rn->tn_op == CON)) { 673 if (hflag && !constcond_flag && 674 !ln->tn_system_dependent) 675 /* constant in conditional context */ 676 warning(161); 677 } 678 } 679 680 /* Fold if the operator requires it */ 681 if (mp->m_fold_constant_operands) { 682 if (ln->tn_op == CON && (!mp->m_binary || rn->tn_op == CON)) { 683 if (mp->m_left_test_context) { 684 ntn = fold_test(ntn); 685 } else if (is_floating(ntn->tn_type->t_tspec)) { 686 ntn = fold_float(ntn); 687 } else { 688 ntn = fold(ntn); 689 } 690 } else if (op == QUEST && ln->tn_op == CON) { 691 ntn = ln->tn_val->v_quad != 0 692 ? rn->tn_left : rn->tn_right; 693 } 694 } 695 696 return ntn; 697 } 698 699 tnode_t * 700 build_unary(op_t op, tnode_t *tn) 701 { 702 return build_binary(tn, op, NULL); 703 } 704 705 tnode_t * 706 build_member_access(tnode_t *ln, op_t op, sbuf_t *member) 707 { 708 sym_t *msym; 709 710 if (ln == NULL) 711 return NULL; 712 713 if (op == ARROW) { 714 /* must do this before struct_or_union_member is called */ 715 ln = cconv(ln); 716 } 717 msym = struct_or_union_member(ln, op, getsym(member)); 718 return build_binary(ln, op, build_name(msym, 0)); 719 } 720 721 /* 722 * Perform class conversions. 723 * 724 * Arrays of type T are converted into pointers to type T. 725 * Functions are converted to pointers to functions. 726 * Lvalues are converted to rvalues. 727 * 728 * C99 6.3 "Conversions" 729 * C99 6.3.2 "Other operands" 730 * C99 6.3.2.1 "Lvalues, arrays, and function designators" 731 */ 732 tnode_t * 733 cconv(tnode_t *tn) 734 { 735 type_t *tp; 736 737 /* 738 * Array-lvalue (array of type T) is converted into rvalue 739 * (pointer to type T) 740 */ 741 if (tn->tn_type->t_tspec == ARRAY) { 742 if (!tn->tn_lvalue) { 743 /* XXX print correct operator */ 744 /* %soperand of '%s' must be lvalue */ 745 gnuism(114, "", op_name(ADDR)); 746 } 747 tn = new_tnode(ADDR, 748 expr_derive_type(tn->tn_type->t_subt, PTR), tn, NULL); 749 } 750 751 /* 752 * Expression of type function (function with return value of type T) 753 * in rvalue-expression (pointer to function with return value 754 * of type T) 755 */ 756 if (tn->tn_type->t_tspec == FUNC) 757 tn = build_address(tn, true); 758 759 /* lvalue to rvalue */ 760 if (tn->tn_lvalue) { 761 tp = expr_dup_type(tn->tn_type); 762 /* C99 6.3.2.1p2 sentence 2 says to remove the qualifiers. */ 763 tp->t_const = tp->t_volatile = false; 764 tn = new_tnode(LOAD, tp, tn, NULL); 765 } 766 767 return tn; 768 } 769 770 const tnode_t * 771 before_conversion(const tnode_t *tn) 772 { 773 while (tn->tn_op == CVT && !tn->tn_cast) 774 tn = tn->tn_left; 775 return tn; 776 } 777 778 static bool 779 is_null_pointer(const tnode_t *tn) 780 { 781 tspec_t t = tn->tn_type->t_tspec; 782 783 return ((t == PTR && tn->tn_type->t_subt->t_tspec == VOID) || 784 is_integer(t)) 785 && (tn->tn_op == CON && tn->tn_val->v_quad == 0); 786 } 787 788 /* 789 * Most errors required by ANSI C are reported in struct_or_union_member(). 790 * Here we only check for totally wrong things. 791 */ 792 static bool 793 typeok_point(const tnode_t *ln, const type_t *ltp, tspec_t lt) 794 { 795 if (lt == FUNC || lt == VOID || ltp->t_bitfield || 796 ((lt != STRUCT && lt != UNION) && !ln->tn_lvalue)) { 797 /* Without tflag we got already an error */ 798 if (tflag) 799 /* unacceptable operand of '%s' */ 800 error(111, op_name(POINT)); 801 return false; 802 } 803 return true; 804 } 805 806 static bool 807 typeok_arrow(tspec_t lt) 808 { 809 if (lt == PTR || (tflag && is_integer(lt))) 810 return true; 811 812 /* Without tflag we got already an error */ 813 if (tflag) 814 /* unacceptable operand of '%s' */ 815 error(111, op_name(ARROW)); 816 return false; 817 } 818 819 static bool 820 typeok_incdec(op_t op, const tnode_t *tn, const type_t *tp) 821 { 822 /* operand has scalar type (checked in typeok) */ 823 if (!tn->tn_lvalue) { 824 if (tn->tn_op == CVT && tn->tn_cast && 825 tn->tn_left->tn_op == LOAD) { 826 /* a cast does not yield an lvalue */ 827 error(163); 828 } 829 /* %soperand of '%s' must be lvalue */ 830 error(114, "", op_name(op)); 831 return false; 832 } else if (tp->t_const) { 833 if (!tflag) 834 /* %soperand of '%s' must be modifiable lvalue */ 835 warning(115, "", op_name(op)); 836 } 837 return true; 838 } 839 840 static bool 841 typeok_address(const mod_t *mp, 842 const tnode_t *tn, const type_t *tp, tspec_t t) 843 { 844 if (t == ARRAY || t == FUNC) { 845 /* ok, a warning comes later (in build_address()) */ 846 } else if (!tn->tn_lvalue) { 847 if (tn->tn_op == CVT && tn->tn_cast && 848 tn->tn_left->tn_op == LOAD) { 849 /* a cast does not yield an lvalue */ 850 error(163); 851 } 852 /* %soperand of '%s' must be lvalue */ 853 error(114, "", mp->m_name); 854 return false; 855 } else if (is_scalar(t)) { 856 if (tp->t_bitfield) { 857 /* cannot take address of bit-field */ 858 error(112); 859 return false; 860 } 861 } else if (t != STRUCT && t != UNION) { 862 /* unacceptable operand of '%s' */ 863 error(111, mp->m_name); 864 return false; 865 } 866 if (tn->tn_op == NAME && tn->tn_sym->s_reg) { 867 /* cannot take address of register %s */ 868 error(113, tn->tn_sym->s_name); 869 return false; 870 } 871 return true; 872 } 873 874 static bool 875 typeok_indir(tspec_t t) 876 { 877 /* until now there were no type checks for this operator */ 878 if (t != PTR) { 879 /* cannot dereference non-pointer type */ 880 error(96); 881 return false; 882 } 883 return true; 884 } 885 886 static bool 887 typeok_plus(op_t op, 888 const type_t *ltp, tspec_t lt, 889 const type_t *rtp, tspec_t rt) 890 { 891 /* operands have scalar types (checked above) */ 892 if ((lt == PTR && !is_integer(rt)) || (rt == PTR && !is_integer(lt))) { 893 warn_incompatible_types(op, ltp, lt, rtp, rt); 894 return false; 895 } 896 return true; 897 } 898 899 static bool 900 typeok_minus(op_t op, 901 const type_t *ltp, tspec_t lt, 902 const type_t *rtp, tspec_t rt) 903 { 904 /* operands have scalar types (checked above) */ 905 if (lt == PTR && (!is_integer(rt) && rt != PTR)) { 906 warn_incompatible_types(op, ltp, lt, rtp, rt); 907 return false; 908 } else if (rt == PTR && lt != PTR) { 909 warn_incompatible_types(op, ltp, lt, rtp, rt); 910 return false; 911 } 912 if (lt == PTR && rt == PTR) { 913 if (!eqtype(ltp->t_subt, rtp->t_subt, true, false, NULL)) { 914 /* illegal pointer subtraction */ 915 error(116); 916 } 917 } 918 return true; 919 } 920 921 static void 922 typeok_shr(const mod_t *mp, 923 const tnode_t *ln, tspec_t lt, 924 const tnode_t *rn, tspec_t rt) 925 { 926 tspec_t olt, ort; 927 928 olt = before_conversion(ln)->tn_type->t_tspec; 929 ort = before_conversion(rn)->tn_type->t_tspec; 930 931 /* operands have integer types (checked above) */ 932 if (pflag && !is_uinteger(olt)) { 933 /* 934 * The left operand is signed. This means that 935 * the operation is (possibly) nonportable. 936 */ 937 if (ln->tn_op != CON) { 938 /* bitwise '%s' on signed value possibly nonportable */ 939 warning(117, mp->m_name); 940 } else if (ln->tn_val->v_quad < 0) { 941 /* bitwise '%s' on signed value nonportable */ 942 warning(120, mp->m_name); 943 } 944 } else if (!tflag && !sflag && !is_uinteger(olt) && is_uinteger(ort)) { 945 /* 946 * The left operand would become unsigned in 947 * traditional C. 948 */ 949 if (hflag && !Sflag && 950 (ln->tn_op != CON || ln->tn_val->v_quad < 0)) { 951 /* semantics of '%s' change in ANSI C; use ... */ 952 warning(118, mp->m_name); 953 } 954 } else if (!tflag && !sflag && !is_uinteger(olt) && !is_uinteger(ort) && 955 portable_size_in_bits(lt) < portable_size_in_bits(rt)) { 956 /* 957 * In traditional C the left operand would be extended, 958 * possibly with 1, and then shifted. 959 */ 960 if (hflag && !Sflag && 961 (ln->tn_op != CON || ln->tn_val->v_quad < 0)) { 962 /* semantics of '%s' change in ANSI C; use ... */ 963 warning(118, mp->m_name); 964 } 965 } 966 } 967 968 static void 969 typeok_shl(const mod_t *mp, tspec_t lt, tspec_t rt) 970 { 971 /* 972 * C90 does not perform balancing for shift operations, 973 * but traditional C does. If the width of the right operand 974 * is greater than the width of the left operand, then in 975 * traditional C the left operand would be extended to the 976 * width of the right operand. For SHL this may result in 977 * different results. 978 */ 979 if (portable_size_in_bits(lt) < portable_size_in_bits(rt)) { 980 /* 981 * XXX If both operands are constant, make sure 982 * that there is really a difference between 983 * ANSI C and traditional C. 984 */ 985 if (hflag && !Sflag) 986 /* semantics of '%s' change in ANSI C; use ... */ 987 warning(118, mp->m_name); 988 } 989 } 990 991 static void 992 typeok_shift(tspec_t lt, const tnode_t *rn, tspec_t rt) 993 { 994 if (rn->tn_op != CON) 995 return; 996 997 if (!is_uinteger(rt) && rn->tn_val->v_quad < 0) { 998 /* negative shift */ 999 warning(121); 1000 } else if ((uint64_t)rn->tn_val->v_quad == 1001 (uint64_t)size_in_bits(lt)) { 1002 /* shift equal to size of object */ 1003 warning(267); 1004 } else if ((uint64_t)rn->tn_val->v_quad > (uint64_t)size_in_bits(lt)) { 1005 /* shift amount %llu is greater than bit-size %llu of '%s' */ 1006 warning(122, (unsigned long long)rn->tn_val->v_quad, 1007 (unsigned long long)size_in_bits(lt), 1008 tspec_name(lt)); 1009 } 1010 } 1011 1012 static bool 1013 is_typeok_eq(const tnode_t *ln, tspec_t lt, const tnode_t *rn, tspec_t rt) 1014 { 1015 if (lt == PTR && is_null_pointer(rn)) 1016 return true; 1017 if (rt == PTR && is_null_pointer(ln)) 1018 return true; 1019 return false; 1020 } 1021 1022 static bool 1023 typeok_compare(op_t op, 1024 const tnode_t *ln, const type_t *ltp, tspec_t lt, 1025 const tnode_t *rn, const type_t *rtp, tspec_t rt) 1026 { 1027 if (lt == PTR && rt == PTR) { 1028 check_pointer_comparison(op, ln, rn); 1029 return true; 1030 } 1031 1032 if (lt != PTR && rt != PTR) 1033 return true; 1034 1035 if (!is_integer(lt) && !is_integer(rt)) { 1036 warn_incompatible_types(op, ltp, lt, rtp, rt); 1037 return false; 1038 } 1039 1040 const char *lx = lt == PTR ? "pointer" : "integer"; 1041 const char *rx = rt == PTR ? "pointer" : "integer"; 1042 /* illegal combination of %s (%s) and %s (%s), op %s */ 1043 warning(123, lx, type_name(ltp), rx, type_name(rtp), op_name(op)); 1044 return true; 1045 } 1046 1047 static bool 1048 typeok_quest(tspec_t lt, const tnode_t *rn) 1049 { 1050 if (!is_scalar(lt)) { 1051 /* first operand must have scalar type, op ? : */ 1052 error(170); 1053 return false; 1054 } 1055 lint_assert(before_conversion(rn)->tn_op == COLON); 1056 return true; 1057 } 1058 1059 static void 1060 typeok_colon_pointer(const mod_t *mp, const type_t *ltp, const type_t *rtp) 1061 { 1062 type_t *lstp = ltp->t_subt; 1063 type_t *rstp = rtp->t_subt; 1064 tspec_t lst = lstp->t_tspec; 1065 tspec_t rst = rstp->t_tspec; 1066 1067 if ((lst == VOID && rst == FUNC) || (lst == FUNC && rst == VOID)) { 1068 /* (void *)0 handled above */ 1069 if (sflag) 1070 /* ANSI C forbids conversion of %s to %s, op %s */ 1071 warning(305, "function pointer", "'void *'", 1072 mp->m_name); 1073 return; 1074 } 1075 1076 if (eqptrtype(lstp, rstp, true)) 1077 return; 1078 if (!eqtype(lstp, rstp, true, false, NULL)) 1079 warn_incompatible_pointers(mp, ltp, rtp); 1080 } 1081 1082 static bool 1083 typeok_colon(const mod_t *mp, 1084 const tnode_t *ln, const type_t *ltp, tspec_t lt, 1085 const tnode_t *rn, const type_t *rtp, tspec_t rt) 1086 { 1087 1088 if (is_arithmetic(lt) && is_arithmetic(rt)) 1089 return true; 1090 if (lt == BOOL && rt == BOOL) 1091 return true; 1092 1093 if (lt == STRUCT && rt == STRUCT && ltp->t_str == rtp->t_str) 1094 return true; 1095 if (lt == UNION && rt == UNION && ltp->t_str == rtp->t_str) 1096 return true; 1097 1098 if (lt == PTR && is_null_pointer(rn)) 1099 return true; 1100 if (rt == PTR && is_null_pointer(ln)) 1101 return true; 1102 1103 if ((lt == PTR && is_integer(rt)) || (is_integer(lt) && rt == PTR)) { 1104 const char *lx = lt == PTR ? "pointer" : "integer"; 1105 const char *rx = rt == PTR ? "pointer" : "integer"; 1106 /* illegal combination of %s (%s) and %s (%s), op %s */ 1107 warning(123, lx, type_name(ltp), 1108 rx, type_name(rtp), mp->m_name); 1109 return true; 1110 } 1111 1112 if (lt == VOID || rt == VOID) { 1113 if (lt != VOID || rt != VOID) 1114 /* incompatible types '%s' and '%s' in conditional */ 1115 warning(126, type_name(ltp), type_name(rtp)); 1116 return true; 1117 } 1118 1119 if (lt == PTR && rt == PTR) { 1120 typeok_colon_pointer(mp, ltp, rtp); 1121 return true; 1122 } 1123 1124 /* incompatible types '%s' and '%s' in conditional */ 1125 error(126, type_name(ltp), type_name(rtp)); 1126 return false; 1127 } 1128 1129 static bool 1130 typeok_assign(op_t op, const tnode_t *ln, const type_t *ltp, tspec_t lt) 1131 { 1132 if (op == RETURN || op == INIT || op == FARG) 1133 return true; 1134 1135 if (!ln->tn_lvalue) { 1136 if (ln->tn_op == CVT && ln->tn_cast && 1137 ln->tn_left->tn_op == LOAD) { 1138 /* a cast does not yield an lvalue */ 1139 error(163); 1140 } 1141 /* %soperand of '%s' must be lvalue */ 1142 error(114, "left ", op_name(op)); 1143 return false; 1144 } else if (ltp->t_const || ((lt == STRUCT || lt == UNION) && 1145 has_constant_member(ltp))) { 1146 if (!tflag) 1147 /* %soperand of '%s' must be modifiable lvalue */ 1148 warning(115, "left ", op_name(op)); 1149 } 1150 return true; 1151 } 1152 1153 /* Check the types using the information from modtab[]. */ 1154 static bool 1155 typeok_scalar(op_t op, const mod_t *mp, 1156 const type_t *ltp, tspec_t lt, 1157 const type_t *rtp, tspec_t rt) 1158 { 1159 if (mp->m_takes_bool && lt == BOOL && rt == BOOL) 1160 return true; 1161 if (mp->m_requires_integer) { 1162 if (!is_integer(lt) || (mp->m_binary && !is_integer(rt))) { 1163 warn_incompatible_types(op, ltp, lt, rtp, rt); 1164 return false; 1165 } 1166 } else if (mp->m_requires_integer_or_complex) { 1167 if ((!is_integer(lt) && !is_complex(lt)) || 1168 (mp->m_binary && (!is_integer(rt) && !is_complex(rt)))) { 1169 warn_incompatible_types(op, ltp, lt, rtp, rt); 1170 return false; 1171 } 1172 } else if (mp->m_requires_scalar) { 1173 if (!is_scalar(lt) || (mp->m_binary && !is_scalar(rt))) { 1174 warn_incompatible_types(op, ltp, lt, rtp, rt); 1175 return false; 1176 } 1177 } else if (mp->m_requires_arith) { 1178 if (!is_arithmetic(lt) || 1179 (mp->m_binary && !is_arithmetic(rt))) { 1180 warn_incompatible_types(op, ltp, lt, rtp, rt); 1181 return false; 1182 } 1183 } 1184 return true; 1185 } 1186 1187 /* 1188 * Check the types for specific operators and type combinations. 1189 * 1190 * At this point, the operands already conform to the type requirements of 1191 * the operator, such as being integer, floating or scalar. 1192 */ 1193 static bool 1194 typeok_op(op_t op, const mod_t *mp, int arg, 1195 const tnode_t *ln, const type_t *ltp, tspec_t lt, 1196 const tnode_t *rn, const type_t *rtp, tspec_t rt) 1197 { 1198 switch (op) { 1199 case ARROW: 1200 return typeok_arrow(lt); 1201 case POINT: 1202 return typeok_point(ln, ltp, lt); 1203 case INCBEF: 1204 case DECBEF: 1205 case INCAFT: 1206 case DECAFT: 1207 return typeok_incdec(op, ln, ltp); 1208 case INDIR: 1209 return typeok_indir(lt); 1210 case ADDR: 1211 return typeok_address(mp, ln, ltp, lt); 1212 case PLUS: 1213 return typeok_plus(op, ltp, lt, rtp, rt); 1214 case MINUS: 1215 return typeok_minus(op, ltp, lt, rtp, rt); 1216 case SHL: 1217 typeok_shl(mp, lt, rt); 1218 goto shift; 1219 case SHR: 1220 typeok_shr(mp, ln, lt, rn, rt); 1221 shift: 1222 typeok_shift(lt, rn, rt); 1223 break; 1224 case LT: 1225 case LE: 1226 case GT: 1227 case GE: 1228 compare: 1229 return typeok_compare(op, ln, ltp, lt, rn, rtp, rt); 1230 case EQ: 1231 case NE: 1232 if (is_typeok_eq(ln, lt, rn, rt)) 1233 break; 1234 goto compare; 1235 case QUEST: 1236 return typeok_quest(lt, rn); 1237 case COLON: 1238 return typeok_colon(mp, ln, ltp, lt, rn, rtp, rt); 1239 case ASSIGN: 1240 case INIT: 1241 case FARG: 1242 case RETURN: 1243 if (!check_assign_types_compatible(op, arg, ln, rn)) 1244 return false; 1245 goto assign; 1246 case MULASS: 1247 case DIVASS: 1248 case MODASS: 1249 goto assign; 1250 case ADDASS: 1251 case SUBASS: 1252 if ((lt == PTR && !is_integer(rt)) || rt == PTR) { 1253 warn_incompatible_types(op, ltp, lt, rtp, rt); 1254 return false; 1255 } 1256 goto assign; 1257 case SHLASS: 1258 goto assign; 1259 case SHRASS: 1260 if (pflag && !is_uinteger(lt) && !(tflag && is_uinteger(rt))) { 1261 /* bitwise '%s' on signed value possibly nonportable */ 1262 warning(117, mp->m_name); 1263 } 1264 goto assign; 1265 case ANDASS: 1266 case XORASS: 1267 case ORASS: 1268 assign: 1269 return typeok_assign(op, ln, ltp, lt); 1270 case COMMA: 1271 if (!modtab[ln->tn_op].m_has_side_effect) 1272 check_null_effect(ln); 1273 break; 1274 default: 1275 break; 1276 } 1277 return true; 1278 } 1279 1280 static void 1281 typeok_enum(op_t op, const mod_t *mp, int arg, 1282 const tnode_t *ln, const type_t *ltp, 1283 const tnode_t *rn, const type_t *rtp) 1284 { 1285 if (mp->m_bad_on_enum && 1286 (ltp->t_is_enum || (mp->m_binary && rtp->t_is_enum))) { 1287 check_bad_enum_operation(op, ln, rn); 1288 } else if (mp->m_valid_on_enum && 1289 (ltp->t_is_enum && rtp != NULL && rtp->t_is_enum)) { 1290 check_enum_type_mismatch(op, arg, ln, rn); 1291 } else if (mp->m_valid_on_enum && 1292 (ltp->t_is_enum || (rtp != NULL && rtp->t_is_enum))) { 1293 check_enum_int_mismatch(op, arg, ln, rn); 1294 } 1295 } 1296 1297 /* Perform most type checks. Return whether the types are ok. */ 1298 bool 1299 typeok(op_t op, int arg, const tnode_t *ln, const tnode_t *rn) 1300 { 1301 const mod_t *mp; 1302 tspec_t lt, rt; 1303 type_t *ltp, *rtp; 1304 1305 mp = &modtab[op]; 1306 1307 lint_assert((ltp = ln->tn_type) != NULL); 1308 lt = ltp->t_tspec; 1309 1310 if (mp->m_binary) { 1311 lint_assert((rtp = rn->tn_type) != NULL); 1312 rt = rtp->t_tspec; 1313 } else { 1314 rtp = NULL; 1315 rt = NOTSPEC; 1316 } 1317 1318 if (Tflag && !typeok_scalar_strict_bool(op, mp, arg, ln, rn)) 1319 return false; 1320 if (!typeok_scalar(op, mp, ltp, lt, rtp, rt)) 1321 return false; 1322 1323 if (!typeok_op(op, mp, arg, ln, ltp, lt, rn, rtp, rt)) 1324 return false; 1325 1326 typeok_enum(op, mp, arg, ln, ltp, rn, rtp); 1327 return true; 1328 } 1329 1330 static void 1331 check_pointer_comparison(op_t op, const tnode_t *ln, const tnode_t *rn) 1332 { 1333 type_t *ltp, *rtp; 1334 tspec_t lst, rst; 1335 const char *lsts, *rsts; 1336 1337 lst = (ltp = ln->tn_type)->t_subt->t_tspec; 1338 rst = (rtp = rn->tn_type)->t_subt->t_tspec; 1339 1340 if (lst == VOID || rst == VOID) { 1341 if (sflag && (lst == FUNC || rst == FUNC)) { 1342 /* (void *)0 already handled in typeok() */ 1343 *(lst == FUNC ? &lsts : &rsts) = "function pointer"; 1344 *(lst == VOID ? &lsts : &rsts) = "'void *'"; 1345 /* ANSI C forbids comparison of %s with %s */ 1346 warning(274, lsts, rsts); 1347 } 1348 return; 1349 } 1350 1351 if (!eqtype(ltp->t_subt, rtp->t_subt, true, false, NULL)) { 1352 warn_incompatible_pointers(&modtab[op], ltp, rtp); 1353 return; 1354 } 1355 1356 if (lst == FUNC && rst == FUNC) { 1357 if (sflag && op != EQ && op != NE) 1358 /* ANSI C forbids ordered comparisons of ... */ 1359 warning(125); 1360 } 1361 } 1362 1363 static bool 1364 is_direct_function_call(const tnode_t *tn, const char **out_name) 1365 { 1366 1367 if (!(tn->tn_op == CALL && 1368 tn->tn_left->tn_op == ADDR && 1369 tn->tn_left->tn_left->tn_op == NAME)) 1370 return false; 1371 1372 *out_name = tn->tn_left->tn_left->tn_sym->s_name; 1373 return true; 1374 } 1375 1376 static bool 1377 is_unconst_function(const char *name) 1378 { 1379 1380 return strcmp(name, "memchr") == 0 || 1381 strcmp(name, "strchr") == 0 || 1382 strcmp(name, "strpbrk") == 0 || 1383 strcmp(name, "strrchr") == 0 || 1384 strcmp(name, "strstr") == 0; 1385 } 1386 1387 static bool 1388 is_const_char_pointer(const tnode_t *tn) 1389 { 1390 const type_t *tp; 1391 1392 /* 1393 * For traditional reasons, C99 6.4.5p5 defines that string literals 1394 * have type 'char[]'. They are often implicitly converted to 1395 * 'char *', for example when they are passed as function arguments. 1396 * 1397 * C99 6.4.5p6 further defines that modifying a string that is 1398 * constructed from a string literal invokes undefined behavior. 1399 * 1400 * Out of these reasons, string literals are treated as 'effectively 1401 * const' here. 1402 */ 1403 if (tn->tn_op == CVT && 1404 tn->tn_left->tn_op == ADDR && 1405 tn->tn_left->tn_left->tn_op == STRING) 1406 return true; 1407 1408 tp = before_conversion(tn)->tn_type; 1409 return tp->t_tspec == PTR && 1410 tp->t_subt->t_tspec == CHAR && 1411 tp->t_subt->t_const; 1412 } 1413 1414 static bool 1415 is_const_pointer(const tnode_t *tn) 1416 { 1417 const type_t *tp; 1418 1419 tp = before_conversion(tn)->tn_type; 1420 return tp->t_tspec == PTR && tp->t_subt->t_const; 1421 } 1422 1423 static bool 1424 is_first_arg_const_char_pointer(const tnode_t *tn) 1425 { 1426 const tnode_t *an; 1427 1428 an = tn->tn_right; 1429 if (an == NULL) 1430 return false; 1431 1432 while (an->tn_right != NULL) 1433 an = an->tn_right; 1434 return is_const_char_pointer(an->tn_left); 1435 } 1436 1437 static bool 1438 is_second_arg_const_pointer(const tnode_t *tn) 1439 { 1440 const tnode_t *an; 1441 1442 an = tn->tn_right; 1443 if (an == NULL || an->tn_right == NULL) 1444 return false; 1445 1446 while (an->tn_right->tn_right != NULL) 1447 an = an->tn_right; 1448 return is_const_pointer(an->tn_left); 1449 } 1450 1451 static void 1452 check_unconst_function(const type_t *lstp, const tnode_t *rn) 1453 { 1454 const char *function_name; 1455 1456 if (lstp->t_tspec == CHAR && !lstp->t_const && 1457 is_direct_function_call(rn, &function_name) && 1458 is_unconst_function(function_name) && 1459 is_first_arg_const_char_pointer(rn)) { 1460 /* call to '%s' effectively discards 'const' from argument */ 1461 warning(346, function_name); 1462 } 1463 1464 if (!lstp->t_const && 1465 is_direct_function_call(rn, &function_name) && 1466 strcmp(function_name, "bsearch") == 0 && 1467 is_second_arg_const_pointer(rn)) { 1468 /* call to '%s' effectively discards 'const' from argument */ 1469 warning(346, function_name); 1470 } 1471 } 1472 1473 static void 1474 check_assign_void_pointer(op_t op, int arg, 1475 tspec_t lt, tspec_t lst, 1476 tspec_t rt, tspec_t rst) 1477 { 1478 const char *lts, *rts; 1479 1480 if (!(lt == PTR && rt == PTR && (lst == VOID || rst == VOID))) 1481 return; 1482 /* two pointers, at least one pointer to void */ 1483 1484 if (!(sflag && (lst == FUNC || rst == FUNC))) 1485 return; 1486 /* comb. of ptr to func and ptr to void */ 1487 1488 *(lst == FUNC ? <s : &rts) = "function pointer"; 1489 *(lst == VOID ? <s : &rts) = "'void *'"; 1490 1491 switch (op) { 1492 case INIT: 1493 case RETURN: 1494 /* ANSI C forbids conversion of %s to %s */ 1495 warning(303, rts, lts); 1496 break; 1497 case FARG: 1498 /* ANSI C forbids conversion of %s to %s, arg #%d */ 1499 warning(304, rts, lts, arg); 1500 break; 1501 default: 1502 /* ANSI C forbids conversion of %s to %s, op %s */ 1503 warning(305, rts, lts, op_name(op)); 1504 break; 1505 } 1506 } 1507 1508 static bool 1509 check_assign_void_pointer_compat(op_t op, int arg, 1510 const type_t *const ltp, tspec_t const lt, 1511 const type_t *const lstp, tspec_t const lst, 1512 const tnode_t *const rn, 1513 const type_t *const rtp, tspec_t const rt, 1514 const type_t *const rstp, tspec_t const rst) 1515 { 1516 if (!(lt == PTR && rt == PTR && (lst == VOID || rst == VOID || 1517 eqtype(lstp, rstp, true, false, NULL)))) 1518 return false; 1519 1520 /* compatible pointer types (qualifiers ignored) */ 1521 if (!tflag && 1522 ((!lstp->t_const && rstp->t_const) || 1523 (!lstp->t_volatile && rstp->t_volatile))) { 1524 /* left side has not all qualifiers of right */ 1525 switch (op) { 1526 case INIT: 1527 case RETURN: 1528 /* incompatible pointer types (%s != %s) */ 1529 warning(182, type_name(lstp), type_name(rstp)); 1530 break; 1531 case FARG: 1532 /* converting '%s' to incompatible '%s' ... */ 1533 warning(153, 1534 type_name(rtp), type_name(ltp), arg); 1535 break; 1536 default: 1537 /* operands have incompatible pointer type... */ 1538 warning(128, op_name(op), 1539 type_name(lstp), type_name(rstp)); 1540 break; 1541 } 1542 } 1543 1544 if (!tflag) 1545 check_unconst_function(lstp, rn); 1546 1547 return true; 1548 } 1549 1550 static bool 1551 check_assign_pointer_integer(op_t op, int arg, 1552 const type_t *const ltp, tspec_t const lt, 1553 const type_t *const rtp, tspec_t const rt) 1554 { 1555 if (!((lt == PTR && is_integer(rt)) || (is_integer(lt) && rt == PTR))) 1556 return false; 1557 1558 const char *lx = lt == PTR ? "pointer" : "integer"; 1559 const char *rx = rt == PTR ? "pointer" : "integer"; 1560 1561 switch (op) { 1562 case INIT: 1563 case RETURN: 1564 /* illegal combination of %s (%s) and %s (%s) */ 1565 warning(183, lx, type_name(ltp), rx, type_name(rtp)); 1566 break; 1567 case FARG: 1568 /* illegal combination of %s (%s) and %s (%s), arg #%d */ 1569 warning(154, 1570 lx, type_name(ltp), rx, type_name(rtp), arg); 1571 break; 1572 default: 1573 /* illegal combination of %s (%s) and %s (%s), op %s */ 1574 warning(123, 1575 lx, type_name(ltp), rx, type_name(rtp), op_name(op)); 1576 break; 1577 } 1578 return true; 1579 } 1580 1581 static bool 1582 check_assign_pointer(op_t op, int arg, 1583 const type_t *ltp, tspec_t lt, 1584 const type_t *rtp, tspec_t rt) 1585 { 1586 if (!(lt == PTR && rt == PTR)) 1587 return false; 1588 1589 switch (op) { 1590 case RETURN: 1591 warn_incompatible_pointers(NULL, ltp, rtp); 1592 break; 1593 case FARG: 1594 /* converting '%s' to incompatible '%s' for ... */ 1595 warning(153, type_name(rtp), type_name(ltp), arg); 1596 break; 1597 default: 1598 warn_incompatible_pointers(&modtab[op], ltp, rtp); 1599 break; 1600 } 1601 return true; 1602 } 1603 1604 static void 1605 warn_assign(op_t op, int arg, 1606 const type_t *ltp, tspec_t lt, 1607 const type_t *rtp, tspec_t rt) 1608 { 1609 switch (op) { 1610 case INIT: 1611 /* cannot initialize '%s' from '%s' */ 1612 error(185, type_name(ltp), type_name(rtp)); 1613 break; 1614 case RETURN: 1615 /* return value type mismatch (%s) and (%s) */ 1616 error(211, type_name(ltp), type_name(rtp)); 1617 break; 1618 case FARG: 1619 /* passing '%s' to incompatible '%s', arg #%d */ 1620 warning(155, type_name(rtp), type_name(ltp), arg); 1621 break; 1622 default: 1623 warn_incompatible_types(op, ltp, lt, rtp, rt); 1624 break; 1625 } 1626 } 1627 1628 /* 1629 * Checks type compatibility for ASSIGN, INIT, FARG and RETURN 1630 * and prints warnings/errors if necessary. 1631 * Returns whether the types are (almost) compatible. 1632 */ 1633 static bool 1634 check_assign_types_compatible(op_t op, int arg, 1635 const tnode_t *ln, const tnode_t *rn) 1636 { 1637 tspec_t lt, rt, lst = NOTSPEC, rst = NOTSPEC; 1638 type_t *ltp, *rtp, *lstp = NULL, *rstp = NULL; 1639 1640 if ((lt = (ltp = ln->tn_type)->t_tspec) == PTR) 1641 lst = (lstp = ltp->t_subt)->t_tspec; 1642 if ((rt = (rtp = rn->tn_type)->t_tspec) == PTR) 1643 rst = (rstp = rtp->t_subt)->t_tspec; 1644 1645 if (lt == BOOL && is_scalar(rt)) /* C99 6.3.1.2 */ 1646 return true; 1647 1648 if (is_arithmetic(lt) && (is_arithmetic(rt) || rt == BOOL)) 1649 return true; 1650 1651 if ((lt == STRUCT || lt == UNION) && (rt == STRUCT || rt == UNION)) 1652 /* both are struct or union */ 1653 return ltp->t_str == rtp->t_str; 1654 1655 /* a null pointer may be assigned to any pointer */ 1656 if (lt == PTR && is_null_pointer(rn)) 1657 return true; 1658 1659 check_assign_void_pointer(op, arg, lt, lst, rt, rst); 1660 1661 if (check_assign_void_pointer_compat(op, arg, 1662 ltp, lt, lstp, lst, rn, rtp, rt, rstp, rst)) 1663 return true; 1664 1665 if (check_assign_pointer_integer(op, arg, ltp, lt, rtp, rt)) 1666 return true; 1667 1668 if (check_assign_pointer(op, arg, ltp, lt, rtp, rt)) 1669 return true; 1670 1671 warn_assign(op, arg, ltp, lt, rtp, rt); 1672 return false; 1673 } 1674 1675 /* Prints a warning if a strange operator is used on an enum type. */ 1676 static void 1677 check_bad_enum_operation(op_t op, const tnode_t *ln, const tnode_t *rn) 1678 { 1679 1680 if (!eflag) 1681 return; 1682 1683 /* 1684 * Enum as offset to a pointer is an exception (otherwise enums 1685 * could not be used as array indices). 1686 */ 1687 if (op == PLUS && 1688 ((ln->tn_type->t_is_enum && rn->tn_type->t_tspec == PTR) || 1689 (rn->tn_type->t_is_enum && ln->tn_type->t_tspec == PTR))) { 1690 return; 1691 } 1692 1693 /* dubious operation on enum, op %s */ 1694 warning(241, op_name(op)); 1695 } 1696 1697 /* 1698 * Prints a warning if an operator is applied to two different enum types. 1699 */ 1700 static void 1701 check_enum_type_mismatch(op_t op, int arg, const tnode_t *ln, const tnode_t *rn) 1702 { 1703 const mod_t *mp; 1704 1705 mp = &modtab[op]; 1706 1707 if (ln->tn_type->t_enum != rn->tn_type->t_enum) { 1708 switch (op) { 1709 case INIT: 1710 /* enum type mismatch between '%s' and '%s' in ... */ 1711 warning(210, 1712 type_name(ln->tn_type), type_name(rn->tn_type)); 1713 break; 1714 case FARG: 1715 /* enum type mismatch, arg #%d (%s != %s) */ 1716 warning(156, arg, 1717 type_name(ln->tn_type), type_name(rn->tn_type)); 1718 break; 1719 case RETURN: 1720 /* return value type mismatch (%s) and (%s) */ 1721 warning(211, 1722 type_name(ln->tn_type), type_name(rn->tn_type)); 1723 break; 1724 default: 1725 /* enum type mismatch: '%s' '%s' '%s' */ 1726 warning(130, type_name(ln->tn_type), mp->m_name, 1727 type_name(rn->tn_type)); 1728 break; 1729 } 1730 } else if (Pflag && mp->m_comparison && op != EQ && op != NE) { 1731 if (eflag) 1732 /* dubious comparison of enums, op %s */ 1733 warning(243, mp->m_name); 1734 } 1735 } 1736 1737 /* Prints a warning if the operands mix between enum and integer. */ 1738 static void 1739 check_enum_int_mismatch(op_t op, int arg, const tnode_t *ln, const tnode_t *rn) 1740 { 1741 1742 if (!eflag) 1743 return; 1744 1745 switch (op) { 1746 case INIT: 1747 /* 1748 * Initialization with 0 is allowed. Otherwise, all implicit 1749 * initializations would need to be warned upon as well. 1750 */ 1751 if (!rn->tn_type->t_is_enum && rn->tn_op == CON && 1752 is_integer(rn->tn_type->t_tspec) && 1753 rn->tn_val->v_quad == 0) { 1754 return; 1755 } 1756 /* initialization of '%s' with '%s' */ 1757 warning(277, type_name(ln->tn_type), type_name(rn->tn_type)); 1758 break; 1759 case FARG: 1760 /* combination of '%s' and '%s', arg #%d */ 1761 warning(278, 1762 type_name(ln->tn_type), type_name(rn->tn_type), arg); 1763 break; 1764 case RETURN: 1765 /* combination of '%s' and '%s' in return */ 1766 warning(279, type_name(ln->tn_type), type_name(rn->tn_type)); 1767 break; 1768 default: 1769 /* combination of '%s' and '%s', op %s */ 1770 warning(242, type_name(ln->tn_type), type_name(rn->tn_type), 1771 op_name(op)); 1772 break; 1773 } 1774 } 1775 1776 static void 1777 check_enum_array_index(const tnode_t *ln, const tnode_t *rn) 1778 { 1779 int max_enum_value, max_array_index; 1780 const struct sym *ec; 1781 1782 if (ln->tn_op != ADDR) 1783 return; 1784 if (ln->tn_left->tn_op != NAME) 1785 return; 1786 if (ln->tn_left->tn_type->t_tspec != ARRAY) 1787 return; 1788 if (ln->tn_left->tn_type->t_incomplete_array) 1789 return; 1790 if (rn->tn_op != CVT) 1791 return; 1792 if (rn->tn_left->tn_op != LOAD) 1793 return; 1794 if (rn->tn_left->tn_type->t_tspec != ENUM) 1795 return; 1796 1797 max_enum_value = INT_MIN; 1798 ec = rn->tn_type->t_enum->en_first_enumerator; 1799 for (; ec != NULL; ec = ec->s_next) { 1800 int64_t ev = ec->s_value.v_quad; 1801 lint_assert(INT_MIN <= ev && ev <= INT_MAX); 1802 if (ev > max_enum_value) 1803 max_enum_value = (int)ev; 1804 } 1805 1806 max_array_index = ln->tn_left->tn_type->t_dim - 1; 1807 if (max_enum_value == max_array_index) 1808 return; 1809 1810 /* maximum value %d of '%s' does not match maximum array index %d */ 1811 warning(348, max_enum_value, type_name(rn->tn_type), max_array_index); 1812 } 1813 1814 /* 1815 * Build and initialize a new node. 1816 */ 1817 static tnode_t * 1818 new_tnode(op_t op, type_t *type, tnode_t *ln, tnode_t *rn) 1819 { 1820 tnode_t *ntn; 1821 tspec_t t; 1822 #if 0 /* not yet */ 1823 size_t l; 1824 uint64_t rnum; 1825 #endif 1826 1827 ntn = expr_zalloc_tnode(); 1828 1829 ntn->tn_op = op; 1830 ntn->tn_type = type; 1831 ntn->tn_relaxed = ln->tn_relaxed || (rn != NULL && rn->tn_relaxed); 1832 ntn->tn_left = ln; 1833 ntn->tn_right = rn; 1834 1835 switch (op) { 1836 #if 0 /* not yet */ 1837 case SHR: 1838 if (rn->tn_op != CON) 1839 break; 1840 rnum = rn->tn_val->v_quad; 1841 l = type_size_in_bits(ln->tn_type) / CHAR_SIZE; 1842 t = ln->tn_type->t_tspec; 1843 switch (l) { 1844 case 8: 1845 if (rnum >= 56) 1846 t = UCHAR; 1847 else if (rnum >= 48) 1848 t = USHORT; 1849 else if (rnum >= 32) 1850 t = UINT; 1851 break; 1852 case 4: 1853 if (rnum >= 24) 1854 t = UCHAR; 1855 else if (rnum >= 16) 1856 t = USHORT; 1857 break; 1858 case 2: 1859 if (rnum >= 8) 1860 t = UCHAR; 1861 break; 1862 default: 1863 break; 1864 } 1865 if (t != ln->tn_type->t_tspec) 1866 ntn->tn_type->t_tspec = t; 1867 break; 1868 #endif 1869 case INDIR: 1870 case FSEL: 1871 lint_assert(ln->tn_type->t_tspec == PTR); 1872 t = ln->tn_type->t_subt->t_tspec; 1873 if (t != FUNC && t != VOID) 1874 ntn->tn_lvalue = true; 1875 break; 1876 default: 1877 break; 1878 } 1879 1880 return ntn; 1881 } 1882 1883 /* 1884 * Performs the "integer promotions" (C99 6.3.1.1p2), which convert small 1885 * integer types to either int or unsigned int. 1886 * 1887 * If tflag is set or the operand is a function argument with no type 1888 * information (no prototype or variable # of args), converts float to double. 1889 */ 1890 tnode_t * 1891 promote(op_t op, bool farg, tnode_t *tn) 1892 { 1893 tspec_t t; 1894 type_t *ntp; 1895 unsigned int len; 1896 1897 t = tn->tn_type->t_tspec; 1898 1899 if (!is_arithmetic(t)) 1900 return tn; 1901 1902 if (!tflag) { 1903 /* 1904 * C99 6.3.1.1p2 requires for types with lower rank than int 1905 * that "If an int can represent all the values of the 1906 * original type, the value is converted to an int; otherwise 1907 * it is converted to an unsigned int", and that "All other 1908 * types are unchanged by the integer promotions". 1909 */ 1910 if (tn->tn_type->t_bitfield) { 1911 len = tn->tn_type->t_flen; 1912 if (len < size_in_bits(INT)) { 1913 t = INT; 1914 } else if (len == size_in_bits(INT)) { 1915 t = is_uinteger(t) ? UINT : INT; 1916 } 1917 } else if (t == CHAR || t == UCHAR || t == SCHAR) { 1918 t = (size_in_bits(CHAR) < size_in_bits(INT) 1919 || t != UCHAR) ? INT : UINT; 1920 } else if (t == SHORT || t == USHORT) { 1921 t = (size_in_bits(SHORT) < size_in_bits(INT) 1922 || t == SHORT) ? INT : UINT; 1923 } else if (t == ENUM) { 1924 t = INT; 1925 } else if (farg && t == FLOAT) { 1926 t = DOUBLE; 1927 } 1928 } else { 1929 /* 1930 * In traditional C, keep unsigned and promote FLOAT 1931 * to DOUBLE. 1932 */ 1933 if (t == UCHAR || t == USHORT) { 1934 t = UINT; 1935 } else if (t == CHAR || t == SCHAR || t == SHORT) { 1936 t = INT; 1937 } else if (t == FLOAT) { 1938 t = DOUBLE; 1939 } else if (t == ENUM) { 1940 t = INT; 1941 } 1942 } 1943 1944 if (t != tn->tn_type->t_tspec) { 1945 ntp = expr_dup_type(tn->tn_type); 1946 ntp->t_tspec = t; 1947 /* 1948 * Keep t_is_enum even though t_tspec gets converted from 1949 * ENUM to INT, so we are later able to check compatibility 1950 * of enum types. 1951 */ 1952 tn = convert(op, 0, ntp, tn); 1953 } 1954 1955 return tn; 1956 } 1957 1958 /* 1959 * Apply the "usual arithmetic conversions" (C99 6.3.1.8). 1960 * 1961 * This gives both operands the same type. 1962 * This is done in different ways for traditional C and C90. 1963 */ 1964 static void 1965 balance(op_t op, tnode_t **lnp, tnode_t **rnp) 1966 { 1967 tspec_t lt, rt, t; 1968 int i; 1969 bool u; 1970 type_t *ntp; 1971 static const tspec_t tl[] = { 1972 LDOUBLE, DOUBLE, FLOAT, 1973 #ifdef INT128_SIZE 1974 UINT128, INT128, 1975 #endif 1976 UQUAD, QUAD, 1977 ULONG, LONG, 1978 UINT, INT, 1979 }; 1980 1981 lt = (*lnp)->tn_type->t_tspec; 1982 rt = (*rnp)->tn_type->t_tspec; 1983 1984 if (!is_arithmetic(lt) || !is_arithmetic(rt)) 1985 return; 1986 1987 if (!tflag) { 1988 if (lt == rt) { 1989 t = lt; 1990 } else if (lt == LCOMPLEX || rt == LCOMPLEX) { 1991 t = LCOMPLEX; 1992 } else if (lt == DCOMPLEX || rt == DCOMPLEX) { 1993 t = DCOMPLEX; 1994 } else if (lt == FCOMPLEX || rt == FCOMPLEX) { 1995 t = FCOMPLEX; 1996 } else if (lt == LDOUBLE || rt == LDOUBLE) { 1997 t = LDOUBLE; 1998 } else if (lt == DOUBLE || rt == DOUBLE) { 1999 t = DOUBLE; 2000 } else if (lt == FLOAT || rt == FLOAT) { 2001 t = FLOAT; 2002 } else { 2003 /* 2004 * If type A has more bits than type B it should 2005 * be able to hold all possible values of type B. 2006 */ 2007 if (size_in_bits(lt) > size_in_bits(rt)) { 2008 t = lt; 2009 } else if (size_in_bits(lt) < size_in_bits(rt)) { 2010 t = rt; 2011 } else { 2012 for (i = 3; tl[i] != INT; i++) { 2013 if (tl[i] == lt || tl[i] == rt) 2014 break; 2015 } 2016 if ((is_uinteger(lt) || is_uinteger(rt)) && 2017 !is_uinteger(tl[i])) { 2018 i--; 2019 } 2020 t = tl[i]; 2021 } 2022 } 2023 } else { 2024 /* Keep unsigned in traditional C */ 2025 u = is_uinteger(lt) || is_uinteger(rt); 2026 for (i = 0; tl[i] != INT; i++) { 2027 if (lt == tl[i] || rt == tl[i]) 2028 break; 2029 } 2030 t = tl[i]; 2031 if (u && is_integer(t) && !is_uinteger(t)) 2032 t = unsigned_type(t); 2033 } 2034 2035 if (t != lt) { 2036 ntp = expr_dup_type((*lnp)->tn_type); 2037 ntp->t_tspec = t; 2038 *lnp = convert(op, 0, ntp, *lnp); 2039 } 2040 if (t != rt) { 2041 ntp = expr_dup_type((*rnp)->tn_type); 2042 ntp->t_tspec = t; 2043 *rnp = convert(op, 0, ntp, *rnp); 2044 } 2045 } 2046 2047 /* 2048 * Insert a conversion operator, which converts the type of the node 2049 * to another given type. 2050 * If op is FARG, arg is the number of the argument (used for warnings). 2051 */ 2052 tnode_t * 2053 convert(op_t op, int arg, type_t *tp, tnode_t *tn) 2054 { 2055 tnode_t *ntn; 2056 tspec_t nt, ot; 2057 2058 nt = tp->t_tspec; 2059 ot = tn->tn_type->t_tspec; 2060 2061 if (!tflag && !sflag && op == FARG) 2062 check_prototype_conversion(arg, nt, ot, tp, tn); 2063 if (is_integer(nt) && is_integer(ot)) { 2064 check_integer_conversion(op, arg, nt, ot, tp, tn); 2065 } else if (nt == PTR && is_null_pointer(tn)) { 2066 /* a null pointer may be assigned to any pointer. */ 2067 } else if (is_integer(nt) && nt != BOOL && ot == PTR) { 2068 check_pointer_integer_conversion(op, nt, tp, tn); 2069 } else if (nt == PTR && ot == PTR && op == CVT) { 2070 check_pointer_conversion(tn, tp); 2071 } 2072 2073 ntn = expr_zalloc_tnode(); 2074 ntn->tn_op = CVT; 2075 ntn->tn_type = tp; 2076 ntn->tn_cast = op == CVT; 2077 ntn->tn_relaxed |= tn->tn_relaxed; 2078 ntn->tn_right = NULL; 2079 if (tn->tn_op != CON || nt == VOID) { 2080 ntn->tn_left = tn; 2081 } else { 2082 ntn->tn_op = CON; 2083 ntn->tn_val = expr_zalloc(sizeof(*ntn->tn_val)); 2084 convert_constant(op, arg, ntn->tn_type, ntn->tn_val, 2085 tn->tn_val); 2086 } 2087 2088 return ntn; 2089 } 2090 2091 static bool 2092 should_warn_about_prototype_conversion(tspec_t nt, 2093 tspec_t ot, const tnode_t *ptn) 2094 { 2095 2096 if (nt == ot) 2097 return false; 2098 2099 if (nt == ENUM && ot == INT) 2100 return false; 2101 2102 if (is_floating(nt) != is_floating(ot) || 2103 portable_size_in_bits(nt) != portable_size_in_bits(ot)) { 2104 /* representation and/or width change */ 2105 if (!is_integer(ot)) 2106 return true; 2107 /* 2108 * XXX: Investigate whether this rule makes sense; see 2109 * tests/usr.bin/xlint/lint1/platform_long.c. 2110 */ 2111 return portable_size_in_bits(ot) > portable_size_in_bits(INT); 2112 } 2113 2114 if (!hflag) 2115 return false; 2116 2117 /* 2118 * If the types differ only in sign and the argument has the same 2119 * representation in both types, print no warning. 2120 */ 2121 if (ptn->tn_op == CON && is_integer(nt) && 2122 signed_type(nt) == signed_type(ot) && 2123 !msb(ptn->tn_val->v_quad, ot)) 2124 return false; 2125 2126 return true; 2127 } 2128 2129 /* 2130 * Warn if a prototype causes a type conversion that is different from what 2131 * would happen to the same argument in the absence of a prototype. This 2132 * check is intended for code that needs to stay compatible with pre-C90 C. 2133 * 2134 * Errors/warnings about illegal type combinations are already printed 2135 * in check_assign_types_compatible(). 2136 */ 2137 static void 2138 check_prototype_conversion(int arg, tspec_t nt, tspec_t ot, type_t *tp, 2139 tnode_t *tn) 2140 { 2141 tnode_t *ptn; 2142 2143 if (!is_arithmetic(nt) || !is_arithmetic(ot)) 2144 return; 2145 2146 /* 2147 * If the type of the formal parameter is char/short, a warning 2148 * would be useless, because functions declared the old style 2149 * can't expect char/short arguments. 2150 */ 2151 if (nt == CHAR || nt == SCHAR || nt == UCHAR || 2152 nt == SHORT || nt == USHORT) 2153 return; 2154 2155 /* apply the default promotion */ 2156 ptn = promote(NOOP, true, tn); 2157 ot = ptn->tn_type->t_tspec; 2158 2159 if (should_warn_about_prototype_conversion(nt, ot, ptn)) { 2160 /* argument #%d is converted from '%s' to '%s' ... */ 2161 warning(259, arg, type_name(tn->tn_type), type_name(tp)); 2162 } 2163 } 2164 2165 /* 2166 * Print warnings for conversions of integer types which may cause problems. 2167 */ 2168 static void 2169 check_integer_conversion(op_t op, int arg, tspec_t nt, tspec_t ot, type_t *tp, 2170 tnode_t *tn) 2171 { 2172 2173 if (tn->tn_op == CON) 2174 return; 2175 2176 if (op == CVT) 2177 return; 2178 2179 if (Sflag && nt == BOOL) 2180 return; /* See C99 6.3.1.2 */ 2181 2182 if (Pflag && portable_size_in_bits(nt) > portable_size_in_bits(ot) && 2183 is_uinteger(nt) != is_uinteger(ot)) { 2184 if (aflag > 0 && pflag) { 2185 if (op == FARG) { 2186 /* conversion to '%s' may sign-extend ... */ 2187 warning(297, type_name(tp), arg); 2188 } else { 2189 /* conversion to '%s' may sign-extend ... */ 2190 warning(131, type_name(tp)); 2191 } 2192 } 2193 } 2194 2195 if (Pflag && portable_size_in_bits(nt) > portable_size_in_bits(ot)) { 2196 switch (tn->tn_op) { 2197 case PLUS: 2198 case MINUS: 2199 case MULT: 2200 case SHL: 2201 /* suggest cast from '%s' to '%s' on op %s to ... */ 2202 warning(324, type_name(gettyp(ot)), type_name(tp), 2203 op_name(tn->tn_op)); 2204 break; 2205 default: 2206 break; 2207 } 2208 } 2209 2210 if (portable_size_in_bits(nt) < portable_size_in_bits(ot) && 2211 (ot == LONG || ot == ULONG || ot == QUAD || ot == UQUAD || 2212 aflag > 1)) { 2213 /* conversion from '%s' may lose accuracy */ 2214 if (aflag > 0) { 2215 if (op == FARG) { 2216 /* conversion from '%s' to '%s' may ... */ 2217 warning(298, 2218 type_name(tn->tn_type), type_name(tp), arg); 2219 } else { 2220 /* conversion from '%s' to '%s' may ... */ 2221 warning(132, 2222 type_name(tn->tn_type), type_name(tp)); 2223 } 2224 } 2225 } 2226 } 2227 2228 /* 2229 * Print warnings for dubious conversions of pointer to integer. 2230 */ 2231 static void 2232 check_pointer_integer_conversion(op_t op, tspec_t nt, type_t *tp, tnode_t *tn) 2233 { 2234 2235 if (tn->tn_op == CON) 2236 return; 2237 if (op != CVT) 2238 return; /* We got already an error. */ 2239 if (portable_size_in_bits(nt) >= portable_size_in_bits(PTR)) 2240 return; 2241 2242 if (pflag && size_in_bits(nt) >= size_in_bits(PTR)) { 2243 /* conversion of pointer to '%s' may lose bits */ 2244 warning(134, type_name(tp)); 2245 } else { 2246 /* conversion of pointer to '%s' loses bits */ 2247 warning(133, type_name(tp)); 2248 } 2249 } 2250 2251 static bool 2252 should_warn_about_pointer_cast(const type_t *nstp, tspec_t nst, 2253 const type_t *ostp, tspec_t ost) 2254 { 2255 /* 2256 * Casting a pointer to 'struct S' to a pointer to another struct that 2257 * has 'struct S' as its first member is ok, see msg_247.c, 'struct 2258 * counter'. 2259 */ 2260 if (nst == STRUCT && ost == STRUCT && 2261 nstp->t_str->sou_first_member != NULL && 2262 nstp->t_str->sou_first_member->s_type == ostp) 2263 return false; 2264 2265 if (is_incomplete(nstp) || is_incomplete(ostp)) 2266 return false; 2267 2268 if ((nst == STRUCT || nst == UNION) && nstp->t_str != ostp->t_str) 2269 return true; 2270 2271 if (nst == CHAR || nst == UCHAR) 2272 return false; /* for the sake of traditional C code */ 2273 if (ost == CHAR || ost == UCHAR) 2274 return false; /* for the sake of traditional C code */ 2275 2276 return portable_size_in_bits(nst) != portable_size_in_bits(ost); 2277 } 2278 2279 /* 2280 * Warn about questionable pointer conversions. 2281 */ 2282 static void 2283 check_pointer_conversion(tnode_t *tn, type_t *ntp) 2284 { 2285 const type_t *nstp, *otp, *ostp; 2286 tspec_t nst, ost; 2287 const char *nts, *ots; 2288 2289 nstp = ntp->t_subt; 2290 otp = tn->tn_type; 2291 ostp = otp->t_subt; 2292 nst = nstp->t_tspec; 2293 ost = ostp->t_tspec; 2294 2295 if (nst == VOID || ost == VOID) { 2296 if (sflag && (nst == FUNC || ost == FUNC)) { 2297 /* null pointers are already handled in convert() */ 2298 *(nst == FUNC ? &nts : &ots) = "function pointer"; 2299 *(nst == VOID ? &nts : &ots) = "'void *'"; 2300 /* ANSI C forbids conversion of %s to %s */ 2301 warning(303, ots, nts); 2302 } 2303 return; 2304 } else if (nst == FUNC && ost == FUNC) { 2305 return; 2306 } else if (nst == FUNC || ost == FUNC) { 2307 /* converting '%s' to '%s' is questionable */ 2308 warning(229, type_name(otp), type_name(ntp)); 2309 return; 2310 } 2311 2312 if (hflag && alignment_in_bits(nstp) > alignment_in_bits(ostp) && 2313 ost != CHAR && ost != UCHAR && 2314 !is_incomplete(ostp)) { 2315 /* converting '%s' to '%s' may cause alignment problem */ 2316 warning(135, type_name(otp), type_name(ntp)); 2317 } 2318 2319 if (cflag && should_warn_about_pointer_cast(nstp, nst, ostp, ost)) { 2320 /* pointer cast from '%s' to '%s' may be troublesome */ 2321 warning(247, type_name(otp), type_name(ntp)); 2322 } 2323 } 2324 2325 static void 2326 convert_constant_floating(op_t op, int arg, tspec_t ot, const type_t *tp, 2327 tspec_t nt, val_t *v, val_t *nv) 2328 { 2329 ldbl_t max = 0.0, min = 0.0; 2330 2331 switch (nt) { 2332 case CHAR: 2333 max = TARG_CHAR_MAX; min = TARG_CHAR_MIN; break; 2334 case UCHAR: 2335 max = TARG_UCHAR_MAX; min = 0; break; 2336 case SCHAR: 2337 max = TARG_SCHAR_MAX; min = TARG_SCHAR_MIN; break; 2338 case SHORT: 2339 max = TARG_SHRT_MAX; min = TARG_SHRT_MIN; break; 2340 case USHORT: 2341 max = TARG_USHRT_MAX; min = 0; break; 2342 case ENUM: 2343 case INT: 2344 max = TARG_INT_MAX; min = TARG_INT_MIN; break; 2345 case UINT: 2346 max = TARG_UINT_MAX; min = 0; break; 2347 case LONG: 2348 max = TARG_LONG_MAX; min = TARG_LONG_MIN; break; 2349 case ULONG: 2350 max = TARG_ULONG_MAX; min = 0; break; 2351 case QUAD: 2352 max = QUAD_MAX; min = QUAD_MIN; break; 2353 case UQUAD: 2354 max = UQUAD_MAX; min = 0; break; 2355 case FLOAT: 2356 case FCOMPLEX: 2357 max = FLT_MAX; min = -FLT_MAX; break; 2358 case DOUBLE: 2359 case DCOMPLEX: 2360 max = DBL_MAX; min = -DBL_MAX; break; 2361 case PTR: 2362 /* Got already an error because of float --> ptr */ 2363 case LDOUBLE: 2364 case LCOMPLEX: 2365 /* LINTED 248 */ 2366 max = LDBL_MAX; min = -max; break; 2367 default: 2368 lint_assert(/*CONSTCOND*/false); 2369 } 2370 if (v->v_ldbl > max || v->v_ldbl < min) { 2371 lint_assert(nt != LDOUBLE); 2372 if (op == FARG) { 2373 /* conversion of '%s' to '%s' is out of range, ... */ 2374 warning(295, 2375 type_name(gettyp(ot)), type_name(tp), arg); 2376 } else { 2377 /* conversion of '%s' to '%s' is out of range */ 2378 warning(119, 2379 type_name(gettyp(ot)), type_name(tp)); 2380 } 2381 v->v_ldbl = v->v_ldbl > 0 ? max : min; 2382 } 2383 2384 if (nt == FLOAT) { 2385 nv->v_ldbl = (float)v->v_ldbl; 2386 } else if (nt == DOUBLE) { 2387 nv->v_ldbl = (double)v->v_ldbl; 2388 } else if (nt == LDOUBLE) { 2389 nv->v_ldbl = v->v_ldbl; 2390 } else { 2391 nv->v_quad = (int64_t)v->v_ldbl; 2392 } 2393 } 2394 2395 static bool 2396 convert_constant_to_floating(tspec_t nt, val_t *nv, 2397 tspec_t ot, const val_t *v) 2398 { 2399 if (nt == FLOAT) { 2400 nv->v_ldbl = (ot == PTR || is_uinteger(ot)) ? 2401 (float)(uint64_t)v->v_quad : (float)v->v_quad; 2402 } else if (nt == DOUBLE) { 2403 nv->v_ldbl = (ot == PTR || is_uinteger(ot)) ? 2404 (double)(uint64_t)v->v_quad : (double)v->v_quad; 2405 } else if (nt == LDOUBLE) { 2406 nv->v_ldbl = (ot == PTR || is_uinteger(ot)) ? 2407 (ldbl_t)(uint64_t)v->v_quad : (ldbl_t)v->v_quad; 2408 } else 2409 return false; 2410 return true; 2411 } 2412 2413 /* 2414 * Print a warning if bits which were set are lost due to the conversion. 2415 * This can happen with operator ORASS only. 2416 */ 2417 static void 2418 convert_constant_check_range_bitor(size_t nsz, size_t osz, const val_t *v, 2419 uint64_t xmask, op_t op) 2420 { 2421 if (nsz < osz && (v->v_quad & xmask) != 0) { 2422 /* constant truncated by conversion, op %s */ 2423 warning(306, op_name(op)); 2424 } 2425 } 2426 2427 /* 2428 * Print a warning if additional bits are not all 1 2429 * and the most significant bit of the old value is 1, 2430 * or if at least one (but not all) removed bit was 0. 2431 */ 2432 static void 2433 convert_constant_check_range_bitand(size_t nsz, size_t osz, 2434 uint64_t xmask, const val_t *nv, 2435 tspec_t ot, const val_t *v, 2436 const type_t *tp, op_t op) 2437 { 2438 if (nsz > osz && 2439 (nv->v_quad & bit((unsigned int)(osz - 1))) != 0 && 2440 (nv->v_quad & xmask) != xmask) { 2441 /* extra bits set to 0 in conversion of '%s' to '%s', ... */ 2442 warning(309, type_name(gettyp(ot)), 2443 type_name(tp), op_name(op)); 2444 } else if (nsz < osz && 2445 (v->v_quad & xmask) != xmask && 2446 (v->v_quad & xmask) != 0) { 2447 /* constant truncated by conversion, op %s */ 2448 warning(306, op_name(op)); 2449 } 2450 } 2451 2452 static void 2453 convert_constant_check_range_signed(op_t op, int arg) 2454 { 2455 if (op == ASSIGN) { 2456 /* assignment of negative constant to unsigned type */ 2457 warning(164); 2458 } else if (op == INIT) { 2459 /* initialization of unsigned with negative constant */ 2460 warning(221); 2461 } else if (op == FARG) { 2462 /* conversion of negative constant to unsigned type, ... */ 2463 warning(296, arg); 2464 } else if (modtab[op].m_comparison) { 2465 /* handled by check_integer_comparison() */ 2466 } else { 2467 /* conversion of negative constant to unsigned type */ 2468 warning(222); 2469 } 2470 } 2471 2472 /* 2473 * Loss of significant bit(s). All truncated bits 2474 * of unsigned types or all truncated bits plus the 2475 * msb of the target for signed types are considered 2476 * to be significant bits. Loss of significant bits 2477 * means that at least one of the bits was set in an 2478 * unsigned type or that at least one but not all of 2479 * the bits was set in a signed type. 2480 * Loss of significant bits means that it is not 2481 * possible, also not with necessary casts, to convert 2482 * back to the original type. A example for a 2483 * necessary cast is: 2484 * char c; int i; c = 128; 2485 * i = c; ** yields -128 ** 2486 * i = (unsigned char)c; ** yields 128 ** 2487 */ 2488 static void 2489 convert_constant_check_range_truncated(op_t op, int arg, const type_t *tp, 2490 tspec_t ot) 2491 { 2492 if (op == ASSIGN && tp->t_bitfield) { 2493 /* precision lost in bit-field assignment */ 2494 warning(166); 2495 } else if (op == ASSIGN) { 2496 /* constant truncated by assignment */ 2497 warning(165); 2498 } else if (op == INIT && tp->t_bitfield) { 2499 /* bit-field initializer does not fit */ 2500 warning(180); 2501 } else if (op == INIT) { 2502 /* initializer does not fit */ 2503 warning(178); 2504 } else if (op == CASE) { 2505 /* case label affected by conversion */ 2506 warning(196); 2507 } else if (op == FARG) { 2508 /* conversion of '%s' to '%s' is out of range, arg #%d */ 2509 warning(295, 2510 type_name(gettyp(ot)), type_name(tp), arg); 2511 } else { 2512 /* conversion of '%s' to '%s' is out of range */ 2513 warning(119, 2514 type_name(gettyp(ot)), type_name(tp)); 2515 } 2516 } 2517 2518 static void 2519 convert_constant_check_range_loss(op_t op, int arg, const type_t *tp, 2520 tspec_t ot) 2521 { 2522 if (op == ASSIGN && tp->t_bitfield) { 2523 /* precision lost in bit-field assignment */ 2524 warning(166); 2525 } else if (op == INIT && tp->t_bitfield) { 2526 /* bit-field initializer out of range */ 2527 warning(11); 2528 } else if (op == CASE) { 2529 /* case label affected by conversion */ 2530 warning(196); 2531 } else if (op == FARG) { 2532 /* conversion of '%s' to '%s' is out of range, arg #%d */ 2533 warning(295, 2534 type_name(gettyp(ot)), type_name(tp), arg); 2535 } else { 2536 /* conversion of '%s' to '%s' is out of range */ 2537 warning(119, 2538 type_name(gettyp(ot)), type_name(tp)); 2539 } 2540 } 2541 2542 static void 2543 convert_constant_check_range(tspec_t ot, const type_t *tp, tspec_t nt, 2544 op_t op, int arg, const val_t *v, val_t *nv) 2545 { 2546 unsigned int osz, nsz; 2547 uint64_t xmask, xmsk1; 2548 2549 osz = size_in_bits(ot); 2550 nsz = tp->t_bitfield ? tp->t_flen : size_in_bits(nt); 2551 xmask = value_bits(nsz) ^ value_bits(osz); 2552 xmsk1 = value_bits(nsz) ^ value_bits(osz - 1); 2553 /* 2554 * For bitwise operations we are not interested in the 2555 * value, but in the bits itself. 2556 */ 2557 if (op == ORASS || op == BITOR || op == BITXOR) { 2558 convert_constant_check_range_bitor(nsz, osz, v, xmask, op); 2559 } else if (op == ANDASS || op == BITAND) { 2560 convert_constant_check_range_bitand(nsz, osz, xmask, nv, ot, 2561 v, tp, op); 2562 } else if ((nt != PTR && is_uinteger(nt)) && 2563 (ot != PTR && !is_uinteger(ot)) && 2564 v->v_quad < 0) { 2565 convert_constant_check_range_signed(op, arg); 2566 } else if (nv->v_quad != v->v_quad && nsz <= osz && 2567 (v->v_quad & xmask) != 0 && 2568 (is_uinteger(ot) || (v->v_quad & xmsk1) != xmsk1)) { 2569 convert_constant_check_range_truncated(op, arg, tp, ot); 2570 } else if (nv->v_quad != v->v_quad) { 2571 convert_constant_check_range_loss(op, arg, tp, ot); 2572 } 2573 } 2574 2575 /* 2576 * Converts a typed constant to a constant of another type. 2577 * 2578 * op operator which requires conversion 2579 * arg if op is FARG, # of argument 2580 * tp type in which to convert the constant 2581 * nv new constant 2582 * v old constant 2583 */ 2584 void 2585 convert_constant(op_t op, int arg, const type_t *tp, val_t *nv, val_t *v) 2586 { 2587 tspec_t ot, nt; 2588 unsigned int sz; 2589 bool range_check; 2590 2591 /* 2592 * TODO: make 'v' const; the name of this function does not suggest 2593 * that it modifies 'v'. 2594 */ 2595 ot = v->v_tspec; 2596 nt = nv->v_tspec = tp->t_tspec; 2597 range_check = false; 2598 2599 if (nt == BOOL) { /* C99 6.3.1.2 */ 2600 nv->v_unsigned_since_c90 = false; 2601 nv->v_quad = is_nonzero_val(v) ? 1 : 0; 2602 return; 2603 } 2604 2605 if (ot == FLOAT || ot == DOUBLE || ot == LDOUBLE) { 2606 convert_constant_floating(op, arg, ot, tp, nt, v, nv); 2607 } else if (!convert_constant_to_floating(nt, nv, ot, v)) { 2608 range_check = true; /* Check for lost precision. */ 2609 nv->v_quad = v->v_quad; 2610 } 2611 2612 if ((v->v_unsigned_since_c90 && is_floating(nt)) || 2613 (v->v_unsigned_since_c90 && (is_integer(nt) && !is_uinteger(nt) && 2614 portable_size_in_bits(nt) > 2615 portable_size_in_bits(ot)))) { 2616 /* ANSI C treats constant as unsigned */ 2617 warning(157); 2618 v->v_unsigned_since_c90 = false; 2619 } 2620 2621 if (is_integer(nt)) { 2622 sz = tp->t_bitfield ? tp->t_flen : size_in_bits(nt); 2623 nv->v_quad = convert_integer(nv->v_quad, nt, sz); 2624 } 2625 2626 if (range_check && op != CVT) 2627 convert_constant_check_range(ot, tp, nt, op, arg, v, nv); 2628 } 2629 2630 /* 2631 * Called if incompatible types were detected. 2632 * Prints a appropriate warning. 2633 */ 2634 static void 2635 warn_incompatible_types(op_t op, 2636 const type_t *ltp, tspec_t lt, 2637 const type_t *rtp, tspec_t rt) 2638 { 2639 const mod_t *mp; 2640 2641 mp = &modtab[op]; 2642 2643 if (lt == VOID || (mp->m_binary && rt == VOID)) { 2644 /* void type illegal in expression */ 2645 error(109); 2646 } else if (op == ASSIGN) { 2647 if ((lt == STRUCT || lt == UNION) && 2648 (rt == STRUCT || rt == UNION)) { 2649 /* assignment of different structures (%s != %s) */ 2650 error(240, tspec_name(lt), tspec_name(rt)); 2651 } else { 2652 /* cannot assign to '%s' from '%s' */ 2653 error(171, type_name(ltp), type_name(rtp)); 2654 } 2655 } else if (mp->m_binary) { 2656 /* operands of '%s' have incompatible types (%s != %s) */ 2657 error(107, mp->m_name, tspec_name(lt), tspec_name(rt)); 2658 } else { 2659 lint_assert(rt == NOTSPEC); 2660 /* operand of '%s' has invalid type (%s) */ 2661 error(108, mp->m_name, tspec_name(lt)); 2662 } 2663 } 2664 2665 /* 2666 * Called if incompatible pointer types are detected. 2667 * Print an appropriate warning. 2668 */ 2669 static void 2670 warn_incompatible_pointers(const mod_t *mp, 2671 const type_t *ltp, const type_t *rtp) 2672 { 2673 tspec_t lt, rt; 2674 2675 lint_assert(ltp->t_tspec == PTR); 2676 lint_assert(rtp->t_tspec == PTR); 2677 2678 lt = ltp->t_subt->t_tspec; 2679 rt = rtp->t_subt->t_tspec; 2680 2681 if ((lt == STRUCT || lt == UNION) && (rt == STRUCT || rt == UNION)) { 2682 if (mp == NULL) { 2683 /* illegal structure pointer combination */ 2684 warning(244); 2685 } else { 2686 /* incompatible structure pointers: '%s' '%s' '%s' */ 2687 warning(245, type_name(ltp), mp->m_name, type_name(rtp)); 2688 } 2689 } else { 2690 if (mp == NULL) { 2691 /* illegal combination of '%s' and '%s' */ 2692 warning(184, type_name(ltp), type_name(rtp)); 2693 } else { 2694 /* illegal combination of '%s' and '%s', op '%s' */ 2695 warning(124, 2696 type_name(ltp), type_name(rtp), mp->m_name); 2697 } 2698 } 2699 } 2700 2701 /* Return a type based on tp1, with added qualifiers from tp2. */ 2702 static type_t * 2703 merge_qualifiers(type_t *tp1, const type_t *tp2) 2704 { 2705 type_t *ntp, *nstp; 2706 2707 lint_assert(tp1->t_tspec == PTR); 2708 lint_assert(tp2->t_tspec == PTR); 2709 2710 bool c1 = tp1->t_subt->t_const; 2711 bool c2 = tp2->t_subt->t_const; 2712 bool v1 = tp1->t_subt->t_volatile; 2713 bool v2 = tp2->t_subt->t_volatile; 2714 2715 if (c1 == (c1 | c2) && v1 == (v1 | v2)) 2716 return tp1; 2717 2718 nstp = expr_dup_type(tp1->t_subt); 2719 nstp->t_const |= c2; 2720 nstp->t_volatile |= v2; 2721 2722 ntp = expr_dup_type(tp1); 2723 ntp->t_subt = nstp; 2724 return ntp; 2725 } 2726 2727 /* 2728 * Returns true if the given structure or union has a constant member 2729 * (maybe recursively). 2730 */ 2731 static bool 2732 has_constant_member(const type_t *tp) 2733 { 2734 sym_t *m; 2735 2736 lint_assert(is_struct_or_union(tp->t_tspec)); 2737 2738 for (m = tp->t_str->sou_first_member; m != NULL; m = m->s_next) { 2739 const type_t *mtp = m->s_type; 2740 if (mtp->t_const) 2741 return true; 2742 if (is_struct_or_union(mtp->t_tspec) && 2743 has_constant_member(mtp)) 2744 return true; 2745 } 2746 return false; 2747 } 2748 2749 /* 2750 * Create a new node for one of the operators POINT and ARROW. 2751 */ 2752 static tnode_t * 2753 build_struct_access(op_t op, tnode_t *ln, tnode_t *rn) 2754 { 2755 tnode_t *ntn, *ctn; 2756 bool nolval; 2757 2758 lint_assert(rn->tn_op == NAME); 2759 lint_assert(rn->tn_sym->s_value.v_tspec == INT); 2760 lint_assert(rn->tn_sym->s_scl == MOS || rn->tn_sym->s_scl == MOU); 2761 2762 /* 2763 * Remember if the left operand is an lvalue (structure members 2764 * are lvalues if and only if the structure itself is an lvalue). 2765 */ 2766 nolval = op == POINT && !ln->tn_lvalue; 2767 2768 if (op == POINT) { 2769 ln = build_address(ln, true); 2770 } else if (ln->tn_type->t_tspec != PTR) { 2771 lint_assert(tflag); 2772 lint_assert(is_integer(ln->tn_type->t_tspec)); 2773 ln = convert(NOOP, 0, expr_derive_type(gettyp(VOID), PTR), ln); 2774 } 2775 2776 ctn = build_integer_constant(PTRDIFF_TSPEC, 2777 rn->tn_sym->s_value.v_quad / CHAR_SIZE); 2778 2779 ntn = new_tnode(PLUS, expr_derive_type(rn->tn_type, PTR), ln, ctn); 2780 if (ln->tn_op == CON) 2781 ntn = fold(ntn); 2782 2783 if (rn->tn_type->t_bitfield) { 2784 ntn = new_tnode(FSEL, ntn->tn_type->t_subt, ntn, NULL); 2785 } else { 2786 ntn = new_tnode(INDIR, ntn->tn_type->t_subt, ntn, NULL); 2787 } 2788 2789 if (nolval) 2790 ntn->tn_lvalue = false; 2791 2792 return ntn; 2793 } 2794 2795 /* 2796 * Create a node for INCAFT, INCBEF, DECAFT and DECBEF. 2797 */ 2798 static tnode_t * 2799 build_prepost_incdec(op_t op, tnode_t *ln) 2800 { 2801 tnode_t *cn, *ntn; 2802 2803 lint_assert(ln != NULL); 2804 2805 if (ln->tn_type->t_tspec == PTR) { 2806 cn = plength(ln->tn_type); 2807 } else { 2808 cn = build_integer_constant(INT, (int64_t)1); 2809 } 2810 ntn = new_tnode(op, ln->tn_type, ln, cn); 2811 2812 return ntn; 2813 } 2814 2815 /* 2816 * Create a node for REAL, IMAG 2817 */ 2818 static tnode_t * 2819 build_real_imag(op_t op, tnode_t *ln) 2820 { 2821 tnode_t *cn, *ntn; 2822 2823 lint_assert(ln != NULL); 2824 2825 if (ln->tn_op == NAME) { 2826 /* 2827 * This may be too much, but it avoids wrong warnings. 2828 * See d_c99_complex_split.c. 2829 */ 2830 mark_as_used(ln->tn_sym, false, false); 2831 mark_as_set(ln->tn_sym); 2832 } 2833 2834 switch (ln->tn_type->t_tspec) { 2835 case LCOMPLEX: 2836 /* XXX: integer and LDOUBLE don't match. */ 2837 cn = build_integer_constant(LDOUBLE, (int64_t)1); 2838 break; 2839 case DCOMPLEX: 2840 /* XXX: integer and DOUBLE don't match. */ 2841 cn = build_integer_constant(DOUBLE, (int64_t)1); 2842 break; 2843 case FCOMPLEX: 2844 /* XXX: integer and FLOAT don't match. */ 2845 cn = build_integer_constant(FLOAT, (int64_t)1); 2846 break; 2847 default: 2848 /* __%s__ is illegal for type %s */ 2849 error(276, op == REAL ? "real" : "imag", 2850 type_name(ln->tn_type)); 2851 return NULL; 2852 } 2853 ntn = new_tnode(op, cn->tn_type, ln, cn); 2854 ntn->tn_lvalue = true; 2855 2856 return ntn; 2857 } 2858 2859 /* 2860 * Create a tree node for the unary & operator 2861 */ 2862 static tnode_t * 2863 build_address(tnode_t *tn, bool noign) 2864 { 2865 tspec_t t; 2866 2867 if (!noign && ((t = tn->tn_type->t_tspec) == ARRAY || t == FUNC)) { 2868 if (tflag) 2869 /* '&' before array or function: ignored */ 2870 warning(127); 2871 return tn; 2872 } 2873 2874 /* eliminate &* */ 2875 if (tn->tn_op == INDIR && 2876 tn->tn_left->tn_type->t_tspec == PTR && 2877 tn->tn_left->tn_type->t_subt == tn->tn_type) { 2878 return tn->tn_left; 2879 } 2880 2881 return new_tnode(ADDR, expr_derive_type(tn->tn_type, PTR), tn, NULL); 2882 } 2883 2884 /* 2885 * Create a node for operators PLUS and MINUS. 2886 */ 2887 static tnode_t * 2888 build_plus_minus(op_t op, tnode_t *ln, tnode_t *rn) 2889 { 2890 tnode_t *ntn, *ctn; 2891 type_t *tp; 2892 2893 /* If pointer and integer, then pointer to the lhs. */ 2894 if (rn->tn_type->t_tspec == PTR && is_integer(ln->tn_type->t_tspec)) { 2895 ntn = ln; 2896 ln = rn; 2897 rn = ntn; 2898 } 2899 2900 if (ln->tn_type->t_tspec == PTR && rn->tn_type->t_tspec != PTR) { 2901 lint_assert(is_integer(rn->tn_type->t_tspec)); 2902 2903 check_ctype_macro_invocation(ln, rn); 2904 check_enum_array_index(ln, rn); 2905 2906 ctn = plength(ln->tn_type); 2907 if (rn->tn_type->t_tspec != ctn->tn_type->t_tspec) 2908 rn = convert(NOOP, 0, ctn->tn_type, rn); 2909 rn = new_tnode(MULT, rn->tn_type, rn, ctn); 2910 if (rn->tn_left->tn_op == CON) 2911 rn = fold(rn); 2912 ntn = new_tnode(op, ln->tn_type, ln, rn); 2913 2914 } else if (rn->tn_type->t_tspec == PTR) { 2915 2916 lint_assert(ln->tn_type->t_tspec == PTR); 2917 lint_assert(op == MINUS); 2918 tp = gettyp(PTRDIFF_TSPEC); 2919 ntn = new_tnode(op, tp, ln, rn); 2920 if (ln->tn_op == CON && rn->tn_op == CON) 2921 ntn = fold(ntn); 2922 ctn = plength(ln->tn_type); 2923 balance(NOOP, &ntn, &ctn); 2924 ntn = new_tnode(DIV, tp, ntn, ctn); 2925 2926 } else { 2927 2928 ntn = new_tnode(op, ln->tn_type, ln, rn); 2929 2930 } 2931 return ntn; 2932 } 2933 2934 /* 2935 * Create a node for operators SHL and SHR. 2936 */ 2937 static tnode_t * 2938 build_bit_shift(op_t op, tnode_t *ln, tnode_t *rn) 2939 { 2940 tspec_t t; 2941 tnode_t *ntn; 2942 2943 if ((t = rn->tn_type->t_tspec) != INT && t != UINT) 2944 rn = convert(CVT, 0, gettyp(INT), rn); 2945 ntn = new_tnode(op, ln->tn_type, ln, rn); 2946 return ntn; 2947 } 2948 2949 /* 2950 * Create a node for COLON. 2951 */ 2952 static tnode_t * 2953 build_colon(tnode_t *ln, tnode_t *rn) 2954 { 2955 tspec_t lt, rt, pdt; 2956 type_t *tp; 2957 tnode_t *ntn; 2958 2959 lt = ln->tn_type->t_tspec; 2960 rt = rn->tn_type->t_tspec; 2961 pdt = PTRDIFF_TSPEC; 2962 2963 /* 2964 * Arithmetic types are balanced, all other type combinations 2965 * still need to be handled. 2966 */ 2967 if (is_arithmetic(lt) && is_arithmetic(rt)) { 2968 tp = ln->tn_type; 2969 } else if (lt == BOOL && rt == BOOL) { 2970 tp = ln->tn_type; 2971 } else if (lt == VOID || rt == VOID) { 2972 tp = gettyp(VOID); 2973 } else if (lt == STRUCT || lt == UNION) { 2974 /* Both types must be identical. */ 2975 lint_assert(rt == STRUCT || rt == UNION); 2976 lint_assert(ln->tn_type->t_str == rn->tn_type->t_str); 2977 if (is_incomplete(ln->tn_type)) { 2978 /* unknown operand size, op %s */ 2979 error(138, op_name(COLON)); 2980 return NULL; 2981 } 2982 tp = ln->tn_type; 2983 } else if (lt == PTR && is_integer(rt)) { 2984 if (rt != pdt) { 2985 rn = convert(NOOP, 0, gettyp(pdt), rn); 2986 rt = pdt; 2987 } 2988 tp = ln->tn_type; 2989 } else if (rt == PTR && is_integer(lt)) { 2990 if (lt != pdt) { 2991 ln = convert(NOOP, 0, gettyp(pdt), ln); 2992 lt = pdt; 2993 } 2994 tp = rn->tn_type; 2995 } else if (lt == PTR && ln->tn_type->t_subt->t_tspec == VOID) { 2996 tp = merge_qualifiers(rn->tn_type, ln->tn_type); 2997 } else if (rt == PTR && rn->tn_type->t_subt->t_tspec == VOID) { 2998 tp = merge_qualifiers(ln->tn_type, rn->tn_type); 2999 } else { 3000 /* 3001 * XXX For now we simply take the left type. This is 3002 * probably wrong, if one type contains a function prototype 3003 * and the other one, at the same place, only an old style 3004 * declaration. 3005 */ 3006 tp = merge_qualifiers(ln->tn_type, rn->tn_type); 3007 } 3008 3009 ntn = new_tnode(COLON, tp, ln, rn); 3010 3011 return ntn; 3012 } 3013 3014 /* 3015 * Create a node for an assignment operator (both = and op= ). 3016 */ 3017 static tnode_t * 3018 build_assignment(op_t op, tnode_t *ln, tnode_t *rn) 3019 { 3020 tspec_t lt, rt; 3021 tnode_t *ntn, *ctn; 3022 3023 lint_assert(ln != NULL); 3024 lint_assert(rn != NULL); 3025 3026 lt = ln->tn_type->t_tspec; 3027 rt = rn->tn_type->t_tspec; 3028 3029 if ((op == ADDASS || op == SUBASS) && lt == PTR) { 3030 lint_assert(is_integer(rt)); 3031 ctn = plength(ln->tn_type); 3032 if (rn->tn_type->t_tspec != ctn->tn_type->t_tspec) 3033 rn = convert(NOOP, 0, ctn->tn_type, rn); 3034 rn = new_tnode(MULT, rn->tn_type, rn, ctn); 3035 if (rn->tn_left->tn_op == CON) 3036 rn = fold(rn); 3037 } 3038 3039 if ((op == ASSIGN || op == RETURN || op == INIT) && 3040 (lt == STRUCT || rt == STRUCT)) { 3041 lint_assert(lt == rt); 3042 lint_assert(ln->tn_type->t_str == rn->tn_type->t_str); 3043 if (is_incomplete(ln->tn_type)) { 3044 if (op == RETURN) { 3045 /* cannot return incomplete type */ 3046 error(212); 3047 } else { 3048 /* unknown operand size, op %s */ 3049 error(138, op_name(op)); 3050 } 3051 return NULL; 3052 } 3053 } 3054 3055 if (op == SHLASS) { 3056 if (portable_size_in_bits(lt) < portable_size_in_bits(rt)) { 3057 if (hflag) 3058 /* semantics of '%s' change in ANSI C; ... */ 3059 warning(118, "<<="); 3060 } 3061 } else if (op != SHRASS) { 3062 if (op == ASSIGN || lt != PTR) { 3063 if (lt != rt || 3064 (ln->tn_type->t_bitfield && rn->tn_op == CON)) { 3065 rn = convert(op, 0, ln->tn_type, rn); 3066 rt = lt; 3067 } 3068 } 3069 } 3070 3071 ntn = new_tnode(op, ln->tn_type, ln, rn); 3072 3073 return ntn; 3074 } 3075 3076 /* 3077 * Get length of type tp->t_subt, as a constant expression of type ptrdiff_t 3078 * as seen from the target platform. 3079 */ 3080 static tnode_t * 3081 plength(type_t *tp) 3082 { 3083 int elem, elsz_in_bits; 3084 3085 lint_assert(tp->t_tspec == PTR); 3086 tp = tp->t_subt; 3087 3088 elem = 1; 3089 elsz_in_bits = 0; 3090 3091 while (tp->t_tspec == ARRAY) { 3092 elem *= tp->t_dim; 3093 tp = tp->t_subt; 3094 } 3095 3096 switch (tp->t_tspec) { 3097 case FUNC: 3098 /* pointer to function is not allowed here */ 3099 error(110); 3100 break; 3101 case VOID: 3102 /* cannot do pointer arithmetic on operand of unknown size */ 3103 gnuism(136); 3104 break; 3105 case STRUCT: 3106 case UNION: 3107 if ((elsz_in_bits = tp->t_str->sou_size_in_bits) == 0) 3108 /* cannot do pointer arithmetic on operand of ... */ 3109 error(136); 3110 break; 3111 case ENUM: 3112 if (is_incomplete(tp)) { 3113 /* cannot do pointer arithmetic on operand of ... */ 3114 warning(136); 3115 } 3116 /* FALLTHROUGH */ 3117 default: 3118 if ((elsz_in_bits = size_in_bits(tp->t_tspec)) == 0) { 3119 /* cannot do pointer arithmetic on operand of ... */ 3120 error(136); 3121 } else { 3122 lint_assert(elsz_in_bits != -1); 3123 } 3124 break; 3125 } 3126 3127 if (elem == 0 && elsz_in_bits != 0) { 3128 /* cannot do pointer arithmetic on operand of unknown size */ 3129 error(136); 3130 } 3131 3132 if (elsz_in_bits == 0) 3133 elsz_in_bits = CHAR_SIZE; 3134 3135 return build_integer_constant(PTRDIFF_TSPEC, 3136 (int64_t)(elem * elsz_in_bits / CHAR_SIZE)); 3137 } 3138 3139 /* 3140 * XXX 3141 * Note: There appear to be a number of bugs in detecting overflow in 3142 * this function. An audit and a set of proper regression tests are needed. 3143 * --Perry Metzger, Nov. 16, 2001 3144 */ 3145 /* 3146 * Do only as much as necessary to compute constant expressions. 3147 * Called only if the operator allows folding and all operands are constants. 3148 */ 3149 static tnode_t * 3150 fold(tnode_t *tn) 3151 { 3152 val_t *v; 3153 tspec_t t; 3154 bool utyp, ovfl; 3155 int64_t sl, sr = 0, q = 0, mask; 3156 uint64_t ul, ur = 0; 3157 tnode_t *cn; 3158 3159 v = xcalloc(1, sizeof(*v)); 3160 v->v_tspec = tn->tn_type->t_tspec; 3161 3162 t = tn->tn_left->tn_type->t_tspec; 3163 utyp = !is_integer(t) || is_uinteger(t); 3164 ul = sl = tn->tn_left->tn_val->v_quad; 3165 if (is_binary(tn)) 3166 ur = sr = tn->tn_right->tn_val->v_quad; 3167 3168 mask = value_bits(size_in_bits(t)); 3169 ovfl = false; 3170 3171 switch (tn->tn_op) { 3172 case UPLUS: 3173 q = sl; 3174 break; 3175 case UMINUS: 3176 q = -sl; 3177 if (sl != 0 && msb(q, t) == msb(sl, t)) 3178 ovfl = true; 3179 break; 3180 case COMPL: 3181 q = ~sl; 3182 break; 3183 case MULT: 3184 if (utyp) { 3185 q = ul * ur; 3186 if (q != (q & mask)) 3187 ovfl = true; 3188 else if ((ul != 0) && ((q / ul) != ur)) 3189 ovfl = true; 3190 } else { 3191 q = sl * sr; 3192 if (msb(q, t) != (msb(sl, t) ^ msb(sr, t))) 3193 ovfl = true; 3194 } 3195 break; 3196 case DIV: 3197 if (sr == 0) { 3198 /* division by 0 */ 3199 error(139); 3200 q = utyp ? -1 : INT64_MAX; 3201 } else { 3202 q = utyp ? (int64_t)(ul / ur) : sl / sr; 3203 } 3204 break; 3205 case MOD: 3206 if (sr == 0) { 3207 /* modulus by 0 */ 3208 error(140); 3209 q = 0; 3210 } else { 3211 q = utyp ? (int64_t)(ul % ur) : sl % sr; 3212 } 3213 break; 3214 case PLUS: 3215 q = utyp ? (int64_t)(ul + ur) : sl + sr; 3216 if (msb(sl, t) && msb(sr, t) && !msb(q, t)) 3217 ovfl = true; 3218 if (!utyp && !msb(sl, t) && !msb(sr, t) && msb(q, t)) 3219 ovfl = true; 3220 break; 3221 case MINUS: 3222 q = utyp ? (int64_t)(ul - ur) : sl - sr; 3223 if (!utyp && msb(sl, t) && !msb(sr, t) && !msb(q, t)) 3224 ovfl = true; 3225 if (!msb(sl, t) && msb(sr, t) && msb(q, t)) 3226 ovfl = true; 3227 break; 3228 case SHL: 3229 q = utyp ? (int64_t)(ul << sr) : sl << sr; 3230 break; 3231 case SHR: 3232 /* 3233 * The sign must be explicitly extended because 3234 * shifts of signed values are implementation dependent. 3235 */ 3236 q = ul >> sr; 3237 q = convert_integer(q, t, size_in_bits(t) - (int)sr); 3238 break; 3239 case LT: 3240 q = (utyp ? ul < ur : sl < sr) ? 1 : 0; 3241 break; 3242 case LE: 3243 q = (utyp ? ul <= ur : sl <= sr) ? 1 : 0; 3244 break; 3245 case GE: 3246 q = (utyp ? ul >= ur : sl >= sr) ? 1 : 0; 3247 break; 3248 case GT: 3249 q = (utyp ? ul > ur : sl > sr) ? 1 : 0; 3250 break; 3251 case EQ: 3252 q = (utyp ? ul == ur : sl == sr) ? 1 : 0; 3253 break; 3254 case NE: 3255 q = (utyp ? ul != ur : sl != sr) ? 1 : 0; 3256 break; 3257 case BITAND: 3258 q = utyp ? (int64_t)(ul & ur) : sl & sr; 3259 break; 3260 case BITXOR: 3261 q = utyp ? (int64_t)(ul ^ ur) : sl ^ sr; 3262 break; 3263 case BITOR: 3264 q = utyp ? (int64_t)(ul | ur) : sl | sr; 3265 break; 3266 default: 3267 lint_assert(/*CONSTCOND*/false); 3268 } 3269 3270 /* XXX does not work for quads. */ 3271 if (ovfl || 3272 ((uint64_t)(q | mask) != ~(uint64_t)0 && (q & ~mask) != 0)) { 3273 if (hflag) 3274 /* integer overflow detected, op '%s' */ 3275 warning(141, op_name(tn->tn_op)); 3276 } 3277 3278 v->v_quad = convert_integer(q, t, 0); 3279 3280 cn = build_constant(tn->tn_type, v); 3281 if (tn->tn_left->tn_system_dependent) 3282 cn->tn_system_dependent = true; 3283 if (is_binary(tn) && tn->tn_right->tn_system_dependent) 3284 cn->tn_system_dependent = true; 3285 3286 return cn; 3287 } 3288 3289 /* 3290 * Fold constant nodes, as much as is needed for comparing the value with 0 3291 * (test context, for controlling expressions). 3292 */ 3293 static tnode_t * 3294 fold_test(tnode_t *tn) 3295 { 3296 bool l, r; 3297 val_t *v; 3298 3299 v = xcalloc(1, sizeof(*v)); 3300 v->v_tspec = tn->tn_type->t_tspec; 3301 lint_assert(v->v_tspec == INT || (Tflag && v->v_tspec == BOOL)); 3302 3303 l = constant_is_nonzero(tn->tn_left); 3304 r = is_binary(tn) && constant_is_nonzero(tn->tn_right); 3305 3306 switch (tn->tn_op) { 3307 case NOT: 3308 if (hflag && !constcond_flag) 3309 /* constant argument to '!' */ 3310 warning(239); 3311 v->v_quad = !l ? 1 : 0; 3312 break; 3313 case LOGAND: 3314 v->v_quad = l && r ? 1 : 0; 3315 break; 3316 case LOGOR: 3317 v->v_quad = l || r ? 1 : 0; 3318 break; 3319 default: 3320 lint_assert(/*CONSTCOND*/false); 3321 } 3322 3323 return build_constant(tn->tn_type, v); 3324 } 3325 3326 static ldbl_t 3327 floating_error_value(tspec_t t, ldbl_t lv) 3328 { 3329 if (t == FLOAT) { 3330 return lv < 0 ? -FLT_MAX : FLT_MAX; 3331 } else if (t == DOUBLE) { 3332 return lv < 0 ? -DBL_MAX : DBL_MAX; 3333 } else { 3334 /* LINTED 248: floating-point constant out of range */ 3335 ldbl_t max = LDBL_MAX; 3336 return lv < 0 ? -max : max; 3337 } 3338 } 3339 3340 /* 3341 * Fold constant nodes having operands with floating point type. 3342 */ 3343 static tnode_t * 3344 fold_float(tnode_t *tn) 3345 { 3346 val_t *v; 3347 tspec_t t; 3348 ldbl_t lv, rv = 0; 3349 3350 fpe = 0; 3351 v = xcalloc(1, sizeof(*v)); 3352 v->v_tspec = t = tn->tn_type->t_tspec; 3353 3354 lint_assert(is_floating(t)); 3355 lint_assert(t == tn->tn_left->tn_type->t_tspec); 3356 lint_assert(!is_binary(tn) || t == tn->tn_right->tn_type->t_tspec); 3357 3358 lv = tn->tn_left->tn_val->v_ldbl; 3359 if (is_binary(tn)) 3360 rv = tn->tn_right->tn_val->v_ldbl; 3361 3362 switch (tn->tn_op) { 3363 case UPLUS: 3364 v->v_ldbl = lv; 3365 break; 3366 case UMINUS: 3367 v->v_ldbl = -lv; 3368 break; 3369 case MULT: 3370 v->v_ldbl = lv * rv; 3371 break; 3372 case DIV: 3373 if (rv == 0.0) { 3374 /* division by 0 */ 3375 error(139); 3376 v->v_ldbl = floating_error_value(t, lv); 3377 } else { 3378 v->v_ldbl = lv / rv; 3379 } 3380 break; 3381 case PLUS: 3382 v->v_ldbl = lv + rv; 3383 break; 3384 case MINUS: 3385 v->v_ldbl = lv - rv; 3386 break; 3387 case LT: 3388 v->v_quad = lv < rv ? 1 : 0; 3389 break; 3390 case LE: 3391 v->v_quad = lv <= rv ? 1 : 0; 3392 break; 3393 case GE: 3394 v->v_quad = lv >= rv ? 1 : 0; 3395 break; 3396 case GT: 3397 v->v_quad = lv > rv ? 1 : 0; 3398 break; 3399 case EQ: 3400 v->v_quad = lv == rv ? 1 : 0; 3401 break; 3402 case NE: 3403 v->v_quad = lv != rv ? 1 : 0; 3404 break; 3405 default: 3406 lint_assert(/*CONSTCOND*/false); 3407 } 3408 3409 lint_assert(fpe != 0 || isnan((double)v->v_ldbl) == 0); 3410 if (fpe != 0 || isfinite((double)v->v_ldbl) == 0 || 3411 (t == FLOAT && 3412 (v->v_ldbl > FLT_MAX || v->v_ldbl < -FLT_MAX)) || 3413 (t == DOUBLE && 3414 (v->v_ldbl > DBL_MAX || v->v_ldbl < -DBL_MAX))) { 3415 /* floating point overflow detected, op %s */ 3416 warning(142, op_name(tn->tn_op)); 3417 v->v_ldbl = floating_error_value(t, v->v_ldbl); 3418 fpe = 0; 3419 } 3420 3421 return build_constant(tn->tn_type, v); 3422 } 3423 3424 3425 /* 3426 * Create a constant node for sizeof. 3427 */ 3428 tnode_t * 3429 build_sizeof(const type_t *tp) 3430 { 3431 unsigned int size_in_bytes = type_size_in_bits(tp) / CHAR_SIZE; 3432 tnode_t *tn = build_integer_constant(SIZEOF_TSPEC, size_in_bytes); 3433 tn->tn_system_dependent = true; 3434 return tn; 3435 } 3436 3437 /* 3438 * Create a constant node for offsetof. 3439 */ 3440 /* ARGSUSED */ /* See implementation comments. */ 3441 tnode_t * 3442 build_offsetof(const type_t *tp, const sym_t *sym) 3443 { 3444 tspec_t t = tp->t_tspec; 3445 if (t != STRUCT && t != UNION) 3446 /* unacceptable operand of '%s' */ 3447 error(111, "offsetof"); 3448 3449 // XXX: wrong size, no checking for sym fixme 3450 unsigned int offset_in_bytes = type_size_in_bits(tp) / CHAR_SIZE; 3451 tnode_t *tn = build_integer_constant(SIZEOF_TSPEC, offset_in_bytes); 3452 tn->tn_system_dependent = true; 3453 return tn; 3454 } 3455 3456 unsigned int 3457 type_size_in_bits(const type_t *tp) 3458 { 3459 unsigned int elem, elsz; 3460 bool flex; 3461 3462 elem = 1; 3463 flex = false; 3464 while (tp->t_tspec == ARRAY) { 3465 flex = true; /* allow c99 flex arrays [] [0] */ 3466 elem *= tp->t_dim; 3467 tp = tp->t_subt; 3468 } 3469 if (elem == 0) { 3470 if (!flex) { 3471 /* cannot take size/alignment of incomplete type */ 3472 error(143); 3473 elem = 1; 3474 } 3475 } 3476 switch (tp->t_tspec) { 3477 case FUNC: 3478 /* cannot take size/alignment of function */ 3479 error(144); 3480 elsz = 1; 3481 break; 3482 case STRUCT: 3483 case UNION: 3484 if (is_incomplete(tp)) { 3485 /* cannot take size/alignment of incomplete type */ 3486 error(143); 3487 elsz = 1; 3488 } else { 3489 elsz = tp->t_str->sou_size_in_bits; 3490 } 3491 break; 3492 case ENUM: 3493 if (is_incomplete(tp)) { 3494 /* cannot take size/alignment of incomplete type */ 3495 warning(143); 3496 } 3497 /* FALLTHROUGH */ 3498 default: 3499 if (tp->t_bitfield) { 3500 /* cannot take size/alignment of bit-field */ 3501 error(145); 3502 } 3503 if (tp->t_tspec == VOID) { 3504 /* cannot take size/alignment of void */ 3505 error(146); 3506 elsz = 1; 3507 } else { 3508 elsz = size_in_bits(tp->t_tspec); 3509 lint_assert(elsz > 0); 3510 } 3511 break; 3512 } 3513 3514 return elem * elsz; 3515 } 3516 3517 tnode_t * 3518 build_alignof(const type_t *tp) 3519 { 3520 switch (tp->t_tspec) { 3521 case ARRAY: 3522 break; 3523 3524 case FUNC: 3525 /* cannot take size/alignment of function */ 3526 error(144); 3527 return 0; 3528 3529 case STRUCT: 3530 case UNION: 3531 if (is_incomplete(tp)) { 3532 /* cannot take size/alignment of incomplete type */ 3533 error(143); 3534 return 0; 3535 } 3536 break; 3537 case ENUM: 3538 break; 3539 default: 3540 if (tp->t_bitfield) { 3541 /* cannot take size/alignment of bit-field */ 3542 error(145); 3543 return 0; 3544 } 3545 if (tp->t_tspec == VOID) { 3546 /* cannot take size/alignment of void */ 3547 error(146); 3548 return 0; 3549 } 3550 break; 3551 } 3552 3553 return build_integer_constant(SIZEOF_TSPEC, 3554 (int64_t)alignment_in_bits(tp) / CHAR_SIZE); 3555 } 3556 3557 /* 3558 * Type casts. 3559 */ 3560 tnode_t * 3561 cast(tnode_t *tn, type_t *tp) 3562 { 3563 tspec_t nt, ot; 3564 3565 if (tn == NULL) 3566 return NULL; 3567 3568 /* 3569 * XXX: checking for tp == NULL is only a quick fix for PR 22119. 3570 * The proper fix needs to be investigated properly. 3571 * See d_pr_22119.c for how to get here. 3572 */ 3573 if (tp == NULL) 3574 return NULL; 3575 3576 tn = cconv(tn); 3577 3578 nt = tp->t_tspec; 3579 ot = tn->tn_type->t_tspec; 3580 3581 if (nt == VOID) { 3582 /* 3583 * XXX ANSI C requires scalar types or void (Plauger & Brodie). 3584 * But this seems really questionable. 3585 */ 3586 } else if (nt == UNION) { 3587 sym_t *m; 3588 struct_or_union *str = tp->t_str; 3589 if (!gflag) { 3590 /* union cast is a GCC extension */ 3591 error(328); 3592 return NULL; 3593 } 3594 for (m = str->sou_first_member; m != NULL; m = m->s_next) { 3595 if (eqtype(m->s_type, tn->tn_type, 3596 false, false, NULL)) { 3597 tn = expr_zalloc_tnode(); 3598 tn->tn_op = CVT; 3599 tn->tn_type = tp; 3600 tn->tn_cast = true; 3601 tn->tn_right = NULL; 3602 return tn; 3603 } 3604 } 3605 /* type '%s' is not a member of '%s' */ 3606 error(329, type_name(tn->tn_type), type_name(tp)); 3607 return NULL; 3608 } else if (nt == STRUCT || nt == ARRAY || nt == FUNC) { 3609 /* Casting to a struct is an undocumented GCC extension. */ 3610 if (!(gflag && nt == STRUCT)) 3611 goto invalid_cast; 3612 } else if (ot == STRUCT || ot == UNION) { 3613 goto invalid_cast; 3614 } else if (ot == VOID) { 3615 /* improper cast of void expression */ 3616 error(148); 3617 return NULL; 3618 } else if (is_integer(nt) && is_scalar(ot)) { 3619 /* ok */ 3620 } else if (is_floating(nt) && is_arithmetic(ot)) { 3621 /* ok */ 3622 } else if (nt == PTR && is_integer(ot)) { 3623 /* ok */ 3624 } else if (nt == PTR && ot == PTR) { 3625 if (!tp->t_subt->t_const && tn->tn_type->t_subt->t_const) { 3626 if (hflag) 3627 /* cast discards 'const' from type '%s' */ 3628 warning(275, type_name(tn->tn_type)); 3629 } 3630 } else 3631 goto invalid_cast; 3632 3633 tn = convert(CVT, 0, tp, tn); 3634 tn->tn_cast = true; 3635 3636 return tn; 3637 3638 invalid_cast: 3639 /* invalid cast from '%s' to '%s' */ 3640 error(147, type_name(tn->tn_type), type_name(tp)); 3641 return NULL; 3642 } 3643 3644 /* 3645 * Create the node for a function argument. 3646 * All necessary conversions and type checks are done in 3647 * build_function_call because build_function_argument has no 3648 * information about expected argument types. 3649 */ 3650 tnode_t * 3651 build_function_argument(tnode_t *args, tnode_t *arg) 3652 { 3653 tnode_t *ntn; 3654 3655 /* 3656 * If there was a serious error in the expression for the argument, 3657 * create a dummy argument so the positions of the remaining arguments 3658 * will not change. 3659 */ 3660 if (arg == NULL) 3661 arg = build_integer_constant(INT, 0); 3662 3663 ntn = new_tnode(PUSH, arg->tn_type, arg, args); 3664 3665 return ntn; 3666 } 3667 3668 /* 3669 * Create the node for a function call. Also check types of 3670 * function arguments and insert conversions, if necessary. 3671 */ 3672 tnode_t * 3673 build_function_call(tnode_t *func, tnode_t *args) 3674 { 3675 tnode_t *ntn; 3676 op_t fcop; 3677 3678 if (func == NULL) 3679 return NULL; 3680 3681 if (func->tn_op == NAME && func->tn_type->t_tspec == FUNC) { 3682 fcop = CALL; 3683 } else { 3684 fcop = ICALL; 3685 } 3686 3687 check_ctype_function_call(func, args); 3688 3689 /* 3690 * after cconv() func will always be a pointer to a function 3691 * if it is a valid function designator. 3692 */ 3693 func = cconv(func); 3694 3695 if (func->tn_type->t_tspec != PTR || 3696 func->tn_type->t_subt->t_tspec != FUNC) { 3697 /* illegal function (type %s) */ 3698 error(149, type_name(func->tn_type)); 3699 return NULL; 3700 } 3701 3702 args = check_function_arguments(func->tn_type->t_subt, args); 3703 3704 ntn = new_tnode(fcop, func->tn_type->t_subt->t_subt, func, args); 3705 3706 return ntn; 3707 } 3708 3709 /* 3710 * Check types of all function arguments and insert conversions, 3711 * if necessary. 3712 */ 3713 static tnode_t * 3714 check_function_arguments(type_t *ftp, tnode_t *args) 3715 { 3716 tnode_t *arg; 3717 sym_t *asym; 3718 tspec_t at; 3719 int narg, npar, n, i; 3720 3721 /* get # of args in the prototype */ 3722 npar = 0; 3723 for (asym = ftp->t_args; asym != NULL; asym = asym->s_next) 3724 npar++; 3725 3726 /* get # of args in function call */ 3727 narg = 0; 3728 for (arg = args; arg != NULL; arg = arg->tn_right) 3729 narg++; 3730 3731 asym = ftp->t_args; 3732 if (ftp->t_proto && npar != narg && !(ftp->t_vararg && npar < narg)) { 3733 /* argument mismatch: %d arg%s passed, %d expected */ 3734 error(150, narg, narg > 1 ? "s" : "", npar); 3735 asym = NULL; 3736 } 3737 3738 for (n = 1; n <= narg; n++) { 3739 3740 /* 3741 * The rightmost argument is at the top of the argument 3742 * subtree. 3743 */ 3744 for (i = narg, arg = args; i > n; i--, arg = arg->tn_right) 3745 continue; 3746 3747 /* some things which are always not allowed */ 3748 if ((at = arg->tn_left->tn_type->t_tspec) == VOID) { 3749 /* void expressions may not be arguments, arg #%d */ 3750 error(151, n); 3751 return NULL; 3752 } else if ((at == STRUCT || at == UNION) && 3753 is_incomplete(arg->tn_left->tn_type)) { 3754 /* argument cannot have unknown size, arg #%d */ 3755 error(152, n); 3756 return NULL; 3757 } else if (is_integer(at) && 3758 arg->tn_left->tn_type->t_is_enum && 3759 is_incomplete(arg->tn_left->tn_type)) { 3760 /* argument cannot have unknown size, arg #%d */ 3761 warning(152, n); 3762 } 3763 3764 /* class conversions (arg in value context) */ 3765 arg->tn_left = cconv(arg->tn_left); 3766 3767 if (asym != NULL) { 3768 arg->tn_left = check_prototype_argument( 3769 n, asym->s_type, arg->tn_left); 3770 } else { 3771 arg->tn_left = promote(NOOP, true, arg->tn_left); 3772 } 3773 arg->tn_type = arg->tn_left->tn_type; 3774 3775 if (asym != NULL) 3776 asym = asym->s_next; 3777 } 3778 3779 return args; 3780 } 3781 3782 /* 3783 * Compare the type of an argument with the corresponding type of a 3784 * prototype parameter. If it is a valid combination, but both types 3785 * are not the same, insert a conversion to convert the argument into 3786 * the type of the parameter. 3787 */ 3788 static tnode_t * 3789 check_prototype_argument( 3790 int n, /* pos of arg */ 3791 type_t *tp, /* expected type (from prototype) */ 3792 tnode_t *tn) /* argument */ 3793 { 3794 tnode_t *ln; 3795 bool dowarn; 3796 3797 ln = xcalloc(1, sizeof(*ln)); 3798 ln->tn_type = expr_unqualified_type(tp); 3799 ln->tn_lvalue = true; 3800 if (typeok(FARG, n, ln, tn)) { 3801 if (!eqtype(tp, tn->tn_type, 3802 true, false, (dowarn = false, &dowarn)) || dowarn) 3803 tn = convert(FARG, n, tp, tn); 3804 } 3805 free(ln); 3806 return tn; 3807 } 3808 3809 /* 3810 * Return the value of an integral constant expression. 3811 * If the expression is not constant or its type is not an integer 3812 * type, an error message is printed. 3813 */ 3814 val_t * 3815 constant(tnode_t *tn, bool required) 3816 { 3817 val_t *v; 3818 3819 if (tn != NULL) 3820 tn = cconv(tn); 3821 if (tn != NULL) 3822 tn = promote(NOOP, false, tn); 3823 3824 v = xcalloc(1, sizeof(*v)); 3825 3826 if (tn == NULL) { 3827 lint_assert(nerr != 0); 3828 debug_step("constant node is null; returning 1 instead"); 3829 v->v_tspec = INT; 3830 v->v_quad = 1; 3831 return v; 3832 } 3833 3834 v->v_tspec = tn->tn_type->t_tspec; 3835 3836 if (tn->tn_op == CON) { 3837 lint_assert(tn->tn_type->t_tspec == tn->tn_val->v_tspec); 3838 if (is_integer(tn->tn_val->v_tspec)) { 3839 v->v_unsigned_since_c90 = 3840 tn->tn_val->v_unsigned_since_c90; 3841 v->v_quad = tn->tn_val->v_quad; 3842 return v; 3843 } 3844 v->v_quad = tn->tn_val->v_ldbl; 3845 } else { 3846 v->v_quad = 1; 3847 } 3848 3849 if (required) 3850 /* integral constant expression expected */ 3851 error(55); 3852 else 3853 /* variable array dimension is a C99/GCC extension */ 3854 c99ism(318); 3855 3856 if (!is_integer(v->v_tspec)) 3857 v->v_tspec = INT; 3858 3859 return v; 3860 } 3861 3862 static bool 3863 is_constcond_false(const tnode_t *tn, tspec_t t) 3864 { 3865 return (t == BOOL || t == INT) && 3866 tn->tn_op == CON && tn->tn_val->v_quad == 0; 3867 } 3868 3869 /* 3870 * Perform some tests on expressions which can't be done in build_binary() 3871 * and functions called by build_binary(). These tests must be done here 3872 * because we need some information about the context in which the operations 3873 * are performed. 3874 * After all tests are performed and dofreeblk is true, expr() frees the 3875 * memory which is used for the expression. 3876 */ 3877 void 3878 expr(tnode_t *tn, bool vctx, bool tctx, bool dofreeblk, bool is_do_while) 3879 { 3880 3881 if (tn == NULL) { /* in case of errors */ 3882 expr_free_all(); 3883 return; 3884 } 3885 3886 /* expr() is also called in global initializations */ 3887 if (dcs->d_ctx != EXTERN && !is_do_while) 3888 check_statement_reachable(); 3889 3890 check_expr_misc(tn, vctx, tctx, !tctx, false, false, false); 3891 if (tn->tn_op == ASSIGN) { 3892 if (hflag && tctx) 3893 /* assignment in conditional context */ 3894 warning(159); 3895 } else if (tn->tn_op == CON) { 3896 if (hflag && tctx && !constcond_flag && 3897 !tn->tn_system_dependent && 3898 !(is_do_while && 3899 is_constcond_false(tn, tn->tn_type->t_tspec))) 3900 /* constant in conditional context */ 3901 warning(161); 3902 } 3903 if (!modtab[tn->tn_op].m_has_side_effect) { 3904 /* 3905 * for left operands of COMMA this warning is already 3906 * printed 3907 */ 3908 if (tn->tn_op != COMMA && !vctx && !tctx) 3909 check_null_effect(tn); 3910 } 3911 debug_node(tn); 3912 3913 /* free the tree memory */ 3914 if (dofreeblk) 3915 expr_free_all(); 3916 } 3917 3918 static bool 3919 has_side_effect(const tnode_t *tn) // NOLINT(misc-no-recursion) 3920 { 3921 op_t op = tn->tn_op; 3922 3923 if (modtab[op].m_has_side_effect) 3924 return true; 3925 3926 if (op == CVT && tn->tn_type->t_tspec == VOID) 3927 return has_side_effect(tn->tn_left); 3928 3929 /* XXX: Why not has_side_effect(tn->tn_left) as well? */ 3930 if (op == LOGAND || op == LOGOR) 3931 return has_side_effect(tn->tn_right); 3932 3933 /* XXX: Why not has_side_effect(tn->tn_left) as well? */ 3934 if (op == QUEST) 3935 return has_side_effect(tn->tn_right); 3936 3937 if (op == COLON || op == COMMA) { 3938 return has_side_effect(tn->tn_left) || 3939 has_side_effect(tn->tn_right); 3940 } 3941 3942 return false; 3943 } 3944 3945 static bool 3946 is_void_cast(const tnode_t *tn) 3947 { 3948 3949 return tn->tn_op == CVT && tn->tn_cast && 3950 tn->tn_type->t_tspec == VOID; 3951 } 3952 3953 static bool 3954 is_local_symbol(const tnode_t *tn) 3955 { 3956 3957 return tn->tn_op == LOAD && 3958 tn->tn_left->tn_op == NAME && 3959 tn->tn_left->tn_sym->s_scl == AUTO; 3960 } 3961 3962 static bool 3963 is_int_constant_zero(const tnode_t *tn) 3964 { 3965 3966 return tn->tn_op == CON && 3967 tn->tn_type->t_tspec == INT && 3968 tn->tn_val->v_quad == 0; 3969 } 3970 3971 static void 3972 check_null_effect(const tnode_t *tn) 3973 { 3974 3975 if (!hflag) 3976 return; 3977 if (has_side_effect(tn)) 3978 return; 3979 if (is_void_cast(tn) && is_local_symbol(tn->tn_left)) 3980 return; 3981 if (is_void_cast(tn) && is_int_constant_zero(tn->tn_left)) 3982 return; 3983 3984 /* expression has null effect */ 3985 warning(129); 3986 } 3987 3988 static void 3989 check_expr_addr(const tnode_t *ln, bool szof, bool fcall) 3990 { 3991 /* XXX: Taking warn_about_unreachable into account here feels wrong. */ 3992 if (ln->tn_op == NAME && (reached || !warn_about_unreachable)) { 3993 if (!szof) 3994 mark_as_set(ln->tn_sym); 3995 mark_as_used(ln->tn_sym, fcall, szof); 3996 } 3997 if (ln->tn_op == INDIR && ln->tn_left->tn_op == PLUS) 3998 /* check the range of array indices */ 3999 check_array_index(ln->tn_left, true); 4000 } 4001 4002 static void 4003 check_expr_load(const tnode_t *ln) 4004 { 4005 if (ln->tn_op == INDIR && ln->tn_left->tn_op == PLUS) 4006 /* check the range of array indices */ 4007 check_array_index(ln->tn_left, false); 4008 } 4009 4010 static void 4011 check_expr_side_effect(const tnode_t *ln, bool szof) 4012 { 4013 scl_t sc; 4014 dinfo_t *di; 4015 4016 /* XXX: Taking warn_about_unreachable into account here feels wrong. */ 4017 if (ln->tn_op == NAME && (reached || !warn_about_unreachable)) { 4018 sc = ln->tn_sym->s_scl; 4019 /* 4020 * Look if there was a asm statement in one of the 4021 * compound statements we are in. If not, we don't 4022 * print a warning. 4023 */ 4024 for (di = dcs; di != NULL; di = di->d_next) { 4025 if (di->d_asm) 4026 break; 4027 } 4028 if (sc != EXTERN && sc != STATIC && 4029 !ln->tn_sym->s_set && !szof && di == NULL) { 4030 /* %s may be used before set */ 4031 warning(158, ln->tn_sym->s_name); 4032 mark_as_set(ln->tn_sym); 4033 } 4034 mark_as_used(ln->tn_sym, false, false); 4035 } 4036 } 4037 4038 static void 4039 check_expr_assign(const tnode_t *ln, bool szof) 4040 { 4041 /* XXX: Taking warn_about_unreachable into account here feels wrong. */ 4042 if (ln->tn_op == NAME && !szof && (reached || !warn_about_unreachable)) { 4043 mark_as_set(ln->tn_sym); 4044 if (ln->tn_sym->s_scl == EXTERN) 4045 outusg(ln->tn_sym); 4046 } 4047 if (ln->tn_op == INDIR && ln->tn_left->tn_op == PLUS) 4048 /* check the range of array indices */ 4049 check_array_index(ln->tn_left, false); 4050 } 4051 4052 static void 4053 check_expr_call(const tnode_t *tn, const tnode_t *ln, 4054 bool szof, bool vctx, bool tctx, bool retval_discarded) 4055 { 4056 lint_assert(ln->tn_op == ADDR); 4057 lint_assert(ln->tn_left->tn_op == NAME); 4058 if (!szof && 4059 !is_compiler_builtin(ln->tn_left->tn_sym->s_name)) 4060 outcall(tn, vctx || tctx, retval_discarded); 4061 } 4062 4063 static bool 4064 check_expr_op(const tnode_t *tn, op_t op, const tnode_t *ln, 4065 bool szof, bool fcall, bool vctx, bool tctx, 4066 bool retval_discarded, bool eqwarn) 4067 { 4068 switch (op) { 4069 case ADDR: 4070 check_expr_addr(ln, szof, fcall); 4071 break; 4072 case LOAD: 4073 check_expr_load(ln); 4074 /* FALLTHROUGH */ 4075 case PUSH: 4076 case INCBEF: 4077 case DECBEF: 4078 case INCAFT: 4079 case DECAFT: 4080 case ADDASS: 4081 case SUBASS: 4082 case MULASS: 4083 case DIVASS: 4084 case MODASS: 4085 case ANDASS: 4086 case ORASS: 4087 case XORASS: 4088 case SHLASS: 4089 case SHRASS: 4090 case REAL: 4091 case IMAG: 4092 check_expr_side_effect(ln, szof); 4093 break; 4094 case ASSIGN: 4095 check_expr_assign(ln, szof); 4096 break; 4097 case CALL: 4098 check_expr_call(tn, ln, szof, vctx, tctx, retval_discarded); 4099 break; 4100 case EQ: 4101 if (hflag && eqwarn) 4102 /* operator '==' found where '=' was expected */ 4103 warning(160); 4104 break; 4105 case CON: 4106 case NAME: 4107 case STRING: 4108 return false; 4109 /* LINTED206: (enumeration values not handled in switch) */ 4110 case BITOR: 4111 case BITXOR: 4112 case NE: 4113 case GE: 4114 case GT: 4115 case LE: 4116 case LT: 4117 case SHR: 4118 case SHL: 4119 case MINUS: 4120 case PLUS: 4121 case MOD: 4122 case DIV: 4123 case MULT: 4124 case INDIR: 4125 case UMINUS: 4126 case UPLUS: 4127 case DEC: 4128 case INC: 4129 case COMPL: 4130 case NOT: 4131 case POINT: 4132 case ARROW: 4133 case NOOP: 4134 case BITAND: 4135 case FARG: 4136 case CASE: 4137 case INIT: 4138 case RETURN: 4139 case ICALL: 4140 case CVT: 4141 case COMMA: 4142 case FSEL: 4143 case COLON: 4144 case QUEST: 4145 case LOGOR: 4146 case LOGAND: 4147 break; 4148 } 4149 return true; 4150 } 4151 4152 /* ARGSUSED */ 4153 void 4154 check_expr_misc(const tnode_t *tn, bool vctx, bool tctx, 4155 bool eqwarn, bool fcall, bool retval_discarded, bool szof) 4156 { 4157 tnode_t *ln, *rn; 4158 const mod_t *mp; 4159 op_t op; 4160 4161 if (tn == NULL) 4162 return; 4163 4164 ln = tn->tn_left; 4165 rn = tn->tn_right; 4166 mp = &modtab[op = tn->tn_op]; 4167 4168 if (!check_expr_op(tn, op, ln, 4169 szof, fcall, vctx, tctx, retval_discarded, eqwarn)) 4170 return; 4171 4172 bool cvctx = mp->m_left_value_context; 4173 bool ctctx = mp->m_left_test_context; 4174 bool eq = mp->m_warn_if_operand_eq && 4175 !ln->tn_parenthesized && 4176 rn != NULL && !rn->tn_parenthesized; 4177 4178 /* 4179 * values of operands of ':' are not used if the type of at least 4180 * one of the operands (for gcc compatibility) is void 4181 * XXX test/value context of QUEST should probably be used as 4182 * context for both operands of COLON 4183 */ 4184 if (op == COLON && tn->tn_type->t_tspec == VOID) 4185 cvctx = ctctx = false; 4186 bool discard = op == CVT && tn->tn_type->t_tspec == VOID; 4187 check_expr_misc(ln, cvctx, ctctx, eq, op == CALL, discard, szof); 4188 4189 switch (op) { 4190 case PUSH: 4191 if (rn != NULL) 4192 check_expr_misc(rn, false, false, eq, false, false, 4193 szof); 4194 break; 4195 case LOGAND: 4196 case LOGOR: 4197 check_expr_misc(rn, false, true, eq, false, false, szof); 4198 break; 4199 case COLON: 4200 check_expr_misc(rn, cvctx, ctctx, eq, false, false, szof); 4201 break; 4202 case COMMA: 4203 check_expr_misc(rn, vctx, tctx, eq, false, false, szof); 4204 break; 4205 default: 4206 if (mp->m_binary) 4207 check_expr_misc(rn, true, false, eq, false, false, 4208 szof); 4209 break; 4210 } 4211 } 4212 4213 /* 4214 * Checks the range of array indices, if possible. 4215 * amper is set if only the address of the element is used. This 4216 * means that the index is allowed to refer to the first element 4217 * after the array. 4218 */ 4219 static void 4220 check_array_index(tnode_t *tn, bool amper) 4221 { 4222 int dim; 4223 tnode_t *ln, *rn; 4224 int elsz; 4225 int64_t con; 4226 4227 ln = tn->tn_left; 4228 rn = tn->tn_right; 4229 4230 /* We can only check constant indices. */ 4231 if (rn->tn_op != CON) 4232 return; 4233 4234 /* Return if the left node does not stem from an array. */ 4235 if (ln->tn_op != ADDR) 4236 return; 4237 if (ln->tn_left->tn_op != STRING && ln->tn_left->tn_op != NAME) 4238 return; 4239 if (ln->tn_left->tn_type->t_tspec != ARRAY) 4240 return; 4241 4242 /* 4243 * For incomplete array types, we can print a warning only if 4244 * the index is negative. 4245 */ 4246 if (is_incomplete(ln->tn_left->tn_type) && rn->tn_val->v_quad >= 0) 4247 return; 4248 4249 /* Get the size of one array element */ 4250 if ((elsz = length(ln->tn_type->t_subt, NULL)) == 0) 4251 return; 4252 elsz /= CHAR_SIZE; 4253 4254 /* Change the unit of the index from bytes to element size. */ 4255 if (is_uinteger(rn->tn_type->t_tspec)) { 4256 con = (uint64_t)rn->tn_val->v_quad / elsz; 4257 } else { 4258 con = rn->tn_val->v_quad / elsz; 4259 } 4260 4261 dim = ln->tn_left->tn_type->t_dim + (amper ? 1 : 0); 4262 4263 if (!is_uinteger(rn->tn_type->t_tspec) && con < 0) { 4264 /* array subscript cannot be negative: %ld */ 4265 warning(167, (long)con); 4266 } else if (dim > 0 && (uint64_t)con >= (uint64_t)dim) { 4267 /* array subscript cannot be > %d: %ld */ 4268 warning(168, dim - 1, (long)con); 4269 } 4270 } 4271 4272 static bool 4273 is_out_of_char_range(const tnode_t *tn) 4274 { 4275 return tn->tn_op == CON && 4276 !(0 <= tn->tn_val->v_quad && 4277 tn->tn_val->v_quad < 1 << (CHAR_SIZE - 1)); 4278 } 4279 4280 /* 4281 * Check for ordered comparisons of unsigned values with 0. 4282 */ 4283 static void 4284 check_integer_comparison(op_t op, tnode_t *ln, tnode_t *rn) 4285 { 4286 tspec_t lt, rt; 4287 4288 lt = ln->tn_type->t_tspec; 4289 rt = rn->tn_type->t_tspec; 4290 4291 if (ln->tn_op != CON && rn->tn_op != CON) 4292 return; 4293 4294 if (!is_integer(lt) || !is_integer(rt)) 4295 return; 4296 4297 if (hflag || pflag) { 4298 if (lt == CHAR && is_out_of_char_range(rn)) { 4299 /* nonportable character comparison '%s %d' */ 4300 warning(230, op_name(op), (int)rn->tn_val->v_quad); 4301 return; 4302 } 4303 if (rt == CHAR && is_out_of_char_range(ln)) { 4304 /* nonportable character comparison '%s %d' */ 4305 warning(230, op_name(op), (int)ln->tn_val->v_quad); 4306 return; 4307 } 4308 } 4309 4310 if (is_uinteger(lt) && !is_uinteger(rt) && 4311 rn->tn_op == CON && rn->tn_val->v_quad <= 0) { 4312 if (rn->tn_val->v_quad < 0) { 4313 /* comparison of %s with %s, op %s */ 4314 warning(162, type_name(ln->tn_type), 4315 "negative constant", op_name(op)); 4316 } else if (op == LT || op == GE) { 4317 /* comparison of %s with %s, op %s */ 4318 warning(162, type_name(ln->tn_type), "0", op_name(op)); 4319 } 4320 return; 4321 } 4322 if (is_uinteger(rt) && !is_uinteger(lt) && 4323 ln->tn_op == CON && ln->tn_val->v_quad <= 0) { 4324 if (ln->tn_val->v_quad < 0) { 4325 /* comparison of %s with %s, op %s */ 4326 warning(162, "negative constant", 4327 type_name(rn->tn_type), op_name(op)); 4328 } else if (op == GT || op == LE) { 4329 /* comparison of %s with %s, op %s */ 4330 warning(162, "0", type_name(rn->tn_type), op_name(op)); 4331 } 4332 return; 4333 } 4334 } 4335 4336 /* 4337 * Return whether the expression can be used for static initialization. 4338 * 4339 * Constant initialization expressions must be constant or an address 4340 * of a static object with an optional offset. In the first case, 4341 * the result is returned in *offsp. In the second case, the static 4342 * object is returned in *symp and the offset in *offsp. 4343 * 4344 * The expression can consist of PLUS, MINUS, ADDR, NAME, STRING and 4345 * CON. Type conversions are allowed if they do not change binary 4346 * representation (including width). 4347 * 4348 * C99 6.6 "Constant expressions" 4349 * C99 6.7.8p4 restricts initializers for static storage duration 4350 */ 4351 bool 4352 constant_addr(const tnode_t *tn, const sym_t **symp, ptrdiff_t *offsp) 4353 { 4354 const sym_t *sym; 4355 ptrdiff_t offs1, offs2; 4356 tspec_t t, ot; 4357 4358 switch (tn->tn_op) { 4359 case MINUS: 4360 if (tn->tn_right->tn_op == CVT) 4361 return constant_addr(tn->tn_right, symp, offsp); 4362 else if (tn->tn_right->tn_op != CON) 4363 return false; 4364 /* FALLTHROUGH */ 4365 case PLUS: 4366 offs1 = offs2 = 0; 4367 if (tn->tn_left->tn_op == CON) { 4368 offs1 = (ptrdiff_t)tn->tn_left->tn_val->v_quad; 4369 if (!constant_addr(tn->tn_right, &sym, &offs2)) 4370 return false; 4371 } else if (tn->tn_right->tn_op == CON) { 4372 offs2 = (ptrdiff_t)tn->tn_right->tn_val->v_quad; 4373 if (tn->tn_op == MINUS) 4374 offs2 = -offs2; 4375 if (!constant_addr(tn->tn_left, &sym, &offs1)) 4376 return false; 4377 } else { 4378 return false; 4379 } 4380 *symp = sym; 4381 *offsp = offs1 + offs2; 4382 return true; 4383 case ADDR: 4384 if (tn->tn_left->tn_op == NAME) { 4385 *symp = tn->tn_left->tn_sym; 4386 *offsp = 0; 4387 return true; 4388 } else { 4389 /* 4390 * If this would be the front end of a compiler we 4391 * would return a label instead of 0, at least if 4392 * 'tn->tn_left->tn_op == STRING'. 4393 */ 4394 *symp = NULL; 4395 *offsp = 0; 4396 return true; 4397 } 4398 case CVT: 4399 t = tn->tn_type->t_tspec; 4400 ot = tn->tn_left->tn_type->t_tspec; 4401 if ((!is_integer(t) && t != PTR) || 4402 (!is_integer(ot) && ot != PTR)) { 4403 return false; 4404 } 4405 #if 0 4406 /* 4407 * consider: 4408 * struct foo { 4409 * unsigned char a; 4410 * } f = { 4411 * (unsigned char)(unsigned long) 4412 * (&(((struct foo *)0)->a)) 4413 * }; 4414 * since psize(unsigned long) != psize(unsigned char), 4415 * this fails. 4416 */ 4417 else if (psize(t) != psize(ot)) 4418 return -1; 4419 #endif 4420 return constant_addr(tn->tn_left, symp, offsp); 4421 default: 4422 return false; 4423 } 4424 } 4425 4426 /* Append s2 to s1, then free s2. */ 4427 strg_t * 4428 cat_strings(strg_t *s1, strg_t *s2) 4429 { 4430 size_t len1, len2, sz; 4431 4432 if (s1->st_tspec != s2->st_tspec) { 4433 /* cannot concatenate wide and regular string literals */ 4434 error(292); 4435 return s1; 4436 } 4437 4438 len1 = s1->st_len; 4439 len2 = s2->st_len; 4440 4441 if (s1->st_tspec == CHAR) { 4442 sz = sizeof(*s1->st_cp); 4443 s1->st_cp = xrealloc(s1->st_cp, (len1 + len2 + 1) * sz); 4444 memcpy(s1->st_cp + len1, s2->st_cp, (len2 + 1) * sz); 4445 free(s2->st_cp); 4446 } else { 4447 sz = sizeof(*s1->st_wcp); 4448 s1->st_wcp = xrealloc(s1->st_wcp, (len1 + len2 + 1) * sz); 4449 memcpy(s1->st_wcp + len1, s2->st_wcp, (len2 + 1) * sz); 4450 free(s2->st_wcp); 4451 } 4452 4453 s1->st_len = len1 + len2; 4454 free(s2); 4455 4456 return s1; 4457 } 4458 4459 static bool 4460 is_confusing_precedence(op_t op, op_t lop, bool lparen, op_t rop, bool rparen) 4461 { 4462 4463 if (op == SHL || op == SHR) { 4464 if (!lparen && (lop == PLUS || lop == MINUS)) 4465 return true; 4466 if (!rparen && (rop == PLUS || rop == MINUS)) 4467 return true; 4468 return false; 4469 } 4470 4471 if (op == LOGOR) { 4472 if (!lparen && lop == LOGAND) 4473 return true; 4474 if (!rparen && rop == LOGAND) 4475 return true; 4476 return false; 4477 } 4478 4479 lint_assert(op == BITAND || op == BITXOR || op == BITOR); 4480 if (!lparen && lop != op) { 4481 if (lop == PLUS || lop == MINUS) 4482 return true; 4483 if (lop == BITAND || lop == BITXOR) 4484 return true; 4485 } 4486 if (!rparen && rop != op) { 4487 if (rop == PLUS || rop == MINUS) 4488 return true; 4489 if (rop == BITAND || rop == BITXOR) 4490 return true; 4491 } 4492 return false; 4493 } 4494 4495 /* 4496 * Print a warning if the given node has operands which should be 4497 * parenthesized. 4498 * 4499 * XXX Does not work if an operand is a constant expression. Constant 4500 * expressions are already folded. 4501 */ 4502 static void 4503 check_precedence_confusion(tnode_t *tn) 4504 { 4505 tnode_t *ln, *rn; 4506 4507 if (!hflag) 4508 return; 4509 4510 debug_node(tn); 4511 4512 lint_assert(is_binary(tn)); 4513 for (ln = tn->tn_left; ln->tn_op == CVT; ln = ln->tn_left) 4514 continue; 4515 for (rn = tn->tn_right; rn->tn_op == CVT; rn = rn->tn_left) 4516 continue; 4517 4518 if (is_confusing_precedence(tn->tn_op, 4519 ln->tn_op, ln->tn_parenthesized, 4520 rn->tn_op, rn->tn_parenthesized)) { 4521 /* precedence confusion possible: parenthesize! */ 4522 warning(169); 4523 } 4524 } 4525
Indexes created Tue Sep 23 14:10:03 GMT 2025