tree.c revision 1.387
1 /* $NetBSD: tree.c,v 1.387 2021/10/31 16:42:16 christos 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.387 2021/10/31 16:42:16 christos 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 // XXX: why? 1797 if (rn->tn_type->t_enum == NULL) 1798 return; 1799 1800 max_enum_value = INT_MIN; 1801 ec = rn->tn_type->t_enum->en_first_enumerator; 1802 for (; ec != NULL; ec = ec->s_next) { 1803 int64_t ev = ec->s_value.v_quad; 1804 lint_assert(INT_MIN <= ev && ev <= INT_MAX); 1805 if (ev > max_enum_value) 1806 max_enum_value = (int)ev; 1807 } 1808 1809 max_array_index = ln->tn_left->tn_type->t_dim - 1; 1810 if (max_enum_value == max_array_index) 1811 return; 1812 1813 /* maximum value %d of '%s' does not match maximum array index %d */ 1814 warning(348, max_enum_value, type_name(rn->tn_type), max_array_index); 1815 } 1816 1817 /* 1818 * Build and initialize a new node. 1819 */ 1820 static tnode_t * 1821 new_tnode(op_t op, type_t *type, tnode_t *ln, tnode_t *rn) 1822 { 1823 tnode_t *ntn; 1824 tspec_t t; 1825 #if 0 /* not yet */ 1826 size_t l; 1827 uint64_t rnum; 1828 #endif 1829 1830 ntn = expr_zalloc_tnode(); 1831 1832 ntn->tn_op = op; 1833 ntn->tn_type = type; 1834 ntn->tn_relaxed = ln->tn_relaxed || (rn != NULL && rn->tn_relaxed); 1835 ntn->tn_left = ln; 1836 ntn->tn_right = rn; 1837 1838 switch (op) { 1839 #if 0 /* not yet */ 1840 case SHR: 1841 if (rn->tn_op != CON) 1842 break; 1843 rnum = rn->tn_val->v_quad; 1844 l = type_size_in_bits(ln->tn_type) / CHAR_SIZE; 1845 t = ln->tn_type->t_tspec; 1846 switch (l) { 1847 case 8: 1848 if (rnum >= 56) 1849 t = UCHAR; 1850 else if (rnum >= 48) 1851 t = USHORT; 1852 else if (rnum >= 32) 1853 t = UINT; 1854 break; 1855 case 4: 1856 if (rnum >= 24) 1857 t = UCHAR; 1858 else if (rnum >= 16) 1859 t = USHORT; 1860 break; 1861 case 2: 1862 if (rnum >= 8) 1863 t = UCHAR; 1864 break; 1865 default: 1866 break; 1867 } 1868 if (t != ln->tn_type->t_tspec) 1869 ntn->tn_type->t_tspec = t; 1870 break; 1871 #endif 1872 case INDIR: 1873 case FSEL: 1874 lint_assert(ln->tn_type->t_tspec == PTR); 1875 t = ln->tn_type->t_subt->t_tspec; 1876 if (t != FUNC && t != VOID) 1877 ntn->tn_lvalue = true; 1878 break; 1879 default: 1880 break; 1881 } 1882 1883 return ntn; 1884 } 1885 1886 /* 1887 * Performs the "integer promotions" (C99 6.3.1.1p2), which convert small 1888 * integer types to either int or unsigned int. 1889 * 1890 * If tflag is set or the operand is a function argument with no type 1891 * information (no prototype or variable # of args), converts float to double. 1892 */ 1893 tnode_t * 1894 promote(op_t op, bool farg, tnode_t *tn) 1895 { 1896 tspec_t t; 1897 type_t *ntp; 1898 unsigned int len; 1899 1900 t = tn->tn_type->t_tspec; 1901 1902 if (!is_arithmetic(t)) 1903 return tn; 1904 1905 if (!tflag) { 1906 /* 1907 * C99 6.3.1.1p2 requires for types with lower rank than int 1908 * that "If an int can represent all the values of the 1909 * original type, the value is converted to an int; otherwise 1910 * it is converted to an unsigned int", and that "All other 1911 * types are unchanged by the integer promotions". 1912 */ 1913 if (tn->tn_type->t_bitfield) { 1914 len = tn->tn_type->t_flen; 1915 if (len < size_in_bits(INT)) { 1916 t = INT; 1917 } else if (len == size_in_bits(INT)) { 1918 t = is_uinteger(t) ? UINT : INT; 1919 } 1920 } else if (t == CHAR || t == UCHAR || t == SCHAR) { 1921 t = (size_in_bits(CHAR) < size_in_bits(INT) 1922 || t != UCHAR) ? INT : UINT; 1923 } else if (t == SHORT || t == USHORT) { 1924 t = (size_in_bits(SHORT) < size_in_bits(INT) 1925 || t == SHORT) ? INT : UINT; 1926 } else if (t == ENUM) { 1927 t = INT; 1928 } else if (farg && t == FLOAT) { 1929 t = DOUBLE; 1930 } 1931 } else { 1932 /* 1933 * In traditional C, keep unsigned and promote FLOAT 1934 * to DOUBLE. 1935 */ 1936 if (t == UCHAR || t == USHORT) { 1937 t = UINT; 1938 } else if (t == CHAR || t == SCHAR || t == SHORT) { 1939 t = INT; 1940 } else if (t == FLOAT) { 1941 t = DOUBLE; 1942 } else if (t == ENUM) { 1943 t = INT; 1944 } 1945 } 1946 1947 if (t != tn->tn_type->t_tspec) { 1948 ntp = expr_dup_type(tn->tn_type); 1949 ntp->t_tspec = t; 1950 /* 1951 * Keep t_is_enum even though t_tspec gets converted from 1952 * ENUM to INT, so we are later able to check compatibility 1953 * of enum types. 1954 */ 1955 tn = convert(op, 0, ntp, tn); 1956 } 1957 1958 return tn; 1959 } 1960 1961 /* 1962 * Apply the "usual arithmetic conversions" (C99 6.3.1.8). 1963 * 1964 * This gives both operands the same type. 1965 * This is done in different ways for traditional C and C90. 1966 */ 1967 static void 1968 balance(op_t op, tnode_t **lnp, tnode_t **rnp) 1969 { 1970 tspec_t lt, rt, t; 1971 int i; 1972 bool u; 1973 type_t *ntp; 1974 static const tspec_t tl[] = { 1975 LDOUBLE, DOUBLE, FLOAT, 1976 #ifdef INT128_SIZE 1977 UINT128, INT128, 1978 #endif 1979 UQUAD, QUAD, 1980 ULONG, LONG, 1981 UINT, INT, 1982 }; 1983 1984 lt = (*lnp)->tn_type->t_tspec; 1985 rt = (*rnp)->tn_type->t_tspec; 1986 1987 if (!is_arithmetic(lt) || !is_arithmetic(rt)) 1988 return; 1989 1990 if (!tflag) { 1991 if (lt == rt) { 1992 t = lt; 1993 } else if (lt == LCOMPLEX || rt == LCOMPLEX) { 1994 t = LCOMPLEX; 1995 } else if (lt == DCOMPLEX || rt == DCOMPLEX) { 1996 t = DCOMPLEX; 1997 } else if (lt == FCOMPLEX || rt == FCOMPLEX) { 1998 t = FCOMPLEX; 1999 } else if (lt == LDOUBLE || rt == LDOUBLE) { 2000 t = LDOUBLE; 2001 } else if (lt == DOUBLE || rt == DOUBLE) { 2002 t = DOUBLE; 2003 } else if (lt == FLOAT || rt == FLOAT) { 2004 t = FLOAT; 2005 } else { 2006 /* 2007 * If type A has more bits than type B it should 2008 * be able to hold all possible values of type B. 2009 */ 2010 if (size_in_bits(lt) > size_in_bits(rt)) { 2011 t = lt; 2012 } else if (size_in_bits(lt) < size_in_bits(rt)) { 2013 t = rt; 2014 } else { 2015 for (i = 3; tl[i] != INT; i++) { 2016 if (tl[i] == lt || tl[i] == rt) 2017 break; 2018 } 2019 if ((is_uinteger(lt) || is_uinteger(rt)) && 2020 !is_uinteger(tl[i])) { 2021 i--; 2022 } 2023 t = tl[i]; 2024 } 2025 } 2026 } else { 2027 /* Keep unsigned in traditional C */ 2028 u = is_uinteger(lt) || is_uinteger(rt); 2029 for (i = 0; tl[i] != INT; i++) { 2030 if (lt == tl[i] || rt == tl[i]) 2031 break; 2032 } 2033 t = tl[i]; 2034 if (u && is_integer(t) && !is_uinteger(t)) 2035 t = unsigned_type(t); 2036 } 2037 2038 if (t != lt) { 2039 ntp = expr_dup_type((*lnp)->tn_type); 2040 ntp->t_tspec = t; 2041 *lnp = convert(op, 0, ntp, *lnp); 2042 } 2043 if (t != rt) { 2044 ntp = expr_dup_type((*rnp)->tn_type); 2045 ntp->t_tspec = t; 2046 *rnp = convert(op, 0, ntp, *rnp); 2047 } 2048 } 2049 2050 /* 2051 * Insert a conversion operator, which converts the type of the node 2052 * to another given type. 2053 * If op is FARG, arg is the number of the argument (used for warnings). 2054 */ 2055 tnode_t * 2056 convert(op_t op, int arg, type_t *tp, tnode_t *tn) 2057 { 2058 tnode_t *ntn; 2059 tspec_t nt, ot; 2060 2061 nt = tp->t_tspec; 2062 ot = tn->tn_type->t_tspec; 2063 2064 if (!tflag && !sflag && op == FARG) 2065 check_prototype_conversion(arg, nt, ot, tp, tn); 2066 if (is_integer(nt) && is_integer(ot)) { 2067 check_integer_conversion(op, arg, nt, ot, tp, tn); 2068 } else if (nt == PTR && is_null_pointer(tn)) { 2069 /* a null pointer may be assigned to any pointer. */ 2070 } else if (is_integer(nt) && nt != BOOL && ot == PTR) { 2071 check_pointer_integer_conversion(op, nt, tp, tn); 2072 } else if (nt == PTR && ot == PTR && op == CVT) { 2073 check_pointer_conversion(tn, tp); 2074 } 2075 2076 ntn = expr_zalloc_tnode(); 2077 ntn->tn_op = CVT; 2078 ntn->tn_type = tp; 2079 ntn->tn_cast = op == CVT; 2080 ntn->tn_relaxed |= tn->tn_relaxed; 2081 ntn->tn_right = NULL; 2082 if (tn->tn_op != CON || nt == VOID) { 2083 ntn->tn_left = tn; 2084 } else { 2085 ntn->tn_op = CON; 2086 ntn->tn_val = expr_zalloc(sizeof(*ntn->tn_val)); 2087 convert_constant(op, arg, ntn->tn_type, ntn->tn_val, 2088 tn->tn_val); 2089 } 2090 2091 return ntn; 2092 } 2093 2094 static bool 2095 should_warn_about_prototype_conversion(tspec_t nt, 2096 tspec_t ot, const tnode_t *ptn) 2097 { 2098 2099 if (nt == ot) 2100 return false; 2101 2102 if (nt == ENUM && ot == INT) 2103 return false; 2104 2105 if (is_floating(nt) != is_floating(ot) || 2106 portable_size_in_bits(nt) != portable_size_in_bits(ot)) { 2107 /* representation and/or width change */ 2108 if (!is_integer(ot)) 2109 return true; 2110 /* 2111 * XXX: Investigate whether this rule makes sense; see 2112 * tests/usr.bin/xlint/lint1/platform_long.c. 2113 */ 2114 return portable_size_in_bits(ot) > portable_size_in_bits(INT); 2115 } 2116 2117 if (!hflag) 2118 return false; 2119 2120 /* 2121 * If the types differ only in sign and the argument has the same 2122 * representation in both types, print no warning. 2123 */ 2124 if (ptn->tn_op == CON && is_integer(nt) && 2125 signed_type(nt) == signed_type(ot) && 2126 !msb(ptn->tn_val->v_quad, ot)) 2127 return false; 2128 2129 return true; 2130 } 2131 2132 /* 2133 * Warn if a prototype causes a type conversion that is different from what 2134 * would happen to the same argument in the absence of a prototype. This 2135 * check is intended for code that needs to stay compatible with pre-C90 C. 2136 * 2137 * Errors/warnings about illegal type combinations are already printed 2138 * in check_assign_types_compatible(). 2139 */ 2140 static void 2141 check_prototype_conversion(int arg, tspec_t nt, tspec_t ot, type_t *tp, 2142 tnode_t *tn) 2143 { 2144 tnode_t *ptn; 2145 2146 if (!is_arithmetic(nt) || !is_arithmetic(ot)) 2147 return; 2148 2149 /* 2150 * If the type of the formal parameter is char/short, a warning 2151 * would be useless, because functions declared the old style 2152 * can't expect char/short arguments. 2153 */ 2154 if (nt == CHAR || nt == SCHAR || nt == UCHAR || 2155 nt == SHORT || nt == USHORT) 2156 return; 2157 2158 /* apply the default promotion */ 2159 ptn = promote(NOOP, true, tn); 2160 ot = ptn->tn_type->t_tspec; 2161 2162 if (should_warn_about_prototype_conversion(nt, ot, ptn)) { 2163 /* argument #%d is converted from '%s' to '%s' ... */ 2164 warning(259, arg, type_name(tn->tn_type), type_name(tp)); 2165 } 2166 } 2167 2168 /* 2169 * Print warnings for conversions of integer types which may cause problems. 2170 */ 2171 static void 2172 check_integer_conversion(op_t op, int arg, tspec_t nt, tspec_t ot, type_t *tp, 2173 tnode_t *tn) 2174 { 2175 2176 if (tn->tn_op == CON) 2177 return; 2178 2179 if (op == CVT) 2180 return; 2181 2182 if (Sflag && nt == BOOL) 2183 return; /* See C99 6.3.1.2 */ 2184 2185 if (Pflag && portable_size_in_bits(nt) > portable_size_in_bits(ot) && 2186 is_uinteger(nt) != is_uinteger(ot)) { 2187 if (aflag > 0 && pflag) { 2188 if (op == FARG) { 2189 /* conversion to '%s' may sign-extend ... */ 2190 warning(297, type_name(tp), arg); 2191 } else { 2192 /* conversion to '%s' may sign-extend ... */ 2193 warning(131, type_name(tp)); 2194 } 2195 } 2196 } 2197 2198 if (Pflag && portable_size_in_bits(nt) > portable_size_in_bits(ot)) { 2199 switch (tn->tn_op) { 2200 case PLUS: 2201 case MINUS: 2202 case MULT: 2203 case SHL: 2204 /* suggest cast from '%s' to '%s' on op %s to ... */ 2205 warning(324, type_name(gettyp(ot)), type_name(tp), 2206 op_name(tn->tn_op)); 2207 break; 2208 default: 2209 break; 2210 } 2211 } 2212 2213 if (portable_size_in_bits(nt) < portable_size_in_bits(ot) && 2214 (ot == LONG || ot == ULONG || ot == QUAD || ot == UQUAD || 2215 aflag > 1)) { 2216 /* conversion from '%s' may lose accuracy */ 2217 if (aflag > 0) { 2218 if (op == FARG) { 2219 /* conversion from '%s' to '%s' may ... */ 2220 warning(298, 2221 type_name(tn->tn_type), type_name(tp), arg); 2222 } else { 2223 /* conversion from '%s' to '%s' may ... */ 2224 warning(132, 2225 type_name(tn->tn_type), type_name(tp)); 2226 } 2227 } 2228 } 2229 } 2230 2231 /* 2232 * Print warnings for dubious conversions of pointer to integer. 2233 */ 2234 static void 2235 check_pointer_integer_conversion(op_t op, tspec_t nt, type_t *tp, tnode_t *tn) 2236 { 2237 2238 if (tn->tn_op == CON) 2239 return; 2240 if (op != CVT) 2241 return; /* We got already an error. */ 2242 if (portable_size_in_bits(nt) >= portable_size_in_bits(PTR)) 2243 return; 2244 2245 if (pflag && size_in_bits(nt) >= size_in_bits(PTR)) { 2246 /* conversion of pointer to '%s' may lose bits */ 2247 warning(134, type_name(tp)); 2248 } else { 2249 /* conversion of pointer to '%s' loses bits */ 2250 warning(133, type_name(tp)); 2251 } 2252 } 2253 2254 static bool 2255 should_warn_about_pointer_cast(const type_t *nstp, tspec_t nst, 2256 const type_t *ostp, tspec_t ost) 2257 { 2258 /* 2259 * Casting a pointer to 'struct S' to a pointer to another struct that 2260 * has 'struct S' as its first member is ok, see msg_247.c, 'struct 2261 * counter'. 2262 */ 2263 if (nst == STRUCT && ost == STRUCT && 2264 nstp->t_str->sou_first_member != NULL && 2265 nstp->t_str->sou_first_member->s_type == ostp) 2266 return false; 2267 2268 if (is_incomplete(nstp) || is_incomplete(ostp)) 2269 return false; 2270 2271 if ((nst == STRUCT || nst == UNION) && nstp->t_str != ostp->t_str) 2272 return true; 2273 2274 if (nst == CHAR || nst == UCHAR) 2275 return false; /* for the sake of traditional C code */ 2276 if (ost == CHAR || ost == UCHAR) 2277 return false; /* for the sake of traditional C code */ 2278 2279 return portable_size_in_bits(nst) != portable_size_in_bits(ost); 2280 } 2281 2282 /* 2283 * Warn about questionable pointer conversions. 2284 */ 2285 static void 2286 check_pointer_conversion(tnode_t *tn, type_t *ntp) 2287 { 2288 const type_t *nstp, *otp, *ostp; 2289 tspec_t nst, ost; 2290 const char *nts, *ots; 2291 2292 nstp = ntp->t_subt; 2293 otp = tn->tn_type; 2294 ostp = otp->t_subt; 2295 nst = nstp->t_tspec; 2296 ost = ostp->t_tspec; 2297 2298 if (nst == VOID || ost == VOID) { 2299 if (sflag && (nst == FUNC || ost == FUNC)) { 2300 /* null pointers are already handled in convert() */ 2301 *(nst == FUNC ? &nts : &ots) = "function pointer"; 2302 *(nst == VOID ? &nts : &ots) = "'void *'"; 2303 /* ANSI C forbids conversion of %s to %s */ 2304 warning(303, ots, nts); 2305 } 2306 return; 2307 } else if (nst == FUNC && ost == FUNC) { 2308 return; 2309 } else if (nst == FUNC || ost == FUNC) { 2310 /* converting '%s' to '%s' is questionable */ 2311 warning(229, type_name(otp), type_name(ntp)); 2312 return; 2313 } 2314 2315 if (hflag && alignment_in_bits(nstp) > alignment_in_bits(ostp) && 2316 ost != CHAR && ost != UCHAR && 2317 !is_incomplete(ostp)) { 2318 /* converting '%s' to '%s' may cause alignment problem */ 2319 warning(135, type_name(otp), type_name(ntp)); 2320 } 2321 2322 if (cflag && should_warn_about_pointer_cast(nstp, nst, ostp, ost)) { 2323 /* pointer cast from '%s' to '%s' may be troublesome */ 2324 warning(247, type_name(otp), type_name(ntp)); 2325 } 2326 } 2327 2328 static void 2329 convert_constant_floating(op_t op, int arg, tspec_t ot, const type_t *tp, 2330 tspec_t nt, val_t *v, val_t *nv) 2331 { 2332 ldbl_t max = 0.0, min = 0.0; 2333 2334 switch (nt) { 2335 case CHAR: 2336 max = TARG_CHAR_MAX; min = TARG_CHAR_MIN; break; 2337 case UCHAR: 2338 max = TARG_UCHAR_MAX; min = 0; break; 2339 case SCHAR: 2340 max = TARG_SCHAR_MAX; min = TARG_SCHAR_MIN; break; 2341 case SHORT: 2342 max = TARG_SHRT_MAX; min = TARG_SHRT_MIN; break; 2343 case USHORT: 2344 max = TARG_USHRT_MAX; min = 0; break; 2345 case ENUM: 2346 case INT: 2347 max = TARG_INT_MAX; min = TARG_INT_MIN; break; 2348 case UINT: 2349 max = TARG_UINT_MAX; min = 0; break; 2350 case LONG: 2351 max = TARG_LONG_MAX; min = TARG_LONG_MIN; break; 2352 case ULONG: 2353 max = TARG_ULONG_MAX; min = 0; break; 2354 case QUAD: 2355 max = QUAD_MAX; min = QUAD_MIN; break; 2356 case UQUAD: 2357 max = UQUAD_MAX; min = 0; break; 2358 case FLOAT: 2359 case FCOMPLEX: 2360 max = FLT_MAX; min = -FLT_MAX; break; 2361 case DOUBLE: 2362 case DCOMPLEX: 2363 max = DBL_MAX; min = -DBL_MAX; break; 2364 case PTR: 2365 /* Got already an error because of float --> ptr */ 2366 case LDOUBLE: 2367 case LCOMPLEX: 2368 /* LINTED 248 */ 2369 max = LDBL_MAX; min = -max; break; 2370 default: 2371 lint_assert(/*CONSTCOND*/false); 2372 } 2373 if (v->v_ldbl > max || v->v_ldbl < min) { 2374 lint_assert(nt != LDOUBLE); 2375 if (op == FARG) { 2376 /* conversion of '%s' to '%s' is out of range, ... */ 2377 warning(295, 2378 type_name(gettyp(ot)), type_name(tp), arg); 2379 } else { 2380 /* conversion of '%s' to '%s' is out of range */ 2381 warning(119, 2382 type_name(gettyp(ot)), type_name(tp)); 2383 } 2384 v->v_ldbl = v->v_ldbl > 0 ? max : min; 2385 } 2386 2387 if (nt == FLOAT) { 2388 nv->v_ldbl = (float)v->v_ldbl; 2389 } else if (nt == DOUBLE) { 2390 nv->v_ldbl = (double)v->v_ldbl; 2391 } else if (nt == LDOUBLE) { 2392 nv->v_ldbl = v->v_ldbl; 2393 } else { 2394 nv->v_quad = (int64_t)v->v_ldbl; 2395 } 2396 } 2397 2398 static bool 2399 convert_constant_to_floating(tspec_t nt, val_t *nv, 2400 tspec_t ot, const val_t *v) 2401 { 2402 if (nt == FLOAT) { 2403 nv->v_ldbl = (ot == PTR || is_uinteger(ot)) ? 2404 (float)(uint64_t)v->v_quad : (float)v->v_quad; 2405 } else if (nt == DOUBLE) { 2406 nv->v_ldbl = (ot == PTR || is_uinteger(ot)) ? 2407 (double)(uint64_t)v->v_quad : (double)v->v_quad; 2408 } else if (nt == LDOUBLE) { 2409 nv->v_ldbl = (ot == PTR || is_uinteger(ot)) ? 2410 (ldbl_t)(uint64_t)v->v_quad : (ldbl_t)v->v_quad; 2411 } else 2412 return false; 2413 return true; 2414 } 2415 2416 /* 2417 * Print a warning if bits which were set are lost due to the conversion. 2418 * This can happen with operator ORASS only. 2419 */ 2420 static void 2421 convert_constant_check_range_bitor(size_t nsz, size_t osz, const val_t *v, 2422 uint64_t xmask, op_t op) 2423 { 2424 if (nsz < osz && (v->v_quad & xmask) != 0) { 2425 /* constant truncated by conversion, op %s */ 2426 warning(306, op_name(op)); 2427 } 2428 } 2429 2430 /* 2431 * Print a warning if additional bits are not all 1 2432 * and the most significant bit of the old value is 1, 2433 * or if at least one (but not all) removed bit was 0. 2434 */ 2435 static void 2436 convert_constant_check_range_bitand(size_t nsz, size_t osz, 2437 uint64_t xmask, const val_t *nv, 2438 tspec_t ot, const val_t *v, 2439 const type_t *tp, op_t op) 2440 { 2441 if (nsz > osz && 2442 (nv->v_quad & bit((unsigned int)(osz - 1))) != 0 && 2443 (nv->v_quad & xmask) != xmask) { 2444 /* extra bits set to 0 in conversion of '%s' to '%s', ... */ 2445 warning(309, type_name(gettyp(ot)), 2446 type_name(tp), op_name(op)); 2447 } else if (nsz < osz && 2448 (v->v_quad & xmask) != xmask && 2449 (v->v_quad & xmask) != 0) { 2450 /* constant truncated by conversion, op %s */ 2451 warning(306, op_name(op)); 2452 } 2453 } 2454 2455 static void 2456 convert_constant_check_range_signed(op_t op, int arg) 2457 { 2458 if (op == ASSIGN) { 2459 /* assignment of negative constant to unsigned type */ 2460 warning(164); 2461 } else if (op == INIT) { 2462 /* initialization of unsigned with negative constant */ 2463 warning(221); 2464 } else if (op == FARG) { 2465 /* conversion of negative constant to unsigned type, ... */ 2466 warning(296, arg); 2467 } else if (modtab[op].m_comparison) { 2468 /* handled by check_integer_comparison() */ 2469 } else { 2470 /* conversion of negative constant to unsigned type */ 2471 warning(222); 2472 } 2473 } 2474 2475 /* 2476 * Loss of significant bit(s). All truncated bits 2477 * of unsigned types or all truncated bits plus the 2478 * msb of the target for signed types are considered 2479 * to be significant bits. Loss of significant bits 2480 * means that at least one of the bits was set in an 2481 * unsigned type or that at least one but not all of 2482 * the bits was set in a signed type. 2483 * Loss of significant bits means that it is not 2484 * possible, also not with necessary casts, to convert 2485 * back to the original type. A example for a 2486 * necessary cast is: 2487 * char c; int i; c = 128; 2488 * i = c; ** yields -128 ** 2489 * i = (unsigned char)c; ** yields 128 ** 2490 */ 2491 static void 2492 convert_constant_check_range_truncated(op_t op, int arg, const type_t *tp, 2493 tspec_t ot) 2494 { 2495 if (op == ASSIGN && tp->t_bitfield) { 2496 /* precision lost in bit-field assignment */ 2497 warning(166); 2498 } else if (op == ASSIGN) { 2499 /* constant truncated by assignment */ 2500 warning(165); 2501 } else if (op == INIT && tp->t_bitfield) { 2502 /* bit-field initializer does not fit */ 2503 warning(180); 2504 } else if (op == INIT) { 2505 /* initializer does not fit */ 2506 warning(178); 2507 } else if (op == CASE) { 2508 /* case label affected by conversion */ 2509 warning(196); 2510 } else if (op == FARG) { 2511 /* conversion of '%s' to '%s' is out of range, arg #%d */ 2512 warning(295, 2513 type_name(gettyp(ot)), type_name(tp), arg); 2514 } else { 2515 /* conversion of '%s' to '%s' is out of range */ 2516 warning(119, 2517 type_name(gettyp(ot)), type_name(tp)); 2518 } 2519 } 2520 2521 static void 2522 convert_constant_check_range_loss(op_t op, int arg, const type_t *tp, 2523 tspec_t ot) 2524 { 2525 if (op == ASSIGN && tp->t_bitfield) { 2526 /* precision lost in bit-field assignment */ 2527 warning(166); 2528 } else if (op == INIT && tp->t_bitfield) { 2529 /* bit-field initializer out of range */ 2530 warning(11); 2531 } else if (op == CASE) { 2532 /* case label affected by conversion */ 2533 warning(196); 2534 } else if (op == FARG) { 2535 /* conversion of '%s' to '%s' is out of range, arg #%d */ 2536 warning(295, 2537 type_name(gettyp(ot)), type_name(tp), arg); 2538 } else { 2539 /* conversion of '%s' to '%s' is out of range */ 2540 warning(119, 2541 type_name(gettyp(ot)), type_name(tp)); 2542 } 2543 } 2544 2545 static void 2546 convert_constant_check_range(tspec_t ot, const type_t *tp, tspec_t nt, 2547 op_t op, int arg, const val_t *v, val_t *nv) 2548 { 2549 unsigned int osz, nsz; 2550 uint64_t xmask, xmsk1; 2551 2552 osz = size_in_bits(ot); 2553 nsz = tp->t_bitfield ? tp->t_flen : size_in_bits(nt); 2554 xmask = value_bits(nsz) ^ value_bits(osz); 2555 xmsk1 = value_bits(nsz) ^ value_bits(osz - 1); 2556 /* 2557 * For bitwise operations we are not interested in the 2558 * value, but in the bits itself. 2559 */ 2560 if (op == ORASS || op == BITOR || op == BITXOR) { 2561 convert_constant_check_range_bitor(nsz, osz, v, xmask, op); 2562 } else if (op == ANDASS || op == BITAND) { 2563 convert_constant_check_range_bitand(nsz, osz, xmask, nv, ot, 2564 v, tp, op); 2565 } else if ((nt != PTR && is_uinteger(nt)) && 2566 (ot != PTR && !is_uinteger(ot)) && 2567 v->v_quad < 0) { 2568 convert_constant_check_range_signed(op, arg); 2569 } else if (nv->v_quad != v->v_quad && nsz <= osz && 2570 (v->v_quad & xmask) != 0 && 2571 (is_uinteger(ot) || (v->v_quad & xmsk1) != xmsk1)) { 2572 convert_constant_check_range_truncated(op, arg, tp, ot); 2573 } else if (nv->v_quad != v->v_quad) { 2574 convert_constant_check_range_loss(op, arg, tp, ot); 2575 } 2576 } 2577 2578 /* 2579 * Converts a typed constant to a constant of another type. 2580 * 2581 * op operator which requires conversion 2582 * arg if op is FARG, # of argument 2583 * tp type in which to convert the constant 2584 * nv new constant 2585 * v old constant 2586 */ 2587 void 2588 convert_constant(op_t op, int arg, const type_t *tp, val_t *nv, val_t *v) 2589 { 2590 tspec_t ot, nt; 2591 unsigned int sz; 2592 bool range_check; 2593 2594 /* 2595 * TODO: make 'v' const; the name of this function does not suggest 2596 * that it modifies 'v'. 2597 */ 2598 ot = v->v_tspec; 2599 nt = nv->v_tspec = tp->t_tspec; 2600 range_check = false; 2601 2602 if (nt == BOOL) { /* C99 6.3.1.2 */ 2603 nv->v_unsigned_since_c90 = false; 2604 nv->v_quad = is_nonzero_val(v) ? 1 : 0; 2605 return; 2606 } 2607 2608 if (ot == FLOAT || ot == DOUBLE || ot == LDOUBLE) { 2609 convert_constant_floating(op, arg, ot, tp, nt, v, nv); 2610 } else if (!convert_constant_to_floating(nt, nv, ot, v)) { 2611 range_check = true; /* Check for lost precision. */ 2612 nv->v_quad = v->v_quad; 2613 } 2614 2615 if ((v->v_unsigned_since_c90 && is_floating(nt)) || 2616 (v->v_unsigned_since_c90 && (is_integer(nt) && !is_uinteger(nt) && 2617 portable_size_in_bits(nt) > 2618 portable_size_in_bits(ot)))) { 2619 /* ANSI C treats constant as unsigned */ 2620 warning(157); 2621 v->v_unsigned_since_c90 = false; 2622 } 2623 2624 if (is_integer(nt)) { 2625 sz = tp->t_bitfield ? tp->t_flen : size_in_bits(nt); 2626 nv->v_quad = convert_integer(nv->v_quad, nt, sz); 2627 } 2628 2629 if (range_check && op != CVT) 2630 convert_constant_check_range(ot, tp, nt, op, arg, v, nv); 2631 } 2632 2633 /* 2634 * Called if incompatible types were detected. 2635 * Prints a appropriate warning. 2636 */ 2637 static void 2638 warn_incompatible_types(op_t op, 2639 const type_t *ltp, tspec_t lt, 2640 const type_t *rtp, tspec_t rt) 2641 { 2642 const mod_t *mp; 2643 2644 mp = &modtab[op]; 2645 2646 if (lt == VOID || (mp->m_binary && rt == VOID)) { 2647 /* void type illegal in expression */ 2648 error(109); 2649 } else if (op == ASSIGN) { 2650 if ((lt == STRUCT || lt == UNION) && 2651 (rt == STRUCT || rt == UNION)) { 2652 /* assignment of different structures (%s != %s) */ 2653 error(240, tspec_name(lt), tspec_name(rt)); 2654 } else { 2655 /* cannot assign to '%s' from '%s' */ 2656 error(171, type_name(ltp), type_name(rtp)); 2657 } 2658 } else if (mp->m_binary) { 2659 /* operands of '%s' have incompatible types (%s != %s) */ 2660 error(107, mp->m_name, tspec_name(lt), tspec_name(rt)); 2661 } else { 2662 lint_assert(rt == NOTSPEC); 2663 /* operand of '%s' has invalid type (%s) */ 2664 error(108, mp->m_name, tspec_name(lt)); 2665 } 2666 } 2667 2668 /* 2669 * Called if incompatible pointer types are detected. 2670 * Print an appropriate warning. 2671 */ 2672 static void 2673 warn_incompatible_pointers(const mod_t *mp, 2674 const type_t *ltp, const type_t *rtp) 2675 { 2676 tspec_t lt, rt; 2677 2678 lint_assert(ltp->t_tspec == PTR); 2679 lint_assert(rtp->t_tspec == PTR); 2680 2681 lt = ltp->t_subt->t_tspec; 2682 rt = rtp->t_subt->t_tspec; 2683 2684 if ((lt == STRUCT || lt == UNION) && (rt == STRUCT || rt == UNION)) { 2685 if (mp == NULL) { 2686 /* illegal structure pointer combination */ 2687 warning(244); 2688 } else { 2689 /* incompatible structure pointers: '%s' '%s' '%s' */ 2690 warning(245, type_name(ltp), mp->m_name, type_name(rtp)); 2691 } 2692 } else { 2693 if (mp == NULL) { 2694 /* illegal combination of '%s' and '%s' */ 2695 warning(184, type_name(ltp), type_name(rtp)); 2696 } else { 2697 /* illegal combination of '%s' and '%s', op '%s' */ 2698 warning(124, 2699 type_name(ltp), type_name(rtp), mp->m_name); 2700 } 2701 } 2702 } 2703 2704 /* Return a type based on tp1, with added qualifiers from tp2. */ 2705 static type_t * 2706 merge_qualifiers(type_t *tp1, const type_t *tp2) 2707 { 2708 type_t *ntp, *nstp; 2709 2710 lint_assert(tp1->t_tspec == PTR); 2711 lint_assert(tp2->t_tspec == PTR); 2712 2713 bool c1 = tp1->t_subt->t_const; 2714 bool c2 = tp2->t_subt->t_const; 2715 bool v1 = tp1->t_subt->t_volatile; 2716 bool v2 = tp2->t_subt->t_volatile; 2717 2718 if (c1 == (c1 | c2) && v1 == (v1 | v2)) 2719 return tp1; 2720 2721 nstp = expr_dup_type(tp1->t_subt); 2722 nstp->t_const |= c2; 2723 nstp->t_volatile |= v2; 2724 2725 ntp = expr_dup_type(tp1); 2726 ntp->t_subt = nstp; 2727 return ntp; 2728 } 2729 2730 /* 2731 * Returns true if the given structure or union has a constant member 2732 * (maybe recursively). 2733 */ 2734 static bool 2735 has_constant_member(const type_t *tp) 2736 { 2737 sym_t *m; 2738 2739 lint_assert(is_struct_or_union(tp->t_tspec)); 2740 2741 for (m = tp->t_str->sou_first_member; m != NULL; m = m->s_next) { 2742 const type_t *mtp = m->s_type; 2743 if (mtp->t_const) 2744 return true; 2745 if (is_struct_or_union(mtp->t_tspec) && 2746 has_constant_member(mtp)) 2747 return true; 2748 } 2749 return false; 2750 } 2751 2752 /* 2753 * Create a new node for one of the operators POINT and ARROW. 2754 */ 2755 static tnode_t * 2756 build_struct_access(op_t op, tnode_t *ln, tnode_t *rn) 2757 { 2758 tnode_t *ntn, *ctn; 2759 bool nolval; 2760 2761 lint_assert(rn->tn_op == NAME); 2762 lint_assert(rn->tn_sym->s_value.v_tspec == INT); 2763 lint_assert(rn->tn_sym->s_scl == MOS || rn->tn_sym->s_scl == MOU); 2764 2765 /* 2766 * Remember if the left operand is an lvalue (structure members 2767 * are lvalues if and only if the structure itself is an lvalue). 2768 */ 2769 nolval = op == POINT && !ln->tn_lvalue; 2770 2771 if (op == POINT) { 2772 ln = build_address(ln, true); 2773 } else if (ln->tn_type->t_tspec != PTR) { 2774 lint_assert(tflag); 2775 lint_assert(is_integer(ln->tn_type->t_tspec)); 2776 ln = convert(NOOP, 0, expr_derive_type(gettyp(VOID), PTR), ln); 2777 } 2778 2779 ctn = build_integer_constant(PTRDIFF_TSPEC, 2780 rn->tn_sym->s_value.v_quad / CHAR_SIZE); 2781 2782 ntn = new_tnode(PLUS, expr_derive_type(rn->tn_type, PTR), ln, ctn); 2783 if (ln->tn_op == CON) 2784 ntn = fold(ntn); 2785 2786 if (rn->tn_type->t_bitfield) { 2787 ntn = new_tnode(FSEL, ntn->tn_type->t_subt, ntn, NULL); 2788 } else { 2789 ntn = new_tnode(INDIR, ntn->tn_type->t_subt, ntn, NULL); 2790 } 2791 2792 if (nolval) 2793 ntn->tn_lvalue = false; 2794 2795 return ntn; 2796 } 2797 2798 /* 2799 * Create a node for INCAFT, INCBEF, DECAFT and DECBEF. 2800 */ 2801 static tnode_t * 2802 build_prepost_incdec(op_t op, tnode_t *ln) 2803 { 2804 tnode_t *cn, *ntn; 2805 2806 lint_assert(ln != NULL); 2807 2808 if (ln->tn_type->t_tspec == PTR) { 2809 cn = plength(ln->tn_type); 2810 } else { 2811 cn = build_integer_constant(INT, (int64_t)1); 2812 } 2813 ntn = new_tnode(op, ln->tn_type, ln, cn); 2814 2815 return ntn; 2816 } 2817 2818 /* 2819 * Create a node for REAL, IMAG 2820 */ 2821 static tnode_t * 2822 build_real_imag(op_t op, tnode_t *ln) 2823 { 2824 tnode_t *cn, *ntn; 2825 2826 lint_assert(ln != NULL); 2827 2828 if (ln->tn_op == NAME) { 2829 /* 2830 * This may be too much, but it avoids wrong warnings. 2831 * See d_c99_complex_split.c. 2832 */ 2833 mark_as_used(ln->tn_sym, false, false); 2834 mark_as_set(ln->tn_sym); 2835 } 2836 2837 switch (ln->tn_type->t_tspec) { 2838 case LCOMPLEX: 2839 /* XXX: integer and LDOUBLE don't match. */ 2840 cn = build_integer_constant(LDOUBLE, (int64_t)1); 2841 break; 2842 case DCOMPLEX: 2843 /* XXX: integer and DOUBLE don't match. */ 2844 cn = build_integer_constant(DOUBLE, (int64_t)1); 2845 break; 2846 case FCOMPLEX: 2847 /* XXX: integer and FLOAT don't match. */ 2848 cn = build_integer_constant(FLOAT, (int64_t)1); 2849 break; 2850 default: 2851 /* __%s__ is illegal for type %s */ 2852 error(276, op == REAL ? "real" : "imag", 2853 type_name(ln->tn_type)); 2854 return NULL; 2855 } 2856 ntn = new_tnode(op, cn->tn_type, ln, cn); 2857 ntn->tn_lvalue = true; 2858 2859 return ntn; 2860 } 2861 2862 /* 2863 * Create a tree node for the unary & operator 2864 */ 2865 static tnode_t * 2866 build_address(tnode_t *tn, bool noign) 2867 { 2868 tspec_t t; 2869 2870 if (!noign && ((t = tn->tn_type->t_tspec) == ARRAY || t == FUNC)) { 2871 if (tflag) 2872 /* '&' before array or function: ignored */ 2873 warning(127); 2874 return tn; 2875 } 2876 2877 /* eliminate &* */ 2878 if (tn->tn_op == INDIR && 2879 tn->tn_left->tn_type->t_tspec == PTR && 2880 tn->tn_left->tn_type->t_subt == tn->tn_type) { 2881 return tn->tn_left; 2882 } 2883 2884 return new_tnode(ADDR, expr_derive_type(tn->tn_type, PTR), tn, NULL); 2885 } 2886 2887 /* 2888 * Create a node for operators PLUS and MINUS. 2889 */ 2890 static tnode_t * 2891 build_plus_minus(op_t op, tnode_t *ln, tnode_t *rn) 2892 { 2893 tnode_t *ntn, *ctn; 2894 type_t *tp; 2895 2896 /* If pointer and integer, then pointer to the lhs. */ 2897 if (rn->tn_type->t_tspec == PTR && is_integer(ln->tn_type->t_tspec)) { 2898 ntn = ln; 2899 ln = rn; 2900 rn = ntn; 2901 } 2902 2903 if (ln->tn_type->t_tspec == PTR && rn->tn_type->t_tspec != PTR) { 2904 lint_assert(is_integer(rn->tn_type->t_tspec)); 2905 2906 check_ctype_macro_invocation(ln, rn); 2907 check_enum_array_index(ln, rn); 2908 2909 ctn = plength(ln->tn_type); 2910 if (rn->tn_type->t_tspec != ctn->tn_type->t_tspec) 2911 rn = convert(NOOP, 0, ctn->tn_type, rn); 2912 rn = new_tnode(MULT, rn->tn_type, rn, ctn); 2913 if (rn->tn_left->tn_op == CON) 2914 rn = fold(rn); 2915 ntn = new_tnode(op, ln->tn_type, ln, rn); 2916 2917 } else if (rn->tn_type->t_tspec == PTR) { 2918 2919 lint_assert(ln->tn_type->t_tspec == PTR); 2920 lint_assert(op == MINUS); 2921 tp = gettyp(PTRDIFF_TSPEC); 2922 ntn = new_tnode(op, tp, ln, rn); 2923 if (ln->tn_op == CON && rn->tn_op == CON) 2924 ntn = fold(ntn); 2925 ctn = plength(ln->tn_type); 2926 balance(NOOP, &ntn, &ctn); 2927 ntn = new_tnode(DIV, tp, ntn, ctn); 2928 2929 } else { 2930 2931 ntn = new_tnode(op, ln->tn_type, ln, rn); 2932 2933 } 2934 return ntn; 2935 } 2936 2937 /* 2938 * Create a node for operators SHL and SHR. 2939 */ 2940 static tnode_t * 2941 build_bit_shift(op_t op, tnode_t *ln, tnode_t *rn) 2942 { 2943 tspec_t t; 2944 tnode_t *ntn; 2945 2946 if ((t = rn->tn_type->t_tspec) != INT && t != UINT) 2947 rn = convert(CVT, 0, gettyp(INT), rn); 2948 ntn = new_tnode(op, ln->tn_type, ln, rn); 2949 return ntn; 2950 } 2951 2952 /* 2953 * Create a node for COLON. 2954 */ 2955 static tnode_t * 2956 build_colon(tnode_t *ln, tnode_t *rn) 2957 { 2958 tspec_t lt, rt, pdt; 2959 type_t *tp; 2960 tnode_t *ntn; 2961 2962 lt = ln->tn_type->t_tspec; 2963 rt = rn->tn_type->t_tspec; 2964 pdt = PTRDIFF_TSPEC; 2965 2966 /* 2967 * Arithmetic types are balanced, all other type combinations 2968 * still need to be handled. 2969 */ 2970 if (is_arithmetic(lt) && is_arithmetic(rt)) { 2971 tp = ln->tn_type; 2972 } else if (lt == BOOL && rt == BOOL) { 2973 tp = ln->tn_type; 2974 } else if (lt == VOID || rt == VOID) { 2975 tp = gettyp(VOID); 2976 } else if (lt == STRUCT || lt == UNION) { 2977 /* Both types must be identical. */ 2978 lint_assert(rt == STRUCT || rt == UNION); 2979 lint_assert(ln->tn_type->t_str == rn->tn_type->t_str); 2980 if (is_incomplete(ln->tn_type)) { 2981 /* unknown operand size, op %s */ 2982 error(138, op_name(COLON)); 2983 return NULL; 2984 } 2985 tp = ln->tn_type; 2986 } else if (lt == PTR && is_integer(rt)) { 2987 if (rt != pdt) { 2988 rn = convert(NOOP, 0, gettyp(pdt), rn); 2989 rt = pdt; 2990 } 2991 tp = ln->tn_type; 2992 } else if (rt == PTR && is_integer(lt)) { 2993 if (lt != pdt) { 2994 ln = convert(NOOP, 0, gettyp(pdt), ln); 2995 lt = pdt; 2996 } 2997 tp = rn->tn_type; 2998 } else if (lt == PTR && ln->tn_type->t_subt->t_tspec == VOID) { 2999 tp = merge_qualifiers(rn->tn_type, ln->tn_type); 3000 } else if (rt == PTR && rn->tn_type->t_subt->t_tspec == VOID) { 3001 tp = merge_qualifiers(ln->tn_type, rn->tn_type); 3002 } else { 3003 /* 3004 * XXX For now we simply take the left type. This is 3005 * probably wrong, if one type contains a function prototype 3006 * and the other one, at the same place, only an old style 3007 * declaration. 3008 */ 3009 tp = merge_qualifiers(ln->tn_type, rn->tn_type); 3010 } 3011 3012 ntn = new_tnode(COLON, tp, ln, rn); 3013 3014 return ntn; 3015 } 3016 3017 /* 3018 * Create a node for an assignment operator (both = and op= ). 3019 */ 3020 static tnode_t * 3021 build_assignment(op_t op, tnode_t *ln, tnode_t *rn) 3022 { 3023 tspec_t lt, rt; 3024 tnode_t *ntn, *ctn; 3025 3026 lint_assert(ln != NULL); 3027 lint_assert(rn != NULL); 3028 3029 lt = ln->tn_type->t_tspec; 3030 rt = rn->tn_type->t_tspec; 3031 3032 if ((op == ADDASS || op == SUBASS) && lt == PTR) { 3033 lint_assert(is_integer(rt)); 3034 ctn = plength(ln->tn_type); 3035 if (rn->tn_type->t_tspec != ctn->tn_type->t_tspec) 3036 rn = convert(NOOP, 0, ctn->tn_type, rn); 3037 rn = new_tnode(MULT, rn->tn_type, rn, ctn); 3038 if (rn->tn_left->tn_op == CON) 3039 rn = fold(rn); 3040 } 3041 3042 if ((op == ASSIGN || op == RETURN || op == INIT) && 3043 (lt == STRUCT || rt == STRUCT)) { 3044 lint_assert(lt == rt); 3045 lint_assert(ln->tn_type->t_str == rn->tn_type->t_str); 3046 if (is_incomplete(ln->tn_type)) { 3047 if (op == RETURN) { 3048 /* cannot return incomplete type */ 3049 error(212); 3050 } else { 3051 /* unknown operand size, op %s */ 3052 error(138, op_name(op)); 3053 } 3054 return NULL; 3055 } 3056 } 3057 3058 if (op == SHLASS) { 3059 if (portable_size_in_bits(lt) < portable_size_in_bits(rt)) { 3060 if (hflag) 3061 /* semantics of '%s' change in ANSI C; ... */ 3062 warning(118, "<<="); 3063 } 3064 } else if (op != SHRASS) { 3065 if (op == ASSIGN || lt != PTR) { 3066 if (lt != rt || 3067 (ln->tn_type->t_bitfield && rn->tn_op == CON)) { 3068 rn = convert(op, 0, ln->tn_type, rn); 3069 rt = lt; 3070 } 3071 } 3072 } 3073 3074 ntn = new_tnode(op, ln->tn_type, ln, rn); 3075 3076 return ntn; 3077 } 3078 3079 /* 3080 * Get length of type tp->t_subt, as a constant expression of type ptrdiff_t 3081 * as seen from the target platform. 3082 */ 3083 static tnode_t * 3084 plength(type_t *tp) 3085 { 3086 int elem, elsz_in_bits; 3087 3088 lint_assert(tp->t_tspec == PTR); 3089 tp = tp->t_subt; 3090 3091 elem = 1; 3092 elsz_in_bits = 0; 3093 3094 while (tp->t_tspec == ARRAY) { 3095 elem *= tp->t_dim; 3096 tp = tp->t_subt; 3097 } 3098 3099 switch (tp->t_tspec) { 3100 case FUNC: 3101 /* pointer to function is not allowed here */ 3102 error(110); 3103 break; 3104 case VOID: 3105 /* cannot do pointer arithmetic on operand of unknown size */ 3106 gnuism(136); 3107 break; 3108 case STRUCT: 3109 case UNION: 3110 if ((elsz_in_bits = tp->t_str->sou_size_in_bits) == 0) 3111 /* cannot do pointer arithmetic on operand of ... */ 3112 error(136); 3113 break; 3114 case ENUM: 3115 if (is_incomplete(tp)) { 3116 /* cannot do pointer arithmetic on operand of ... */ 3117 warning(136); 3118 } 3119 /* FALLTHROUGH */ 3120 default: 3121 if ((elsz_in_bits = size_in_bits(tp->t_tspec)) == 0) { 3122 /* cannot do pointer arithmetic on operand of ... */ 3123 error(136); 3124 } else { 3125 lint_assert(elsz_in_bits != -1); 3126 } 3127 break; 3128 } 3129 3130 if (elem == 0 && elsz_in_bits != 0) { 3131 /* cannot do pointer arithmetic on operand of unknown size */ 3132 error(136); 3133 } 3134 3135 if (elsz_in_bits == 0) 3136 elsz_in_bits = CHAR_SIZE; 3137 3138 return build_integer_constant(PTRDIFF_TSPEC, 3139 (int64_t)(elem * elsz_in_bits / CHAR_SIZE)); 3140 } 3141 3142 /* 3143 * XXX 3144 * Note: There appear to be a number of bugs in detecting overflow in 3145 * this function. An audit and a set of proper regression tests are needed. 3146 * --Perry Metzger, Nov. 16, 2001 3147 */ 3148 /* 3149 * Do only as much as necessary to compute constant expressions. 3150 * Called only if the operator allows folding and all operands are constants. 3151 */ 3152 static tnode_t * 3153 fold(tnode_t *tn) 3154 { 3155 val_t *v; 3156 tspec_t t; 3157 bool utyp, ovfl; 3158 int64_t sl, sr = 0, q = 0, mask; 3159 uint64_t ul, ur = 0; 3160 tnode_t *cn; 3161 3162 v = xcalloc(1, sizeof(*v)); 3163 v->v_tspec = tn->tn_type->t_tspec; 3164 3165 t = tn->tn_left->tn_type->t_tspec; 3166 utyp = !is_integer(t) || is_uinteger(t); 3167 ul = sl = tn->tn_left->tn_val->v_quad; 3168 if (is_binary(tn)) 3169 ur = sr = tn->tn_right->tn_val->v_quad; 3170 3171 mask = value_bits(size_in_bits(t)); 3172 ovfl = false; 3173 3174 switch (tn->tn_op) { 3175 case UPLUS: 3176 q = sl; 3177 break; 3178 case UMINUS: 3179 q = -sl; 3180 if (sl != 0 && msb(q, t) == msb(sl, t)) 3181 ovfl = true; 3182 break; 3183 case COMPL: 3184 q = ~sl; 3185 break; 3186 case MULT: 3187 if (utyp) { 3188 q = ul * ur; 3189 if (q != (q & mask)) 3190 ovfl = true; 3191 else if ((ul != 0) && ((q / ul) != ur)) 3192 ovfl = true; 3193 } else { 3194 q = sl * sr; 3195 if (msb(q, t) != (msb(sl, t) ^ msb(sr, t))) 3196 ovfl = true; 3197 } 3198 break; 3199 case DIV: 3200 if (sr == 0) { 3201 /* division by 0 */ 3202 error(139); 3203 q = utyp ? -1 : INT64_MAX; 3204 } else { 3205 q = utyp ? (int64_t)(ul / ur) : sl / sr; 3206 } 3207 break; 3208 case MOD: 3209 if (sr == 0) { 3210 /* modulus by 0 */ 3211 error(140); 3212 q = 0; 3213 } else { 3214 q = utyp ? (int64_t)(ul % ur) : sl % sr; 3215 } 3216 break; 3217 case PLUS: 3218 q = utyp ? (int64_t)(ul + ur) : sl + sr; 3219 if (msb(sl, t) && msb(sr, t) && !msb(q, t)) 3220 ovfl = true; 3221 if (!utyp && !msb(sl, t) && !msb(sr, t) && msb(q, t)) 3222 ovfl = true; 3223 break; 3224 case MINUS: 3225 q = utyp ? (int64_t)(ul - ur) : sl - sr; 3226 if (!utyp && msb(sl, t) && !msb(sr, t) && !msb(q, t)) 3227 ovfl = true; 3228 if (!msb(sl, t) && msb(sr, t) && msb(q, t)) 3229 ovfl = true; 3230 break; 3231 case SHL: 3232 q = utyp ? (int64_t)(ul << sr) : sl << sr; 3233 break; 3234 case SHR: 3235 /* 3236 * The sign must be explicitly extended because 3237 * shifts of signed values are implementation dependent. 3238 */ 3239 q = ul >> sr; 3240 q = convert_integer(q, t, size_in_bits(t) - (int)sr); 3241 break; 3242 case LT: 3243 q = (utyp ? ul < ur : sl < sr) ? 1 : 0; 3244 break; 3245 case LE: 3246 q = (utyp ? ul <= ur : sl <= sr) ? 1 : 0; 3247 break; 3248 case GE: 3249 q = (utyp ? ul >= ur : sl >= sr) ? 1 : 0; 3250 break; 3251 case GT: 3252 q = (utyp ? ul > ur : sl > sr) ? 1 : 0; 3253 break; 3254 case EQ: 3255 q = (utyp ? ul == ur : sl == sr) ? 1 : 0; 3256 break; 3257 case NE: 3258 q = (utyp ? ul != ur : sl != sr) ? 1 : 0; 3259 break; 3260 case BITAND: 3261 q = utyp ? (int64_t)(ul & ur) : sl & sr; 3262 break; 3263 case BITXOR: 3264 q = utyp ? (int64_t)(ul ^ ur) : sl ^ sr; 3265 break; 3266 case BITOR: 3267 q = utyp ? (int64_t)(ul | ur) : sl | sr; 3268 break; 3269 default: 3270 lint_assert(/*CONSTCOND*/false); 3271 } 3272 3273 /* XXX does not work for quads. */ 3274 if (ovfl || 3275 ((uint64_t)(q | mask) != ~(uint64_t)0 && (q & ~mask) != 0)) { 3276 if (hflag) 3277 /* integer overflow detected, op '%s' */ 3278 warning(141, op_name(tn->tn_op)); 3279 } 3280 3281 v->v_quad = convert_integer(q, t, 0); 3282 3283 cn = build_constant(tn->tn_type, v); 3284 if (tn->tn_left->tn_system_dependent) 3285 cn->tn_system_dependent = true; 3286 if (is_binary(tn) && tn->tn_right->tn_system_dependent) 3287 cn->tn_system_dependent = true; 3288 3289 return cn; 3290 } 3291 3292 /* 3293 * Fold constant nodes, as much as is needed for comparing the value with 0 3294 * (test context, for controlling expressions). 3295 */ 3296 static tnode_t * 3297 fold_test(tnode_t *tn) 3298 { 3299 bool l, r; 3300 val_t *v; 3301 3302 v = xcalloc(1, sizeof(*v)); 3303 v->v_tspec = tn->tn_type->t_tspec; 3304 lint_assert(v->v_tspec == INT || (Tflag && v->v_tspec == BOOL)); 3305 3306 l = constant_is_nonzero(tn->tn_left); 3307 r = is_binary(tn) && constant_is_nonzero(tn->tn_right); 3308 3309 switch (tn->tn_op) { 3310 case NOT: 3311 if (hflag && !constcond_flag) 3312 /* constant argument to '!' */ 3313 warning(239); 3314 v->v_quad = !l ? 1 : 0; 3315 break; 3316 case LOGAND: 3317 v->v_quad = l && r ? 1 : 0; 3318 break; 3319 case LOGOR: 3320 v->v_quad = l || r ? 1 : 0; 3321 break; 3322 default: 3323 lint_assert(/*CONSTCOND*/false); 3324 } 3325 3326 return build_constant(tn->tn_type, v); 3327 } 3328 3329 static ldbl_t 3330 floating_error_value(tspec_t t, ldbl_t lv) 3331 { 3332 if (t == FLOAT) { 3333 return lv < 0 ? -FLT_MAX : FLT_MAX; 3334 } else if (t == DOUBLE) { 3335 return lv < 0 ? -DBL_MAX : DBL_MAX; 3336 } else { 3337 /* LINTED 248: floating-point constant out of range */ 3338 ldbl_t max = LDBL_MAX; 3339 return lv < 0 ? -max : max; 3340 } 3341 } 3342 3343 /* 3344 * Fold constant nodes having operands with floating point type. 3345 */ 3346 static tnode_t * 3347 fold_float(tnode_t *tn) 3348 { 3349 val_t *v; 3350 tspec_t t; 3351 ldbl_t lv, rv = 0; 3352 3353 fpe = 0; 3354 v = xcalloc(1, sizeof(*v)); 3355 v->v_tspec = t = tn->tn_type->t_tspec; 3356 3357 lint_assert(is_floating(t)); 3358 lint_assert(t == tn->tn_left->tn_type->t_tspec); 3359 lint_assert(!is_binary(tn) || t == tn->tn_right->tn_type->t_tspec); 3360 3361 lv = tn->tn_left->tn_val->v_ldbl; 3362 if (is_binary(tn)) 3363 rv = tn->tn_right->tn_val->v_ldbl; 3364 3365 switch (tn->tn_op) { 3366 case UPLUS: 3367 v->v_ldbl = lv; 3368 break; 3369 case UMINUS: 3370 v->v_ldbl = -lv; 3371 break; 3372 case MULT: 3373 v->v_ldbl = lv * rv; 3374 break; 3375 case DIV: 3376 if (rv == 0.0) { 3377 /* division by 0 */ 3378 error(139); 3379 v->v_ldbl = floating_error_value(t, lv); 3380 } else { 3381 v->v_ldbl = lv / rv; 3382 } 3383 break; 3384 case PLUS: 3385 v->v_ldbl = lv + rv; 3386 break; 3387 case MINUS: 3388 v->v_ldbl = lv - rv; 3389 break; 3390 case LT: 3391 v->v_quad = lv < rv ? 1 : 0; 3392 break; 3393 case LE: 3394 v->v_quad = lv <= rv ? 1 : 0; 3395 break; 3396 case GE: 3397 v->v_quad = lv >= rv ? 1 : 0; 3398 break; 3399 case GT: 3400 v->v_quad = lv > rv ? 1 : 0; 3401 break; 3402 case EQ: 3403 v->v_quad = lv == rv ? 1 : 0; 3404 break; 3405 case NE: 3406 v->v_quad = lv != rv ? 1 : 0; 3407 break; 3408 default: 3409 lint_assert(/*CONSTCOND*/false); 3410 } 3411 3412 lint_assert(fpe != 0 || isnan((double)v->v_ldbl) == 0); 3413 if (fpe != 0 || isfinite((double)v->v_ldbl) == 0 || 3414 (t == FLOAT && 3415 (v->v_ldbl > FLT_MAX || v->v_ldbl < -FLT_MAX)) || 3416 (t == DOUBLE && 3417 (v->v_ldbl > DBL_MAX || v->v_ldbl < -DBL_MAX))) { 3418 /* floating point overflow detected, op %s */ 3419 warning(142, op_name(tn->tn_op)); 3420 v->v_ldbl = floating_error_value(t, v->v_ldbl); 3421 fpe = 0; 3422 } 3423 3424 return build_constant(tn->tn_type, v); 3425 } 3426 3427 3428 /* 3429 * Create a constant node for sizeof. 3430 */ 3431 tnode_t * 3432 build_sizeof(const type_t *tp) 3433 { 3434 unsigned int size_in_bytes = type_size_in_bits(tp) / CHAR_SIZE; 3435 tnode_t *tn = build_integer_constant(SIZEOF_TSPEC, size_in_bytes); 3436 tn->tn_system_dependent = true; 3437 return tn; 3438 } 3439 3440 /* 3441 * Create a constant node for offsetof. 3442 */ 3443 /* ARGSUSED */ /* See implementation comments. */ 3444 tnode_t * 3445 build_offsetof(const type_t *tp, const sym_t *sym) 3446 { 3447 tspec_t t = tp->t_tspec; 3448 if (t != STRUCT && t != UNION) 3449 /* unacceptable operand of '%s' */ 3450 error(111, "offsetof"); 3451 3452 // XXX: wrong size, no checking for sym fixme 3453 unsigned int offset_in_bytes = type_size_in_bits(tp) / CHAR_SIZE; 3454 tnode_t *tn = build_integer_constant(SIZEOF_TSPEC, offset_in_bytes); 3455 tn->tn_system_dependent = true; 3456 return tn; 3457 } 3458 3459 unsigned int 3460 type_size_in_bits(const type_t *tp) 3461 { 3462 unsigned int elem, elsz; 3463 bool flex; 3464 3465 elem = 1; 3466 flex = false; 3467 while (tp->t_tspec == ARRAY) { 3468 flex = true; /* allow c99 flex arrays [] [0] */ 3469 elem *= tp->t_dim; 3470 tp = tp->t_subt; 3471 } 3472 if (elem == 0) { 3473 if (!flex) { 3474 /* cannot take size/alignment of incomplete type */ 3475 error(143); 3476 elem = 1; 3477 } 3478 } 3479 switch (tp->t_tspec) { 3480 case FUNC: 3481 /* cannot take size/alignment of function */ 3482 error(144); 3483 elsz = 1; 3484 break; 3485 case STRUCT: 3486 case UNION: 3487 if (is_incomplete(tp)) { 3488 /* cannot take size/alignment of incomplete type */ 3489 error(143); 3490 elsz = 1; 3491 } else { 3492 elsz = tp->t_str->sou_size_in_bits; 3493 } 3494 break; 3495 case ENUM: 3496 if (is_incomplete(tp)) { 3497 /* cannot take size/alignment of incomplete type */ 3498 warning(143); 3499 } 3500 /* FALLTHROUGH */ 3501 default: 3502 if (tp->t_bitfield) { 3503 /* cannot take size/alignment of bit-field */ 3504 error(145); 3505 } 3506 if (tp->t_tspec == VOID) { 3507 /* cannot take size/alignment of void */ 3508 error(146); 3509 elsz = 1; 3510 } else { 3511 elsz = size_in_bits(tp->t_tspec); 3512 lint_assert(elsz > 0); 3513 } 3514 break; 3515 } 3516 3517 return elem * elsz; 3518 } 3519 3520 tnode_t * 3521 build_alignof(const type_t *tp) 3522 { 3523 switch (tp->t_tspec) { 3524 case ARRAY: 3525 break; 3526 3527 case FUNC: 3528 /* cannot take size/alignment of function */ 3529 error(144); 3530 return 0; 3531 3532 case STRUCT: 3533 case UNION: 3534 if (is_incomplete(tp)) { 3535 /* cannot take size/alignment of incomplete type */ 3536 error(143); 3537 return 0; 3538 } 3539 break; 3540 case ENUM: 3541 break; 3542 default: 3543 if (tp->t_bitfield) { 3544 /* cannot take size/alignment of bit-field */ 3545 error(145); 3546 return 0; 3547 } 3548 if (tp->t_tspec == VOID) { 3549 /* cannot take size/alignment of void */ 3550 error(146); 3551 return 0; 3552 } 3553 break; 3554 } 3555 3556 return build_integer_constant(SIZEOF_TSPEC, 3557 (int64_t)alignment_in_bits(tp) / CHAR_SIZE); 3558 } 3559 3560 /* 3561 * Type casts. 3562 */ 3563 tnode_t * 3564 cast(tnode_t *tn, type_t *tp) 3565 { 3566 tspec_t nt, ot; 3567 3568 if (tn == NULL) 3569 return NULL; 3570 3571 /* 3572 * XXX: checking for tp == NULL is only a quick fix for PR 22119. 3573 * The proper fix needs to be investigated properly. 3574 * See d_pr_22119.c for how to get here. 3575 */ 3576 if (tp == NULL) 3577 return NULL; 3578 3579 tn = cconv(tn); 3580 3581 nt = tp->t_tspec; 3582 ot = tn->tn_type->t_tspec; 3583 3584 if (nt == VOID) { 3585 /* 3586 * XXX ANSI C requires scalar types or void (Plauger & Brodie). 3587 * But this seems really questionable. 3588 */ 3589 } else if (nt == UNION) { 3590 sym_t *m; 3591 struct_or_union *str = tp->t_str; 3592 if (!gflag) { 3593 /* union cast is a GCC extension */ 3594 error(328); 3595 return NULL; 3596 } 3597 for (m = str->sou_first_member; m != NULL; m = m->s_next) { 3598 if (eqtype(m->s_type, tn->tn_type, 3599 false, false, NULL)) { 3600 tn = expr_zalloc_tnode(); 3601 tn->tn_op = CVT; 3602 tn->tn_type = tp; 3603 tn->tn_cast = true; 3604 tn->tn_right = NULL; 3605 return tn; 3606 } 3607 } 3608 /* type '%s' is not a member of '%s' */ 3609 error(329, type_name(tn->tn_type), type_name(tp)); 3610 return NULL; 3611 } else if (nt == STRUCT || nt == ARRAY || nt == FUNC) { 3612 /* Casting to a struct is an undocumented GCC extension. */ 3613 if (!(gflag && nt == STRUCT)) 3614 goto invalid_cast; 3615 } else if (ot == STRUCT || ot == UNION) { 3616 goto invalid_cast; 3617 } else if (ot == VOID) { 3618 /* improper cast of void expression */ 3619 error(148); 3620 return NULL; 3621 } else if (is_integer(nt) && is_scalar(ot)) { 3622 /* ok */ 3623 } else if (is_floating(nt) && is_arithmetic(ot)) { 3624 /* ok */ 3625 } else if (nt == PTR && is_integer(ot)) { 3626 /* ok */ 3627 } else if (nt == PTR && ot == PTR) { 3628 if (!tp->t_subt->t_const && tn->tn_type->t_subt->t_const) { 3629 if (hflag) 3630 /* cast discards 'const' from type '%s' */ 3631 warning(275, type_name(tn->tn_type)); 3632 } 3633 } else 3634 goto invalid_cast; 3635 3636 tn = convert(CVT, 0, tp, tn); 3637 tn->tn_cast = true; 3638 3639 return tn; 3640 3641 invalid_cast: 3642 /* invalid cast from '%s' to '%s' */ 3643 error(147, type_name(tn->tn_type), type_name(tp)); 3644 return NULL; 3645 } 3646 3647 /* 3648 * Create the node for a function argument. 3649 * All necessary conversions and type checks are done in 3650 * build_function_call because build_function_argument has no 3651 * information about expected argument types. 3652 */ 3653 tnode_t * 3654 build_function_argument(tnode_t *args, tnode_t *arg) 3655 { 3656 tnode_t *ntn; 3657 3658 /* 3659 * If there was a serious error in the expression for the argument, 3660 * create a dummy argument so the positions of the remaining arguments 3661 * will not change. 3662 */ 3663 if (arg == NULL) 3664 arg = build_integer_constant(INT, 0); 3665 3666 ntn = new_tnode(PUSH, arg->tn_type, arg, args); 3667 3668 return ntn; 3669 } 3670 3671 /* 3672 * Create the node for a function call. Also check types of 3673 * function arguments and insert conversions, if necessary. 3674 */ 3675 tnode_t * 3676 build_function_call(tnode_t *func, tnode_t *args) 3677 { 3678 tnode_t *ntn; 3679 op_t fcop; 3680 3681 if (func == NULL) 3682 return NULL; 3683 3684 if (func->tn_op == NAME && func->tn_type->t_tspec == FUNC) { 3685 fcop = CALL; 3686 } else { 3687 fcop = ICALL; 3688 } 3689 3690 check_ctype_function_call(func, args); 3691 3692 /* 3693 * after cconv() func will always be a pointer to a function 3694 * if it is a valid function designator. 3695 */ 3696 func = cconv(func); 3697 3698 if (func->tn_type->t_tspec != PTR || 3699 func->tn_type->t_subt->t_tspec != FUNC) { 3700 /* illegal function (type %s) */ 3701 error(149, type_name(func->tn_type)); 3702 return NULL; 3703 } 3704 3705 args = check_function_arguments(func->tn_type->t_subt, args); 3706 3707 ntn = new_tnode(fcop, func->tn_type->t_subt->t_subt, func, args); 3708 3709 return ntn; 3710 } 3711 3712 /* 3713 * Check types of all function arguments and insert conversions, 3714 * if necessary. 3715 */ 3716 static tnode_t * 3717 check_function_arguments(type_t *ftp, tnode_t *args) 3718 { 3719 tnode_t *arg; 3720 sym_t *asym; 3721 tspec_t at; 3722 int narg, npar, n, i; 3723 3724 /* get # of args in the prototype */ 3725 npar = 0; 3726 for (asym = ftp->t_args; asym != NULL; asym = asym->s_next) 3727 npar++; 3728 3729 /* get # of args in function call */ 3730 narg = 0; 3731 for (arg = args; arg != NULL; arg = arg->tn_right) 3732 narg++; 3733 3734 asym = ftp->t_args; 3735 if (ftp->t_proto && npar != narg && !(ftp->t_vararg && npar < narg)) { 3736 /* argument mismatch: %d arg%s passed, %d expected */ 3737 error(150, narg, narg > 1 ? "s" : "", npar); 3738 asym = NULL; 3739 } 3740 3741 for (n = 1; n <= narg; n++) { 3742 3743 /* 3744 * The rightmost argument is at the top of the argument 3745 * subtree. 3746 */ 3747 for (i = narg, arg = args; i > n; i--, arg = arg->tn_right) 3748 continue; 3749 3750 /* some things which are always not allowed */ 3751 if ((at = arg->tn_left->tn_type->t_tspec) == VOID) { 3752 /* void expressions may not be arguments, arg #%d */ 3753 error(151, n); 3754 return NULL; 3755 } else if ((at == STRUCT || at == UNION) && 3756 is_incomplete(arg->tn_left->tn_type)) { 3757 /* argument cannot have unknown size, arg #%d */ 3758 error(152, n); 3759 return NULL; 3760 } else if (is_integer(at) && 3761 arg->tn_left->tn_type->t_is_enum && 3762 is_incomplete(arg->tn_left->tn_type)) { 3763 /* argument cannot have unknown size, arg #%d */ 3764 warning(152, n); 3765 } 3766 3767 /* class conversions (arg in value context) */ 3768 arg->tn_left = cconv(arg->tn_left); 3769 3770 if (asym != NULL) { 3771 arg->tn_left = check_prototype_argument( 3772 n, asym->s_type, arg->tn_left); 3773 } else { 3774 arg->tn_left = promote(NOOP, true, arg->tn_left); 3775 } 3776 arg->tn_type = arg->tn_left->tn_type; 3777 3778 if (asym != NULL) 3779 asym = asym->s_next; 3780 } 3781 3782 return args; 3783 } 3784 3785 /* 3786 * Compare the type of an argument with the corresponding type of a 3787 * prototype parameter. If it is a valid combination, but both types 3788 * are not the same, insert a conversion to convert the argument into 3789 * the type of the parameter. 3790 */ 3791 static tnode_t * 3792 check_prototype_argument( 3793 int n, /* pos of arg */ 3794 type_t *tp, /* expected type (from prototype) */ 3795 tnode_t *tn) /* argument */ 3796 { 3797 tnode_t *ln; 3798 bool dowarn; 3799 3800 ln = xcalloc(1, sizeof(*ln)); 3801 ln->tn_type = expr_unqualified_type(tp); 3802 ln->tn_lvalue = true; 3803 if (typeok(FARG, n, ln, tn)) { 3804 if (!eqtype(tp, tn->tn_type, 3805 true, false, (dowarn = false, &dowarn)) || dowarn) 3806 tn = convert(FARG, n, tp, tn); 3807 } 3808 free(ln); 3809 return tn; 3810 } 3811 3812 /* 3813 * Return the value of an integral constant expression. 3814 * If the expression is not constant or its type is not an integer 3815 * type, an error message is printed. 3816 */ 3817 val_t * 3818 constant(tnode_t *tn, bool required) 3819 { 3820 val_t *v; 3821 3822 if (tn != NULL) 3823 tn = cconv(tn); 3824 if (tn != NULL) 3825 tn = promote(NOOP, false, tn); 3826 3827 v = xcalloc(1, sizeof(*v)); 3828 3829 if (tn == NULL) { 3830 lint_assert(nerr != 0); 3831 debug_step("constant node is null; returning 1 instead"); 3832 v->v_tspec = INT; 3833 v->v_quad = 1; 3834 return v; 3835 } 3836 3837 v->v_tspec = tn->tn_type->t_tspec; 3838 3839 if (tn->tn_op == CON) { 3840 lint_assert(tn->tn_type->t_tspec == tn->tn_val->v_tspec); 3841 if (is_integer(tn->tn_val->v_tspec)) { 3842 v->v_unsigned_since_c90 = 3843 tn->tn_val->v_unsigned_since_c90; 3844 v->v_quad = tn->tn_val->v_quad; 3845 return v; 3846 } 3847 v->v_quad = tn->tn_val->v_ldbl; 3848 } else { 3849 v->v_quad = 1; 3850 } 3851 3852 if (required) 3853 /* integral constant expression expected */ 3854 error(55); 3855 else 3856 /* variable array dimension is a C99/GCC extension */ 3857 c99ism(318); 3858 3859 if (!is_integer(v->v_tspec)) 3860 v->v_tspec = INT; 3861 3862 return v; 3863 } 3864 3865 static bool 3866 is_constcond_false(const tnode_t *tn, tspec_t t) 3867 { 3868 return (t == BOOL || t == INT) && 3869 tn->tn_op == CON && tn->tn_val->v_quad == 0; 3870 } 3871 3872 /* 3873 * Perform some tests on expressions which can't be done in build_binary() 3874 * and functions called by build_binary(). These tests must be done here 3875 * because we need some information about the context in which the operations 3876 * are performed. 3877 * After all tests are performed and dofreeblk is true, expr() frees the 3878 * memory which is used for the expression. 3879 */ 3880 void 3881 expr(tnode_t *tn, bool vctx, bool tctx, bool dofreeblk, bool is_do_while) 3882 { 3883 3884 if (tn == NULL) { /* in case of errors */ 3885 expr_free_all(); 3886 return; 3887 } 3888 3889 /* expr() is also called in global initializations */ 3890 if (dcs->d_ctx != EXTERN && !is_do_while) 3891 check_statement_reachable(); 3892 3893 check_expr_misc(tn, vctx, tctx, !tctx, false, false, false); 3894 if (tn->tn_op == ASSIGN) { 3895 if (hflag && tctx) 3896 /* assignment in conditional context */ 3897 warning(159); 3898 } else if (tn->tn_op == CON) { 3899 if (hflag && tctx && !constcond_flag && 3900 !tn->tn_system_dependent && 3901 !(is_do_while && 3902 is_constcond_false(tn, tn->tn_type->t_tspec))) 3903 /* constant in conditional context */ 3904 warning(161); 3905 } 3906 if (!modtab[tn->tn_op].m_has_side_effect) { 3907 /* 3908 * for left operands of COMMA this warning is already 3909 * printed 3910 */ 3911 if (tn->tn_op != COMMA && !vctx && !tctx) 3912 check_null_effect(tn); 3913 } 3914 debug_node(tn); 3915 3916 /* free the tree memory */ 3917 if (dofreeblk) 3918 expr_free_all(); 3919 } 3920 3921 static bool 3922 has_side_effect(const tnode_t *tn) // NOLINT(misc-no-recursion) 3923 { 3924 op_t op = tn->tn_op; 3925 3926 if (modtab[op].m_has_side_effect) 3927 return true; 3928 3929 if (op == CVT && tn->tn_type->t_tspec == VOID) 3930 return has_side_effect(tn->tn_left); 3931 3932 /* XXX: Why not has_side_effect(tn->tn_left) as well? */ 3933 if (op == LOGAND || op == LOGOR) 3934 return has_side_effect(tn->tn_right); 3935 3936 /* XXX: Why not has_side_effect(tn->tn_left) as well? */ 3937 if (op == QUEST) 3938 return has_side_effect(tn->tn_right); 3939 3940 if (op == COLON || op == COMMA) { 3941 return has_side_effect(tn->tn_left) || 3942 has_side_effect(tn->tn_right); 3943 } 3944 3945 return false; 3946 } 3947 3948 static bool 3949 is_void_cast(const tnode_t *tn) 3950 { 3951 3952 return tn->tn_op == CVT && tn->tn_cast && 3953 tn->tn_type->t_tspec == VOID; 3954 } 3955 3956 static bool 3957 is_local_symbol(const tnode_t *tn) 3958 { 3959 3960 return tn->tn_op == LOAD && 3961 tn->tn_left->tn_op == NAME && 3962 tn->tn_left->tn_sym->s_scl == AUTO; 3963 } 3964 3965 static bool 3966 is_int_constant_zero(const tnode_t *tn) 3967 { 3968 3969 return tn->tn_op == CON && 3970 tn->tn_type->t_tspec == INT && 3971 tn->tn_val->v_quad == 0; 3972 } 3973 3974 static void 3975 check_null_effect(const tnode_t *tn) 3976 { 3977 3978 if (!hflag) 3979 return; 3980 if (has_side_effect(tn)) 3981 return; 3982 if (is_void_cast(tn) && is_local_symbol(tn->tn_left)) 3983 return; 3984 if (is_void_cast(tn) && is_int_constant_zero(tn->tn_left)) 3985 return; 3986 3987 /* expression has null effect */ 3988 warning(129); 3989 } 3990 3991 static void 3992 check_expr_addr(const tnode_t *ln, bool szof, bool fcall) 3993 { 3994 /* XXX: Taking warn_about_unreachable into account here feels wrong. */ 3995 if (ln->tn_op == NAME && (reached || !warn_about_unreachable)) { 3996 if (!szof) 3997 mark_as_set(ln->tn_sym); 3998 mark_as_used(ln->tn_sym, fcall, szof); 3999 } 4000 if (ln->tn_op == INDIR && ln->tn_left->tn_op == PLUS) 4001 /* check the range of array indices */ 4002 check_array_index(ln->tn_left, true); 4003 } 4004 4005 static void 4006 check_expr_load(const tnode_t *ln) 4007 { 4008 if (ln->tn_op == INDIR && ln->tn_left->tn_op == PLUS) 4009 /* check the range of array indices */ 4010 check_array_index(ln->tn_left, false); 4011 } 4012 4013 static void 4014 check_expr_side_effect(const tnode_t *ln, bool szof) 4015 { 4016 scl_t sc; 4017 dinfo_t *di; 4018 4019 /* XXX: Taking warn_about_unreachable into account here feels wrong. */ 4020 if (ln->tn_op == NAME && (reached || !warn_about_unreachable)) { 4021 sc = ln->tn_sym->s_scl; 4022 /* 4023 * Look if there was a asm statement in one of the 4024 * compound statements we are in. If not, we don't 4025 * print a warning. 4026 */ 4027 for (di = dcs; di != NULL; di = di->d_next) { 4028 if (di->d_asm) 4029 break; 4030 } 4031 if (sc != EXTERN && sc != STATIC && 4032 !ln->tn_sym->s_set && !szof && di == NULL) { 4033 /* %s may be used before set */ 4034 warning(158, ln->tn_sym->s_name); 4035 mark_as_set(ln->tn_sym); 4036 } 4037 mark_as_used(ln->tn_sym, false, false); 4038 } 4039 } 4040 4041 static void 4042 check_expr_assign(const tnode_t *ln, bool szof) 4043 { 4044 /* XXX: Taking warn_about_unreachable into account here feels wrong. */ 4045 if (ln->tn_op == NAME && !szof && (reached || !warn_about_unreachable)) { 4046 mark_as_set(ln->tn_sym); 4047 if (ln->tn_sym->s_scl == EXTERN) 4048 outusg(ln->tn_sym); 4049 } 4050 if (ln->tn_op == INDIR && ln->tn_left->tn_op == PLUS) 4051 /* check the range of array indices */ 4052 check_array_index(ln->tn_left, false); 4053 } 4054 4055 static void 4056 check_expr_call(const tnode_t *tn, const tnode_t *ln, 4057 bool szof, bool vctx, bool tctx, bool retval_discarded) 4058 { 4059 lint_assert(ln->tn_op == ADDR); 4060 lint_assert(ln->tn_left->tn_op == NAME); 4061 if (!szof && 4062 !is_compiler_builtin(ln->tn_left->tn_sym->s_name)) 4063 outcall(tn, vctx || tctx, retval_discarded); 4064 } 4065 4066 static bool 4067 check_expr_op(const tnode_t *tn, op_t op, const tnode_t *ln, 4068 bool szof, bool fcall, bool vctx, bool tctx, 4069 bool retval_discarded, bool eqwarn) 4070 { 4071 switch (op) { 4072 case ADDR: 4073 check_expr_addr(ln, szof, fcall); 4074 break; 4075 case LOAD: 4076 check_expr_load(ln); 4077 /* FALLTHROUGH */ 4078 case PUSH: 4079 case INCBEF: 4080 case DECBEF: 4081 case INCAFT: 4082 case DECAFT: 4083 case ADDASS: 4084 case SUBASS: 4085 case MULASS: 4086 case DIVASS: 4087 case MODASS: 4088 case ANDASS: 4089 case ORASS: 4090 case XORASS: 4091 case SHLASS: 4092 case SHRASS: 4093 case REAL: 4094 case IMAG: 4095 check_expr_side_effect(ln, szof); 4096 break; 4097 case ASSIGN: 4098 check_expr_assign(ln, szof); 4099 break; 4100 case CALL: 4101 check_expr_call(tn, ln, szof, vctx, tctx, retval_discarded); 4102 break; 4103 case EQ: 4104 if (hflag && eqwarn) 4105 /* operator '==' found where '=' was expected */ 4106 warning(160); 4107 break; 4108 case CON: 4109 case NAME: 4110 case STRING: 4111 return false; 4112 /* LINTED206: (enumeration values not handled in switch) */ 4113 case BITOR: 4114 case BITXOR: 4115 case NE: 4116 case GE: 4117 case GT: 4118 case LE: 4119 case LT: 4120 case SHR: 4121 case SHL: 4122 case MINUS: 4123 case PLUS: 4124 case MOD: 4125 case DIV: 4126 case MULT: 4127 case INDIR: 4128 case UMINUS: 4129 case UPLUS: 4130 case DEC: 4131 case INC: 4132 case COMPL: 4133 case NOT: 4134 case POINT: 4135 case ARROW: 4136 case NOOP: 4137 case BITAND: 4138 case FARG: 4139 case CASE: 4140 case INIT: 4141 case RETURN: 4142 case ICALL: 4143 case CVT: 4144 case COMMA: 4145 case FSEL: 4146 case COLON: 4147 case QUEST: 4148 case LOGOR: 4149 case LOGAND: 4150 break; 4151 } 4152 return true; 4153 } 4154 4155 /* ARGSUSED */ 4156 void 4157 check_expr_misc(const tnode_t *tn, bool vctx, bool tctx, 4158 bool eqwarn, bool fcall, bool retval_discarded, bool szof) 4159 { 4160 tnode_t *ln, *rn; 4161 const mod_t *mp; 4162 op_t op; 4163 4164 if (tn == NULL) 4165 return; 4166 4167 ln = tn->tn_left; 4168 rn = tn->tn_right; 4169 mp = &modtab[op = tn->tn_op]; 4170 4171 if (!check_expr_op(tn, op, ln, 4172 szof, fcall, vctx, tctx, retval_discarded, eqwarn)) 4173 return; 4174 4175 bool cvctx = mp->m_left_value_context; 4176 bool ctctx = mp->m_left_test_context; 4177 bool eq = mp->m_warn_if_operand_eq && 4178 !ln->tn_parenthesized && 4179 rn != NULL && !rn->tn_parenthesized; 4180 4181 /* 4182 * values of operands of ':' are not used if the type of at least 4183 * one of the operands (for gcc compatibility) is void 4184 * XXX test/value context of QUEST should probably be used as 4185 * context for both operands of COLON 4186 */ 4187 if (op == COLON && tn->tn_type->t_tspec == VOID) 4188 cvctx = ctctx = false; 4189 bool discard = op == CVT && tn->tn_type->t_tspec == VOID; 4190 check_expr_misc(ln, cvctx, ctctx, eq, op == CALL, discard, szof); 4191 4192 switch (op) { 4193 case PUSH: 4194 if (rn != NULL) 4195 check_expr_misc(rn, false, false, eq, false, false, 4196 szof); 4197 break; 4198 case LOGAND: 4199 case LOGOR: 4200 check_expr_misc(rn, false, true, eq, false, false, szof); 4201 break; 4202 case COLON: 4203 check_expr_misc(rn, cvctx, ctctx, eq, false, false, szof); 4204 break; 4205 case COMMA: 4206 check_expr_misc(rn, vctx, tctx, eq, false, false, szof); 4207 break; 4208 default: 4209 if (mp->m_binary) 4210 check_expr_misc(rn, true, false, eq, false, false, 4211 szof); 4212 break; 4213 } 4214 } 4215 4216 /* 4217 * Checks the range of array indices, if possible. 4218 * amper is set if only the address of the element is used. This 4219 * means that the index is allowed to refer to the first element 4220 * after the array. 4221 */ 4222 static void 4223 check_array_index(tnode_t *tn, bool amper) 4224 { 4225 int dim; 4226 tnode_t *ln, *rn; 4227 int elsz; 4228 int64_t con; 4229 4230 ln = tn->tn_left; 4231 rn = tn->tn_right; 4232 4233 /* We can only check constant indices. */ 4234 if (rn->tn_op != CON) 4235 return; 4236 4237 /* Return if the left node does not stem from an array. */ 4238 if (ln->tn_op != ADDR) 4239 return; 4240 if (ln->tn_left->tn_op != STRING && ln->tn_left->tn_op != NAME) 4241 return; 4242 if (ln->tn_left->tn_type->t_tspec != ARRAY) 4243 return; 4244 4245 /* 4246 * For incomplete array types, we can print a warning only if 4247 * the index is negative. 4248 */ 4249 if (is_incomplete(ln->tn_left->tn_type) && rn->tn_val->v_quad >= 0) 4250 return; 4251 4252 /* Get the size of one array element */ 4253 if ((elsz = length(ln->tn_type->t_subt, NULL)) == 0) 4254 return; 4255 elsz /= CHAR_SIZE; 4256 4257 /* Change the unit of the index from bytes to element size. */ 4258 if (is_uinteger(rn->tn_type->t_tspec)) { 4259 con = (uint64_t)rn->tn_val->v_quad / elsz; 4260 } else { 4261 con = rn->tn_val->v_quad / elsz; 4262 } 4263 4264 dim = ln->tn_left->tn_type->t_dim + (amper ? 1 : 0); 4265 4266 if (!is_uinteger(rn->tn_type->t_tspec) && con < 0) { 4267 /* array subscript cannot be negative: %ld */ 4268 warning(167, (long)con); 4269 } else if (dim > 0 && (uint64_t)con >= (uint64_t)dim) { 4270 /* array subscript cannot be > %d: %ld */ 4271 warning(168, dim - 1, (long)con); 4272 } 4273 } 4274 4275 static bool 4276 is_out_of_char_range(const tnode_t *tn) 4277 { 4278 return tn->tn_op == CON && 4279 !(0 <= tn->tn_val->v_quad && 4280 tn->tn_val->v_quad < 1 << (CHAR_SIZE - 1)); 4281 } 4282 4283 /* 4284 * Check for ordered comparisons of unsigned values with 0. 4285 */ 4286 static void 4287 check_integer_comparison(op_t op, tnode_t *ln, tnode_t *rn) 4288 { 4289 tspec_t lt, rt; 4290 4291 lt = ln->tn_type->t_tspec; 4292 rt = rn->tn_type->t_tspec; 4293 4294 if (ln->tn_op != CON && rn->tn_op != CON) 4295 return; 4296 4297 if (!is_integer(lt) || !is_integer(rt)) 4298 return; 4299 4300 if (hflag || pflag) { 4301 if (lt == CHAR && is_out_of_char_range(rn)) { 4302 /* nonportable character comparison '%s %d' */ 4303 warning(230, op_name(op), (int)rn->tn_val->v_quad); 4304 return; 4305 } 4306 if (rt == CHAR && is_out_of_char_range(ln)) { 4307 /* nonportable character comparison '%s %d' */ 4308 warning(230, op_name(op), (int)ln->tn_val->v_quad); 4309 return; 4310 } 4311 } 4312 4313 if (is_uinteger(lt) && !is_uinteger(rt) && 4314 rn->tn_op == CON && rn->tn_val->v_quad <= 0) { 4315 if (rn->tn_val->v_quad < 0) { 4316 /* comparison of %s with %s, op %s */ 4317 warning(162, type_name(ln->tn_type), 4318 "negative constant", op_name(op)); 4319 } else if (op == LT || op == GE) { 4320 /* comparison of %s with %s, op %s */ 4321 warning(162, type_name(ln->tn_type), "0", op_name(op)); 4322 } 4323 return; 4324 } 4325 if (is_uinteger(rt) && !is_uinteger(lt) && 4326 ln->tn_op == CON && ln->tn_val->v_quad <= 0) { 4327 if (ln->tn_val->v_quad < 0) { 4328 /* comparison of %s with %s, op %s */ 4329 warning(162, "negative constant", 4330 type_name(rn->tn_type), op_name(op)); 4331 } else if (op == GT || op == LE) { 4332 /* comparison of %s with %s, op %s */ 4333 warning(162, "0", type_name(rn->tn_type), op_name(op)); 4334 } 4335 return; 4336 } 4337 } 4338 4339 /* 4340 * Return whether the expression can be used for static initialization. 4341 * 4342 * Constant initialization expressions must be constant or an address 4343 * of a static object with an optional offset. In the first case, 4344 * the result is returned in *offsp. In the second case, the static 4345 * object is returned in *symp and the offset in *offsp. 4346 * 4347 * The expression can consist of PLUS, MINUS, ADDR, NAME, STRING and 4348 * CON. Type conversions are allowed if they do not change binary 4349 * representation (including width). 4350 * 4351 * C99 6.6 "Constant expressions" 4352 * C99 6.7.8p4 restricts initializers for static storage duration 4353 */ 4354 bool 4355 constant_addr(const tnode_t *tn, const sym_t **symp, ptrdiff_t *offsp) 4356 { 4357 const sym_t *sym; 4358 ptrdiff_t offs1, offs2; 4359 tspec_t t, ot; 4360 4361 switch (tn->tn_op) { 4362 case MINUS: 4363 if (tn->tn_right->tn_op == CVT) 4364 return constant_addr(tn->tn_right, symp, offsp); 4365 else if (tn->tn_right->tn_op != CON) 4366 return false; 4367 /* FALLTHROUGH */ 4368 case PLUS: 4369 offs1 = offs2 = 0; 4370 if (tn->tn_left->tn_op == CON) { 4371 offs1 = (ptrdiff_t)tn->tn_left->tn_val->v_quad; 4372 if (!constant_addr(tn->tn_right, &sym, &offs2)) 4373 return false; 4374 } else if (tn->tn_right->tn_op == CON) { 4375 offs2 = (ptrdiff_t)tn->tn_right->tn_val->v_quad; 4376 if (tn->tn_op == MINUS) 4377 offs2 = -offs2; 4378 if (!constant_addr(tn->tn_left, &sym, &offs1)) 4379 return false; 4380 } else { 4381 return false; 4382 } 4383 *symp = sym; 4384 *offsp = offs1 + offs2; 4385 return true; 4386 case ADDR: 4387 if (tn->tn_left->tn_op == NAME) { 4388 *symp = tn->tn_left->tn_sym; 4389 *offsp = 0; 4390 return true; 4391 } else { 4392 /* 4393 * If this would be the front end of a compiler we 4394 * would return a label instead of 0, at least if 4395 * 'tn->tn_left->tn_op == STRING'. 4396 */ 4397 *symp = NULL; 4398 *offsp = 0; 4399 return true; 4400 } 4401 case CVT: 4402 t = tn->tn_type->t_tspec; 4403 ot = tn->tn_left->tn_type->t_tspec; 4404 if ((!is_integer(t) && t != PTR) || 4405 (!is_integer(ot) && ot != PTR)) { 4406 return false; 4407 } 4408 #if 0 4409 /* 4410 * consider: 4411 * struct foo { 4412 * unsigned char a; 4413 * } f = { 4414 * (unsigned char)(unsigned long) 4415 * (&(((struct foo *)0)->a)) 4416 * }; 4417 * since psize(unsigned long) != psize(unsigned char), 4418 * this fails. 4419 */ 4420 else if (psize(t) != psize(ot)) 4421 return -1; 4422 #endif 4423 return constant_addr(tn->tn_left, symp, offsp); 4424 default: 4425 return false; 4426 } 4427 } 4428 4429 /* Append s2 to s1, then free s2. */ 4430 strg_t * 4431 cat_strings(strg_t *s1, strg_t *s2) 4432 { 4433 size_t len1, len2, sz; 4434 4435 if (s1->st_tspec != s2->st_tspec) { 4436 /* cannot concatenate wide and regular string literals */ 4437 error(292); 4438 return s1; 4439 } 4440 4441 len1 = s1->st_len; 4442 len2 = s2->st_len; 4443 4444 if (s1->st_tspec == CHAR) { 4445 sz = sizeof(*s1->st_cp); 4446 s1->st_cp = xrealloc(s1->st_cp, (len1 + len2 + 1) * sz); 4447 memcpy(s1->st_cp + len1, s2->st_cp, (len2 + 1) * sz); 4448 free(s2->st_cp); 4449 } else { 4450 sz = sizeof(*s1->st_wcp); 4451 s1->st_wcp = xrealloc(s1->st_wcp, (len1 + len2 + 1) * sz); 4452 memcpy(s1->st_wcp + len1, s2->st_wcp, (len2 + 1) * sz); 4453 free(s2->st_wcp); 4454 } 4455 4456 s1->st_len = len1 + len2; 4457 free(s2); 4458 4459 return s1; 4460 } 4461 4462 static bool 4463 is_confusing_precedence(op_t op, op_t lop, bool lparen, op_t rop, bool rparen) 4464 { 4465 4466 if (op == SHL || op == SHR) { 4467 if (!lparen && (lop == PLUS || lop == MINUS)) 4468 return true; 4469 if (!rparen && (rop == PLUS || rop == MINUS)) 4470 return true; 4471 return false; 4472 } 4473 4474 if (op == LOGOR) { 4475 if (!lparen && lop == LOGAND) 4476 return true; 4477 if (!rparen && rop == LOGAND) 4478 return true; 4479 return false; 4480 } 4481 4482 lint_assert(op == BITAND || op == BITXOR || op == BITOR); 4483 if (!lparen && lop != op) { 4484 if (lop == PLUS || lop == MINUS) 4485 return true; 4486 if (lop == BITAND || lop == BITXOR) 4487 return true; 4488 } 4489 if (!rparen && rop != op) { 4490 if (rop == PLUS || rop == MINUS) 4491 return true; 4492 if (rop == BITAND || rop == BITXOR) 4493 return true; 4494 } 4495 return false; 4496 } 4497 4498 /* 4499 * Print a warning if the given node has operands which should be 4500 * parenthesized. 4501 * 4502 * XXX Does not work if an operand is a constant expression. Constant 4503 * expressions are already folded. 4504 */ 4505 static void 4506 check_precedence_confusion(tnode_t *tn) 4507 { 4508 tnode_t *ln, *rn; 4509 4510 if (!hflag) 4511 return; 4512 4513 debug_node(tn); 4514 4515 lint_assert(is_binary(tn)); 4516 for (ln = tn->tn_left; ln->tn_op == CVT; ln = ln->tn_left) 4517 continue; 4518 for (rn = tn->tn_right; rn->tn_op == CVT; rn = rn->tn_left) 4519 continue; 4520 4521 if (is_confusing_precedence(tn->tn_op, 4522 ln->tn_op, ln->tn_parenthesized, 4523 rn->tn_op, rn->tn_parenthesized)) { 4524 /* precedence confusion possible: parenthesize! */ 4525 warning(169); 4526 } 4527 } 4528
Indexes created Fri Oct 03 17:10:05 GMT 2025