tree.c revision 1.248
1 /* $NetBSD: tree.c,v 1.248 2021/03/26 16:53:19 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.248 2021/03/26 16:53:19 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 static bool 2226 should_warn_about_pointer_cast(const type_t *tp, tspec_t nst, 2227 const tnode_t *tn, tspec_t ost) 2228 { 2229 if (nst == STRUCT || nst == UNION) 2230 if (tp->t_subt->t_str != tn->tn_type->t_subt->t_str) 2231 return true; 2232 2233 /* 2234 * XXX: Why should it be ok to cast between arbitrary structs that 2235 * just happen to be of the same size? 2236 */ 2237 return portable_size_in_bits(nst) != portable_size_in_bits(ost); 2238 } 2239 2240 /* 2241 * Warn about questionable pointer conversions. 2242 */ 2243 static void 2244 check_pointer_conversion(op_t op, tnode_t *tn, type_t *tp) 2245 { 2246 tspec_t nst, ost; 2247 const char *nts, *ots; 2248 2249 /* 2250 * We got already an error (pointers of different types 2251 * without a cast) or we will not get a warning. 2252 */ 2253 if (op != CVT) 2254 return; 2255 2256 nst = tp->t_subt->t_tspec; 2257 ost = tn->tn_type->t_subt->t_tspec; 2258 2259 if (nst == VOID || ost == VOID) { 2260 if (sflag && (nst == FUNC || ost == FUNC)) { 2261 /* null pointers are already handled in convert() */ 2262 *(nst == FUNC ? &nts : &ots) = "function pointer"; 2263 *(nst == VOID ? &nts : &ots) = "'void *'"; 2264 /* ANSI C forbids conversion of %s to %s */ 2265 warning(303, ots, nts); 2266 } 2267 return; 2268 } else if (nst == FUNC && ost == FUNC) { 2269 return; 2270 } else if (nst == FUNC || ost == FUNC) { 2271 /* converting '%s' to '%s' is questionable */ 2272 warning(229, type_name(tn->tn_type), type_name(tp)); 2273 return; 2274 } 2275 2276 if (hflag && alignment_in_bits(tp->t_subt) > 2277 alignment_in_bits(tn->tn_type->t_subt)) { 2278 /* converting '%s' to '%s' may cause alignment problem */ 2279 warning(135, type_name(tn->tn_type), type_name(tp)); 2280 } 2281 2282 if (cflag && should_warn_about_pointer_cast(tp, nst, tn, ost)) { 2283 /* pointer cast from '%s' to '%s' may be troublesome */ 2284 warning(247, type_name(tn->tn_type), type_name(tp)); 2285 } 2286 } 2287 2288 /* 2289 * Converts a typed constant to a constant of another type. 2290 * 2291 * op operator which requires conversion 2292 * arg if op is FARG, # of argument 2293 * tp type in which to convert the constant 2294 * nv new constant 2295 * v old constant 2296 */ 2297 void 2298 convert_constant(op_t op, int arg, type_t *tp, val_t *nv, val_t *v) 2299 { 2300 tspec_t ot, nt; 2301 ldbl_t max = 0.0, min = 0.0; 2302 int sz; 2303 bool rchk; 2304 int64_t xmask, xmsk1; 2305 int osz, nsz; 2306 2307 ot = v->v_tspec; 2308 nt = nv->v_tspec = tp->t_tspec; 2309 rchk = false; 2310 2311 if (nt == BOOL) { /* C99 6.3.1.2 */ 2312 nv->v_ansiu = false; 2313 nv->v_quad = is_nonzero_val(v) ? 1 : 0; 2314 return; 2315 } 2316 2317 if (ot == FLOAT || ot == DOUBLE || ot == LDOUBLE) { 2318 switch (nt) { 2319 case CHAR: 2320 max = TARG_CHAR_MAX; min = TARG_CHAR_MIN; break; 2321 case UCHAR: 2322 max = TARG_UCHAR_MAX; min = 0; break; 2323 case SCHAR: 2324 max = TARG_SCHAR_MAX; min = TARG_SCHAR_MIN; break; 2325 case SHORT: 2326 max = TARG_SHRT_MAX; min = TARG_SHRT_MIN; break; 2327 case USHORT: 2328 max = TARG_USHRT_MAX; min = 0; break; 2329 case ENUM: 2330 case INT: 2331 max = TARG_INT_MAX; min = TARG_INT_MIN; break; 2332 case UINT: 2333 max = (u_int)TARG_UINT_MAX;min = 0; break; 2334 case LONG: 2335 max = TARG_LONG_MAX; min = TARG_LONG_MIN; break; 2336 case ULONG: 2337 max = (u_long)TARG_ULONG_MAX; min = 0; break; 2338 case QUAD: 2339 max = QUAD_MAX; min = QUAD_MIN; break; 2340 case UQUAD: 2341 max = (uint64_t)UQUAD_MAX; min = 0; break; 2342 case FLOAT: 2343 case FCOMPLEX: 2344 max = FLT_MAX; min = -FLT_MAX; break; 2345 case DOUBLE: 2346 case DCOMPLEX: 2347 max = DBL_MAX; min = -DBL_MAX; break; 2348 case PTR: 2349 /* Got already an error because of float --> ptr */ 2350 case LDOUBLE: 2351 case LCOMPLEX: 2352 max = LDBL_MAX; min = -LDBL_MAX; break; 2353 default: 2354 lint_assert(/*CONSTCOND*/false); 2355 } 2356 if (v->v_ldbl > max || v->v_ldbl < min) { 2357 lint_assert(nt != LDOUBLE); 2358 if (op == FARG) { 2359 /* conv. of '%s' to '%s' is out of range, ... */ 2360 warning(295, 2361 type_name(gettyp(ot)), type_name(tp), arg); 2362 } else { 2363 /* conversion of '%s' to '%s' is out of range */ 2364 warning(119, 2365 type_name(gettyp(ot)), type_name(tp)); 2366 } 2367 v->v_ldbl = v->v_ldbl > 0 ? max : min; 2368 } 2369 if (nt == FLOAT) { 2370 nv->v_ldbl = (float)v->v_ldbl; 2371 } else if (nt == DOUBLE) { 2372 nv->v_ldbl = (double)v->v_ldbl; 2373 } else if (nt == LDOUBLE) { 2374 nv->v_ldbl = v->v_ldbl; 2375 } else { 2376 nv->v_quad = (nt == PTR || is_uinteger(nt)) ? 2377 (int64_t)v->v_ldbl : (int64_t)v->v_ldbl; 2378 } 2379 } else { 2380 if (nt == FLOAT) { 2381 nv->v_ldbl = (ot == PTR || is_uinteger(ot)) ? 2382 (float)(uint64_t)v->v_quad : (float)v->v_quad; 2383 } else if (nt == DOUBLE) { 2384 nv->v_ldbl = (ot == PTR || is_uinteger(ot)) ? 2385 (double)(uint64_t)v->v_quad : (double)v->v_quad; 2386 } else if (nt == LDOUBLE) { 2387 nv->v_ldbl = (ot == PTR || is_uinteger(ot)) ? 2388 (ldbl_t)(uint64_t)v->v_quad : (ldbl_t)v->v_quad; 2389 } else { 2390 rchk = true; /* Check for lost precision. */ 2391 nv->v_quad = v->v_quad; 2392 } 2393 } 2394 2395 if (v->v_ansiu && is_floating(nt)) { 2396 /* ANSI C treats constant as unsigned */ 2397 warning(157); 2398 v->v_ansiu = false; 2399 } else if (v->v_ansiu && (is_integer(nt) && !is_uinteger(nt) && 2400 portable_size_in_bits(nt) > 2401 portable_size_in_bits(ot))) { 2402 /* ANSI C treats constant as unsigned */ 2403 warning(157); 2404 v->v_ansiu = false; 2405 } 2406 2407 switch (nt) { 2408 case FLOAT: 2409 case FCOMPLEX: 2410 case DOUBLE: 2411 case DCOMPLEX: 2412 case LDOUBLE: 2413 case LCOMPLEX: 2414 break; 2415 default: 2416 sz = tp->t_bitfield ? tp->t_flen : size_in_bits(nt); 2417 nv->v_quad = xsign(nv->v_quad, nt, sz); 2418 break; 2419 } 2420 2421 if (rchk && op != CVT) { 2422 osz = size_in_bits(ot); 2423 nsz = tp->t_bitfield ? tp->t_flen : size_in_bits(nt); 2424 xmask = qlmasks[nsz] ^ qlmasks[osz]; 2425 xmsk1 = qlmasks[nsz] ^ qlmasks[osz - 1]; 2426 /* 2427 * For bitwise operations we are not interested in the 2428 * value, but in the bits itself. 2429 */ 2430 if (op == ORASS || op == BITOR || op == BITXOR) { 2431 /* 2432 * Print a warning if bits which were set are 2433 * lost due to the conversion. 2434 * This can happen with operator ORASS only. 2435 */ 2436 if (nsz < osz && (v->v_quad & xmask) != 0) { 2437 /* constant truncated by conv., op %s */ 2438 warning(306, getopname(op)); 2439 } 2440 } else if (op == ANDASS || op == BITAND) { 2441 /* 2442 * Print a warning if additional bits are not all 1 2443 * and the most significant bit of the old value is 1, 2444 * or if at least one (but not all) removed bit was 0. 2445 */ 2446 if (nsz > osz && 2447 (nv->v_quad & qbmasks[osz - 1]) != 0 && 2448 (nv->v_quad & xmask) != xmask) { 2449 /* extra bits set to 0 in conv. of '%s' ... */ 2450 warning(309, type_name(gettyp(ot)), 2451 type_name(tp), getopname(op)); 2452 } else if (nsz < osz && 2453 (v->v_quad & xmask) != xmask && 2454 (v->v_quad & xmask) != 0) { 2455 /* constant truncated by conv., op %s */ 2456 warning(306, getopname(op)); 2457 } 2458 } else if ((nt != PTR && is_uinteger(nt)) && 2459 (ot != PTR && !is_uinteger(ot)) && 2460 v->v_quad < 0) { 2461 if (op == ASSIGN) { 2462 /* assignment of negative constant to ... */ 2463 warning(164); 2464 } else if (op == INIT) { 2465 /* initialization of unsigned with neg... */ 2466 warning(221); 2467 } else if (op == FARG) { 2468 /* conversion of negative constant to ... */ 2469 warning(296, arg); 2470 } else if (modtab[op].m_comparison) { 2471 /* handled by check_integer_comparison() */ 2472 } else { 2473 /* conversion of negative constant to ... */ 2474 warning(222); 2475 } 2476 } else if (nv->v_quad != v->v_quad && nsz <= osz && 2477 (v->v_quad & xmask) != 0 && 2478 (is_uinteger(ot) || (v->v_quad & xmsk1) != xmsk1)) { 2479 /* 2480 * Loss of significant bit(s). All truncated bits 2481 * of unsigned types or all truncated bits plus the 2482 * msb of the target for signed types are considered 2483 * to be significant bits. Loss of significant bits 2484 * means that at least on of the bits was set in an 2485 * unsigned type or that at least one, but not all of 2486 * the bits was set in an signed type. 2487 * Loss of significant bits means that it is not 2488 * possible, also not with necessary casts, to convert 2489 * back to the original type. A example for a 2490 * necessary cast is: 2491 * char c; int i; c = 128; 2492 * i = c; ** yields -128 ** 2493 * i = (unsigned char)c; ** yields 128 ** 2494 */ 2495 if (op == ASSIGN && tp->t_bitfield) { 2496 /* precision lost in bit-field assignment */ 2497 warning(166); 2498 } else if (op == ASSIGN) { 2499 /* constant truncated by assignment */ 2500 warning(165); 2501 } else if (op == INIT && tp->t_bitfield) { 2502 /* bit-field initializer does not fit */ 2503 warning(180); 2504 } else if (op == INIT) { 2505 /* initializer does not fit */ 2506 warning(178); 2507 } else if (op == CASE) { 2508 /* case label affected by conversion */ 2509 warning(196); 2510 } else if (op == FARG) { 2511 /* conv. of '%s' to '%s' is out of range, ... */ 2512 warning(295, 2513 type_name(gettyp(ot)), type_name(tp), arg); 2514 } else { 2515 /* conversion of '%s' to '%s' is out of range */ 2516 warning(119, 2517 type_name(gettyp(ot)), type_name(tp)); 2518 } 2519 } else if (nv->v_quad != v->v_quad) { 2520 if (op == ASSIGN && tp->t_bitfield) { 2521 /* precision lost in bit-field assignment */ 2522 warning(166); 2523 } else if (op == INIT && tp->t_bitfield) { 2524 /* bit-field initializer out of range */ 2525 warning(11); 2526 } else if (op == CASE) { 2527 /* case label affected by conversion */ 2528 warning(196); 2529 } else if (op == FARG) { 2530 /* conv. of '%s' to '%s' is out of range, ... */ 2531 warning(295, 2532 type_name(gettyp(ot)), type_name(tp), arg); 2533 } else { 2534 /* conversion of '%s' to '%s' is out of range */ 2535 warning(119, 2536 type_name(gettyp(ot)), type_name(tp)); 2537 } 2538 } 2539 } 2540 } 2541 2542 /* 2543 * Called if incompatible types were detected. 2544 * Prints a appropriate warning. 2545 */ 2546 static void 2547 warn_incompatible_types(op_t op, 2548 const type_t *ltp, tspec_t lt, 2549 const type_t *rtp, tspec_t rt) 2550 { 2551 const mod_t *mp; 2552 2553 mp = &modtab[op]; 2554 2555 if (lt == VOID || (mp->m_binary && rt == VOID)) { 2556 /* void type illegal in expression */ 2557 error(109); 2558 } else if (op == ASSIGN) { 2559 if ((lt == STRUCT || lt == UNION) && 2560 (rt == STRUCT || rt == UNION)) { 2561 /* assignment of different structures (%s != %s) */ 2562 error(240, tspec_name(lt), tspec_name(rt)); 2563 } else { 2564 /* cannot assign to '%s' from '%s' */ 2565 error(171, type_name(ltp), type_name(rtp)); 2566 } 2567 } else if (mp->m_binary) { 2568 /* operands of '%s' have incompatible types (%s != %s) */ 2569 error(107, mp->m_name, tspec_name(lt), tspec_name(rt)); 2570 } else { 2571 lint_assert(rt == NOTSPEC); 2572 /* operand of '%s' has invalid type (%s) */ 2573 error(108, mp->m_name, tspec_name(lt)); 2574 } 2575 } 2576 2577 /* 2578 * Called if incompatible pointer types are detected. 2579 * Print an appropriate warning. 2580 */ 2581 static void 2582 warn_incompatible_pointers(const mod_t *mp, 2583 const type_t *ltp, const type_t *rtp) 2584 { 2585 tspec_t lt, rt; 2586 2587 lint_assert(ltp->t_tspec == PTR); 2588 lint_assert(rtp->t_tspec == PTR); 2589 2590 lt = ltp->t_subt->t_tspec; 2591 rt = rtp->t_subt->t_tspec; 2592 2593 if ((lt == STRUCT || lt == UNION) && (rt == STRUCT || rt == UNION)) { 2594 if (mp == NULL) { 2595 /* illegal structure pointer combination */ 2596 warning(244); 2597 } else { 2598 /* incompatible structure pointers: '%s' '%s' '%s' */ 2599 warning(245, type_name(ltp), mp->m_name, type_name(rtp)); 2600 } 2601 } else { 2602 if (mp == NULL) { 2603 /* illegal pointer combination */ 2604 warning(184); 2605 } else { 2606 /* illegal pointer combination (%s) and (%s), op %s */ 2607 warning(124, 2608 type_name(ltp), type_name(rtp), mp->m_name); 2609 } 2610 } 2611 } 2612 2613 /* 2614 * Make sure type (*tpp)->t_subt has at least the qualifiers 2615 * of tp1->t_subt and tp2->t_subt. 2616 */ 2617 static void 2618 merge_qualifiers(type_t **tpp, type_t *tp1, type_t *tp2) 2619 { 2620 2621 lint_assert((*tpp)->t_tspec == PTR); 2622 lint_assert(tp1->t_tspec == PTR); 2623 lint_assert(tp2->t_tspec == PTR); 2624 2625 if ((*tpp)->t_subt->t_const == 2626 (tp1->t_subt->t_const | tp2->t_subt->t_const) && 2627 (*tpp)->t_subt->t_volatile == 2628 (tp1->t_subt->t_volatile | tp2->t_subt->t_volatile)) { 2629 return; 2630 } 2631 2632 *tpp = tduptyp(*tpp); 2633 (*tpp)->t_subt = tduptyp((*tpp)->t_subt); 2634 (*tpp)->t_subt->t_const = 2635 tp1->t_subt->t_const | tp2->t_subt->t_const; 2636 (*tpp)->t_subt->t_volatile = 2637 tp1->t_subt->t_volatile | tp2->t_subt->t_volatile; 2638 } 2639 2640 /* 2641 * Returns true if the given structure or union has a constant member 2642 * (maybe recursively). 2643 */ 2644 static bool 2645 has_constant_member(const type_t *tp) 2646 { 2647 sym_t *m; 2648 tspec_t t; 2649 2650 lint_assert((t = tp->t_tspec) == STRUCT || t == UNION); 2651 2652 for (m = tp->t_str->sou_first_member; m != NULL; m = m->s_next) { 2653 tp = m->s_type; 2654 if (tp->t_const) 2655 return true; 2656 if ((t = tp->t_tspec) == STRUCT || t == UNION) { 2657 if (has_constant_member(m->s_type)) 2658 return true; 2659 } 2660 } 2661 return false; 2662 } 2663 2664 /* 2665 * Create a new node for one of the operators POINT and ARROW. 2666 */ 2667 static tnode_t * 2668 build_struct_access(op_t op, tnode_t *ln, tnode_t *rn) 2669 { 2670 tnode_t *ntn, *ctn; 2671 bool nolval; 2672 2673 lint_assert(rn->tn_op == NAME); 2674 lint_assert(rn->tn_sym->s_value.v_tspec == INT); 2675 lint_assert(rn->tn_sym->s_scl == MOS || rn->tn_sym->s_scl == MOU); 2676 2677 /* 2678 * Remember if the left operand is an lvalue (structure members 2679 * are lvalues if and only if the structure itself is an lvalue). 2680 */ 2681 nolval = op == POINT && !ln->tn_lvalue; 2682 2683 if (op == POINT) { 2684 ln = build_address(ln, true); 2685 } else if (ln->tn_type->t_tspec != PTR) { 2686 lint_assert(tflag); 2687 lint_assert(is_integer(ln->tn_type->t_tspec)); 2688 ln = convert(NOOP, 0, tincref(gettyp(VOID), PTR), ln); 2689 } 2690 2691 ctn = new_integer_constant_node(PTRDIFF_TSPEC, 2692 rn->tn_sym->s_value.v_quad / CHAR_SIZE); 2693 2694 ntn = new_tnode(PLUS, tincref(rn->tn_type, PTR), ln, ctn); 2695 if (ln->tn_op == CON) 2696 ntn = fold(ntn); 2697 2698 if (rn->tn_type->t_bitfield) { 2699 ntn = new_tnode(FSEL, ntn->tn_type->t_subt, ntn, NULL); 2700 } else { 2701 ntn = new_tnode(INDIR, ntn->tn_type->t_subt, ntn, NULL); 2702 } 2703 2704 if (nolval) 2705 ntn->tn_lvalue = false; 2706 2707 return ntn; 2708 } 2709 2710 /* 2711 * Create a node for INCAFT, INCBEF, DECAFT and DECBEF. 2712 */ 2713 static tnode_t * 2714 build_prepost_incdec(op_t op, tnode_t *ln) 2715 { 2716 tnode_t *cn, *ntn; 2717 2718 lint_assert(ln != NULL); 2719 2720 if (ln->tn_type->t_tspec == PTR) { 2721 cn = plength(ln->tn_type); 2722 } else { 2723 cn = new_integer_constant_node(INT, (int64_t)1); 2724 } 2725 ntn = new_tnode(op, ln->tn_type, ln, cn); 2726 2727 return ntn; 2728 } 2729 2730 /* 2731 * Create a node for REAL, IMAG 2732 */ 2733 static tnode_t * 2734 build_real_imag(op_t op, tnode_t *ln) 2735 { 2736 tnode_t *cn, *ntn; 2737 2738 lint_assert(ln != NULL); 2739 2740 switch (ln->tn_type->t_tspec) { 2741 case LCOMPLEX: 2742 /* XXX: integer and LDOUBLE don't match. */ 2743 cn = new_integer_constant_node(LDOUBLE, (int64_t)1); 2744 break; 2745 case DCOMPLEX: 2746 cn = new_integer_constant_node(DOUBLE, (int64_t)1); 2747 break; 2748 case FCOMPLEX: 2749 cn = new_integer_constant_node(FLOAT, (int64_t)1); 2750 break; 2751 default: 2752 /* __%s__ is illegal for type %s */ 2753 error(276, op == REAL ? "real" : "imag", 2754 type_name(ln->tn_type)); 2755 return NULL; 2756 } 2757 ntn = new_tnode(op, cn->tn_type, ln, cn); 2758 ntn->tn_lvalue = true; 2759 2760 return ntn; 2761 } 2762 /* 2763 * Create a tree node for the unary & operator 2764 */ 2765 static tnode_t * 2766 build_address(tnode_t *tn, bool noign) 2767 { 2768 tspec_t t; 2769 2770 if (!noign && ((t = tn->tn_type->t_tspec) == ARRAY || t == FUNC)) { 2771 if (tflag) 2772 /* '&' before array or function: ignored */ 2773 warning(127); 2774 return tn; 2775 } 2776 2777 /* eliminate &* */ 2778 if (tn->tn_op == INDIR && 2779 tn->tn_left->tn_type->t_tspec == PTR && 2780 tn->tn_left->tn_type->t_subt == tn->tn_type) { 2781 return tn->tn_left; 2782 } 2783 2784 return new_tnode(ADDR, tincref(tn->tn_type, PTR), tn, NULL); 2785 } 2786 2787 /* 2788 * Create a node for operators PLUS and MINUS. 2789 */ 2790 static tnode_t * 2791 build_plus_minus(op_t op, tnode_t *ln, tnode_t *rn) 2792 { 2793 tnode_t *ntn, *ctn; 2794 type_t *tp; 2795 2796 /* If pointer and integer, then pointer to the lhs. */ 2797 if (rn->tn_type->t_tspec == PTR && is_integer(ln->tn_type->t_tspec)) { 2798 ntn = ln; 2799 ln = rn; 2800 rn = ntn; 2801 } 2802 2803 if (ln->tn_type->t_tspec == PTR && rn->tn_type->t_tspec != PTR) { 2804 2805 lint_assert(is_integer(rn->tn_type->t_tspec)); 2806 2807 ctn = plength(ln->tn_type); 2808 if (rn->tn_type->t_tspec != ctn->tn_type->t_tspec) 2809 rn = convert(NOOP, 0, ctn->tn_type, rn); 2810 rn = new_tnode(MULT, rn->tn_type, rn, ctn); 2811 if (rn->tn_left->tn_op == CON) 2812 rn = fold(rn); 2813 ntn = new_tnode(op, ln->tn_type, ln, rn); 2814 2815 } else if (rn->tn_type->t_tspec == PTR) { 2816 2817 lint_assert(ln->tn_type->t_tspec == PTR); 2818 lint_assert(op == MINUS); 2819 tp = gettyp(PTRDIFF_TSPEC); 2820 ntn = new_tnode(op, tp, ln, rn); 2821 if (ln->tn_op == CON && rn->tn_op == CON) 2822 ntn = fold(ntn); 2823 ctn = plength(ln->tn_type); 2824 balance(NOOP, &ntn, &ctn); 2825 ntn = new_tnode(DIV, tp, ntn, ctn); 2826 2827 } else { 2828 2829 ntn = new_tnode(op, ln->tn_type, ln, rn); 2830 2831 } 2832 return ntn; 2833 } 2834 2835 /* 2836 * Create a node for operators SHL and SHR. 2837 */ 2838 static tnode_t * 2839 build_bit_shift(op_t op, tnode_t *ln, tnode_t *rn) 2840 { 2841 tspec_t t; 2842 tnode_t *ntn; 2843 2844 if ((t = rn->tn_type->t_tspec) != INT && t != UINT) 2845 rn = convert(CVT, 0, gettyp(INT), rn); 2846 ntn = new_tnode(op, ln->tn_type, ln, rn); 2847 return ntn; 2848 } 2849 2850 /* 2851 * Create a node for COLON. 2852 */ 2853 static tnode_t * 2854 build_colon(tnode_t *ln, tnode_t *rn) 2855 { 2856 tspec_t lt, rt, pdt; 2857 type_t *rtp; 2858 tnode_t *ntn; 2859 2860 lt = ln->tn_type->t_tspec; 2861 rt = rn->tn_type->t_tspec; 2862 pdt = PTRDIFF_TSPEC; 2863 2864 /* 2865 * Arithmetic types are balanced, all other type combinations 2866 * still need to be handled. 2867 */ 2868 if (is_arithmetic(lt) && is_arithmetic(rt)) { 2869 rtp = ln->tn_type; 2870 } else if (lt == BOOL && rt == BOOL) { 2871 rtp = ln->tn_type; 2872 } else if (lt == VOID || rt == VOID) { 2873 rtp = gettyp(VOID); 2874 } else if (lt == STRUCT || lt == UNION) { 2875 /* Both types must be identical. */ 2876 lint_assert(rt == STRUCT || rt == UNION); 2877 lint_assert(ln->tn_type->t_str == rn->tn_type->t_str); 2878 if (is_incomplete(ln->tn_type)) { 2879 /* unknown operand size, op %s */ 2880 error(138, modtab[COLON].m_name); 2881 return NULL; 2882 } 2883 rtp = ln->tn_type; 2884 } else if (lt == PTR && is_integer(rt)) { 2885 if (rt != pdt) { 2886 rn = convert(NOOP, 0, gettyp(pdt), rn); 2887 rt = pdt; 2888 } 2889 rtp = ln->tn_type; 2890 } else if (rt == PTR && is_integer(lt)) { 2891 if (lt != pdt) { 2892 ln = convert(NOOP, 0, gettyp(pdt), ln); 2893 lt = pdt; 2894 } 2895 rtp = rn->tn_type; 2896 } else if (lt == PTR && ln->tn_type->t_subt->t_tspec == VOID) { 2897 lint_assert(rt == PTR); 2898 rtp = rn->tn_type; 2899 merge_qualifiers(&rtp, ln->tn_type, rn->tn_type); 2900 } else if (rt == PTR && rn->tn_type->t_subt->t_tspec == VOID) { 2901 lint_assert(lt == PTR); 2902 rtp = ln->tn_type; 2903 merge_qualifiers(&rtp, ln->tn_type, rn->tn_type); 2904 } else { 2905 lint_assert(lt == PTR); 2906 lint_assert(rt == PTR); 2907 /* 2908 * XXX For now we simply take the left type. This is 2909 * probably wrong, if one type contains a function prototype 2910 * and the other one, at the same place, only an old style 2911 * declaration. 2912 */ 2913 rtp = ln->tn_type; 2914 merge_qualifiers(&rtp, ln->tn_type, rn->tn_type); 2915 } 2916 2917 ntn = new_tnode(COLON, rtp, ln, rn); 2918 2919 return ntn; 2920 } 2921 2922 /* 2923 * Create a node for an assignment operator (both = and op= ). 2924 */ 2925 static tnode_t * 2926 build_assignment(op_t op, tnode_t *ln, tnode_t *rn) 2927 { 2928 tspec_t lt, rt; 2929 tnode_t *ntn, *ctn; 2930 2931 lint_assert(ln != NULL); 2932 lint_assert(rn != NULL); 2933 2934 lt = ln->tn_type->t_tspec; 2935 rt = rn->tn_type->t_tspec; 2936 2937 if ((op == ADDASS || op == SUBASS) && lt == PTR) { 2938 lint_assert(is_integer(rt)); 2939 ctn = plength(ln->tn_type); 2940 if (rn->tn_type->t_tspec != ctn->tn_type->t_tspec) 2941 rn = convert(NOOP, 0, ctn->tn_type, rn); 2942 rn = new_tnode(MULT, rn->tn_type, rn, ctn); 2943 if (rn->tn_left->tn_op == CON) 2944 rn = fold(rn); 2945 } 2946 2947 if ((op == ASSIGN || op == RETURN) && (lt == STRUCT || rt == STRUCT)) { 2948 lint_assert(lt == rt); 2949 lint_assert(ln->tn_type->t_str == rn->tn_type->t_str); 2950 if (is_incomplete(ln->tn_type)) { 2951 if (op == RETURN) { 2952 /* cannot return incomplete type */ 2953 error(212); 2954 } else { 2955 /* unknown operand size, op %s */ 2956 error(138, getopname(op)); 2957 } 2958 return NULL; 2959 } 2960 } 2961 2962 if (op == SHLASS) { 2963 if (portable_size_in_bits(lt) < portable_size_in_bits(rt)) { 2964 if (hflag) 2965 /* semantics of '%s' change in ANSI C; ... */ 2966 warning(118, "<<="); 2967 } 2968 } else if (op != SHRASS) { 2969 if (op == ASSIGN || lt != PTR) { 2970 if (lt != rt || 2971 (ln->tn_type->t_bitfield && rn->tn_op == CON)) { 2972 rn = convert(op, 0, ln->tn_type, rn); 2973 rt = lt; 2974 } 2975 } 2976 } 2977 2978 ntn = new_tnode(op, ln->tn_type, ln, rn); 2979 2980 return ntn; 2981 } 2982 2983 /* 2984 * Get length of type tp->t_subt. 2985 */ 2986 static tnode_t * 2987 plength(type_t *tp) 2988 { 2989 int elem, elsz; 2990 2991 lint_assert(tp->t_tspec == PTR); 2992 tp = tp->t_subt; 2993 2994 elem = 1; 2995 elsz = 0; 2996 2997 while (tp->t_tspec == ARRAY) { 2998 elem *= tp->t_dim; 2999 tp = tp->t_subt; 3000 } 3001 3002 switch (tp->t_tspec) { 3003 case FUNC: 3004 /* pointer to function is not allowed here */ 3005 error(110); 3006 break; 3007 case VOID: 3008 /* cannot do pointer arithmetic on operand of unknown size */ 3009 gnuism(136); 3010 break; 3011 case STRUCT: 3012 case UNION: 3013 if ((elsz = tp->t_str->sou_size_in_bits) == 0) 3014 /* cannot do pointer arithmetic on operand of ... */ 3015 error(136); 3016 break; 3017 case ENUM: 3018 if (is_incomplete(tp)) { 3019 /* cannot do pointer arithmetic on operand of ... */ 3020 warning(136); 3021 } 3022 /* FALLTHROUGH */ 3023 default: 3024 if ((elsz = size_in_bits(tp->t_tspec)) == 0) { 3025 /* cannot do pointer arithmetic on operand of ... */ 3026 error(136); 3027 } else { 3028 lint_assert(elsz != -1); 3029 } 3030 break; 3031 } 3032 3033 if (elem == 0 && elsz != 0) { 3034 /* cannot do pointer arithmetic on operand of unknown size */ 3035 error(136); 3036 } 3037 3038 if (elsz == 0) 3039 elsz = CHAR_SIZE; 3040 3041 return new_integer_constant_node(PTRDIFF_TSPEC, 3042 (int64_t)(elem * elsz / CHAR_SIZE)); 3043 } 3044 3045 /* 3046 * XXX 3047 * Note: There appear to be a number of bugs in detecting overflow in 3048 * this function. An audit and a set of proper regression tests are needed. 3049 * --Perry Metzger, Nov. 16, 2001 3050 */ 3051 /* 3052 * Do only as much as necessary to compute constant expressions. 3053 * Called only if the operator allows folding and all operands are constants. 3054 */ 3055 static tnode_t * 3056 fold(tnode_t *tn) 3057 { 3058 val_t *v; 3059 tspec_t t; 3060 bool utyp, ovfl; 3061 int64_t sl, sr = 0, q = 0, mask; 3062 uint64_t ul, ur = 0; 3063 tnode_t *cn; 3064 3065 v = xcalloc(1, sizeof (val_t)); 3066 v->v_tspec = t = tn->tn_type->t_tspec; 3067 3068 utyp = t == PTR || is_uinteger(t); 3069 ul = sl = tn->tn_left->tn_val->v_quad; 3070 if (modtab[tn->tn_op].m_binary) 3071 ur = sr = tn->tn_right->tn_val->v_quad; 3072 3073 mask = qlmasks[size_in_bits(t)]; 3074 ovfl = false; 3075 3076 switch (tn->tn_op) { 3077 case UPLUS: 3078 q = sl; 3079 break; 3080 case UMINUS: 3081 q = -sl; 3082 if (sl != 0 && msb(q, t, -1) == msb(sl, t, -1)) 3083 ovfl = true; 3084 break; 3085 case COMPL: 3086 q = ~sl; 3087 break; 3088 case MULT: 3089 if (utyp) { 3090 q = ul * ur; 3091 if (q != (q & mask)) 3092 ovfl = true; 3093 else if ((ul != 0) && ((q / ul) != ur)) 3094 ovfl = true; 3095 } else { 3096 q = sl * sr; 3097 if (msb(q, t, -1) != (msb(sl, t, -1) ^ msb(sr, t, -1))) 3098 ovfl = true; 3099 } 3100 break; 3101 case DIV: 3102 if (sr == 0) { 3103 /* division by 0 */ 3104 error(139); 3105 q = utyp ? UQUAD_MAX : QUAD_MAX; 3106 } else { 3107 q = utyp ? (int64_t)(ul / ur) : sl / sr; 3108 } 3109 break; 3110 case MOD: 3111 if (sr == 0) { 3112 /* modulus by 0 */ 3113 error(140); 3114 q = 0; 3115 } else { 3116 q = utyp ? (int64_t)(ul % ur) : sl % sr; 3117 } 3118 break; 3119 case PLUS: 3120 q = utyp ? (int64_t)(ul + ur) : sl + sr; 3121 if (msb(sl, t, -1) != 0 && msb(sr, t, -1) != 0) { 3122 if (msb(q, t, -1) == 0) 3123 ovfl = true; 3124 } else if (msb(sl, t, -1) == 0 && msb(sr, t, -1) == 0) { 3125 if (msb(q, t, -1) != 0) 3126 ovfl = true; 3127 } 3128 break; 3129 case MINUS: 3130 q = utyp ? (int64_t)(ul - ur) : sl - sr; 3131 if (msb(sl, t, -1) != 0 && msb(sr, t, -1) == 0) { 3132 if (msb(q, t, -1) == 0) 3133 ovfl = true; 3134 } else if (msb(sl, t, -1) == 0 && msb(sr, t, -1) != 0) { 3135 if (msb(q, t, -1) != 0) 3136 ovfl = true; 3137 } 3138 break; 3139 case SHL: 3140 q = utyp ? (int64_t)(ul << sr) : sl << sr; 3141 break; 3142 case SHR: 3143 /* 3144 * The sign must be explicitly extended because 3145 * shifts of signed values are implementation dependent. 3146 */ 3147 q = ul >> sr; 3148 q = xsign(q, t, size_in_bits(t) - (int)sr); 3149 break; 3150 case LT: 3151 q = (utyp ? ul < ur : sl < sr) ? 1 : 0; 3152 break; 3153 case LE: 3154 q = (utyp ? ul <= ur : sl <= sr) ? 1 : 0; 3155 break; 3156 case GE: 3157 q = (utyp ? ul >= ur : sl >= sr) ? 1 : 0; 3158 break; 3159 case GT: 3160 q = (utyp ? ul > ur : sl > sr) ? 1 : 0; 3161 break; 3162 case EQ: 3163 q = (utyp ? ul == ur : sl == sr) ? 1 : 0; 3164 break; 3165 case NE: 3166 q = (utyp ? ul != ur : sl != sr) ? 1 : 0; 3167 break; 3168 case BITAND: 3169 q = utyp ? (int64_t)(ul & ur) : sl & sr; 3170 break; 3171 case BITXOR: 3172 q = utyp ? (int64_t)(ul ^ ur) : sl ^ sr; 3173 break; 3174 case BITOR: 3175 q = utyp ? (int64_t)(ul | ur) : sl | sr; 3176 break; 3177 default: 3178 lint_assert(/*CONSTCOND*/false); 3179 } 3180 3181 /* XXX does not work for quads. */ 3182 if (ovfl || ((uint64_t)(q | mask) != ~(uint64_t)0 && 3183 (q & ~mask) != 0)) { 3184 if (hflag) 3185 /* integer overflow detected, op %s */ 3186 warning(141, modtab[tn->tn_op].m_name); 3187 } 3188 3189 v->v_quad = xsign(q, t, -1); 3190 3191 cn = new_constant_node(tn->tn_type, v); 3192 if (tn->tn_left->tn_system_dependent) 3193 cn->tn_system_dependent = true; 3194 if (modtab[tn->tn_op].m_binary && tn->tn_right->tn_system_dependent) 3195 cn->tn_system_dependent = true; 3196 3197 return cn; 3198 } 3199 3200 /* 3201 * Fold constant nodes, as much as is needed for comparing the value with 0 3202 * (test context, for controlling expressions). 3203 */ 3204 static tnode_t * 3205 fold_test(tnode_t *tn) 3206 { 3207 bool l, r; 3208 val_t *v; 3209 3210 v = xcalloc(1, sizeof (val_t)); 3211 v->v_tspec = tn->tn_type->t_tspec; 3212 lint_assert(v->v_tspec == INT || (Tflag && v->v_tspec == BOOL)); 3213 3214 l = constant_is_nonzero(tn->tn_left); 3215 r = modtab[tn->tn_op].m_binary && constant_is_nonzero(tn->tn_right); 3216 3217 switch (tn->tn_op) { 3218 case NOT: 3219 if (hflag && !constcond_flag) 3220 /* constant argument to NOT */ 3221 warning(239); 3222 v->v_quad = !l ? 1 : 0; 3223 break; 3224 case LOGAND: 3225 v->v_quad = l && r ? 1 : 0; 3226 break; 3227 case LOGOR: 3228 v->v_quad = l || r ? 1 : 0; 3229 break; 3230 default: 3231 lint_assert(/*CONSTCOND*/false); 3232 } 3233 3234 return new_constant_node(tn->tn_type, v); 3235 } 3236 3237 /* 3238 * Fold constant nodes having operands with floating point type. 3239 */ 3240 static tnode_t * 3241 fold_float(tnode_t *tn) 3242 { 3243 val_t *v; 3244 tspec_t t; 3245 ldbl_t l, r = 0; 3246 3247 fpe = 0; 3248 v = xcalloc(1, sizeof (val_t)); 3249 v->v_tspec = t = tn->tn_type->t_tspec; 3250 3251 lint_assert(is_floating(t)); 3252 lint_assert(t == tn->tn_left->tn_type->t_tspec); 3253 lint_assert(!modtab[tn->tn_op].m_binary || 3254 t == tn->tn_right->tn_type->t_tspec); 3255 3256 l = tn->tn_left->tn_val->v_ldbl; 3257 if (modtab[tn->tn_op].m_binary) 3258 r = tn->tn_right->tn_val->v_ldbl; 3259 3260 switch (tn->tn_op) { 3261 case UPLUS: 3262 v->v_ldbl = l; 3263 break; 3264 case UMINUS: 3265 v->v_ldbl = -l; 3266 break; 3267 case MULT: 3268 v->v_ldbl = l * r; 3269 break; 3270 case DIV: 3271 if (r == 0.0) { 3272 /* division by 0 */ 3273 error(139); 3274 if (t == FLOAT) { 3275 v->v_ldbl = l < 0 ? -FLT_MAX : FLT_MAX; 3276 } else if (t == DOUBLE) { 3277 v->v_ldbl = l < 0 ? -DBL_MAX : DBL_MAX; 3278 } else { 3279 v->v_ldbl = l < 0 ? -LDBL_MAX : LDBL_MAX; 3280 } 3281 } else { 3282 v->v_ldbl = l / r; 3283 } 3284 break; 3285 case PLUS: 3286 v->v_ldbl = l + r; 3287 break; 3288 case MINUS: 3289 v->v_ldbl = l - r; 3290 break; 3291 case LT: 3292 v->v_quad = l < r ? 1 : 0; 3293 break; 3294 case LE: 3295 v->v_quad = l <= r ? 1 : 0; 3296 break; 3297 case GE: 3298 v->v_quad = l >= r ? 1 : 0; 3299 break; 3300 case GT: 3301 v->v_quad = l > r ? 1 : 0; 3302 break; 3303 case EQ: 3304 v->v_quad = l == r ? 1 : 0; 3305 break; 3306 case NE: 3307 v->v_quad = l != r ? 1 : 0; 3308 break; 3309 default: 3310 lint_assert(/*CONSTCOND*/false); 3311 } 3312 3313 lint_assert(fpe != 0 || isnan((double)v->v_ldbl) == 0); 3314 if (fpe != 0 || finite((double)v->v_ldbl) == 0 || 3315 (t == FLOAT && 3316 (v->v_ldbl > FLT_MAX || v->v_ldbl < -FLT_MAX)) || 3317 (t == DOUBLE && 3318 (v->v_ldbl > DBL_MAX || v->v_ldbl < -DBL_MAX))) { 3319 /* floating point overflow detected, op %s */ 3320 warning(142, modtab[tn->tn_op].m_name); 3321 if (t == FLOAT) { 3322 v->v_ldbl = v->v_ldbl < 0 ? -FLT_MAX : FLT_MAX; 3323 } else if (t == DOUBLE) { 3324 v->v_ldbl = v->v_ldbl < 0 ? -DBL_MAX : DBL_MAX; 3325 } else { 3326 v->v_ldbl = v->v_ldbl < 0 ? -LDBL_MAX: LDBL_MAX; 3327 } 3328 fpe = 0; 3329 } 3330 3331 return new_constant_node(tn->tn_type, v); 3332 } 3333 3334 3335 /* 3336 * Create a constant node for sizeof. 3337 */ 3338 tnode_t * 3339 build_sizeof(type_t *tp) 3340 { 3341 int64_t size_in_bytes = type_size_in_bits(tp) / CHAR_SIZE; 3342 tnode_t *tn = new_integer_constant_node(SIZEOF_TSPEC, size_in_bytes); 3343 tn->tn_system_dependent = true; 3344 return tn; 3345 } 3346 3347 /* 3348 * Create a constant node for offsetof. 3349 */ 3350 tnode_t * 3351 build_offsetof(type_t *tp, sym_t *sym) 3352 { 3353 tspec_t t = tp->t_tspec; 3354 if (t != STRUCT && t != UNION) 3355 /* unacceptable operand of '%s' */ 3356 error(111, "offsetof"); 3357 3358 // XXX: wrong size, no checking for sym fixme 3359 int64_t offset_in_bytes = type_size_in_bits(tp) / CHAR_SIZE; 3360 tnode_t *tn = new_integer_constant_node(SIZEOF_TSPEC, offset_in_bytes); 3361 tn->tn_system_dependent = true; 3362 return tn; 3363 } 3364 3365 int64_t 3366 type_size_in_bits(type_t *tp) 3367 { 3368 int elem, elsz; 3369 bool flex; 3370 3371 elem = 1; 3372 flex = false; 3373 while (tp->t_tspec == ARRAY) { 3374 flex = true; /* allow c99 flex arrays [] [0] */ 3375 elem *= tp->t_dim; 3376 tp = tp->t_subt; 3377 } 3378 if (elem == 0) { 3379 if (!flex) { 3380 /* cannot take size/alignment of incomplete type */ 3381 error(143); 3382 elem = 1; 3383 } 3384 } 3385 switch (tp->t_tspec) { 3386 case FUNC: 3387 /* cannot take size/alignment of function */ 3388 error(144); 3389 elsz = 1; 3390 break; 3391 case STRUCT: 3392 case UNION: 3393 if (is_incomplete(tp)) { 3394 /* cannot take size/alignment of incomplete type */ 3395 error(143); 3396 elsz = 1; 3397 } else { 3398 elsz = tp->t_str->sou_size_in_bits; 3399 } 3400 break; 3401 case ENUM: 3402 if (is_incomplete(tp)) { 3403 /* cannot take size/alignment of incomplete type */ 3404 warning(143); 3405 } 3406 /* FALLTHROUGH */ 3407 default: 3408 if (tp->t_bitfield) { 3409 /* cannot take size/alignment of bit-field */ 3410 error(145); 3411 } 3412 if (tp->t_tspec == VOID) { 3413 /* cannot take size/alignment of void */ 3414 error(146); 3415 elsz = 1; 3416 } else { 3417 elsz = size_in_bits(tp->t_tspec); 3418 lint_assert(elsz > 0); 3419 } 3420 break; 3421 } 3422 3423 return (int64_t)elem * elsz; 3424 } 3425 3426 tnode_t * 3427 build_alignof(type_t *tp) 3428 { 3429 switch (tp->t_tspec) { 3430 case ARRAY: 3431 break; 3432 3433 case FUNC: 3434 /* cannot take size/alignment of function */ 3435 error(144); 3436 return 0; 3437 3438 case STRUCT: 3439 case UNION: 3440 if (is_incomplete(tp)) { 3441 /* cannot take size/alignment of incomplete type */ 3442 error(143); 3443 return 0; 3444 } 3445 break; 3446 case ENUM: 3447 break; 3448 default: 3449 if (tp->t_bitfield) { 3450 /* cannot take size/alignment of bit-field */ 3451 error(145); 3452 return 0; 3453 } 3454 if (tp->t_tspec == VOID) { 3455 /* cannot take size/alignment of void */ 3456 error(146); 3457 return 0; 3458 } 3459 break; 3460 } 3461 3462 return new_integer_constant_node(SIZEOF_TSPEC, 3463 (int64_t)alignment_in_bits(tp) / CHAR_SIZE); 3464 } 3465 3466 /* 3467 * Type casts. 3468 */ 3469 tnode_t * 3470 cast(tnode_t *tn, type_t *tp) 3471 { 3472 tspec_t nt, ot; 3473 3474 if (tn == NULL) 3475 return NULL; 3476 3477 /* 3478 * XXX: checking for tp == NULL is only a quick fix for PR 22119. 3479 * The proper fix needs to be investigated properly. 3480 * See d_pr_22119.c for how to get here. 3481 */ 3482 if (tp == NULL) 3483 return NULL; 3484 3485 tn = cconv(tn); 3486 3487 nt = tp->t_tspec; 3488 ot = tn->tn_type->t_tspec; 3489 3490 if (nt == VOID) { 3491 /* 3492 * XXX ANSI C requires scalar types or void (Plauger & Brodie). 3493 * But this seems really questionable. 3494 */ 3495 } else if (nt == UNION) { 3496 sym_t *m; 3497 struct_or_union *str = tp->t_str; 3498 if (!Sflag) { 3499 /* union cast is a C9X feature */ 3500 error(328); 3501 return NULL; 3502 } 3503 for (m = str->sou_first_member; m != NULL; m = m->s_next) { 3504 if (sametype(m->s_type, tn->tn_type)) { 3505 tn = getnode(); 3506 tn->tn_op = CVT; 3507 tn->tn_type = tp; 3508 tn->tn_cast = true; 3509 tn->tn_right = NULL; 3510 return tn; 3511 } 3512 } 3513 /* type '%s' is not a member of '%s' */ 3514 error(329, type_name(tn->tn_type), type_name(tp)); 3515 return NULL; 3516 } else if (nt == STRUCT || nt == ARRAY || nt == FUNC) { 3517 if (!Sflag || nt == ARRAY || nt == FUNC) { 3518 /* invalid cast expression */ 3519 error(147); 3520 return NULL; 3521 } 3522 } else if (ot == STRUCT || ot == UNION) { 3523 /* invalid cast expression */ 3524 error(147); 3525 return NULL; 3526 } else if (ot == VOID) { 3527 /* improper cast of void expression */ 3528 error(148); 3529 return NULL; 3530 } else if (is_integer(nt) && is_scalar(ot)) { 3531 /* ok */ 3532 } else if (is_floating(nt) && is_arithmetic(ot)) { 3533 /* ok */ 3534 } else if (nt == PTR && is_integer(ot)) { 3535 /* ok */ 3536 } else if (nt == PTR && ot == PTR) { 3537 if (!tp->t_subt->t_const && tn->tn_type->t_subt->t_const) { 3538 if (hflag) 3539 /* cast discards 'const' from type '%s' */ 3540 warning(275, type_name(tn->tn_type)); 3541 } 3542 } else { 3543 /* invalid cast expression */ 3544 error(147); 3545 return NULL; 3546 } 3547 3548 tn = convert(CVT, 0, tp, tn); 3549 tn->tn_cast = true; 3550 3551 return tn; 3552 } 3553 3554 /* 3555 * Create the node for a function argument. 3556 * All necessary conversions and type checks are done in 3557 * new_function_call_node because new_function_argument_node has no 3558 * information about expected argument types. 3559 */ 3560 tnode_t * 3561 new_function_argument_node(tnode_t *args, tnode_t *arg) 3562 { 3563 tnode_t *ntn; 3564 3565 /* 3566 * If there was a serious error in the expression for the argument, 3567 * create a dummy argument so the positions of the remaining arguments 3568 * will not change. 3569 */ 3570 if (arg == NULL) 3571 arg = new_integer_constant_node(INT, (int64_t)0); 3572 3573 ntn = new_tnode(PUSH, arg->tn_type, arg, args); 3574 3575 return ntn; 3576 } 3577 3578 /* 3579 * Create the node for a function call. Also check types of 3580 * function arguments and insert conversions, if necessary. 3581 */ 3582 tnode_t * 3583 new_function_call_node(tnode_t *func, tnode_t *args) 3584 { 3585 tnode_t *ntn; 3586 op_t fcop; 3587 3588 if (func == NULL) 3589 return NULL; 3590 3591 if (func->tn_op == NAME && func->tn_type->t_tspec == FUNC) { 3592 fcop = CALL; 3593 } else { 3594 fcop = ICALL; 3595 } 3596 3597 /* 3598 * after cconv() func will always be a pointer to a function 3599 * if it is a valid function designator. 3600 */ 3601 func = cconv(func); 3602 3603 if (func->tn_type->t_tspec != PTR || 3604 func->tn_type->t_subt->t_tspec != FUNC) { 3605 /* illegal function (type %s) */ 3606 error(149, type_name(func->tn_type)); 3607 return NULL; 3608 } 3609 3610 args = check_function_arguments(func->tn_type->t_subt, args); 3611 3612 ntn = new_tnode(fcop, func->tn_type->t_subt->t_subt, func, args); 3613 3614 return ntn; 3615 } 3616 3617 /* 3618 * Check types of all function arguments and insert conversions, 3619 * if necessary. 3620 */ 3621 static tnode_t * 3622 check_function_arguments(type_t *ftp, tnode_t *args) 3623 { 3624 tnode_t *arg; 3625 sym_t *asym; 3626 tspec_t at; 3627 int narg, npar, n, i; 3628 3629 /* get # of args in the prototype */ 3630 npar = 0; 3631 for (asym = ftp->t_args; asym != NULL; asym = asym->s_next) 3632 npar++; 3633 3634 /* get # of args in function call */ 3635 narg = 0; 3636 for (arg = args; arg != NULL; arg = arg->tn_right) 3637 narg++; 3638 3639 asym = ftp->t_args; 3640 if (ftp->t_proto && npar != narg && !(ftp->t_vararg && npar < narg)) { 3641 /* argument mismatch: %d arg%s passed, %d expected */ 3642 error(150, narg, narg > 1 ? "s" : "", npar); 3643 asym = NULL; 3644 } 3645 3646 for (n = 1; n <= narg; n++) { 3647 3648 /* 3649 * The rightmost argument is at the top of the argument 3650 * subtree. 3651 */ 3652 for (i = narg, arg = args; i > n; i--, arg = arg->tn_right) 3653 continue; 3654 3655 /* some things which are always not allowed */ 3656 if ((at = arg->tn_left->tn_type->t_tspec) == VOID) { 3657 /* void expressions may not be arguments, arg #%d */ 3658 error(151, n); 3659 return NULL; 3660 } else if ((at == STRUCT || at == UNION) && 3661 is_incomplete(arg->tn_left->tn_type)) { 3662 /* argument cannot have unknown size, arg #%d */ 3663 error(152, n); 3664 return NULL; 3665 } else if (is_integer(at) && 3666 arg->tn_left->tn_type->t_is_enum && 3667 is_incomplete(arg->tn_left->tn_type)) { 3668 /* argument cannot have unknown size, arg #%d */ 3669 warning(152, n); 3670 } 3671 3672 /* class conversions (arg in value context) */ 3673 arg->tn_left = cconv(arg->tn_left); 3674 3675 if (asym != NULL) { 3676 arg->tn_left = check_prototype_argument( 3677 n, asym->s_type, arg->tn_left); 3678 } else { 3679 arg->tn_left = promote(NOOP, true, arg->tn_left); 3680 } 3681 arg->tn_type = arg->tn_left->tn_type; 3682 3683 if (asym != NULL) 3684 asym = asym->s_next; 3685 } 3686 3687 return args; 3688 } 3689 3690 /* 3691 * Compare the type of an argument with the corresponding type of a 3692 * prototype parameter. If it is a valid combination, but both types 3693 * are not the same, insert a conversion to convert the argument into 3694 * the type of the parameter. 3695 */ 3696 static tnode_t * 3697 check_prototype_argument( 3698 int n, /* pos of arg */ 3699 type_t *tp, /* expected type (from prototype) */ 3700 tnode_t *tn) /* argument */ 3701 { 3702 tnode_t *ln; 3703 bool dowarn; 3704 3705 ln = xcalloc(1, sizeof (tnode_t)); 3706 ln->tn_type = tduptyp(tp); 3707 ln->tn_type->t_const = false; 3708 ln->tn_lvalue = true; 3709 if (typeok(FARG, n, ln, tn)) { 3710 if (!eqtype(tp, tn->tn_type, 3711 true, false, (dowarn = false, &dowarn)) || dowarn) 3712 tn = convert(FARG, n, tp, tn); 3713 } 3714 free(ln); 3715 return tn; 3716 } 3717 3718 /* 3719 * Return the value of an integral constant expression. 3720 * If the expression is not constant or its type is not an integer 3721 * type, an error message is printed. 3722 */ 3723 val_t * 3724 constant(tnode_t *tn, bool required) 3725 { 3726 val_t *v; 3727 3728 if (tn != NULL) 3729 tn = cconv(tn); 3730 if (tn != NULL) 3731 tn = promote(NOOP, false, tn); 3732 3733 v = xcalloc(1, sizeof (val_t)); 3734 3735 if (tn == NULL) { 3736 lint_assert(nerr != 0); 3737 if (dflag) 3738 printf("constant node is null; returning 1 instead\n"); 3739 v->v_tspec = INT; 3740 v->v_quad = 1; 3741 return v; 3742 } 3743 3744 v->v_tspec = tn->tn_type->t_tspec; 3745 3746 if (tn->tn_op == CON) { 3747 lint_assert(tn->tn_type->t_tspec == tn->tn_val->v_tspec); 3748 if (is_integer(tn->tn_val->v_tspec)) { 3749 v->v_ansiu = tn->tn_val->v_ansiu; 3750 v->v_quad = tn->tn_val->v_quad; 3751 return v; 3752 } 3753 v->v_quad = tn->tn_val->v_ldbl; 3754 } else { 3755 v->v_quad = 1; 3756 } 3757 3758 if (required) 3759 /* integral constant expression expected */ 3760 error(55); 3761 else 3762 /* variable array dimension is a C99/GCC extension */ 3763 c99ism(318); 3764 3765 if (!is_integer(v->v_tspec)) 3766 v->v_tspec = INT; 3767 3768 return v; 3769 } 3770 3771 static bool 3772 is_constcond_false(const tnode_t *tn, tspec_t t) 3773 { 3774 return (t == BOOL || t == INT) && 3775 tn->tn_op == CON && tn->tn_val->v_quad == 0; 3776 } 3777 3778 /* 3779 * Perform some tests on expressions which can't be done in build() and 3780 * functions called by build(). These tests must be done here because 3781 * we need some information about the context in which the operations 3782 * are performed. 3783 * After all tests are performed and dofreeblk is true, expr() frees the 3784 * memory which is used for the expression. 3785 */ 3786 void 3787 expr(tnode_t *tn, bool vctx, bool tctx, bool dofreeblk, bool constcond_false_ok) 3788 { 3789 3790 lint_assert(tn != NULL || nerr != 0); 3791 3792 if (tn == NULL) { 3793 tfreeblk(); 3794 return; 3795 } 3796 3797 /* expr() is also called in global initializations */ 3798 /* TODO: rename constcond_false_ok */ 3799 if (dcs->d_ctx != EXTERN && !constcond_false_ok) 3800 check_statement_reachable(); 3801 3802 check_expr_misc(tn, vctx, tctx, !tctx, false, false, false); 3803 if (tn->tn_op == ASSIGN) { 3804 if (hflag && tctx) 3805 /* assignment in conditional context */ 3806 warning(159); 3807 } else if (tn->tn_op == CON) { 3808 if (hflag && tctx && !constcond_flag && 3809 !tn->tn_system_dependent && 3810 !(constcond_false_ok && 3811 is_constcond_false(tn, tn->tn_type->t_tspec))) 3812 /* constant in conditional context */ 3813 warning(161); 3814 } 3815 if (!modtab[tn->tn_op].m_has_side_effect) { 3816 /* 3817 * for left operands of COMMA this warning is already 3818 * printed 3819 */ 3820 if (tn->tn_op != COMMA && !vctx && !tctx) 3821 check_null_effect(tn); 3822 } 3823 if (dflag) 3824 display_expression(tn, 0); 3825 3826 /* free the tree memory */ 3827 if (dofreeblk) 3828 tfreeblk(); 3829 } 3830 3831 static bool 3832 has_side_effect(const tnode_t *tn) // NOLINT(misc-no-recursion) 3833 { 3834 op_t op = tn->tn_op; 3835 3836 if (modtab[op].m_has_side_effect) 3837 return true; 3838 3839 if (op == CVT && tn->tn_type->t_tspec == VOID) 3840 return has_side_effect(tn->tn_left); 3841 3842 /* XXX: Why not has_side_effect(tn->tn_left) as well? */ 3843 if (op == LOGAND || op == LOGOR) 3844 return has_side_effect(tn->tn_right); 3845 3846 /* XXX: Why not has_side_effect(tn->tn_left) as well? */ 3847 if (op == QUEST) 3848 return has_side_effect(tn->tn_right); 3849 3850 if (op == COLON || op == COMMA) { 3851 return has_side_effect(tn->tn_left) || 3852 has_side_effect(tn->tn_right); 3853 } 3854 3855 return false; 3856 } 3857 3858 static void 3859 check_null_effect(const tnode_t *tn) 3860 { 3861 3862 if (hflag && !has_side_effect(tn)) { 3863 /* expression has null effect */ 3864 warning(129); 3865 } 3866 } 3867 3868 /* 3869 * Dump an expression to stdout 3870 * only used for debugging 3871 */ 3872 static void 3873 display_expression(const tnode_t *tn, int offs) 3874 { 3875 uint64_t uq; 3876 3877 if (tn == NULL) { 3878 (void)printf("%*s%s\n", offs, "", "NULL"); 3879 return; 3880 } 3881 (void)printf("%*sop %s ", offs, "", modtab[tn->tn_op].m_name); 3882 3883 if (tn->tn_op == NAME) { 3884 (void)printf("%s: %s ", 3885 tn->tn_sym->s_name, 3886 storage_class_name(tn->tn_sym->s_scl)); 3887 } else if (tn->tn_op == CON && is_floating(tn->tn_type->t_tspec)) { 3888 (void)printf("%#g ", (double)tn->tn_val->v_ldbl); 3889 } else if (tn->tn_op == CON && is_integer(tn->tn_type->t_tspec)) { 3890 uq = tn->tn_val->v_quad; 3891 (void)printf("0x %08lx %08lx ", 3892 (long)(uq >> 32) & 0xffffffffl, 3893 (long)uq & 0xffffffffl); 3894 } else if (tn->tn_op == CON) { 3895 lint_assert(tn->tn_type->t_tspec == PTR); 3896 (void)printf("0x%0*lx ", (int)(sizeof (void *) * CHAR_BIT / 4), 3897 (u_long)tn->tn_val->v_quad); 3898 } else if (tn->tn_op == STRING) { 3899 if (tn->tn_string->st_tspec == CHAR) { 3900 (void)printf("\"%s\"", tn->tn_string->st_cp); 3901 } else { 3902 char *s; 3903 size_t n; 3904 n = MB_CUR_MAX * (tn->tn_string->st_len + 1); 3905 s = xmalloc(n); 3906 (void)wcstombs(s, tn->tn_string->st_wcp, n); 3907 (void)printf("L\"%s\"", s); 3908 free(s); 3909 } 3910 (void)printf(" "); 3911 } else if (tn->tn_op == FSEL) { 3912 (void)printf("o=%d, l=%d ", tn->tn_type->t_foffs, 3913 tn->tn_type->t_flen); 3914 } 3915 (void)printf("%s\n", ttos(tn->tn_type)); 3916 if (tn->tn_op == NAME || tn->tn_op == CON || tn->tn_op == STRING) 3917 return; 3918 display_expression(tn->tn_left, offs + 2); 3919 if (modtab[tn->tn_op].m_binary || 3920 (tn->tn_op == PUSH && tn->tn_right != NULL)) { 3921 display_expression(tn->tn_right, offs + 2); 3922 } 3923 } 3924 3925 /* 3926 * Called by expr() to recursively perform some tests. 3927 */ 3928 /* ARGSUSED */ 3929 void 3930 check_expr_misc(const tnode_t *tn, bool vctx, bool tctx, 3931 bool eqwarn, bool fcall, bool rvdisc, bool szof) 3932 { 3933 tnode_t *ln, *rn; 3934 const mod_t *mp; 3935 op_t op; 3936 scl_t sc; 3937 dinfo_t *di; 3938 3939 if (tn == NULL) 3940 return; 3941 3942 ln = tn->tn_left; 3943 rn = tn->tn_right; 3944 mp = &modtab[op = tn->tn_op]; 3945 3946 switch (op) { 3947 case ADDR: 3948 /* XXX: Taking warn_about_unreachable into account here feels wrong. */ 3949 if (ln->tn_op == NAME && (reached || !warn_about_unreachable)) { 3950 if (!szof) 3951 mark_as_set(ln->tn_sym); 3952 mark_as_used(ln->tn_sym, fcall, szof); 3953 } 3954 if (ln->tn_op == INDIR && ln->tn_left->tn_op == PLUS) 3955 /* check the range of array indices */ 3956 check_array_index(ln->tn_left, true); 3957 break; 3958 case LOAD: 3959 if (ln->tn_op == INDIR && ln->tn_left->tn_op == PLUS) 3960 /* check the range of array indices */ 3961 check_array_index(ln->tn_left, false); 3962 /* FALLTHROUGH */ 3963 case PUSH: 3964 case INCBEF: 3965 case DECBEF: 3966 case INCAFT: 3967 case DECAFT: 3968 case ADDASS: 3969 case SUBASS: 3970 case MULASS: 3971 case DIVASS: 3972 case MODASS: 3973 case ANDASS: 3974 case ORASS: 3975 case XORASS: 3976 case SHLASS: 3977 case SHRASS: 3978 case REAL: 3979 case IMAG: 3980 /* XXX: Taking warn_about_unreachable into account here feels wrong. */ 3981 if (ln->tn_op == NAME && (reached || !warn_about_unreachable)) { 3982 sc = ln->tn_sym->s_scl; 3983 /* 3984 * Look if there was a asm statement in one of the 3985 * compound statements we are in. If not, we don't 3986 * print a warning. 3987 */ 3988 for (di = dcs; di != NULL; di = di->d_next) { 3989 if (di->d_asm) 3990 break; 3991 } 3992 if (sc != EXTERN && sc != STATIC && 3993 !ln->tn_sym->s_set && !szof && di == NULL) { 3994 /* %s may be used before set */ 3995 warning(158, ln->tn_sym->s_name); 3996 mark_as_set(ln->tn_sym); 3997 } 3998 mark_as_used(ln->tn_sym, false, false); 3999 } 4000 break; 4001 case ASSIGN: 4002 /* XXX: Taking warn_about_unreachable into account here feels wrong. */ 4003 if (ln->tn_op == NAME && !szof && (reached || !warn_about_unreachable)) { 4004 mark_as_set(ln->tn_sym); 4005 if (ln->tn_sym->s_scl == EXTERN) 4006 outusg(ln->tn_sym); 4007 } 4008 if (ln->tn_op == INDIR && ln->tn_left->tn_op == PLUS) 4009 /* check the range of array indices */ 4010 check_array_index(ln->tn_left, false); 4011 break; 4012 case CALL: 4013 lint_assert(ln->tn_op == ADDR); 4014 lint_assert(ln->tn_left->tn_op == NAME); 4015 if (!szof) 4016 outcall(tn, vctx || tctx, rvdisc); 4017 break; 4018 case EQ: 4019 if (hflag && eqwarn) 4020 /* operator '==' found where '=' was expected */ 4021 warning(160); 4022 break; 4023 case CON: 4024 case NAME: 4025 case STRING: 4026 return; 4027 /* LINTED206: (enumeration values not handled in switch) */ 4028 case BITOR: 4029 case BITXOR: 4030 case NE: 4031 case GE: 4032 case GT: 4033 case LE: 4034 case LT: 4035 case SHR: 4036 case SHL: 4037 case MINUS: 4038 case PLUS: 4039 case MOD: 4040 case DIV: 4041 case MULT: 4042 case INDIR: 4043 case UMINUS: 4044 case UPLUS: 4045 case DEC: 4046 case INC: 4047 case COMPL: 4048 case NOT: 4049 case POINT: 4050 case ARROW: 4051 case NOOP: 4052 case BITAND: 4053 case FARG: 4054 case CASE: 4055 case INIT: 4056 case RETURN: 4057 case ICALL: 4058 case CVT: 4059 case COMMA: 4060 case FSEL: 4061 case COLON: 4062 case QUEST: 4063 case LOGOR: 4064 case LOGAND: 4065 break; 4066 } 4067 4068 bool cvctx = mp->m_left_value_context; 4069 bool ctctx = mp->m_left_test_context; 4070 bool eq = mp->m_warn_if_operand_eq && 4071 !ln->tn_parenthesized && 4072 rn != NULL && !rn->tn_parenthesized; 4073 4074 /* 4075 * values of operands of ':' are not used if the type of at least 4076 * one of the operands (for gcc compatibility) is void 4077 * XXX test/value context of QUEST should probably be used as 4078 * context for both operands of COLON 4079 */ 4080 if (op == COLON && tn->tn_type->t_tspec == VOID) 4081 cvctx = ctctx = false; 4082 bool discard = op == CVT && tn->tn_type->t_tspec == VOID; 4083 check_expr_misc(ln, cvctx, ctctx, eq, op == CALL, discard, szof); 4084 4085 switch (op) { 4086 case PUSH: 4087 if (rn != NULL) 4088 check_expr_misc(rn, false, false, eq, false, false, 4089 szof); 4090 break; 4091 case LOGAND: 4092 case LOGOR: 4093 check_expr_misc(rn, false, true, eq, false, false, szof); 4094 break; 4095 case COLON: 4096 check_expr_misc(rn, cvctx, ctctx, eq, false, false, szof); 4097 break; 4098 case COMMA: 4099 check_expr_misc(rn, vctx, tctx, eq, false, false, szof); 4100 break; 4101 default: 4102 if (mp->m_binary) 4103 check_expr_misc(rn, true, false, eq, false, false, 4104 szof); 4105 break; 4106 } 4107 4108 } 4109 4110 /* 4111 * Checks the range of array indices, if possible. 4112 * amper is set if only the address of the element is used. This 4113 * means that the index is allowed to refer to the first element 4114 * after the array. 4115 */ 4116 static void 4117 check_array_index(tnode_t *tn, bool amper) 4118 { 4119 int dim; 4120 tnode_t *ln, *rn; 4121 int elsz; 4122 int64_t con; 4123 4124 ln = tn->tn_left; 4125 rn = tn->tn_right; 4126 4127 /* We can only check constant indices. */ 4128 if (rn->tn_op != CON) 4129 return; 4130 4131 /* Return if the left node does not stem from an array. */ 4132 if (ln->tn_op != ADDR) 4133 return; 4134 if (ln->tn_left->tn_op != STRING && ln->tn_left->tn_op != NAME) 4135 return; 4136 if (ln->tn_left->tn_type->t_tspec != ARRAY) 4137 return; 4138 4139 /* 4140 * For incomplete array types, we can print a warning only if 4141 * the index is negative. 4142 */ 4143 if (is_incomplete(ln->tn_left->tn_type) && rn->tn_val->v_quad >= 0) 4144 return; 4145 4146 /* Get the size of one array element */ 4147 if ((elsz = length(ln->tn_type->t_subt, NULL)) == 0) 4148 return; 4149 elsz /= CHAR_SIZE; 4150 4151 /* Change the unit of the index from bytes to element size. */ 4152 if (is_uinteger(rn->tn_type->t_tspec)) { 4153 con = (uint64_t)rn->tn_val->v_quad / elsz; 4154 } else { 4155 con = rn->tn_val->v_quad / elsz; 4156 } 4157 4158 dim = ln->tn_left->tn_type->t_dim + (amper ? 1 : 0); 4159 4160 if (!is_uinteger(rn->tn_type->t_tspec) && con < 0) { 4161 /* array subscript cannot be negative: %ld */ 4162 warning(167, (long)con); 4163 } else if (dim > 0 && (uint64_t)con >= (uint64_t)dim) { 4164 /* array subscript cannot be > %d: %ld */ 4165 warning(168, dim - 1, (long)con); 4166 } 4167 } 4168 4169 /* 4170 * Check for ordered comparisons of unsigned values with 0. 4171 */ 4172 static void 4173 check_integer_comparison(op_t op, tnode_t *ln, tnode_t *rn) 4174 { 4175 tspec_t lt, rt; 4176 const mod_t *mp; 4177 4178 lt = ln->tn_type->t_tspec; 4179 rt = rn->tn_type->t_tspec; 4180 mp = &modtab[op]; 4181 4182 if (ln->tn_op != CON && rn->tn_op != CON) 4183 return; 4184 4185 if (!is_integer(lt) || !is_integer(rt)) 4186 return; 4187 4188 if ((hflag || pflag) && lt == CHAR && rn->tn_op == CON && 4189 (rn->tn_val->v_quad < 0 || 4190 rn->tn_val->v_quad > (int)~(~0U << (CHAR_SIZE - 1)))) { 4191 /* nonportable character comparison, op %s */ 4192 warning(230, mp->m_name); 4193 return; 4194 } 4195 if ((hflag || pflag) && rt == CHAR && ln->tn_op == CON && 4196 (ln->tn_val->v_quad < 0 || 4197 ln->tn_val->v_quad > (int)~(~0U << (CHAR_SIZE - 1)))) { 4198 /* nonportable character comparison, op %s */ 4199 warning(230, mp->m_name); 4200 return; 4201 } 4202 if (is_uinteger(lt) && !is_uinteger(rt) && 4203 rn->tn_op == CON && rn->tn_val->v_quad <= 0) { 4204 if (rn->tn_val->v_quad < 0) { 4205 /* comparison of %s with %s, op %s */ 4206 warning(162, type_name(ln->tn_type), 4207 "negative constant", mp->m_name); 4208 } else if (op == LT || op == GE || (hflag && op == LE)) { 4209 /* comparison of %s with %s, op %s */ 4210 warning(162, type_name(ln->tn_type), "0", mp->m_name); 4211 } 4212 return; 4213 } 4214 if (is_uinteger(rt) && !is_uinteger(lt) && 4215 ln->tn_op == CON && ln->tn_val->v_quad <= 0) { 4216 if (ln->tn_val->v_quad < 0) { 4217 /* comparison of %s with %s, op %s */ 4218 warning(162, "negative constant", 4219 type_name(rn->tn_type), mp->m_name); 4220 } else if (op == GT || op == LE || (hflag && op == GE)) { 4221 /* comparison of %s with %s, op %s */ 4222 warning(162, "0", type_name(rn->tn_type), mp->m_name); 4223 } 4224 return; 4225 } 4226 } 4227 4228 /* 4229 * Return whether the expression can be used for static initialization. 4230 * 4231 * Constant initialization expressions must be constant or an address 4232 * of a static object with an optional offset. In the first case, 4233 * the result is returned in *offsp. In the second case, the static 4234 * object is returned in *symp and the offset in *offsp. 4235 * 4236 * The expression can consist of PLUS, MINUS, ADDR, NAME, STRING and 4237 * CON. Type conversions are allowed if they do not change binary 4238 * representation (including width). 4239 */ 4240 bool 4241 constant_addr(const tnode_t *tn, sym_t **symp, ptrdiff_t *offsp) 4242 { 4243 sym_t *sym; 4244 ptrdiff_t offs1, offs2; 4245 tspec_t t, ot; 4246 4247 switch (tn->tn_op) { 4248 case MINUS: 4249 if (tn->tn_right->tn_op == CVT) 4250 return constant_addr(tn->tn_right, symp, offsp); 4251 else if (tn->tn_right->tn_op != CON) 4252 return false; 4253 /* FALLTHROUGH */ 4254 case PLUS: 4255 offs1 = offs2 = 0; 4256 if (tn->tn_left->tn_op == CON) { 4257 offs1 = (ptrdiff_t)tn->tn_left->tn_val->v_quad; 4258 if (!constant_addr(tn->tn_right, &sym, &offs2)) 4259 return false; 4260 } else if (tn->tn_right->tn_op == CON) { 4261 offs2 = (ptrdiff_t)tn->tn_right->tn_val->v_quad; 4262 if (tn->tn_op == MINUS) 4263 offs2 = -offs2; 4264 if (!constant_addr(tn->tn_left, &sym, &offs1)) 4265 return false; 4266 } else { 4267 return false; 4268 } 4269 *symp = sym; 4270 *offsp = offs1 + offs2; 4271 return true; 4272 case ADDR: 4273 if (tn->tn_left->tn_op == NAME) { 4274 *symp = tn->tn_left->tn_sym; 4275 *offsp = 0; 4276 return true; 4277 } else { 4278 /* 4279 * If this would be the front end of a compiler we 4280 * would return a label instead of 0, at least if 4281 * 'tn->tn_left->tn_op == STRING'. 4282 */ 4283 *symp = NULL; 4284 *offsp = 0; 4285 return true; 4286 } 4287 case CVT: 4288 t = tn->tn_type->t_tspec; 4289 ot = tn->tn_left->tn_type->t_tspec; 4290 if ((!is_integer(t) && t != PTR) || 4291 (!is_integer(ot) && ot != PTR)) { 4292 return false; 4293 } 4294 #ifdef notdef 4295 /* 4296 * consider: 4297 * struct foo { 4298 * unsigned char a; 4299 * } f = { 4300 * (u_char)(u_long)(&(((struct foo *)0)->a)) 4301 * }; 4302 * since psize(u_long) != psize(u_char) this fails. 4303 */ 4304 else if (psize(t) != psize(ot)) 4305 return -1; 4306 #endif 4307 return constant_addr(tn->tn_left, symp, offsp); 4308 default: 4309 return false; 4310 } 4311 } 4312 4313 /* 4314 * Concatenate two string constants. 4315 */ 4316 strg_t * 4317 cat_strings(strg_t *strg1, strg_t *strg2) 4318 { 4319 size_t len1, len2, len; 4320 4321 if (strg1->st_tspec != strg2->st_tspec) { 4322 /* cannot concatenate wide and regular string literals */ 4323 error(292); 4324 return strg1; 4325 } 4326 4327 len1 = strg1->st_len; 4328 len2 = strg2->st_len + 1; /* + NUL */ 4329 len = len1 + len2; 4330 4331 #define COPY(F) \ 4332 do { \ 4333 strg1->F = xrealloc(strg1->F, len * sizeof(*strg1->F)); \ 4334 (void)memcpy(strg1->F + len1, strg2->F, len2 * sizeof(*strg1->F)); \ 4335 free(strg2->F); \ 4336 } while (/*CONSTCOND*/false) 4337 4338 if (strg1->st_tspec == CHAR) 4339 COPY(st_cp); 4340 else 4341 COPY(st_wcp); 4342 4343 strg1->st_len = len - 1; /* - NUL */ 4344 free(strg2); 4345 4346 return strg1; 4347 } 4348 4349 static bool 4350 is_confusing_precedence(op_t op, op_t lop, bool lparen, op_t rop, bool rparen) 4351 { 4352 4353 if (op == SHL || op == SHR) { 4354 if (!lparen && (lop == PLUS || lop == MINUS)) 4355 return true; 4356 if (!rparen && (rop == PLUS || rop == MINUS)) 4357 return true; 4358 return false; 4359 } 4360 4361 if (op == LOGOR) { 4362 if (!lparen && lop == LOGAND) 4363 return true; 4364 if (!rparen && rop == LOGAND) 4365 return true; 4366 return false; 4367 } 4368 4369 lint_assert(op == BITAND || op == BITXOR || op == BITOR); 4370 if (!lparen && lop != op) { 4371 if (lop == PLUS || lop == MINUS) 4372 return true; 4373 if (lop == BITAND || lop == BITXOR) 4374 return true; 4375 } 4376 if (!rparen && rop != op) { 4377 if (rop == PLUS || rop == MINUS) 4378 return true; 4379 if (rop == BITAND || rop == BITXOR) 4380 return true; 4381 } 4382 return false; 4383 } 4384 4385 /* 4386 * Print a warning if the given node has operands which should be 4387 * parenthesized. 4388 * 4389 * XXX Does not work if an operand is a constant expression. Constant 4390 * expressions are already folded. 4391 */ 4392 static void 4393 check_precedence_confusion(tnode_t *tn) 4394 { 4395 tnode_t *ln, *rn; 4396 4397 if (!hflag) 4398 return; 4399 4400 debug_node(tn, 0); 4401 4402 lint_assert(modtab[tn->tn_op].m_binary); 4403 for (ln = tn->tn_left; ln->tn_op == CVT; ln = ln->tn_left) 4404 continue; 4405 for (rn = tn->tn_right; rn->tn_op == CVT; rn = rn->tn_left) 4406 continue; 4407 4408 if (is_confusing_precedence(tn->tn_op, 4409 ln->tn_op, ln->tn_parenthesized, 4410 rn->tn_op, rn->tn_parenthesized)) { 4411 /* precedence confusion possible: parenthesize! */ 4412 warning(169); 4413 } 4414 } 4415
Indexes created Wed Sep 24 05:09:52 GMT 2025