1 /* 2 * sparse/evaluate.c 3 * 4 * Copyright (C) 2003 Transmeta Corp. 5 * 2003-2004 Linus Torvalds 6 * 7 * Permission is hereby granted, free of charge, to any person obtaining a copy 8 * of this software and associated documentation files (the "Software"), to deal 9 * in the Software without restriction, including without limitation the rights 10 * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell 11 * copies of the Software, and to permit persons to whom the Software is 12 * furnished to do so, subject to the following conditions: 13 * 14 * The above copyright notice and this permission notice shall be included in 15 * all copies or substantial portions of the Software. 16 * 17 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR 18 * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, 19 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE 20 * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER 21 * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, 22 * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN 23 * THE SOFTWARE. 24 * 25 * Evaluate constant expressions. 26 */ 27 #include <stdlib.h> 28 #include <stdarg.h> 29 #include <stddef.h> 30 #include <stdio.h> 31 #include <string.h> 32 #include <ctype.h> 33 #include <unistd.h> 34 #include <fcntl.h> 35 #include <limits.h> 36 37 #include "evaluate.h" 38 #include "lib.h" 39 #include "allocate.h" 40 #include "parse.h" 41 #include "token.h" 42 #include "symbol.h" 43 #include "target.h" 44 #include "expression.h" 45 46 struct symbol *current_fn; 47 48 struct ident bad_address_space = { .len = 6, .name = "bad AS", }; 49 50 static struct symbol *degenerate(struct expression *expr); 51 static struct symbol *evaluate_symbol(struct symbol *sym); 52 53 static inline int valid_expr_type(struct expression *expr) 54 { 55 return expr && valid_type(expr->ctype); 56 } 57 58 static inline int valid_subexpr_type(struct expression *expr) 59 { 60 return valid_expr_type(expr->left) 61 && valid_expr_type(expr->right); 62 } 63 64 static struct symbol *evaluate_symbol_expression(struct expression *expr) 65 { 66 struct expression *addr; 67 struct symbol *sym = expr->symbol; 68 struct symbol *base_type; 69 70 if (!sym) { 71 expression_error(expr, "undefined identifier '%s'", show_ident(expr->symbol_name)); 72 return NULL; 73 } 74 75 examine_symbol_type(sym); 76 77 base_type = get_base_type(sym); 78 if (!base_type) { 79 expression_error(expr, "identifier '%s' has no type", show_ident(expr->symbol_name)); 80 return NULL; 81 } 82 83 addr = alloc_expression(expr->pos, EXPR_SYMBOL); 84 addr->symbol = sym; 85 addr->symbol_name = expr->symbol_name; 86 addr->ctype = &lazy_ptr_ctype; /* Lazy evaluation: we need to do a proper job if somebody does &sym */ 87 addr->flags = expr->flags; 88 expr->type = EXPR_PREOP; 89 expr->op = '*'; 90 expr->unop = addr; 91 expr->flags = CEF_NONE; 92 93 /* The type of a symbol is the symbol itself! */ 94 expr->ctype = sym; 95 return sym; 96 } 97 98 static struct symbol *evaluate_string(struct expression *expr) 99 { 100 struct symbol *sym = alloc_symbol(expr->pos, SYM_NODE); 101 struct symbol *array = alloc_symbol(expr->pos, SYM_ARRAY); 102 struct expression *addr = alloc_expression(expr->pos, EXPR_SYMBOL); 103 struct expression *initstr = alloc_expression(expr->pos, EXPR_STRING); 104 unsigned int length = expr->string->length; 105 106 sym->array_size = alloc_const_expression(expr->pos, length); 107 sym->bit_size = bytes_to_bits(length); 108 sym->ctype.alignment = 1; 109 sym->string = 1; 110 sym->ctype.modifiers = MOD_STATIC; 111 sym->ctype.base_type = array; 112 sym->initializer = initstr; 113 114 initstr->ctype = sym; 115 initstr->string = expr->string; 116 117 array->array_size = sym->array_size; 118 array->bit_size = bytes_to_bits(length); 119 array->ctype.alignment = 1; 120 array->ctype.modifiers = MOD_STATIC; 121 array->ctype.base_type = &char_ctype; 122 123 addr->symbol = sym; 124 addr->ctype = &lazy_ptr_ctype; 125 addr->flags = CEF_ADDR; 126 127 expr->type = EXPR_PREOP; 128 expr->op = '*'; 129 expr->unop = addr; 130 expr->ctype = sym; 131 return sym; 132 } 133 134 /* type has come from classify_type and is an integer type */ 135 static inline struct symbol *integer_promotion(struct symbol *type) 136 { 137 unsigned long mod = type->ctype.modifiers; 138 int width = type->bit_size; 139 140 /* 141 * Bitfields always promote to the base type, 142 * even if the bitfield might be bigger than 143 * an "int". 144 */ 145 if (type->type == SYM_BITFIELD) { 146 type = type->ctype.base_type; 147 } 148 mod = type->ctype.modifiers; 149 if (width < bits_in_int) 150 return &int_ctype; 151 152 /* If char/short has as many bits as int, it still gets "promoted" */ 153 if (mod & (MOD_CHAR | MOD_SHORT)) { 154 if (mod & MOD_UNSIGNED) 155 return &uint_ctype; 156 return &int_ctype; 157 } 158 return type; 159 } 160 161 /* 162 * integer part of usual arithmetic conversions: 163 * integer promotions are applied 164 * if left and right are identical, we are done 165 * if signedness is the same, convert one with lower rank 166 * unless unsigned argument has rank lower than signed one, convert the 167 * signed one. 168 * if signed argument is bigger than unsigned one, convert the unsigned. 169 * otherwise, convert signed. 170 * 171 * Leaving aside the integer promotions, that is equivalent to 172 * if identical, don't convert 173 * if left is bigger than right, convert right 174 * if right is bigger than left, convert right 175 * otherwise, if signedness is the same, convert one with lower rank 176 * otherwise convert the signed one. 177 */ 178 static struct symbol *bigger_int_type(struct symbol *left, struct symbol *right) 179 { 180 unsigned long lmod, rmod; 181 182 left = integer_promotion(left); 183 right = integer_promotion(right); 184 185 if (left == right) 186 goto left; 187 188 if (left->bit_size > right->bit_size) 189 goto left; 190 191 if (right->bit_size > left->bit_size) 192 goto right; 193 194 lmod = left->ctype.modifiers; 195 rmod = right->ctype.modifiers; 196 if ((lmod ^ rmod) & MOD_UNSIGNED) { 197 if (lmod & MOD_UNSIGNED) 198 goto left; 199 } else if ((lmod & ~rmod) & (MOD_LONG_ALL)) 200 goto left; 201 right: 202 left = right; 203 left: 204 return left; 205 } 206 207 static int same_cast_type(struct symbol *orig, struct symbol *new) 208 { 209 return orig->bit_size == new->bit_size && 210 orig->bit_offset == new->bit_offset; 211 } 212 213 static struct symbol *base_type(struct symbol *node, unsigned long *modp, struct ident **asp) 214 { 215 unsigned long mod = 0; 216 struct ident *as = NULL; 217 218 while (node) { 219 mod |= node->ctype.modifiers; 220 combine_address_space(node->pos, &as, node->ctype.as); 221 if (node->type == SYM_NODE) { 222 node = node->ctype.base_type; 223 continue; 224 } 225 break; 226 } 227 *modp = mod & ~MOD_IGNORE; 228 *asp = as; 229 return node; 230 } 231 232 static int is_same_type(struct expression *expr, struct symbol *new) 233 { 234 struct symbol *old = expr->ctype; 235 unsigned long oldmod, newmod; 236 struct ident *oldas, *newas; 237 238 old = base_type(old, &oldmod, &oldas); 239 new = base_type(new, &newmod, &newas); 240 241 /* Same base type, same address space? */ 242 if (old == new && oldas == newas) { 243 unsigned long difmod; 244 245 /* Check the modifier bits. */ 246 difmod = (oldmod ^ newmod) & ~MOD_NOCAST; 247 248 /* Exact same type? */ 249 if (!difmod) 250 return 1; 251 252 /* 253 * Not the same type, but differs only in "const". 254 * Don't warn about MOD_NOCAST. 255 */ 256 if (difmod == MOD_CONST) 257 return 0; 258 } 259 if ((oldmod | newmod) & MOD_NOCAST) { 260 const char *tofrom = "to/from"; 261 if (!(newmod & MOD_NOCAST)) 262 tofrom = "from"; 263 if (!(oldmod & MOD_NOCAST)) 264 tofrom = "to"; 265 warning(expr->pos, "implicit cast %s nocast type", tofrom); 266 } 267 return 0; 268 } 269 270 static void 271 warn_for_different_enum_types (struct position pos, 272 struct symbol *typea, 273 struct symbol *typeb) 274 { 275 if (!Wenum_mismatch) 276 return; 277 if (typea->type == SYM_NODE) 278 typea = typea->ctype.base_type; 279 if (typeb->type == SYM_NODE) 280 typeb = typeb->ctype.base_type; 281 282 if (typea == typeb) 283 return; 284 285 if (typea->type == SYM_ENUM && typeb->type == SYM_ENUM) { 286 warning(pos, "mixing different enum types"); 287 info(pos, " %s versus", show_typename(typea)); 288 info(pos, " %s", show_typename(typeb)); 289 } 290 } 291 292 static int cast_flags(struct expression *expr, struct expression *target); 293 static struct symbol *cast_to_bool(struct expression *expr); 294 295 /* 296 * This gets called for implicit casts in assignments and 297 * integer promotion. We often want to try to move the 298 * cast down, because the ops involved may have been 299 * implicitly cast up, and we can get rid of the casts 300 * early. 301 */ 302 static struct expression * cast_to(struct expression *old, struct symbol *type) 303 { 304 struct expression *expr; 305 306 warn_for_different_enum_types (old->pos, old->ctype, type); 307 308 if (old->ctype != &null_ctype && is_same_type(old, type)) 309 return old; 310 311 /* 312 * See if we can simplify the op. Move the cast down. 313 */ 314 switch (old->type) { 315 case EXPR_PREOP: 316 if (old->ctype->bit_size < type->bit_size) 317 break; 318 if (old->op == '~') { 319 old->ctype = type; 320 old->unop = cast_to(old->unop, type); 321 return old; 322 } 323 break; 324 325 case EXPR_IMPLIED_CAST: 326 warn_for_different_enum_types(old->pos, old->ctype, type); 327 328 if (old->ctype->bit_size >= type->bit_size) { 329 struct expression *orig = old->cast_expression; 330 if (same_cast_type(orig->ctype, type)) 331 return orig; 332 if (old->ctype->bit_offset == type->bit_offset) { 333 old->ctype = type; 334 old->cast_type = type; 335 return old; 336 } 337 } 338 break; 339 340 default: 341 /* nothing */; 342 } 343 344 expr = alloc_expression(old->pos, EXPR_IMPLIED_CAST); 345 expr->ctype = type; 346 expr->cast_type = type; 347 expr->cast_expression = old; 348 expr->flags = cast_flags(expr, old); 349 350 if (is_bool_type(type)) 351 cast_to_bool(expr); 352 353 return expr; 354 } 355 356 enum { 357 TYPE_NUM = 1, 358 TYPE_BITFIELD = 2, 359 TYPE_RESTRICT = 4, 360 TYPE_FLOAT = 8, 361 TYPE_PTR = 16, 362 TYPE_COMPOUND = 32, 363 TYPE_FOULED = 64, 364 TYPE_FN = 128, 365 }; 366 367 static inline int classify_type(struct symbol *type, struct symbol **base) 368 { 369 static int type_class[SYM_BAD + 1] = { 370 [SYM_PTR] = TYPE_PTR, 371 [SYM_FN] = TYPE_PTR | TYPE_FN, 372 [SYM_ARRAY] = TYPE_PTR | TYPE_COMPOUND, 373 [SYM_STRUCT] = TYPE_COMPOUND, 374 [SYM_UNION] = TYPE_COMPOUND, 375 [SYM_BITFIELD] = TYPE_NUM | TYPE_BITFIELD, 376 [SYM_RESTRICT] = TYPE_NUM | TYPE_RESTRICT, 377 [SYM_FOULED] = TYPE_NUM | TYPE_RESTRICT | TYPE_FOULED, 378 }; 379 if (type->type == SYM_NODE) 380 type = type->ctype.base_type; 381 if (type->type == SYM_TYPEOF) { 382 type = evaluate_expression(type->initializer); 383 if (!type) 384 type = &bad_ctype; 385 else if (type->type == SYM_NODE) 386 type = type->ctype.base_type; 387 } 388 if (type->type == SYM_ENUM) 389 type = type->ctype.base_type; 390 *base = type; 391 if (type->type == SYM_BASETYPE) { 392 if (type->ctype.base_type == &int_type) 393 return TYPE_NUM; 394 if (type->ctype.base_type == &fp_type) 395 return TYPE_NUM | TYPE_FLOAT; 396 } 397 return type_class[type->type]; 398 } 399 400 #define is_int(class) ((class & (TYPE_NUM | TYPE_FLOAT)) == TYPE_NUM) 401 402 static inline int is_string_type(struct symbol *type) 403 { 404 if (type->type == SYM_NODE) 405 type = type->ctype.base_type; 406 return type->type == SYM_ARRAY && is_byte_type(type->ctype.base_type); 407 } 408 409 static struct symbol *bad_expr_type(struct expression *expr) 410 { 411 switch (expr->type) { 412 case EXPR_BINOP: 413 case EXPR_COMPARE: 414 if (!valid_subexpr_type(expr)) 415 break; 416 sparse_error(expr->pos, "incompatible types for operation (%s)", show_special(expr->op)); 417 info(expr->pos, " left side has type %s", show_typename(expr->left->ctype)); 418 info(expr->pos, " right side has type %s", show_typename(expr->right->ctype)); 419 break; 420 case EXPR_PREOP: 421 case EXPR_POSTOP: 422 if (!valid_expr_type(expr->unop)) 423 break; 424 sparse_error(expr->pos, "incompatible types for operation (%s)", show_special(expr->op)); 425 info(expr->pos, " argument has type %s", show_typename(expr->unop->ctype)); 426 break; 427 default: 428 break; 429 } 430 431 expr->flags = CEF_NONE; 432 return expr->ctype = &bad_ctype; 433 } 434 435 static int restricted_value(struct expression *v, struct symbol *type) 436 { 437 if (v->type != EXPR_VALUE) 438 return 1; 439 if (v->value != 0) 440 return 1; 441 return 0; 442 } 443 444 static int restricted_binop(int op, struct symbol *type) 445 { 446 switch (op) { 447 case '&': 448 case '=': 449 case SPECIAL_AND_ASSIGN: 450 case SPECIAL_OR_ASSIGN: 451 case SPECIAL_XOR_ASSIGN: 452 return 1; /* unfoul */ 453 case '|': 454 case '^': 455 case '?': 456 return 2; /* keep fouled */ 457 case SPECIAL_EQUAL: 458 case SPECIAL_NOTEQUAL: 459 return 3; /* warn if fouled */ 460 default: 461 return 0; /* warn */ 462 } 463 } 464 465 static int restricted_unop(int op, struct symbol **type) 466 { 467 if (op == '~') { 468 if ((*type)->bit_size < bits_in_int) 469 *type = befoul(*type); 470 return 0; 471 } if (op == '+') 472 return 0; 473 return 1; 474 } 475 476 /* type should be SYM_FOULED */ 477 static inline struct symbol *unfoul(struct symbol *type) 478 { 479 return type->ctype.base_type; 480 } 481 482 static struct symbol *restricted_binop_type(int op, 483 struct expression *left, 484 struct expression *right, 485 int lclass, int rclass, 486 struct symbol *ltype, 487 struct symbol *rtype) 488 { 489 struct symbol *ctype = NULL; 490 if (lclass & TYPE_RESTRICT) { 491 if (rclass & TYPE_RESTRICT) { 492 if (ltype == rtype) { 493 ctype = ltype; 494 } else if (lclass & TYPE_FOULED) { 495 if (unfoul(ltype) == rtype) 496 ctype = ltype; 497 } else if (rclass & TYPE_FOULED) { 498 if (unfoul(rtype) == ltype) 499 ctype = rtype; 500 } 501 } else { 502 if (!restricted_value(right, ltype)) 503 ctype = ltype; 504 } 505 } else if (!restricted_value(left, rtype)) 506 ctype = rtype; 507 508 if (ctype) { 509 switch (restricted_binop(op, ctype)) { 510 case 1: 511 if ((lclass ^ rclass) & TYPE_FOULED) 512 ctype = unfoul(ctype); 513 break; 514 case 3: 515 if (!(lclass & rclass & TYPE_FOULED)) 516 break; 517 case 0: 518 ctype = NULL; 519 default: 520 break; 521 } 522 } 523 524 return ctype; 525 } 526 527 static inline void unrestrict(struct expression *expr, 528 int class, struct symbol **ctype) 529 { 530 if (class & TYPE_RESTRICT) { 531 if (class & TYPE_FOULED) 532 *ctype = unfoul(*ctype); 533 warning(expr->pos, "%s degrades to integer", 534 show_typename(*ctype)); 535 *ctype = (*ctype)->ctype.base_type; /* get to arithmetic type */ 536 } 537 } 538 539 static struct symbol *usual_conversions(int op, 540 struct expression *left, 541 struct expression *right, 542 int lclass, int rclass, 543 struct symbol *ltype, 544 struct symbol *rtype) 545 { 546 struct symbol *ctype; 547 548 warn_for_different_enum_types(right->pos, left->ctype, right->ctype); 549 550 if ((lclass | rclass) & TYPE_RESTRICT) 551 goto Restr; 552 553 Normal: 554 if (!(lclass & TYPE_FLOAT)) { 555 if (!(rclass & TYPE_FLOAT)) 556 return bigger_int_type(ltype, rtype); 557 else 558 return rtype; 559 } else if (rclass & TYPE_FLOAT) { 560 unsigned long lmod = ltype->ctype.modifiers; 561 unsigned long rmod = rtype->ctype.modifiers; 562 if (rmod & ~lmod & (MOD_LONG_ALL)) 563 return rtype; 564 else 565 return ltype; 566 } else 567 return ltype; 568 569 Restr: 570 ctype = restricted_binop_type(op, left, right, 571 lclass, rclass, ltype, rtype); 572 if (ctype) 573 return ctype; 574 575 unrestrict(left, lclass, <ype); 576 unrestrict(right, rclass, &rtype); 577 578 goto Normal; 579 } 580 581 static inline int lvalue_expression(struct expression *expr) 582 { 583 return expr->type == EXPR_PREOP && expr->op == '*'; 584 } 585 586 static struct symbol *evaluate_ptr_add(struct expression *expr, struct symbol *itype) 587 { 588 struct expression *index = expr->right; 589 struct symbol *ctype, *base; 590 int multiply; 591 592 classify_type(degenerate(expr->left), &ctype); 593 base = examine_pointer_target(ctype); 594 595 /* 596 * An address constant +/- an integer constant expression 597 * yields an address constant again [6.6(7)]. 598 */ 599 if ((expr->left->flags & CEF_ADDR) && (expr->right->flags & CEF_ICE)) 600 expr->flags = CEF_ADDR; 601 602 if (!base) { 603 expression_error(expr, "missing type information"); 604 return NULL; 605 } 606 if (is_function(base)) { 607 expression_error(expr, "arithmetics on pointers to functions"); 608 return NULL; 609 } 610 611 /* Get the size of whatever the pointer points to */ 612 multiply = is_void_type(base) ? 1 : bits_to_bytes(base->bit_size); 613 614 if (ctype == &null_ctype) 615 ctype = &ptr_ctype; 616 expr->ctype = ctype; 617 618 if (multiply == 1 && itype->bit_size >= bits_in_pointer) 619 return ctype; 620 621 if (index->type == EXPR_VALUE) { 622 struct expression *val = alloc_expression(expr->pos, EXPR_VALUE); 623 unsigned long long v = index->value, mask; 624 mask = 1ULL << (itype->bit_size - 1); 625 if (v & mask) 626 v |= -mask; 627 else 628 v &= mask - 1; 629 v *= multiply; 630 mask = 1ULL << (bits_in_pointer - 1); 631 v &= mask | (mask - 1); 632 val->value = v; 633 val->ctype = ssize_t_ctype; 634 expr->right = val; 635 return ctype; 636 } 637 638 if (itype->bit_size < bits_in_pointer) 639 index = cast_to(index, ssize_t_ctype); 640 641 if (multiply > 1) { 642 struct expression *val = alloc_expression(expr->pos, EXPR_VALUE); 643 struct expression *mul = alloc_expression(expr->pos, EXPR_BINOP); 644 645 val->ctype = ssize_t_ctype; 646 val->value = multiply; 647 648 mul->op = '*'; 649 mul->ctype = ssize_t_ctype; 650 mul->left = index; 651 mul->right = val; 652 index = mul; 653 } 654 655 expr->right = index; 656 return ctype; 657 } 658 659 static void examine_fn_arguments(struct symbol *fn); 660 661 #define MOD_IGN (MOD_QUALIFIER | MOD_PURE) 662 663 const char *type_difference(struct ctype *c1, struct ctype *c2, 664 unsigned long mod1, unsigned long mod2) 665 { 666 struct ident *as1 = c1->as, *as2 = c2->as; 667 struct symbol *t1 = c1->base_type; 668 struct symbol *t2 = c2->base_type; 669 int move1 = 1, move2 = 1; 670 mod1 |= c1->modifiers; 671 mod2 |= c2->modifiers; 672 for (;;) { 673 unsigned long diff; 674 int type; 675 struct symbol *base1 = t1->ctype.base_type; 676 struct symbol *base2 = t2->ctype.base_type; 677 678 /* 679 * FIXME! Collect alignment and context too here! 680 */ 681 if (move1) { 682 if (t1 && t1->type != SYM_PTR) { 683 mod1 |= t1->ctype.modifiers; 684 combine_address_space(t1->pos, &as1, t1->ctype.as); 685 } 686 move1 = 0; 687 } 688 689 if (move2) { 690 if (t2 && t2->type != SYM_PTR) { 691 mod2 |= t2->ctype.modifiers; 692 combine_address_space(t2->pos, &as2, t2->ctype.as); 693 } 694 move2 = 0; 695 } 696 697 if (t1 == t2) 698 break; 699 if (!t1 || !t2) 700 return "different types"; 701 702 if (t1->type == SYM_NODE || t1->type == SYM_ENUM) { 703 t1 = base1; 704 move1 = 1; 705 if (!t1) 706 return "bad types"; 707 continue; 708 } 709 710 if (t2->type == SYM_NODE || t2->type == SYM_ENUM) { 711 t2 = base2; 712 move2 = 1; 713 if (!t2) 714 return "bad types"; 715 continue; 716 } 717 718 move1 = move2 = 1; 719 type = t1->type; 720 if (type != t2->type) 721 return "different base types"; 722 723 switch (type) { 724 default: 725 sparse_error(t1->pos, 726 "internal error: bad type in derived(%d)", 727 type); 728 return "bad types"; 729 case SYM_RESTRICT: 730 return "different base types"; 731 case SYM_UNION: 732 case SYM_STRUCT: 733 /* allow definition of incomplete structs and unions */ 734 if (t1->ident == t2->ident) 735 return NULL; 736 return "different base types"; 737 case SYM_ARRAY: 738 /* XXX: we ought to compare sizes */ 739 break; 740 case SYM_PTR: 741 if (as1 != as2) 742 return "different address spaces"; 743 /* MOD_SPECIFIER is due to idiocy in parse.c */ 744 if ((mod1 ^ mod2) & ~MOD_IGNORE & ~MOD_SPECIFIER) 745 return "different modifiers"; 746 /* we could be lazier here */ 747 base1 = examine_pointer_target(t1); 748 base2 = examine_pointer_target(t2); 749 mod1 = t1->ctype.modifiers; 750 as1 = t1->ctype.as; 751 mod2 = t2->ctype.modifiers; 752 as2 = t2->ctype.as; 753 break; 754 case SYM_FN: { 755 struct symbol *arg1, *arg2; 756 int i; 757 758 if (as1 != as2) 759 return "different address spaces"; 760 if ((mod1 ^ mod2) & ~MOD_IGNORE & ~MOD_SIGNEDNESS) 761 return "different modifiers"; 762 mod1 = t1->ctype.modifiers; 763 as1 = t1->ctype.as; 764 mod2 = t2->ctype.modifiers; 765 as2 = t2->ctype.as; 766 767 if (t1->variadic != t2->variadic) 768 return "incompatible variadic arguments"; 769 examine_fn_arguments(t1); 770 examine_fn_arguments(t2); 771 PREPARE_PTR_LIST(t1->arguments, arg1); 772 PREPARE_PTR_LIST(t2->arguments, arg2); 773 i = 1; 774 for (;;) { 775 const char *diffstr; 776 if (!arg1 && !arg2) 777 break; 778 if (!arg1 || !arg2) 779 return "different argument counts"; 780 diffstr = type_difference(&arg1->ctype, 781 &arg2->ctype, 782 MOD_IGN, MOD_IGN); 783 if (diffstr) { 784 static char argdiff[80]; 785 sprintf(argdiff, "incompatible argument %d (%s)", i, diffstr); 786 return argdiff; 787 } 788 NEXT_PTR_LIST(arg1); 789 NEXT_PTR_LIST(arg2); 790 i++; 791 } 792 FINISH_PTR_LIST(arg2); 793 FINISH_PTR_LIST(arg1); 794 break; 795 } 796 case SYM_BASETYPE: 797 if (as1 != as2) 798 return "different address spaces"; 799 if (base1 != base2) 800 return "different base types"; 801 diff = (mod1 ^ mod2) & ~MOD_IGNORE; 802 if (!diff) 803 return NULL; 804 if (diff & MOD_SIZE) 805 return "different type sizes"; 806 else if (diff & ~MOD_SIGNEDNESS) 807 return "different modifiers"; 808 else 809 return "different signedness"; 810 } 811 t1 = base1; 812 t2 = base2; 813 } 814 if (as1 != as2) 815 return "different address spaces"; 816 if ((mod1 ^ mod2) & ~MOD_IGNORE & ~MOD_SIGNEDNESS) 817 return "different modifiers"; 818 return NULL; 819 } 820 821 static void bad_null(struct expression *expr) 822 { 823 if (Wnon_pointer_null) 824 warning(expr->pos, "Using plain integer as NULL pointer"); 825 } 826 827 static unsigned long target_qualifiers(struct symbol *type) 828 { 829 unsigned long mod = type->ctype.modifiers & MOD_IGN; 830 if (type->ctype.base_type && type->ctype.base_type->type == SYM_ARRAY) 831 mod = 0; 832 return mod; 833 } 834 835 static struct symbol *evaluate_ptr_sub(struct expression *expr) 836 { 837 const char *typediff; 838 struct symbol *ltype, *rtype; 839 struct expression *l = expr->left; 840 struct expression *r = expr->right; 841 struct symbol *lbase; 842 843 classify_type(degenerate(l), <ype); 844 classify_type(degenerate(r), &rtype); 845 846 lbase = examine_pointer_target(ltype); 847 examine_pointer_target(rtype); 848 typediff = type_difference(<ype->ctype, &rtype->ctype, 849 target_qualifiers(rtype), 850 target_qualifiers(ltype)); 851 if (typediff) 852 expression_error(expr, "subtraction of different types can't work (%s)", typediff); 853 854 if (is_function(lbase)) { 855 expression_error(expr, "subtraction of functions? Share your drugs"); 856 return NULL; 857 } 858 859 expr->ctype = ssize_t_ctype; 860 if (lbase->bit_size > bits_in_char) { 861 struct expression *sub = alloc_expression(expr->pos, EXPR_BINOP); 862 struct expression *div = expr; 863 struct expression *val = alloc_expression(expr->pos, EXPR_VALUE); 864 unsigned long value = bits_to_bytes(lbase->bit_size); 865 866 val->ctype = size_t_ctype; 867 val->value = value; 868 869 if (value & (value-1)) { 870 if (Wptr_subtraction_blows) { 871 warning(expr->pos, "potentially expensive pointer subtraction"); 872 info(expr->pos, " '%s' has a non-power-of-2 size: %lu", show_typename(lbase), value); 873 } 874 } 875 876 sub->op = '-'; 877 sub->ctype = ssize_t_ctype; 878 sub->left = l; 879 sub->right = r; 880 881 div->op = '/'; 882 div->left = sub; 883 div->right = val; 884 } 885 886 return ssize_t_ctype; 887 } 888 889 #define is_safe_type(type) ((type)->ctype.modifiers & MOD_SAFE) 890 891 static struct symbol *evaluate_conditional(struct expression *expr, int iterator) 892 { 893 struct symbol *ctype; 894 895 if (!expr) 896 return NULL; 897 898 if (!iterator && expr->type == EXPR_ASSIGNMENT && expr->op == '=') 899 warning(expr->pos, "assignment expression in conditional"); 900 901 ctype = evaluate_expression(expr); 902 if (!valid_type(ctype)) 903 return NULL; 904 if (is_safe_type(ctype)) 905 warning(expr->pos, "testing a 'safe expression'"); 906 if (is_func_type(ctype)) { 907 if (Waddress) 908 warning(expr->pos, "the address of %s will always evaluate as true", "a function"); 909 } else if (is_array_type(ctype)) { 910 if (Waddress) 911 warning(expr->pos, "the address of %s will always evaluate as true", "an array"); 912 } else if (!is_scalar_type(ctype)) { 913 sparse_error(expr->pos, "incorrect type in conditional (non-scalar type)"); 914 info(expr->pos, " got %s", show_typename(ctype)); 915 return NULL; 916 } 917 918 ctype = degenerate(expr); 919 return ctype; 920 } 921 922 static struct symbol *evaluate_logical(struct expression *expr) 923 { 924 if (!evaluate_conditional(expr->left, 0)) 925 return NULL; 926 if (!evaluate_conditional(expr->right, 0)) 927 return NULL; 928 929 /* the result is int [6.5.13(3), 6.5.14(3)] */ 930 expr->ctype = &int_ctype; 931 expr->flags = expr->left->flags & expr->right->flags; 932 expr->flags &= ~(CEF_CONST_MASK | CEF_ADDR); 933 return &int_ctype; 934 } 935 936 static struct symbol *evaluate_binop(struct expression *expr) 937 { 938 struct symbol *ltype, *rtype, *ctype; 939 int lclass = classify_type(expr->left->ctype, <ype); 940 int rclass = classify_type(expr->right->ctype, &rtype); 941 int op = expr->op; 942 943 /* number op number */ 944 if (lclass & rclass & TYPE_NUM) { 945 expr->flags = expr->left->flags & expr->right->flags; 946 expr->flags &= ~CEF_CONST_MASK; 947 948 if ((lclass | rclass) & TYPE_FLOAT) { 949 switch (op) { 950 case '+': case '-': case '*': case '/': 951 break; 952 default: 953 return bad_expr_type(expr); 954 } 955 } 956 957 if (op == SPECIAL_LEFTSHIFT || op == SPECIAL_RIGHTSHIFT) { 958 // shifts do integer promotions, but that's it. 959 unrestrict(expr->left, lclass, <ype); 960 unrestrict(expr->right, rclass, &rtype); 961 ctype = ltype = integer_promotion(ltype); 962 rtype = integer_promotion(rtype); 963 } else { 964 // The rest do usual conversions 965 const unsigned left_not = expr->left->type == EXPR_PREOP 966 && expr->left->op == '!'; 967 const unsigned right_not = expr->right->type == EXPR_PREOP 968 && expr->right->op == '!'; 969 if ((op == '&' || op == '|') && (left_not || right_not)) 970 warning(expr->pos, "dubious: %sx %c %sy", 971 left_not ? "!" : "", 972 op, 973 right_not ? "!" : ""); 974 975 ltype = usual_conversions(op, expr->left, expr->right, 976 lclass, rclass, ltype, rtype); 977 ctype = rtype = ltype; 978 } 979 980 expr->left = cast_to(expr->left, ltype); 981 expr->right = cast_to(expr->right, rtype); 982 expr->ctype = ctype; 983 return ctype; 984 } 985 986 /* pointer (+|-) integer */ 987 if (lclass & TYPE_PTR && is_int(rclass) && (op == '+' || op == '-')) { 988 unrestrict(expr->right, rclass, &rtype); 989 return evaluate_ptr_add(expr, rtype); 990 } 991 992 /* integer + pointer */ 993 if (rclass & TYPE_PTR && is_int(lclass) && op == '+') { 994 struct expression *index = expr->left; 995 unrestrict(index, lclass, <ype); 996 expr->left = expr->right; 997 expr->right = index; 998 return evaluate_ptr_add(expr, ltype); 999 } 1000 1001 /* pointer - pointer */ 1002 if (lclass & rclass & TYPE_PTR && expr->op == '-') 1003 return evaluate_ptr_sub(expr); 1004 1005 return bad_expr_type(expr); 1006 } 1007 1008 static struct symbol *evaluate_comma(struct expression *expr) 1009 { 1010 expr->ctype = degenerate(expr->right); 1011 if (expr->ctype == &null_ctype) 1012 expr->ctype = &ptr_ctype; 1013 expr->flags &= expr->left->flags & expr->right->flags; 1014 return expr->ctype; 1015 } 1016 1017 static int modify_for_unsigned(int op) 1018 { 1019 if (op == '<') 1020 op = SPECIAL_UNSIGNED_LT; 1021 else if (op == '>') 1022 op = SPECIAL_UNSIGNED_GT; 1023 else if (op == SPECIAL_LTE) 1024 op = SPECIAL_UNSIGNED_LTE; 1025 else if (op == SPECIAL_GTE) 1026 op = SPECIAL_UNSIGNED_GTE; 1027 return op; 1028 } 1029 1030 enum null_constant_type { 1031 NON_NULL, 1032 NULL_PTR, 1033 NULL_ZERO, 1034 }; 1035 1036 static inline int is_null_pointer_constant(struct expression *e) 1037 { 1038 if (e->ctype == &null_ctype) 1039 return NULL_PTR; 1040 if (!(e->flags & CEF_ICE)) 1041 return NON_NULL; 1042 return is_zero_constant(e) ? NULL_ZERO : NON_NULL; 1043 } 1044 1045 static struct symbol *evaluate_compare(struct expression *expr) 1046 { 1047 struct expression *left = expr->left, *right = expr->right; 1048 struct symbol *ltype, *rtype, *lbase, *rbase; 1049 int lclass = classify_type(degenerate(left), <ype); 1050 int rclass = classify_type(degenerate(right), &rtype); 1051 struct symbol *ctype; 1052 const char *typediff; 1053 1054 /* Type types? */ 1055 if (is_type_type(ltype) && is_type_type(rtype)) { 1056 /* 1057 * __builtin_types_compatible_p() yields an integer 1058 * constant expression 1059 */ 1060 expr->flags = CEF_SET_ICE; 1061 goto OK; 1062 } 1063 1064 if (is_safe_type(left->ctype) || is_safe_type(right->ctype)) 1065 warning(expr->pos, "testing a 'safe expression'"); 1066 1067 expr->flags = left->flags & right->flags & ~CEF_CONST_MASK & ~CEF_ADDR; 1068 1069 /* number on number */ 1070 if (lclass & rclass & TYPE_NUM) { 1071 ctype = usual_conversions(expr->op, expr->left, expr->right, 1072 lclass, rclass, ltype, rtype); 1073 expr->left = cast_to(expr->left, ctype); 1074 expr->right = cast_to(expr->right, ctype); 1075 if (ctype->ctype.modifiers & MOD_UNSIGNED) 1076 expr->op = modify_for_unsigned(expr->op); 1077 goto OK; 1078 } 1079 1080 /* at least one must be a pointer */ 1081 if (!((lclass | rclass) & TYPE_PTR)) 1082 return bad_expr_type(expr); 1083 1084 /* equality comparisons can be with null pointer constants */ 1085 if (expr->op == SPECIAL_EQUAL || expr->op == SPECIAL_NOTEQUAL) { 1086 int is_null1 = is_null_pointer_constant(left); 1087 int is_null2 = is_null_pointer_constant(right); 1088 if (is_null1 == NULL_ZERO) 1089 bad_null(left); 1090 if (is_null2 == NULL_ZERO) 1091 bad_null(right); 1092 if (is_null1 && is_null2) { 1093 int positive = expr->op == SPECIAL_EQUAL; 1094 expr->type = EXPR_VALUE; 1095 expr->value = positive; 1096 goto OK; 1097 } 1098 if (is_null1 && (rclass & TYPE_PTR)) { 1099 left = cast_to(left, rtype); 1100 goto OK; 1101 } 1102 if (is_null2 && (lclass & TYPE_PTR)) { 1103 right = cast_to(right, ltype); 1104 goto OK; 1105 } 1106 } 1107 /* both should be pointers */ 1108 if (!(lclass & rclass & TYPE_PTR)) 1109 return bad_expr_type(expr); 1110 expr->op = modify_for_unsigned(expr->op); 1111 1112 lbase = examine_pointer_target(ltype); 1113 rbase = examine_pointer_target(rtype); 1114 1115 /* they also have special treatment for pointers to void */ 1116 if (expr->op == SPECIAL_EQUAL || expr->op == SPECIAL_NOTEQUAL) { 1117 if (ltype->ctype.as == rtype->ctype.as) { 1118 if (lbase == &void_ctype) { 1119 right = cast_to(right, ltype); 1120 goto OK; 1121 } 1122 if (rbase == &void_ctype) { 1123 left = cast_to(left, rtype); 1124 goto OK; 1125 } 1126 } 1127 } 1128 1129 typediff = type_difference(<ype->ctype, &rtype->ctype, 1130 target_qualifiers(rtype), 1131 target_qualifiers(ltype)); 1132 if (!typediff) 1133 goto OK; 1134 1135 expression_error(expr, "incompatible types in comparison expression (%s):", typediff); 1136 info(expr->pos, " %s", show_typename(ltype)); 1137 info(expr->pos, " %s", show_typename(rtype)); 1138 return NULL; 1139 1140 OK: 1141 /* the result is int [6.5.8(6), 6.5.9(3)]*/ 1142 expr->ctype = &int_ctype; 1143 return &int_ctype; 1144 } 1145 1146 /* 1147 * NOTE! The degenerate case of "x ? : y", where we don't 1148 * have a true case, this will possibly promote "x" to the 1149 * same type as "y", and thus _change_ the conditional 1150 * test in the expression. But since promotion is "safe" 1151 * for testing, that's OK. 1152 */ 1153 static struct symbol *evaluate_conditional_expression(struct expression *expr) 1154 { 1155 struct expression **cond; 1156 struct symbol *ctype, *ltype, *rtype, *lbase, *rbase; 1157 int lclass, rclass; 1158 const char * typediff; 1159 int qual; 1160 1161 if (!evaluate_conditional(expr->conditional, 0)) 1162 return NULL; 1163 if (!evaluate_expression(expr->cond_false)) 1164 return NULL; 1165 1166 ctype = degenerate(expr->conditional); 1167 rtype = degenerate(expr->cond_false); 1168 1169 cond = &expr->conditional; 1170 ltype = ctype; 1171 if (expr->cond_true) { 1172 if (!evaluate_expression(expr->cond_true)) 1173 return NULL; 1174 ltype = degenerate(expr->cond_true); 1175 cond = &expr->cond_true; 1176 } 1177 1178 expr->flags = (expr->conditional->flags & (*cond)->flags & 1179 expr->cond_false->flags & ~CEF_CONST_MASK); 1180 /* 1181 * A conditional operator yields a particular constant 1182 * expression type only if all of its three subexpressions are 1183 * of that type [6.6(6), 6.6(8)]. 1184 * As an extension, relax this restriction by allowing any 1185 * constant expression type for the condition expression. 1186 * 1187 * A conditional operator never yields an address constant 1188 * [6.6(9)]. 1189 * However, as an extension, if the condition is any constant 1190 * expression, and the true and false expressions are both 1191 * address constants, mark the result as an address constant. 1192 */ 1193 if (expr->conditional->flags & (CEF_ACE | CEF_ADDR)) 1194 expr->flags = (*cond)->flags & expr->cond_false->flags & ~CEF_CONST_MASK; 1195 1196 lclass = classify_type(ltype, <ype); 1197 rclass = classify_type(rtype, &rtype); 1198 if (lclass & rclass & TYPE_NUM) { 1199 ctype = usual_conversions('?', *cond, expr->cond_false, 1200 lclass, rclass, ltype, rtype); 1201 *cond = cast_to(*cond, ctype); 1202 expr->cond_false = cast_to(expr->cond_false, ctype); 1203 goto out; 1204 } 1205 1206 if ((lclass | rclass) & TYPE_PTR) { 1207 int is_null1 = is_null_pointer_constant(*cond); 1208 int is_null2 = is_null_pointer_constant(expr->cond_false); 1209 1210 if (is_null1 && is_null2) { 1211 *cond = cast_to(*cond, &ptr_ctype); 1212 expr->cond_false = cast_to(expr->cond_false, &ptr_ctype); 1213 ctype = &ptr_ctype; 1214 goto out; 1215 } 1216 if (is_null1 && (rclass & TYPE_PTR)) { 1217 if (is_null1 == NULL_ZERO) 1218 bad_null(*cond); 1219 *cond = cast_to(*cond, rtype); 1220 ctype = rtype; 1221 goto out; 1222 } 1223 if (is_null2 && (lclass & TYPE_PTR)) { 1224 if (is_null2 == NULL_ZERO) 1225 bad_null(expr->cond_false); 1226 expr->cond_false = cast_to(expr->cond_false, ltype); 1227 ctype = ltype; 1228 goto out; 1229 } 1230 if (!(lclass & rclass & TYPE_PTR)) { 1231 typediff = "different types"; 1232 goto Err; 1233 } 1234 /* OK, it's pointer on pointer */ 1235 if (ltype->ctype.as != rtype->ctype.as) { 1236 typediff = "different address spaces"; 1237 goto Err; 1238 } 1239 1240 /* need to be lazier here */ 1241 lbase = examine_pointer_target(ltype); 1242 rbase = examine_pointer_target(rtype); 1243 qual = target_qualifiers(ltype) | target_qualifiers(rtype); 1244 1245 if (lbase == &void_ctype) { 1246 /* XXX: pointers to function should warn here */ 1247 ctype = ltype; 1248 goto Qual; 1249 1250 } 1251 if (rbase == &void_ctype) { 1252 /* XXX: pointers to function should warn here */ 1253 ctype = rtype; 1254 goto Qual; 1255 } 1256 /* XXX: that should be pointer to composite */ 1257 ctype = ltype; 1258 typediff = type_difference(<ype->ctype, &rtype->ctype, 1259 qual, qual); 1260 if (!typediff) 1261 goto Qual; 1262 goto Err; 1263 } 1264 1265 /* void on void, struct on same struct, union on same union */ 1266 if (ltype == rtype) { 1267 ctype = ltype; 1268 goto out; 1269 } 1270 typediff = "different base types"; 1271 1272 Err: 1273 expression_error(expr, "incompatible types in conditional expression (%s):", typediff); 1274 info(expr->pos, " %s", show_typename(ltype)); 1275 info(expr->pos, " %s", show_typename(rtype)); 1276 /* 1277 * if the condition is constant, the type is in fact known 1278 * so use it, as gcc & clang do. 1279 */ 1280 switch (expr_truth_value(expr->conditional)) { 1281 case 1: expr->ctype = ltype; 1282 break; 1283 case 0: expr->ctype = rtype; 1284 break; 1285 default: 1286 break; 1287 } 1288 return NULL; 1289 1290 out: 1291 expr->ctype = ctype; 1292 return ctype; 1293 1294 Qual: 1295 if (qual & ~ctype->ctype.modifiers) { 1296 struct symbol *sym = alloc_symbol(ctype->pos, SYM_PTR); 1297 *sym = *ctype; 1298 sym->ctype.modifiers |= qual; 1299 ctype = sym; 1300 } 1301 *cond = cast_to(*cond, ctype); 1302 expr->cond_false = cast_to(expr->cond_false, ctype); 1303 goto out; 1304 } 1305 1306 /* FP assignments can not do modulo or bit operations */ 1307 static int compatible_float_op(int op) 1308 { 1309 return op == SPECIAL_ADD_ASSIGN || 1310 op == SPECIAL_SUB_ASSIGN || 1311 op == SPECIAL_MUL_ASSIGN || 1312 op == SPECIAL_DIV_ASSIGN; 1313 } 1314 1315 static int evaluate_assign_op(struct expression *expr) 1316 { 1317 struct symbol *target = expr->left->ctype; 1318 struct symbol *source = expr->right->ctype; 1319 struct symbol *t, *s; 1320 int tclass = classify_type(target, &t); 1321 int sclass = classify_type(source, &s); 1322 int op = expr->op; 1323 1324 if (tclass & sclass & TYPE_NUM) { 1325 if (tclass & TYPE_FLOAT && !compatible_float_op(op)) { 1326 expression_error(expr, "invalid assignment"); 1327 return 0; 1328 } 1329 if (tclass & TYPE_RESTRICT) { 1330 if (!restricted_binop(op, t)) { 1331 warning(expr->pos, "bad assignment (%s) to %s", 1332 show_special(op), show_typename(t)); 1333 expr->right = cast_to(expr->right, target); 1334 return 0; 1335 } 1336 /* allowed assignments unfoul */ 1337 if (sclass & TYPE_FOULED && unfoul(s) == t) 1338 goto Cast; 1339 if (!restricted_value(expr->right, t)) 1340 return 1; 1341 } else if (op == SPECIAL_SHR_ASSIGN || op == SPECIAL_SHL_ASSIGN) { 1342 // shifts do integer promotions, but that's it. 1343 unrestrict(expr->right, sclass, &s); 1344 target = integer_promotion(s); 1345 goto Cast; 1346 } else if (!(sclass & TYPE_RESTRICT)) 1347 goto usual; 1348 /* source and target would better be identical restricted */ 1349 if (t == s) 1350 return 1; 1351 warning(expr->pos, "invalid assignment: %s", show_special(op)); 1352 info(expr->pos, " left side has type %s", show_typename(t)); 1353 info(expr->pos, " right side has type %s", show_typename(s)); 1354 expr->right = cast_to(expr->right, target); 1355 return 0; 1356 } 1357 if (tclass == TYPE_PTR && is_int(sclass)) { 1358 if (op == SPECIAL_ADD_ASSIGN || op == SPECIAL_SUB_ASSIGN) { 1359 unrestrict(expr->right, sclass, &s); 1360 evaluate_ptr_add(expr, s); 1361 return 1; 1362 } 1363 expression_error(expr, "invalid pointer assignment"); 1364 return 0; 1365 } 1366 1367 expression_error(expr, "invalid assignment"); 1368 return 0; 1369 1370 usual: 1371 target = usual_conversions(op, expr->left, expr->right, 1372 tclass, sclass, target, source); 1373 Cast: 1374 expr->right = cast_to(expr->right, target); 1375 return 1; 1376 } 1377 1378 static int whitelist_pointers(struct symbol *t1, struct symbol *t2) 1379 { 1380 if (t1 == t2) 1381 return 0; /* yes, 0 - we don't want a cast_to here */ 1382 if (t1 == &void_ctype) 1383 return 1; 1384 if (t2 == &void_ctype) 1385 return 1; 1386 if (classify_type(t1, &t1) != TYPE_NUM) 1387 return 0; 1388 if (classify_type(t2, &t2) != TYPE_NUM) 1389 return 0; 1390 if (t1 == t2) 1391 return 1; 1392 if (t1->ctype.modifiers & t2->ctype.modifiers & MOD_CHAR) 1393 return 1; 1394 if ((t1->ctype.modifiers ^ t2->ctype.modifiers) & MOD_SIZE) 1395 return 0; 1396 return !Wtypesign; 1397 } 1398 1399 static int check_assignment_types(struct symbol *target, struct expression **rp, 1400 const char **typediff) 1401 { 1402 struct symbol *source = degenerate(*rp); 1403 struct symbol *t, *s; 1404 int tclass = classify_type(target, &t); 1405 int sclass = classify_type(source, &s); 1406 1407 if (tclass & sclass & TYPE_NUM) { 1408 if (tclass & TYPE_RESTRICT) { 1409 /* allowed assignments unfoul */ 1410 if (sclass & TYPE_FOULED && unfoul(s) == t) 1411 goto Cast; 1412 if (!restricted_value(*rp, target)) 1413 return 1; 1414 if (s == t) 1415 return 1; 1416 } else if (!(sclass & TYPE_RESTRICT)) 1417 goto Cast; 1418 if (t == &bool_ctype) { 1419 if (is_fouled_type(s)) 1420 warning((*rp)->pos, "%s degrades to integer", 1421 show_typename(s->ctype.base_type)); 1422 goto Cast; 1423 } 1424 *typediff = "different base types"; 1425 return 0; 1426 } 1427 1428 if (tclass == TYPE_PTR) { 1429 unsigned long mod1, mod2; 1430 struct symbol *b1, *b2; 1431 // NULL pointer is always OK 1432 int is_null = is_null_pointer_constant(*rp); 1433 if (is_null) { 1434 if (is_null == NULL_ZERO) 1435 bad_null(*rp); 1436 goto Cast; 1437 } 1438 if (!(sclass & TYPE_PTR)) { 1439 *typediff = "different base types"; 1440 return 0; 1441 } 1442 b1 = examine_pointer_target(t); 1443 b2 = examine_pointer_target(s); 1444 mod1 = target_qualifiers(t); 1445 mod2 = target_qualifiers(s); 1446 if (whitelist_pointers(b1, b2)) { 1447 /* 1448 * assignments to/from void * are OK, provided that 1449 * we do not remove qualifiers from pointed to [C] 1450 * or mix address spaces [sparse]. 1451 */ 1452 if (t->ctype.as != s->ctype.as) { 1453 *typediff = "different address spaces"; 1454 return 0; 1455 } 1456 /* 1457 * If this is a function pointer assignment, it is 1458 * actually fine to assign a pointer to const data to 1459 * it, as a function pointer points to const data 1460 * implicitly, i.e., dereferencing it does not produce 1461 * an lvalue. 1462 */ 1463 if (b1->type == SYM_FN) 1464 mod1 |= MOD_CONST; 1465 if (mod2 & ~mod1) { 1466 *typediff = "different modifiers"; 1467 return 0; 1468 } 1469 goto Cast; 1470 } 1471 /* It's OK if the target is more volatile or const than the source */ 1472 *typediff = type_difference(&t->ctype, &s->ctype, 0, mod1); 1473 if (*typediff) 1474 return 0; 1475 return 1; 1476 } 1477 1478 if ((tclass & TYPE_COMPOUND) && s == t) 1479 return 1; 1480 1481 if (tclass & TYPE_NUM) { 1482 /* XXX: need to turn into comparison with NULL */ 1483 if (t == &bool_ctype && (sclass & TYPE_PTR)) 1484 goto Cast; 1485 *typediff = "different base types"; 1486 return 0; 1487 } 1488 *typediff = "invalid types"; 1489 return 0; 1490 1491 Cast: 1492 *rp = cast_to(*rp, target); 1493 return 1; 1494 } 1495 1496 static int compatible_assignment_types(struct expression *expr, struct symbol *target, 1497 struct expression **rp, const char *where) 1498 { 1499 const char *typediff; 1500 struct symbol *source = degenerate(*rp); 1501 1502 if (!check_assignment_types(target, rp, &typediff)) { 1503 warning(expr->pos, "incorrect type in %s (%s)", where, typediff); 1504 info(expr->pos, " expected %s", show_typename(target)); 1505 info(expr->pos, " got %s", show_typename(source)); 1506 *rp = cast_to(*rp, target); 1507 return 0; 1508 } 1509 1510 return 1; 1511 } 1512 1513 static int compatible_transparent_union(struct symbol *target, 1514 struct expression **rp) 1515 { 1516 struct symbol *t, *member; 1517 classify_type(target, &t); 1518 if (t->type != SYM_UNION || !t->transparent_union) 1519 return 0; 1520 1521 FOR_EACH_PTR(t->symbol_list, member) { 1522 const char *typediff; 1523 if (check_assignment_types(member, rp, &typediff)) 1524 return 1; 1525 } END_FOR_EACH_PTR(member); 1526 1527 return 0; 1528 } 1529 1530 static int compatible_argument_type(struct expression *expr, struct symbol *target, 1531 struct expression **rp, const char *where) 1532 { 1533 if (compatible_transparent_union(target, rp)) 1534 return 1; 1535 1536 return compatible_assignment_types(expr, target, rp, where); 1537 } 1538 1539 static void mark_assigned(struct expression *expr) 1540 { 1541 struct symbol *sym; 1542 1543 if (!expr) 1544 return; 1545 switch (expr->type) { 1546 case EXPR_SYMBOL: 1547 sym = expr->symbol; 1548 if (!sym) 1549 return; 1550 if (sym->type != SYM_NODE) 1551 return; 1552 sym->ctype.modifiers |= MOD_ASSIGNED; 1553 return; 1554 1555 case EXPR_BINOP: 1556 mark_assigned(expr->left); 1557 mark_assigned(expr->right); 1558 return; 1559 case EXPR_CAST: 1560 case EXPR_FORCE_CAST: 1561 mark_assigned(expr->cast_expression); 1562 return; 1563 case EXPR_SLICE: 1564 mark_assigned(expr->base); 1565 return; 1566 default: 1567 /* Hmm? */ 1568 return; 1569 } 1570 } 1571 1572 static void evaluate_assign_to(struct expression *left, struct symbol *type) 1573 { 1574 if (type->ctype.modifiers & MOD_CONST) 1575 expression_error(left, "assignment to const expression"); 1576 1577 /* We know left is an lvalue, so it's a "preop-*" */ 1578 mark_assigned(left->unop); 1579 } 1580 1581 static struct symbol *evaluate_assignment(struct expression *expr) 1582 { 1583 struct expression *left = expr->left; 1584 struct symbol *ltype; 1585 1586 if (!lvalue_expression(left)) { 1587 expression_error(expr, "not an lvalue"); 1588 return NULL; 1589 } 1590 1591 ltype = left->ctype; 1592 1593 if (expr->op != '=') { 1594 if (!evaluate_assign_op(expr)) 1595 return NULL; 1596 } else { 1597 if (!compatible_assignment_types(expr, ltype, &expr->right, "assignment")) 1598 return NULL; 1599 } 1600 1601 evaluate_assign_to(left, ltype); 1602 1603 expr->ctype = ltype; 1604 return ltype; 1605 } 1606 1607 static void examine_fn_arguments(struct symbol *fn) 1608 { 1609 struct symbol *s; 1610 1611 FOR_EACH_PTR(fn->arguments, s) { 1612 struct symbol *arg = evaluate_symbol(s); 1613 /* Array/function arguments silently degenerate into pointers */ 1614 if (arg) { 1615 struct symbol *ptr; 1616 switch(arg->type) { 1617 case SYM_ARRAY: 1618 case SYM_FN: 1619 ptr = alloc_symbol(s->pos, SYM_PTR); 1620 if (arg->type == SYM_ARRAY) 1621 ptr->ctype = arg->ctype; 1622 else 1623 ptr->ctype.base_type = arg; 1624 combine_address_space(s->pos, &ptr->ctype.as, s->ctype.as); 1625 ptr->ctype.modifiers |= s->ctype.modifiers & MOD_PTRINHERIT; 1626 1627 s->ctype.base_type = ptr; 1628 s->ctype.as = NULL; 1629 s->ctype.modifiers &= ~MOD_PTRINHERIT; 1630 s->bit_size = 0; 1631 s->examined = 0; 1632 examine_symbol_type(s); 1633 break; 1634 default: 1635 /* nothing */ 1636 break; 1637 } 1638 } 1639 } END_FOR_EACH_PTR(s); 1640 } 1641 1642 static struct symbol *convert_to_as_mod(struct symbol *sym, struct ident *as, int mod) 1643 { 1644 /* Take the modifiers of the pointer, and apply them to the member */ 1645 mod |= sym->ctype.modifiers; 1646 if (sym->ctype.as != as || sym->ctype.modifiers != mod) { 1647 struct symbol *newsym = alloc_symbol(sym->pos, SYM_NODE); 1648 *newsym = *sym; 1649 newsym->ctype.as = as; 1650 newsym->ctype.modifiers = mod; 1651 sym = newsym; 1652 } 1653 return sym; 1654 } 1655 1656 static struct symbol *create_pointer(struct expression *expr, struct symbol *sym, int degenerate) 1657 { 1658 struct symbol *node = alloc_symbol(expr->pos, SYM_NODE); 1659 struct symbol *ptr = alloc_symbol(expr->pos, SYM_PTR); 1660 1661 node->ctype.base_type = ptr; 1662 ptr->bit_size = bits_in_pointer; 1663 ptr->ctype.alignment = pointer_alignment; 1664 1665 node->bit_size = bits_in_pointer; 1666 node->ctype.alignment = pointer_alignment; 1667 1668 access_symbol(sym); 1669 if (sym->ctype.modifiers & MOD_REGISTER) { 1670 warning(expr->pos, "taking address of 'register' variable '%s'", show_ident(sym->ident)); 1671 sym->ctype.modifiers &= ~MOD_REGISTER; 1672 } 1673 if (sym->type == SYM_NODE) { 1674 combine_address_space(sym->pos, &ptr->ctype.as, sym->ctype.as); 1675 ptr->ctype.modifiers |= sym->ctype.modifiers & MOD_PTRINHERIT; 1676 sym = sym->ctype.base_type; 1677 } 1678 if (degenerate && sym->type == SYM_ARRAY) { 1679 combine_address_space(sym->pos, &ptr->ctype.as, sym->ctype.as); 1680 ptr->ctype.modifiers |= sym->ctype.modifiers & MOD_PTRINHERIT; 1681 sym = sym->ctype.base_type; 1682 } 1683 ptr->ctype.base_type = sym; 1684 1685 return node; 1686 } 1687 1688 /* Arrays degenerate into pointers on pointer arithmetic */ 1689 static struct symbol *degenerate(struct expression *expr) 1690 { 1691 struct symbol *ctype, *base; 1692 1693 if (!expr) 1694 return NULL; 1695 ctype = expr->ctype; 1696 if (!ctype) 1697 return NULL; 1698 base = examine_symbol_type(ctype); 1699 if (ctype->type == SYM_NODE) 1700 base = ctype->ctype.base_type; 1701 /* 1702 * Arrays degenerate into pointers to the entries, while 1703 * functions degenerate into pointers to themselves. 1704 * If array was part of non-lvalue compound, we create a copy 1705 * of that compound first and then act as if we were dealing with 1706 * the corresponding field in there. 1707 */ 1708 switch (base->type) { 1709 case SYM_ARRAY: 1710 if (expr->type == EXPR_SLICE) { 1711 struct symbol *a = alloc_symbol(expr->pos, SYM_NODE); 1712 struct expression *e0, *e1, *e2, *e3, *e4; 1713 1714 a->ctype.base_type = expr->base->ctype; 1715 a->bit_size = expr->base->ctype->bit_size; 1716 a->array_size = expr->base->ctype->array_size; 1717 1718 e0 = alloc_expression(expr->pos, EXPR_SYMBOL); 1719 e0->symbol = a; 1720 e0->ctype = &lazy_ptr_ctype; 1721 1722 e1 = alloc_expression(expr->pos, EXPR_PREOP); 1723 e1->unop = e0; 1724 e1->op = '*'; 1725 e1->ctype = expr->base->ctype; /* XXX */ 1726 1727 e2 = alloc_expression(expr->pos, EXPR_ASSIGNMENT); 1728 e2->left = e1; 1729 e2->right = expr->base; 1730 e2->op = '='; 1731 e2->ctype = expr->base->ctype; 1732 1733 if (expr->r_bitpos) { 1734 e3 = alloc_expression(expr->pos, EXPR_BINOP); 1735 e3->op = '+'; 1736 e3->left = e0; 1737 e3->right = alloc_const_expression(expr->pos, 1738 bits_to_bytes(expr->r_bitpos)); 1739 e3->ctype = &lazy_ptr_ctype; 1740 } else { 1741 e3 = e0; 1742 } 1743 1744 e4 = alloc_expression(expr->pos, EXPR_COMMA); 1745 e4->left = e2; 1746 e4->right = e3; 1747 e4->ctype = &lazy_ptr_ctype; 1748 1749 expr->unop = e4; 1750 expr->type = EXPR_PREOP; 1751 expr->op = '*'; 1752 } 1753 case SYM_FN: 1754 if (expr->op != '*' || expr->type != EXPR_PREOP) { 1755 expression_error(expr, "strange non-value function or array"); 1756 return &bad_ctype; 1757 } 1758 *expr = *expr->unop; 1759 ctype = create_pointer(expr, ctype, 1); 1760 expr->ctype = ctype; 1761 default: 1762 /* nothing */; 1763 } 1764 return ctype; 1765 } 1766 1767 static struct symbol *evaluate_addressof(struct expression *expr) 1768 { 1769 struct expression *op = expr->unop; 1770 struct symbol *ctype; 1771 1772 if (op->op != '*' || op->type != EXPR_PREOP) { 1773 expression_error(expr, "not addressable"); 1774 return NULL; 1775 } 1776 ctype = op->ctype; 1777 *expr = *op->unop; 1778 1779 if (expr->type == EXPR_SYMBOL) { 1780 struct symbol *sym = expr->symbol; 1781 sym->ctype.modifiers |= MOD_ADDRESSABLE; 1782 } 1783 1784 /* 1785 * symbol expression evaluation is lazy about the type 1786 * of the sub-expression, so we may have to generate 1787 * the type here if so.. 1788 */ 1789 if (expr->ctype == &lazy_ptr_ctype) { 1790 ctype = create_pointer(expr, ctype, 0); 1791 expr->ctype = ctype; 1792 } 1793 return expr->ctype; 1794 } 1795 1796 1797 static struct symbol *evaluate_dereference(struct expression *expr) 1798 { 1799 struct expression *op = expr->unop; 1800 struct symbol *ctype = op->ctype, *node, *target; 1801 1802 /* Simplify: *&(expr) => (expr) */ 1803 if (op->type == EXPR_PREOP && op->op == '&') { 1804 *expr = *op->unop; 1805 expr->flags = CEF_NONE; 1806 return expr->ctype; 1807 } 1808 1809 examine_symbol_type(ctype); 1810 1811 /* Dereferencing a node drops all the node information. */ 1812 if (ctype->type == SYM_NODE) 1813 ctype = ctype->ctype.base_type; 1814 1815 target = ctype->ctype.base_type; 1816 examine_symbol_type(target); 1817 1818 switch (ctype->type) { 1819 default: 1820 expression_error(expr, "cannot dereference this type"); 1821 return NULL; 1822 case SYM_FN: 1823 *expr = *op; 1824 return expr->ctype; 1825 case SYM_PTR: 1826 node = alloc_symbol(expr->pos, SYM_NODE); 1827 node->ctype.modifiers = target->ctype.modifiers & MOD_SPECIFIER; 1828 merge_type(node, ctype); 1829 break; 1830 1831 case SYM_ARRAY: 1832 if (!lvalue_expression(op)) { 1833 expression_error(op, "non-lvalue array??"); 1834 return NULL; 1835 } 1836 1837 /* Do the implied "addressof" on the array */ 1838 *op = *op->unop; 1839 1840 /* 1841 * When an array is dereferenced, we need to pick 1842 * up the attributes of the original node too.. 1843 */ 1844 node = alloc_symbol(expr->pos, SYM_NODE); 1845 merge_type(node, op->ctype); 1846 merge_type(node, ctype); 1847 break; 1848 } 1849 1850 node->bit_size = target->bit_size; 1851 node->array_size = target->array_size; 1852 1853 expr->ctype = node; 1854 return node; 1855 } 1856 1857 /* 1858 * Unary post-ops: x++ and x-- 1859 */ 1860 static struct symbol *evaluate_postop(struct expression *expr) 1861 { 1862 struct expression *op = expr->unop; 1863 struct symbol *ctype = op->ctype; 1864 int class = classify_type(ctype, &ctype); 1865 int multiply = 0; 1866 1867 if (!class || class & TYPE_COMPOUND) { 1868 expression_error(expr, "need scalar for ++/--"); 1869 return NULL; 1870 } 1871 if (!lvalue_expression(expr->unop)) { 1872 expression_error(expr, "need lvalue expression for ++/--"); 1873 return NULL; 1874 } 1875 1876 if ((class & TYPE_RESTRICT) && restricted_unop(expr->op, &ctype)) 1877 unrestrict(expr, class, &ctype); 1878 1879 if (class & TYPE_NUM) { 1880 multiply = 1; 1881 } else if (class == TYPE_PTR) { 1882 struct symbol *target = examine_pointer_target(ctype); 1883 if (!is_function(target)) 1884 multiply = bits_to_bytes(target->bit_size); 1885 } 1886 1887 if (multiply) { 1888 evaluate_assign_to(op, op->ctype); 1889 expr->op_value = multiply; 1890 expr->ctype = ctype; 1891 return ctype; 1892 } 1893 1894 expression_error(expr, "bad argument type for ++/--"); 1895 return NULL; 1896 } 1897 1898 static struct symbol *evaluate_sign(struct expression *expr) 1899 { 1900 struct symbol *ctype = expr->unop->ctype; 1901 int class = classify_type(ctype, &ctype); 1902 unsigned char flags = expr->unop->flags & ~CEF_CONST_MASK; 1903 1904 /* should be an arithmetic type */ 1905 if (!(class & TYPE_NUM)) 1906 return bad_expr_type(expr); 1907 if (class & TYPE_RESTRICT) 1908 goto Restr; 1909 Normal: 1910 if (!(class & TYPE_FLOAT)) { 1911 ctype = integer_promotion(ctype); 1912 expr->unop = cast_to(expr->unop, ctype); 1913 } else if (expr->op != '~') { 1914 /* no conversions needed */ 1915 } else { 1916 return bad_expr_type(expr); 1917 } 1918 if (expr->op == '+') 1919 *expr = *expr->unop; 1920 expr->flags = flags; 1921 expr->ctype = ctype; 1922 return ctype; 1923 Restr: 1924 if (restricted_unop(expr->op, &ctype)) 1925 unrestrict(expr, class, &ctype); 1926 goto Normal; 1927 } 1928 1929 static struct symbol *evaluate_preop(struct expression *expr) 1930 { 1931 struct symbol *ctype = expr->unop->ctype; 1932 1933 switch (expr->op) { 1934 case '(': 1935 *expr = *expr->unop; 1936 return ctype; 1937 1938 case '+': 1939 case '-': 1940 case '~': 1941 return evaluate_sign(expr); 1942 1943 case '*': 1944 return evaluate_dereference(expr); 1945 1946 case '&': 1947 return evaluate_addressof(expr); 1948 1949 case SPECIAL_INCREMENT: 1950 case SPECIAL_DECREMENT: 1951 /* 1952 * From a type evaluation standpoint the preops are 1953 * the same as the postops 1954 */ 1955 return evaluate_postop(expr); 1956 1957 case '!': 1958 ctype = degenerate(expr->unop); 1959 expr->flags = expr->unop->flags & ~CEF_CONST_MASK; 1960 /* 1961 * A logical negation never yields an address constant 1962 * [6.6(9)]. 1963 */ 1964 expr->flags &= ~CEF_ADDR; 1965 1966 if (is_safe_type(ctype)) 1967 warning(expr->pos, "testing a 'safe expression'"); 1968 if (is_float_type(ctype)) { 1969 struct expression *arg = expr->unop; 1970 expr->type = EXPR_COMPARE; 1971 expr->op = SPECIAL_EQUAL; 1972 expr->left = arg; 1973 expr->right = alloc_expression(expr->pos, EXPR_FVALUE); 1974 expr->right->ctype = ctype; 1975 expr->right->fvalue = 0; 1976 } else if (is_fouled_type(ctype)) { 1977 warning(expr->pos, "%s degrades to integer", 1978 show_typename(ctype->ctype.base_type)); 1979 } 1980 /* the result is int [6.5.3.3(5)]*/ 1981 ctype = &int_ctype; 1982 break; 1983 1984 default: 1985 break; 1986 } 1987 expr->ctype = ctype; 1988 return ctype; 1989 } 1990 1991 struct symbol *find_identifier(struct ident *ident, struct symbol_list *_list, int *offset) 1992 { 1993 struct ptr_list *head = (struct ptr_list *)_list; 1994 struct ptr_list *list = head; 1995 1996 if (!head) 1997 return NULL; 1998 do { 1999 int i; 2000 for (i = 0; i < list->nr; i++) { 2001 struct symbol *sym = (struct symbol *) list->list[i]; 2002 if (sym->ident) { 2003 if (sym->ident != ident) 2004 continue; 2005 *offset = sym->offset; 2006 return sym; 2007 } else { 2008 struct symbol *ctype = sym->ctype.base_type; 2009 struct symbol *sub; 2010 if (!ctype) 2011 continue; 2012 if (ctype->type != SYM_UNION && ctype->type != SYM_STRUCT) 2013 continue; 2014 sub = find_identifier(ident, ctype->symbol_list, offset); 2015 if (!sub) 2016 continue; 2017 *offset += sym->offset; 2018 return sub; 2019 } 2020 } 2021 } while ((list = list->next) != head); 2022 return NULL; 2023 } 2024 2025 static struct expression *evaluate_offset(struct expression *expr, unsigned long offset) 2026 { 2027 struct expression *add; 2028 2029 /* 2030 * Create a new add-expression 2031 * 2032 * NOTE! Even if we just add zero, we need a new node 2033 * for the member pointer, since it has a different 2034 * type than the original pointer. We could make that 2035 * be just a cast, but the fact is, a node is a node, 2036 * so we might as well just do the "add zero" here. 2037 */ 2038 add = alloc_expression(expr->pos, EXPR_BINOP); 2039 add->op = '+'; 2040 add->left = expr; 2041 add->right = alloc_expression(expr->pos, EXPR_VALUE); 2042 add->right->ctype = &int_ctype; 2043 add->right->value = offset; 2044 2045 /* 2046 * The ctype of the pointer will be lazily evaluated if 2047 * we ever take the address of this member dereference.. 2048 */ 2049 add->ctype = &lazy_ptr_ctype; 2050 /* 2051 * The resulting address of a member access through an address 2052 * constant is an address constant again [6.6(9)]. 2053 */ 2054 add->flags = expr->flags; 2055 2056 return add; 2057 } 2058 2059 /* structure/union dereference */ 2060 static struct symbol *evaluate_member_dereference(struct expression *expr) 2061 { 2062 int offset; 2063 struct symbol *ctype, *member; 2064 struct expression *deref = expr->deref, *add; 2065 struct ident *ident = expr->member; 2066 struct ident *address_space; 2067 unsigned int mod; 2068 2069 if (!evaluate_expression(deref)) 2070 return NULL; 2071 if (!ident) { 2072 expression_error(expr, "bad member name"); 2073 return NULL; 2074 } 2075 2076 ctype = deref->ctype; 2077 examine_symbol_type(ctype); 2078 address_space = ctype->ctype.as; 2079 mod = ctype->ctype.modifiers; 2080 if (ctype->type == SYM_NODE) { 2081 ctype = ctype->ctype.base_type; 2082 combine_address_space(deref->pos, &address_space, ctype->ctype.as); 2083 mod |= ctype->ctype.modifiers; 2084 } 2085 if (!ctype || (ctype->type != SYM_STRUCT && ctype->type != SYM_UNION)) { 2086 expression_error(expr, "expected structure or union"); 2087 return NULL; 2088 } 2089 offset = 0; 2090 member = find_identifier(ident, ctype->symbol_list, &offset); 2091 if (!member) { 2092 const char *type = ctype->type == SYM_STRUCT ? "struct" : "union"; 2093 const char *name = "<unnamed>"; 2094 int namelen = 9; 2095 if (ctype->ident) { 2096 name = ctype->ident->name; 2097 namelen = ctype->ident->len; 2098 } 2099 if (ctype->symbol_list) 2100 expression_error(expr, "no member '%s' in %s %.*s", 2101 show_ident(ident), type, namelen, name); 2102 else 2103 expression_error(expr, "using member '%s' in " 2104 "incomplete %s %.*s", show_ident(ident), 2105 type, namelen, name); 2106 return NULL; 2107 } 2108 2109 /* 2110 * The member needs to take on the address space and modifiers of 2111 * the "parent" type. 2112 */ 2113 member = convert_to_as_mod(member, address_space, mod); 2114 ctype = get_base_type(member); 2115 2116 if (!lvalue_expression(deref)) { 2117 if (deref->type != EXPR_SLICE) { 2118 expr->base = deref; 2119 expr->r_bitpos = 0; 2120 } else { 2121 expr->base = deref->base; 2122 expr->r_bitpos = deref->r_bitpos; 2123 } 2124 expr->r_bitpos += bytes_to_bits(offset); 2125 expr->type = EXPR_SLICE; 2126 expr->r_nrbits = member->bit_size; 2127 expr->r_bitpos += member->bit_offset; 2128 expr->ctype = member; 2129 return member; 2130 } 2131 2132 deref = deref->unop; 2133 expr->deref = deref; 2134 2135 add = evaluate_offset(deref, offset); 2136 expr->type = EXPR_PREOP; 2137 expr->op = '*'; 2138 expr->unop = add; 2139 2140 expr->ctype = member; 2141 return member; 2142 } 2143 2144 static int is_promoted(struct expression *expr) 2145 { 2146 while (1) { 2147 switch (expr->type) { 2148 case EXPR_BINOP: 2149 case EXPR_SELECT: 2150 case EXPR_CONDITIONAL: 2151 return 1; 2152 case EXPR_COMMA: 2153 expr = expr->right; 2154 continue; 2155 case EXPR_PREOP: 2156 switch (expr->op) { 2157 case '(': 2158 expr = expr->unop; 2159 continue; 2160 case '+': 2161 case '-': 2162 case '~': 2163 return 1; 2164 default: 2165 return 0; 2166 } 2167 default: 2168 return 0; 2169 } 2170 } 2171 } 2172 2173 2174 static struct symbol *evaluate_cast(struct expression *); 2175 2176 static struct symbol *evaluate_type_information(struct expression *expr) 2177 { 2178 struct symbol *sym = expr->cast_type; 2179 if (!sym) { 2180 sym = evaluate_expression(expr->cast_expression); 2181 if (!sym) 2182 return NULL; 2183 /* 2184 * Expressions of restricted types will possibly get 2185 * promoted - check that here 2186 */ 2187 if (is_restricted_type(sym)) { 2188 if (sym->bit_size < bits_in_int && is_promoted(expr)) 2189 sym = &int_ctype; 2190 } else if (is_fouled_type(sym)) { 2191 sym = &int_ctype; 2192 } 2193 } 2194 examine_symbol_type(sym); 2195 if (is_bitfield_type(sym)) { 2196 expression_error(expr, "trying to examine bitfield type"); 2197 return NULL; 2198 } 2199 return sym; 2200 } 2201 2202 static struct symbol *evaluate_sizeof(struct expression *expr) 2203 { 2204 struct symbol *type; 2205 int size; 2206 2207 type = evaluate_type_information(expr); 2208 if (!type) 2209 return NULL; 2210 2211 size = type->bit_size; 2212 2213 if (size < 0 && is_void_type(type)) { 2214 if (Wpointer_arith) 2215 warning(expr->pos, "expression using sizeof(void)"); 2216 size = bits_in_char; 2217 } 2218 2219 if (is_bool_type(type)) { 2220 if (Wsizeof_bool) 2221 warning(expr->pos, "expression using sizeof _Bool"); 2222 size = bits_to_bytes(bits_in_bool) * bits_in_char; 2223 } 2224 2225 if (is_function(type->ctype.base_type)) { 2226 if (Wpointer_arith) 2227 warning(expr->pos, "expression using sizeof on a function"); 2228 size = bits_in_char; 2229 } 2230 2231 if (is_array_type(type) && size < 0) { // VLA, 1-dimension only 2232 struct expression *base, *size; 2233 struct symbol *base_type; 2234 2235 if (type->type == SYM_NODE) 2236 type = type->ctype.base_type; // strip the SYM_NODE 2237 base_type = get_base_type(type); 2238 if (!base_type) 2239 goto error; 2240 if (base_type->bit_size <= 0) { 2241 base = alloc_expression(expr->pos, EXPR_SIZEOF); 2242 base->cast_type = base_type; 2243 if (!evaluate_sizeof(base)) 2244 goto error; 2245 } else { 2246 base = alloc_expression(expr->pos, EXPR_VALUE); 2247 base->value = bits_to_bytes(base_type->bit_size); 2248 base->ctype = size_t_ctype; 2249 } 2250 size = alloc_expression(expr->pos, EXPR_CAST); 2251 size->cast_type = size_t_ctype; 2252 size->cast_expression = type->array_size; 2253 if (!evaluate_expression(size)) 2254 goto error; 2255 expr->left = size; 2256 expr->right = base; 2257 expr->type = EXPR_BINOP; 2258 expr->op = '*'; 2259 return expr->ctype = size_t_ctype; 2260 } 2261 2262 error: 2263 if ((size < 0) || (size & (bits_in_char - 1))) 2264 expression_error(expr, "cannot size expression"); 2265 2266 expr->type = EXPR_VALUE; 2267 expr->value = bits_to_bytes(size); 2268 expr->taint = 0; 2269 expr->ctype = size_t_ctype; 2270 return size_t_ctype; 2271 } 2272 2273 static struct symbol *evaluate_ptrsizeof(struct expression *expr) 2274 { 2275 struct symbol *type; 2276 int size; 2277 2278 type = evaluate_type_information(expr); 2279 if (!type) 2280 return NULL; 2281 2282 if (type->type == SYM_NODE) 2283 type = type->ctype.base_type; 2284 if (!type) 2285 return NULL; 2286 switch (type->type) { 2287 case SYM_ARRAY: 2288 break; 2289 case SYM_PTR: 2290 type = get_base_type(type); 2291 if (type) 2292 break; 2293 default: 2294 expression_error(expr, "expected pointer expression"); 2295 return NULL; 2296 } 2297 size = type->bit_size; 2298 if (size & (bits_in_char-1)) 2299 size = 0; 2300 expr->type = EXPR_VALUE; 2301 expr->value = bits_to_bytes(size); 2302 expr->taint = 0; 2303 expr->ctype = size_t_ctype; 2304 return size_t_ctype; 2305 } 2306 2307 static struct symbol *evaluate_alignof(struct expression *expr) 2308 { 2309 struct symbol *type; 2310 2311 type = evaluate_type_information(expr); 2312 if (!type) 2313 return NULL; 2314 2315 expr->type = EXPR_VALUE; 2316 expr->value = type->ctype.alignment; 2317 expr->taint = 0; 2318 expr->ctype = size_t_ctype; 2319 return size_t_ctype; 2320 } 2321 2322 static int evaluate_arguments(struct symbol *fn, struct expression_list *head) 2323 { 2324 struct expression *expr; 2325 struct symbol_list *argument_types = fn->arguments; 2326 struct symbol *argtype; 2327 int i = 1; 2328 2329 PREPARE_PTR_LIST(argument_types, argtype); 2330 FOR_EACH_PTR (head, expr) { 2331 struct expression **p = THIS_ADDRESS(expr); 2332 struct symbol *ctype, *target; 2333 ctype = evaluate_expression(expr); 2334 2335 if (!ctype) 2336 return 0; 2337 2338 target = argtype; 2339 if (!target) { 2340 struct symbol *type; 2341 int class = classify_type(ctype, &type); 2342 if (is_int(class)) { 2343 *p = cast_to(expr, integer_promotion(type)); 2344 } else if (class & TYPE_FLOAT) { 2345 unsigned long mod = type->ctype.modifiers; 2346 if (!(mod & (MOD_LONG_ALL))) 2347 *p = cast_to(expr, &double_ctype); 2348 } else if (class & TYPE_PTR) { 2349 if (expr->ctype == &null_ctype) 2350 *p = cast_to(expr, &ptr_ctype); 2351 else 2352 degenerate(expr); 2353 } 2354 } else if (!target->forced_arg){ 2355 static char where[30]; 2356 examine_symbol_type(target); 2357 sprintf(where, "argument %d", i); 2358 compatible_argument_type(expr, target, p, where); 2359 } 2360 2361 i++; 2362 NEXT_PTR_LIST(argtype); 2363 } END_FOR_EACH_PTR(expr); 2364 FINISH_PTR_LIST(argtype); 2365 return 1; 2366 } 2367 2368 static void convert_index(struct expression *e) 2369 { 2370 struct expression *child = e->idx_expression; 2371 unsigned from = e->idx_from; 2372 unsigned to = e->idx_to + 1; 2373 e->type = EXPR_POS; 2374 e->init_offset = from * bits_to_bytes(e->ctype->bit_size); 2375 e->init_nr = to - from; 2376 e->init_expr = child; 2377 } 2378 2379 static void convert_ident(struct expression *e) 2380 { 2381 struct expression *child = e->ident_expression; 2382 int offset = e->offset; 2383 2384 e->type = EXPR_POS; 2385 e->init_offset = offset; 2386 e->init_nr = 1; 2387 e->init_expr = child; 2388 } 2389 2390 static void convert_designators(struct expression *e) 2391 { 2392 while (e) { 2393 if (e->type == EXPR_INDEX) 2394 convert_index(e); 2395 else if (e->type == EXPR_IDENTIFIER) 2396 convert_ident(e); 2397 else 2398 break; 2399 e = e->init_expr; 2400 } 2401 } 2402 2403 static void excess(struct expression *e, const char *s) 2404 { 2405 warning(e->pos, "excessive elements in %s initializer", s); 2406 } 2407 2408 /* 2409 * implicit designator for the first element 2410 */ 2411 static struct expression *first_subobject(struct symbol *ctype, int class, 2412 struct expression **v) 2413 { 2414 struct expression *e = *v, *new; 2415 2416 if (ctype->type == SYM_NODE) 2417 ctype = ctype->ctype.base_type; 2418 2419 if (class & TYPE_PTR) { /* array */ 2420 if (!ctype->bit_size) 2421 return NULL; 2422 new = alloc_expression(e->pos, EXPR_INDEX); 2423 new->idx_expression = e; 2424 new->ctype = ctype->ctype.base_type; 2425 } else { 2426 struct symbol *field, *p; 2427 PREPARE_PTR_LIST(ctype->symbol_list, p); 2428 while (p && !p->ident && is_bitfield_type(p)) 2429 NEXT_PTR_LIST(p); 2430 field = p; 2431 FINISH_PTR_LIST(p); 2432 if (!field) 2433 return NULL; 2434 new = alloc_expression(e->pos, EXPR_IDENTIFIER); 2435 new->ident_expression = e; 2436 new->field = new->ctype = field; 2437 new->offset = field->offset; 2438 } 2439 *v = new; 2440 return new; 2441 } 2442 2443 /* 2444 * sanity-check explicit designators; return the innermost one or NULL 2445 * in case of error. Assign types. 2446 */ 2447 static struct expression *check_designators(struct expression *e, 2448 struct symbol *ctype) 2449 { 2450 struct expression *last = NULL; 2451 const char *err; 2452 while (1) { 2453 if (ctype->type == SYM_NODE) 2454 ctype = ctype->ctype.base_type; 2455 if (e->type == EXPR_INDEX) { 2456 struct symbol *type; 2457 if (ctype->type != SYM_ARRAY) { 2458 err = "array index in non-array"; 2459 break; 2460 } 2461 type = ctype->ctype.base_type; 2462 if (ctype->bit_size >= 0 && type->bit_size >= 0) { 2463 unsigned offset = array_element_offset(type->bit_size, e->idx_to); 2464 if (offset >= ctype->bit_size) { 2465 err = "index out of bounds in"; 2466 break; 2467 } 2468 } 2469 e->ctype = ctype = type; 2470 ctype = type; 2471 last = e; 2472 if (!e->idx_expression) { 2473 err = "invalid"; 2474 break; 2475 } 2476 e = e->idx_expression; 2477 } else if (e->type == EXPR_IDENTIFIER) { 2478 int offset = 0; 2479 if (ctype->type != SYM_STRUCT && ctype->type != SYM_UNION) { 2480 err = "field name not in struct or union"; 2481 break; 2482 } 2483 ctype = find_identifier(e->expr_ident, ctype->symbol_list, &offset); 2484 if (!ctype) { 2485 err = "unknown field name in"; 2486 break; 2487 } 2488 e->offset = offset; 2489 e->field = e->ctype = ctype; 2490 last = e; 2491 if (!e->ident_expression) { 2492 err = "invalid"; 2493 break; 2494 } 2495 e = e->ident_expression; 2496 } else if (e->type == EXPR_POS) { 2497 err = "internal front-end error: EXPR_POS in"; 2498 break; 2499 } else 2500 return last; 2501 } 2502 expression_error(e, "%s initializer", err); 2503 return NULL; 2504 } 2505 2506 /* 2507 * choose the next subobject to initialize. 2508 * 2509 * Get designators for next element, switch old ones to EXPR_POS. 2510 * Return the resulting expression or NULL if we'd run out of subobjects. 2511 * The innermost designator is returned in *v. Designators in old 2512 * are assumed to be already sanity-checked. 2513 */ 2514 static struct expression *next_designators(struct expression *old, 2515 struct symbol *ctype, 2516 struct expression *e, struct expression **v) 2517 { 2518 struct expression *new = NULL; 2519 2520 if (!old) 2521 return NULL; 2522 if (old->type == EXPR_INDEX) { 2523 struct expression *copy; 2524 unsigned n; 2525 2526 copy = next_designators(old->idx_expression, 2527 old->ctype, e, v); 2528 if (!copy) { 2529 n = old->idx_to + 1; 2530 if (array_element_offset(old->ctype->bit_size, n) == ctype->bit_size) { 2531 convert_index(old); 2532 return NULL; 2533 } 2534 copy = e; 2535 *v = new = alloc_expression(e->pos, EXPR_INDEX); 2536 } else { 2537 n = old->idx_to; 2538 new = alloc_expression(e->pos, EXPR_INDEX); 2539 } 2540 2541 new->idx_from = new->idx_to = n; 2542 new->idx_expression = copy; 2543 new->ctype = old->ctype; 2544 convert_index(old); 2545 } else if (old->type == EXPR_IDENTIFIER) { 2546 struct expression *copy; 2547 struct symbol *field; 2548 int offset = 0; 2549 2550 copy = next_designators(old->ident_expression, 2551 old->ctype, e, v); 2552 if (!copy) { 2553 field = old->field->next_subobject; 2554 if (!field) { 2555 convert_ident(old); 2556 return NULL; 2557 } 2558 copy = e; 2559 *v = new = alloc_expression(e->pos, EXPR_IDENTIFIER); 2560 /* 2561 * We can't necessarily trust "field->offset", 2562 * because the field might be in an anonymous 2563 * union, and the field offset is then the offset 2564 * within that union. 2565 * 2566 * The "old->offset - old->field->offset" 2567 * would be the offset of such an anonymous 2568 * union. 2569 */ 2570 offset = old->offset - old->field->offset; 2571 } else { 2572 field = old->field; 2573 new = alloc_expression(e->pos, EXPR_IDENTIFIER); 2574 } 2575 2576 new->field = field; 2577 new->expr_ident = field->ident; 2578 new->ident_expression = copy; 2579 new->ctype = field; 2580 new->offset = field->offset + offset; 2581 convert_ident(old); 2582 } 2583 return new; 2584 } 2585 2586 static int handle_initializer(struct expression **ep, int nested, 2587 int class, struct symbol *ctype, unsigned long mods); 2588 2589 /* 2590 * deal with traversing subobjects [6.7.8(17,18,20)] 2591 */ 2592 static void handle_list_initializer(struct expression *expr, 2593 int class, struct symbol *ctype, unsigned long mods) 2594 { 2595 struct expression *e, *last = NULL, *top = NULL, *next; 2596 int jumped = 0; 2597 2598 FOR_EACH_PTR(expr->expr_list, e) { 2599 struct expression **v; 2600 struct symbol *type; 2601 int lclass; 2602 2603 if (e->type != EXPR_INDEX && e->type != EXPR_IDENTIFIER) { 2604 struct symbol *struct_sym; 2605 if (!top) { 2606 top = e; 2607 last = first_subobject(ctype, class, &top); 2608 } else { 2609 last = next_designators(last, ctype, e, &top); 2610 } 2611 if (!last) { 2612 excess(e, class & TYPE_PTR ? "array" : 2613 "struct or union"); 2614 DELETE_CURRENT_PTR(e); 2615 continue; 2616 } 2617 struct_sym = ctype->type == SYM_NODE ? ctype->ctype.base_type : ctype; 2618 if (Wdesignated_init && struct_sym->designated_init) 2619 warning(e->pos, "%s%.*s%spositional init of field in %s %s, declared with attribute designated_init", 2620 ctype->ident ? "in initializer for " : "", 2621 ctype->ident ? ctype->ident->len : 0, 2622 ctype->ident ? ctype->ident->name : "", 2623 ctype->ident ? ": " : "", 2624 get_type_name(struct_sym->type), 2625 show_ident(struct_sym->ident)); 2626 if (jumped) { 2627 warning(e->pos, "advancing past deep designator"); 2628 jumped = 0; 2629 } 2630 REPLACE_CURRENT_PTR(e, last); 2631 } else { 2632 next = check_designators(e, ctype); 2633 if (!next) { 2634 DELETE_CURRENT_PTR(e); 2635 continue; 2636 } 2637 top = next; 2638 /* deeper than one designator? */ 2639 jumped = top != e; 2640 convert_designators(last); 2641 last = e; 2642 } 2643 2644 found: 2645 lclass = classify_type(top->ctype, &type); 2646 if (top->type == EXPR_INDEX) 2647 v = &top->idx_expression; 2648 else 2649 v = &top->ident_expression; 2650 2651 mods |= ctype->ctype.modifiers & MOD_STORAGE; 2652 if (handle_initializer(v, 1, lclass, top->ctype, mods)) 2653 continue; 2654 2655 if (!(lclass & TYPE_COMPOUND)) { 2656 warning(e->pos, "bogus scalar initializer"); 2657 DELETE_CURRENT_PTR(e); 2658 continue; 2659 } 2660 2661 next = first_subobject(type, lclass, v); 2662 if (next) { 2663 warning(e->pos, "missing braces around initializer"); 2664 top = next; 2665 goto found; 2666 } 2667 2668 DELETE_CURRENT_PTR(e); 2669 excess(e, lclass & TYPE_PTR ? "array" : "struct or union"); 2670 2671 } END_FOR_EACH_PTR(e); 2672 2673 convert_designators(last); 2674 expr->ctype = ctype; 2675 } 2676 2677 static int is_string_literal(struct expression **v) 2678 { 2679 struct expression *e = *v; 2680 while (e && e->type == EXPR_PREOP && e->op == '(') 2681 e = e->unop; 2682 if (!e || e->type != EXPR_STRING) 2683 return 0; 2684 if (e != *v && Wparen_string) 2685 warning(e->pos, 2686 "array initialized from parenthesized string constant"); 2687 *v = e; 2688 return 1; 2689 } 2690 2691 /* 2692 * We want a normal expression, possibly in one layer of braces. Warn 2693 * if the latter happens inside a list (it's legal, but likely to be 2694 * an effect of screwup). In case of anything not legal, we are definitely 2695 * having an effect of screwup, so just fail and let the caller warn. 2696 */ 2697 static struct expression *handle_scalar(struct expression *e, int nested) 2698 { 2699 struct expression *v = NULL, *p; 2700 int count = 0; 2701 2702 /* normal case */ 2703 if (e->type != EXPR_INITIALIZER) 2704 return e; 2705 2706 FOR_EACH_PTR(e->expr_list, p) { 2707 if (!v) 2708 v = p; 2709 count++; 2710 } END_FOR_EACH_PTR(p); 2711 if (count != 1) 2712 return NULL; 2713 switch(v->type) { 2714 case EXPR_INITIALIZER: 2715 case EXPR_INDEX: 2716 case EXPR_IDENTIFIER: 2717 return NULL; 2718 default: 2719 break; 2720 } 2721 if (nested) 2722 warning(e->pos, "braces around scalar initializer"); 2723 return v; 2724 } 2725 2726 /* 2727 * deal with the cases that don't care about subobjects: 2728 * scalar <- assignment expression, possibly in braces [6.7.8(11)] 2729 * character array <- string literal, possibly in braces [6.7.8(14)] 2730 * struct or union <- assignment expression of compatible type [6.7.8(13)] 2731 * compound type <- initializer list in braces [6.7.8(16)] 2732 * The last one punts to handle_list_initializer() which, in turn will call 2733 * us for individual elements of the list. 2734 * 2735 * We do not handle 6.7.8(15) (wide char array <- wide string literal) for 2736 * the lack of support of wide char stuff in general. 2737 * 2738 * One note: we need to take care not to evaluate a string literal until 2739 * we know that we *will* handle it right here. Otherwise we would screw 2740 * the cases like struct { struct {char s[10]; ...} ...} initialized with 2741 * { "string", ...} - we need to preserve that string literal recognizable 2742 * until we dig into the inner struct. 2743 */ 2744 static int handle_initializer(struct expression **ep, int nested, 2745 int class, struct symbol *ctype, unsigned long mods) 2746 { 2747 int is_string = is_string_type(ctype); 2748 struct expression *e = *ep, *p; 2749 struct symbol *type; 2750 2751 if (!e) 2752 return 0; 2753 2754 /* scalar */ 2755 if (!(class & TYPE_COMPOUND)) { 2756 e = handle_scalar(e, nested); 2757 if (!e) 2758 return 0; 2759 *ep = e; 2760 if (!evaluate_expression(e)) 2761 return 1; 2762 compatible_assignment_types(e, ctype, ep, "initializer"); 2763 /* 2764 * Initializers for static storage duration objects 2765 * shall be constant expressions or a string literal [6.7.8(4)]. 2766 */ 2767 mods |= ctype->ctype.modifiers; 2768 mods &= (MOD_TOPLEVEL | MOD_STATIC); 2769 if (mods && !(e->flags & (CEF_ACE | CEF_ADDR))) 2770 if (Wconstexpr_not_const) 2771 warning(e->pos, "non-constant initializer for static object"); 2772 2773 return 1; 2774 } 2775 2776 /* 2777 * sublist; either a string, or we dig in; the latter will deal with 2778 * pathologies, so we don't need anything fancy here. 2779 */ 2780 if (e->type == EXPR_INITIALIZER) { 2781 if (is_string) { 2782 struct expression *v = NULL; 2783 int count = 0; 2784 2785 FOR_EACH_PTR(e->expr_list, p) { 2786 if (!v) 2787 v = p; 2788 count++; 2789 } END_FOR_EACH_PTR(p); 2790 if (count == 1 && is_string_literal(&v)) { 2791 *ep = e = v; 2792 goto String; 2793 } 2794 } 2795 handle_list_initializer(e, class, ctype, mods); 2796 return 1; 2797 } 2798 2799 /* string */ 2800 if (is_string_literal(&e)) { 2801 /* either we are doing array of char, or we'll have to dig in */ 2802 if (is_string) { 2803 *ep = e; 2804 goto String; 2805 } 2806 return 0; 2807 } 2808 /* struct or union can be initialized by compatible */ 2809 if (class != TYPE_COMPOUND) 2810 return 0; 2811 type = evaluate_expression(e); 2812 if (!type) 2813 return 0; 2814 if (ctype->type == SYM_NODE) 2815 ctype = ctype->ctype.base_type; 2816 if (type->type == SYM_NODE) 2817 type = type->ctype.base_type; 2818 if (ctype == type) 2819 return 1; 2820 return 0; 2821 2822 String: 2823 p = alloc_expression(e->pos, EXPR_STRING); 2824 *p = *e; 2825 type = evaluate_expression(p); 2826 if (ctype->bit_size != -1) { 2827 if (ctype->bit_size + bits_in_char < type->bit_size) 2828 warning(e->pos, 2829 "too long initializer-string for array of char"); 2830 else if (Winit_cstring && ctype->bit_size + bits_in_char == type->bit_size) { 2831 warning(e->pos, 2832 "too long initializer-string for array of char(no space for nul char)"); 2833 } 2834 } 2835 *ep = p; 2836 return 1; 2837 } 2838 2839 static void evaluate_initializer(struct symbol *ctype, struct expression **ep) 2840 { 2841 struct symbol *type; 2842 int class = classify_type(ctype, &type); 2843 if (!handle_initializer(ep, 0, class, ctype, 0)) 2844 expression_error(*ep, "invalid initializer"); 2845 } 2846 2847 static struct symbol *cast_to_bool(struct expression *expr) 2848 { 2849 struct expression *old = expr->cast_expression; 2850 struct expression *zero; 2851 struct symbol *otype; 2852 int oclass = classify_type(degenerate(old), &otype); 2853 struct symbol *ctype; 2854 2855 if (oclass & TYPE_COMPOUND) 2856 return NULL; 2857 2858 zero = alloc_const_expression(expr->pos, 0); 2859 expr->op = SPECIAL_NOTEQUAL; 2860 ctype = usual_conversions(expr->op, old, zero, 2861 oclass, TYPE_NUM, otype, zero->ctype); 2862 expr->type = EXPR_COMPARE; 2863 expr->left = cast_to(old, ctype); 2864 expr->right = cast_to(zero, ctype); 2865 2866 return expr->ctype; 2867 } 2868 2869 static int cast_flags(struct expression *expr, struct expression *old) 2870 { 2871 struct symbol *t; 2872 int class; 2873 int flags = CEF_NONE; 2874 2875 class = classify_type(expr->ctype, &t); 2876 if (class & TYPE_NUM) { 2877 flags = old->flags & ~CEF_CONST_MASK; 2878 /* 2879 * Casts to numeric types never result in address 2880 * constants [6.6(9)]. 2881 */ 2882 flags &= ~CEF_ADDR; 2883 2884 /* 2885 * As an extension, treat address constants cast to 2886 * integer type as an arithmetic constant. 2887 */ 2888 if (old->flags & CEF_ADDR) 2889 flags = CEF_ACE; 2890 2891 /* 2892 * Cast to float type -> not an integer constant 2893 * expression [6.6(6)]. 2894 */ 2895 if (class & TYPE_FLOAT) 2896 flags &= ~CEF_CLR_ICE; 2897 /* 2898 * Casts of float literals to integer type results in 2899 * a constant integer expression [6.6(6)]. 2900 */ 2901 else if (old->flags & CEF_FLOAT) 2902 flags = CEF_SET_ICE; 2903 } else if (class & TYPE_PTR) { 2904 /* 2905 * Casts of integer literals to pointer type yield 2906 * address constants [6.6(9)]. 2907 * 2908 * As an extension, treat address constants cast to a 2909 * different pointer type as address constants again. 2910 * 2911 * As another extension, treat integer constant 2912 * expressions (in contrast to literals) cast to 2913 * pointer type as address constants. 2914 */ 2915 if (old->flags & (CEF_ICE | CEF_ADDR)) 2916 flags = CEF_ADDR; 2917 } 2918 2919 return flags; 2920 } 2921 2922 static struct symbol *evaluate_cast(struct expression *expr) 2923 { 2924 struct expression *source = expr->cast_expression; 2925 struct symbol *ctype; 2926 struct symbol *ttype, *stype; 2927 int tclass, sclass; 2928 struct ident *tas = NULL, *sas = NULL; 2929 2930 if (!source) 2931 return NULL; 2932 2933 /* 2934 * Special case: a cast can be followed by an 2935 * initializer, in which case we need to pass 2936 * the type value down to that initializer rather 2937 * than trying to evaluate it as an expression 2938 * 2939 * A more complex case is when the initializer is 2940 * dereferenced as part of a post-fix expression. 2941 * We need to produce an expression that can be dereferenced. 2942 */ 2943 if (source->type == EXPR_INITIALIZER) { 2944 struct symbol *sym = expr->cast_type; 2945 struct expression *addr = alloc_expression(expr->pos, EXPR_SYMBOL); 2946 2947 sym->initializer = source; 2948 evaluate_symbol(sym); 2949 2950 addr->ctype = &lazy_ptr_ctype; /* Lazy eval */ 2951 addr->symbol = sym; 2952 if (sym->ctype.modifiers & MOD_TOPLEVEL) 2953 addr->flags |= CEF_ADDR; 2954 2955 expr->type = EXPR_PREOP; 2956 expr->op = '*'; 2957 expr->unop = addr; 2958 expr->ctype = sym; 2959 2960 return sym; 2961 } 2962 2963 ctype = examine_symbol_type(expr->cast_type); 2964 expr->ctype = ctype; 2965 expr->cast_type = ctype; 2966 2967 evaluate_expression(source); 2968 degenerate(source); 2969 2970 tclass = classify_type(ctype, &ttype); 2971 2972 expr->flags = cast_flags(expr, source); 2973 2974 /* 2975 * You can always throw a value away by casting to 2976 * "void" - that's an implicit "force". Note that 2977 * the same is _not_ true of "void *". 2978 */ 2979 if (ttype == &void_ctype) 2980 goto out; 2981 2982 stype = source->ctype; 2983 if (!stype) { 2984 expression_error(expr, "cast from unknown type"); 2985 goto out; 2986 } 2987 sclass = classify_type(stype, &stype); 2988 2989 if (expr->type == EXPR_FORCE_CAST) 2990 goto out; 2991 2992 if (tclass & (TYPE_COMPOUND | TYPE_FN)) 2993 warning(expr->pos, "cast to non-scalar"); 2994 2995 if (sclass & TYPE_COMPOUND) 2996 warning(expr->pos, "cast from non-scalar"); 2997 2998 /* allowed cast unfouls */ 2999 if (sclass & TYPE_FOULED) 3000 stype = unfoul(stype); 3001 3002 if (ttype != stype) { 3003 if ((tclass & TYPE_RESTRICT) && restricted_value(source, ttype)) 3004 warning(expr->pos, "cast to %s", 3005 show_typename(ttype)); 3006 if (sclass & TYPE_RESTRICT) { 3007 if (ttype == &bool_ctype) { 3008 if (sclass & TYPE_FOULED) 3009 warning(expr->pos, "%s degrades to integer", 3010 show_typename(stype)); 3011 } else { 3012 warning(expr->pos, "cast from %s", 3013 show_typename(stype)); 3014 } 3015 } 3016 } 3017 3018 if ((ttype == &ulong_ctype || ttype == uintptr_ctype) && !Wcast_from_as) 3019 tas = &bad_address_space; 3020 else if (tclass == TYPE_PTR) { 3021 examine_pointer_target(ttype); 3022 tas = ttype->ctype.as; 3023 } 3024 3025 if ((stype == &ulong_ctype || stype == uintptr_ctype)) 3026 sas = &bad_address_space; 3027 else if (sclass == TYPE_PTR) { 3028 examine_pointer_target(stype); 3029 sas = stype->ctype.as; 3030 } 3031 3032 if (!tas && valid_as(sas)) 3033 warning(expr->pos, "cast removes address space '%s' of expression", show_as(sas)); 3034 if (valid_as(tas) && valid_as(sas) && tas != sas) 3035 warning(expr->pos, "cast between address spaces (%s -> %s)", show_as(sas), show_as(tas)); 3036 if (valid_as(tas) && !sas && 3037 !is_null_pointer_constant(source) && Wcast_to_as) 3038 warning(expr->pos, 3039 "cast adds address space '%s' to expression", show_as(tas)); 3040 3041 if (!(ttype->ctype.modifiers & MOD_PTRINHERIT) && tclass == TYPE_PTR && 3042 !tas && (source->flags & CEF_ICE)) { 3043 if (ttype->ctype.base_type == &void_ctype) { 3044 if (is_zero_constant(source)) { 3045 /* NULL */ 3046 expr->type = EXPR_VALUE; 3047 expr->ctype = &null_ctype; 3048 expr->value = 0; 3049 return expr->ctype; 3050 } 3051 } 3052 } 3053 3054 if (ttype == &bool_ctype) 3055 cast_to_bool(expr); 3056 3057 // checks pointers to restricted 3058 while (Wbitwise_pointer && tclass == TYPE_PTR && sclass == TYPE_PTR) { 3059 tclass = classify_type(ttype->ctype.base_type, &ttype); 3060 sclass = classify_type(stype->ctype.base_type, &stype); 3061 if (ttype == stype) 3062 break; 3063 if (!ttype || !stype) 3064 break; 3065 if (ttype == &void_ctype || stype == &void_ctype) 3066 break; 3067 if (tclass & TYPE_RESTRICT) { 3068 warning(expr->pos, "cast to %s", show_typename(ctype)); 3069 break; 3070 } 3071 if (sclass & TYPE_RESTRICT) { 3072 warning(expr->pos, "cast from %s", show_typename(source->ctype)); 3073 break; 3074 } 3075 } 3076 out: 3077 return ctype; 3078 } 3079 3080 /* 3081 * Evaluate a call expression with a symbol. This 3082 * should expand inline functions, and evaluate 3083 * builtins. 3084 */ 3085 static int evaluate_symbol_call(struct expression *expr) 3086 { 3087 struct expression *fn = expr->fn; 3088 struct symbol *ctype = fn->ctype; 3089 3090 if (fn->type != EXPR_PREOP) 3091 return 0; 3092 3093 if (ctype->op && ctype->op->evaluate) 3094 return ctype->op->evaluate(expr); 3095 3096 if (ctype->ctype.modifiers & MOD_INLINE) { 3097 int ret; 3098 struct symbol *curr = current_fn; 3099 3100 if (ctype->definition) 3101 ctype = ctype->definition; 3102 3103 current_fn = ctype->ctype.base_type; 3104 3105 ret = inline_function(expr, ctype); 3106 3107 /* restore the old function */ 3108 current_fn = curr; 3109 return ret; 3110 } 3111 3112 return 0; 3113 } 3114 3115 static struct symbol *evaluate_call(struct expression *expr) 3116 { 3117 int args, fnargs; 3118 struct symbol *ctype, *sym; 3119 struct expression *fn = expr->fn; 3120 struct expression_list *arglist = expr->args; 3121 3122 if (!evaluate_expression(fn)) 3123 return NULL; 3124 sym = ctype = fn->ctype; 3125 if (ctype->type == SYM_NODE) 3126 ctype = ctype->ctype.base_type; 3127 if (ctype->type == SYM_PTR) 3128 ctype = get_base_type(ctype); 3129 3130 if (ctype->type != SYM_FN) { 3131 struct expression *arg; 3132 expression_error(expr, "not a function %s", 3133 show_ident(sym->ident)); 3134 /* do typechecking in arguments */ 3135 FOR_EACH_PTR (arglist, arg) { 3136 evaluate_expression(arg); 3137 } END_FOR_EACH_PTR(arg); 3138 return NULL; 3139 } 3140 3141 examine_fn_arguments(ctype); 3142 if (sym->type == SYM_NODE && fn->type == EXPR_PREOP && 3143 sym->op && sym->op->args) { 3144 if (!sym->op->args(expr)) 3145 return NULL; 3146 } else { 3147 if (!evaluate_arguments(ctype, arglist)) 3148 return NULL; 3149 args = expression_list_size(expr->args); 3150 fnargs = symbol_list_size(ctype->arguments); 3151 if (args < fnargs) { 3152 expression_error(expr, 3153 "not enough arguments for function %s", 3154 show_ident(sym->ident)); 3155 return NULL; 3156 } 3157 if (args > fnargs && !ctype->variadic) 3158 expression_error(expr, 3159 "too many arguments for function %s", 3160 show_ident(sym->ident)); 3161 } 3162 expr->ctype = ctype->ctype.base_type; 3163 if (sym->type == SYM_NODE) { 3164 if (evaluate_symbol_call(expr)) 3165 return expr->ctype; 3166 } 3167 return expr->ctype; 3168 } 3169 3170 static struct symbol *evaluate_offsetof(struct expression *expr) 3171 { 3172 struct expression *e = expr->down; 3173 struct symbol *ctype = expr->in; 3174 int class; 3175 3176 if (expr->op == '.') { 3177 struct symbol *field; 3178 int offset = 0; 3179 if (!ctype) { 3180 expression_error(expr, "expected structure or union"); 3181 return NULL; 3182 } 3183 examine_symbol_type(ctype); 3184 class = classify_type(ctype, &ctype); 3185 if (class != TYPE_COMPOUND) { 3186 expression_error(expr, "expected structure or union"); 3187 return NULL; 3188 } 3189 3190 field = find_identifier(expr->ident, ctype->symbol_list, &offset); 3191 if (!field) { 3192 expression_error(expr, "unknown member"); 3193 return NULL; 3194 } 3195 ctype = field; 3196 expr->type = EXPR_VALUE; 3197 expr->flags = CEF_SET_ICE; 3198 expr->value = offset; 3199 expr->taint = 0; 3200 expr->ctype = size_t_ctype; 3201 } else { 3202 if (!ctype) { 3203 expression_error(expr, "expected structure or union"); 3204 return NULL; 3205 } 3206 examine_symbol_type(ctype); 3207 class = classify_type(ctype, &ctype); 3208 if (class != (TYPE_COMPOUND | TYPE_PTR)) { 3209 expression_error(expr, "expected array"); 3210 return NULL; 3211 } 3212 ctype = ctype->ctype.base_type; 3213 if (!expr->index) { 3214 expr->type = EXPR_VALUE; 3215 expr->flags = CEF_SET_ICE; 3216 expr->value = 0; 3217 expr->taint = 0; 3218 expr->ctype = size_t_ctype; 3219 } else { 3220 struct expression *idx = expr->index, *m; 3221 struct symbol *i_type = evaluate_expression(idx); 3222 unsigned old_idx_flags; 3223 int i_class = classify_type(i_type, &i_type); 3224 3225 if (!is_int(i_class)) { 3226 expression_error(expr, "non-integer index"); 3227 return NULL; 3228 } 3229 unrestrict(idx, i_class, &i_type); 3230 old_idx_flags = idx->flags; 3231 idx = cast_to(idx, size_t_ctype); 3232 idx->flags = old_idx_flags; 3233 m = alloc_const_expression(expr->pos, 3234 bits_to_bytes(ctype->bit_size)); 3235 m->ctype = size_t_ctype; 3236 m->flags = CEF_SET_INT; 3237 expr->type = EXPR_BINOP; 3238 expr->left = idx; 3239 expr->right = m; 3240 expr->op = '*'; 3241 expr->ctype = size_t_ctype; 3242 expr->flags = m->flags & idx->flags & ~CEF_CONST_MASK; 3243 } 3244 } 3245 if (e) { 3246 struct expression *copy = __alloc_expression(0); 3247 *copy = *expr; 3248 if (e->type == EXPR_OFFSETOF) 3249 e->in = ctype; 3250 if (!evaluate_expression(e)) 3251 return NULL; 3252 expr->type = EXPR_BINOP; 3253 expr->flags = e->flags & copy->flags & ~CEF_CONST_MASK; 3254 expr->op = '+'; 3255 expr->ctype = size_t_ctype; 3256 expr->left = copy; 3257 expr->right = e; 3258 } 3259 return size_t_ctype; 3260 } 3261 3262 struct symbol *evaluate_expression(struct expression *expr) 3263 { 3264 if (!expr) 3265 return NULL; 3266 if (expr->ctype) 3267 return expr->ctype; 3268 3269 switch (expr->type) { 3270 case EXPR_VALUE: 3271 case EXPR_FVALUE: 3272 expression_error(expr, "value expression without a type"); 3273 return NULL; 3274 case EXPR_STRING: 3275 return evaluate_string(expr); 3276 case EXPR_SYMBOL: 3277 return evaluate_symbol_expression(expr); 3278 case EXPR_BINOP: 3279 evaluate_expression(expr->left); 3280 evaluate_expression(expr->right); 3281 if (!valid_subexpr_type(expr)) 3282 return NULL; 3283 return evaluate_binop(expr); 3284 case EXPR_LOGICAL: 3285 return evaluate_logical(expr); 3286 case EXPR_COMMA: 3287 evaluate_expression(expr->left); 3288 if (!evaluate_expression(expr->right)) 3289 return NULL; 3290 return evaluate_comma(expr); 3291 case EXPR_COMPARE: 3292 evaluate_expression(expr->left); 3293 evaluate_expression(expr->right); 3294 if (!valid_subexpr_type(expr)) 3295 return NULL; 3296 return evaluate_compare(expr); 3297 case EXPR_ASSIGNMENT: 3298 evaluate_expression(expr->left); 3299 evaluate_expression(expr->right); 3300 if (!valid_subexpr_type(expr)) 3301 return NULL; 3302 return evaluate_assignment(expr); 3303 case EXPR_PREOP: 3304 if (!evaluate_expression(expr->unop)) 3305 return NULL; 3306 return evaluate_preop(expr); 3307 case EXPR_POSTOP: 3308 if (!evaluate_expression(expr->unop)) 3309 return NULL; 3310 return evaluate_postop(expr); 3311 case EXPR_CAST: 3312 case EXPR_FORCE_CAST: 3313 case EXPR_IMPLIED_CAST: 3314 return evaluate_cast(expr); 3315 case EXPR_SIZEOF: 3316 return evaluate_sizeof(expr); 3317 case EXPR_PTRSIZEOF: 3318 return evaluate_ptrsizeof(expr); 3319 case EXPR_ALIGNOF: 3320 return evaluate_alignof(expr); 3321 case EXPR_DEREF: 3322 return evaluate_member_dereference(expr); 3323 case EXPR_CALL: 3324 return evaluate_call(expr); 3325 case EXPR_SELECT: 3326 case EXPR_CONDITIONAL: 3327 return evaluate_conditional_expression(expr); 3328 case EXPR_STATEMENT: 3329 expr->ctype = evaluate_statement(expr->statement); 3330 return expr->ctype; 3331 3332 case EXPR_LABEL: 3333 expr->ctype = &ptr_ctype; 3334 return &ptr_ctype; 3335 3336 case EXPR_TYPE: 3337 /* Evaluate the type of the symbol .. */ 3338 evaluate_symbol(expr->symbol); 3339 /* .. but the type of the _expression_ is a "type" */ 3340 expr->ctype = &type_ctype; 3341 return &type_ctype; 3342 3343 case EXPR_OFFSETOF: 3344 return evaluate_offsetof(expr); 3345 3346 /* These can not exist as stand-alone expressions */ 3347 case EXPR_INITIALIZER: 3348 case EXPR_IDENTIFIER: 3349 case EXPR_INDEX: 3350 case EXPR_POS: 3351 expression_error(expr, "internal front-end error: initializer in expression"); 3352 return NULL; 3353 case EXPR_SLICE: 3354 expression_error(expr, "internal front-end error: SLICE re-evaluated"); 3355 return NULL; 3356 case EXPR_ASM_OPERAND: 3357 expression_error(expr, "internal front-end error: ASM_OPERAND evaluated"); 3358 return NULL; 3359 } 3360 return NULL; 3361 } 3362 3363 void check_duplicates(struct symbol *sym) 3364 { 3365 int declared = 0; 3366 struct symbol *next = sym; 3367 int initialized = sym->initializer != NULL; 3368 3369 while ((next = next->same_symbol) != NULL) { 3370 const char *typediff; 3371 evaluate_symbol(next); 3372 if (initialized && next->initializer) { 3373 sparse_error(sym->pos, "symbol '%s' has multiple initializers (originally initialized at %s:%d)", 3374 show_ident(sym->ident), 3375 stream_name(next->pos.stream), next->pos.line); 3376 /* Only warn once */ 3377 initialized = 0; 3378 } 3379 declared++; 3380 typediff = type_difference(&sym->ctype, &next->ctype, 0, 0); 3381 if (typediff) { 3382 sparse_error(sym->pos, "symbol '%s' redeclared with different type (originally declared at %s:%d) - %s", 3383 show_ident(sym->ident), 3384 stream_name(next->pos.stream), next->pos.line, typediff); 3385 return; 3386 } 3387 } 3388 if (!declared) { 3389 unsigned long mod = sym->ctype.modifiers; 3390 if (mod & (MOD_STATIC | MOD_REGISTER | MOD_EXT_VISIBLE)) 3391 return; 3392 if (!(mod & MOD_TOPLEVEL)) 3393 return; 3394 if (!Wdecl) 3395 return; 3396 if (sym->ident == &main_ident) 3397 return; 3398 warning(sym->pos, "symbol '%s' was not declared. Should it be static?", show_ident(sym->ident)); 3399 } 3400 } 3401 3402 static struct symbol *evaluate_symbol(struct symbol *sym) 3403 { 3404 struct symbol *base_type; 3405 3406 if (!sym) 3407 return sym; 3408 if (sym->evaluated) 3409 return sym; 3410 sym->evaluated = 1; 3411 3412 sym = examine_symbol_type(sym); 3413 base_type = get_base_type(sym); 3414 if (!base_type) 3415 return NULL; 3416 3417 /* Evaluate the initializers */ 3418 if (sym->initializer) 3419 evaluate_initializer(sym, &sym->initializer); 3420 3421 /* And finally, evaluate the body of the symbol too */ 3422 if (base_type->type == SYM_FN) { 3423 struct symbol *curr = current_fn; 3424 3425 if (sym->definition && sym->definition != sym) 3426 return evaluate_symbol(sym->definition); 3427 3428 current_fn = base_type; 3429 3430 examine_fn_arguments(base_type); 3431 if (!base_type->stmt && base_type->inline_stmt) 3432 uninline(sym); 3433 if (base_type->stmt) 3434 evaluate_statement(base_type->stmt); 3435 3436 current_fn = curr; 3437 } 3438 3439 return base_type; 3440 } 3441 3442 void evaluate_symbol_list(struct symbol_list *list) 3443 { 3444 struct symbol *sym; 3445 3446 FOR_EACH_PTR(list, sym) { 3447 has_error &= ~ERROR_CURR_PHASE; 3448 evaluate_symbol(sym); 3449 check_duplicates(sym); 3450 } END_FOR_EACH_PTR(sym); 3451 } 3452 3453 static struct symbol *evaluate_return_expression(struct statement *stmt) 3454 { 3455 struct expression *expr = stmt->expression; 3456 struct symbol *fntype; 3457 3458 evaluate_expression(expr); 3459 fntype = current_fn->ctype.base_type; 3460 if (!fntype || fntype == &void_ctype) { 3461 if (expr && expr->ctype != &void_ctype) 3462 expression_error(expr, "return expression in %s function", fntype?"void":"typeless"); 3463 if (expr && Wreturn_void) 3464 warning(stmt->pos, "returning void-valued expression"); 3465 return NULL; 3466 } 3467 3468 if (!expr) { 3469 sparse_error(stmt->pos, "return with no return value"); 3470 return NULL; 3471 } 3472 if (!expr->ctype) 3473 return NULL; 3474 compatible_assignment_types(expr, fntype, &stmt->expression, "return expression"); 3475 return NULL; 3476 } 3477 3478 static void evaluate_if_statement(struct statement *stmt) 3479 { 3480 if (!stmt->if_conditional) 3481 return; 3482 3483 evaluate_conditional(stmt->if_conditional, 0); 3484 evaluate_statement(stmt->if_true); 3485 evaluate_statement(stmt->if_false); 3486 } 3487 3488 static void evaluate_iterator(struct statement *stmt) 3489 { 3490 evaluate_symbol_list(stmt->iterator_syms); 3491 evaluate_conditional(stmt->iterator_pre_condition, 1); 3492 evaluate_conditional(stmt->iterator_post_condition,1); 3493 evaluate_statement(stmt->iterator_pre_statement); 3494 evaluate_statement(stmt->iterator_statement); 3495 evaluate_statement(stmt->iterator_post_statement); 3496 } 3497 3498 static void verify_output_constraint(struct expression *expr, const char *constraint) 3499 { 3500 switch (*constraint) { 3501 case '=': /* Assignment */ 3502 case '+': /* Update */ 3503 break; 3504 default: 3505 expression_error(expr, "output constraint is not an assignment constraint (\"%s\")", constraint); 3506 } 3507 } 3508 3509 static void verify_input_constraint(struct expression *expr, const char *constraint) 3510 { 3511 switch (*constraint) { 3512 case '=': /* Assignment */ 3513 case '+': /* Update */ 3514 expression_error(expr, "input constraint with assignment (\"%s\")", constraint); 3515 } 3516 } 3517 3518 static void evaluate_asm_statement(struct statement *stmt) 3519 { 3520 struct expression *expr; 3521 struct expression *op; 3522 struct symbol *sym; 3523 3524 expr = stmt->asm_string; 3525 if (!expr || expr->type != EXPR_STRING) { 3526 sparse_error(stmt->pos, "need constant string for inline asm"); 3527 return; 3528 } 3529 3530 FOR_EACH_PTR(stmt->asm_outputs, op) { 3531 /* Identifier */ 3532 3533 /* Constraint */ 3534 expr = op->constraint; 3535 if (!expr || expr->type != EXPR_STRING) { 3536 sparse_error(expr ? expr->pos : stmt->pos, "asm output constraint is not a string"); 3537 op->constraint = NULL; 3538 } else 3539 verify_output_constraint(expr, expr->string->data); 3540 3541 /* Expression */ 3542 expr = op->expr; 3543 if (!evaluate_expression(expr)) 3544 return; 3545 if (!lvalue_expression(expr)) 3546 warning(expr->pos, "asm output is not an lvalue"); 3547 evaluate_assign_to(expr, expr->ctype); 3548 } END_FOR_EACH_PTR(op); 3549 3550 FOR_EACH_PTR(stmt->asm_inputs, op) { 3551 /* Identifier */ 3552 3553 /* Constraint */ 3554 expr = op->constraint; 3555 if (!expr || expr->type != EXPR_STRING) { 3556 sparse_error(expr ? expr->pos : stmt->pos, "asm input constraint is not a string"); 3557 op->constraint = NULL; 3558 } else 3559 verify_input_constraint(expr, expr->string->data); 3560 3561 /* Expression */ 3562 if (!evaluate_expression(op->expr)) 3563 return; 3564 } END_FOR_EACH_PTR(op); 3565 3566 FOR_EACH_PTR(stmt->asm_clobbers, expr) { 3567 if (!expr) { 3568 sparse_error(stmt->pos, "bad asm clobbers"); 3569 return; 3570 } 3571 if (expr->type == EXPR_STRING) 3572 continue; 3573 expression_error(expr, "asm clobber is not a string"); 3574 } END_FOR_EACH_PTR(expr); 3575 3576 FOR_EACH_PTR(stmt->asm_labels, sym) { 3577 if (!sym || sym->type != SYM_LABEL) { 3578 sparse_error(stmt->pos, "bad asm label"); 3579 return; 3580 } 3581 } END_FOR_EACH_PTR(sym); 3582 } 3583 3584 static void evaluate_case_statement(struct statement *stmt) 3585 { 3586 evaluate_expression(stmt->case_expression); 3587 evaluate_expression(stmt->case_to); 3588 evaluate_statement(stmt->case_statement); 3589 } 3590 3591 static void check_case_type(struct expression *switch_expr, 3592 struct expression *case_expr, 3593 struct expression **enumcase) 3594 { 3595 struct symbol *switch_type, *case_type; 3596 int sclass, cclass; 3597 3598 if (!case_expr) 3599 return; 3600 3601 switch_type = switch_expr->ctype; 3602 case_type = evaluate_expression(case_expr); 3603 3604 if (!switch_type || !case_type) 3605 goto Bad; 3606 if (enumcase) { 3607 if (*enumcase) 3608 warn_for_different_enum_types(case_expr->pos, case_type, (*enumcase)->ctype); 3609 else if (is_enum_type(case_type)) 3610 *enumcase = case_expr; 3611 } 3612 3613 sclass = classify_type(switch_type, &switch_type); 3614 cclass = classify_type(case_type, &case_type); 3615 3616 /* both should be arithmetic */ 3617 if (!(sclass & cclass & TYPE_NUM)) 3618 goto Bad; 3619 3620 /* neither should be floating */ 3621 if ((sclass | cclass) & TYPE_FLOAT) 3622 goto Bad; 3623 3624 /* if neither is restricted, we are OK */ 3625 if (!((sclass | cclass) & TYPE_RESTRICT)) 3626 return; 3627 3628 if (!restricted_binop_type(SPECIAL_EQUAL, case_expr, switch_expr, 3629 cclass, sclass, case_type, switch_type)) { 3630 unrestrict(case_expr, cclass, &case_type); 3631 unrestrict(switch_expr, sclass, &switch_type); 3632 } 3633 return; 3634 3635 Bad: 3636 expression_error(case_expr, "incompatible types for 'case' statement"); 3637 } 3638 3639 static void evaluate_switch_statement(struct statement *stmt) 3640 { 3641 struct symbol *sym; 3642 struct expression *enumcase = NULL; 3643 struct expression **enumcase_holder = &enumcase; 3644 struct expression *sel = stmt->switch_expression; 3645 3646 evaluate_expression(sel); 3647 evaluate_statement(stmt->switch_statement); 3648 if (!sel) 3649 return; 3650 if (sel->ctype && is_enum_type(sel->ctype)) 3651 enumcase_holder = NULL; /* Only check cases against switch */ 3652 3653 FOR_EACH_PTR(stmt->switch_case->symbol_list, sym) { 3654 struct statement *case_stmt = sym->stmt; 3655 check_case_type(sel, case_stmt->case_expression, enumcase_holder); 3656 check_case_type(sel, case_stmt->case_to, enumcase_holder); 3657 } END_FOR_EACH_PTR(sym); 3658 } 3659 3660 static void evaluate_goto_statement(struct statement *stmt) 3661 { 3662 struct symbol *label = stmt->goto_label; 3663 3664 if (label && !label->stmt && label->ident && !lookup_keyword(label->ident, NS_KEYWORD)) 3665 sparse_error(stmt->pos, "label '%s' was not declared", show_ident(label->ident)); 3666 3667 evaluate_expression(stmt->goto_expression); 3668 } 3669 3670 struct symbol *evaluate_statement(struct statement *stmt) 3671 { 3672 if (!stmt) 3673 return NULL; 3674 3675 switch (stmt->type) { 3676 case STMT_DECLARATION: { 3677 struct symbol *s; 3678 FOR_EACH_PTR(stmt->declaration, s) { 3679 evaluate_symbol(s); 3680 } END_FOR_EACH_PTR(s); 3681 return NULL; 3682 } 3683 3684 case STMT_RETURN: 3685 return evaluate_return_expression(stmt); 3686 3687 case STMT_EXPRESSION: 3688 if (!evaluate_expression(stmt->expression)) 3689 return NULL; 3690 if (stmt->expression->ctype == &null_ctype) 3691 stmt->expression = cast_to(stmt->expression, &ptr_ctype); 3692 return degenerate(stmt->expression); 3693 3694 case STMT_COMPOUND: { 3695 struct statement *s; 3696 struct symbol *type = NULL; 3697 3698 /* Evaluate the return symbol in the compound statement */ 3699 evaluate_symbol(stmt->ret); 3700 3701 /* 3702 * Then, evaluate each statement, making the type of the 3703 * compound statement be the type of the last statement 3704 */ 3705 type = evaluate_statement(stmt->args); 3706 FOR_EACH_PTR(stmt->stmts, s) { 3707 type = evaluate_statement(s); 3708 } END_FOR_EACH_PTR(s); 3709 if (!type) 3710 type = &void_ctype; 3711 return type; 3712 } 3713 case STMT_IF: 3714 evaluate_if_statement(stmt); 3715 return NULL; 3716 case STMT_ITERATOR: 3717 evaluate_iterator(stmt); 3718 return NULL; 3719 case STMT_SWITCH: 3720 evaluate_switch_statement(stmt); 3721 return NULL; 3722 case STMT_CASE: 3723 evaluate_case_statement(stmt); 3724 return NULL; 3725 case STMT_LABEL: 3726 return evaluate_statement(stmt->label_statement); 3727 case STMT_GOTO: 3728 evaluate_goto_statement(stmt); 3729 return NULL; 3730 case STMT_NONE: 3731 break; 3732 case STMT_ASM: 3733 evaluate_asm_statement(stmt); 3734 return NULL; 3735 case STMT_CONTEXT: 3736 evaluate_expression(stmt->expression); 3737 return NULL; 3738 case STMT_RANGE: 3739 evaluate_expression(stmt->range_expression); 3740 evaluate_expression(stmt->range_low); 3741 evaluate_expression(stmt->range_high); 3742 return NULL; 3743 } 3744 return NULL; 3745 }