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