1 #include "cc.h" 2 3 Node* 4 new(int t, Node *l, Node *r) 5 { 6 Node *n; 7 8 n = alloc(sizeof(*n)); 9 n->op = t; 10 n->left = l; 11 n->right = r; 12 if(l && t != OGOTO) 13 n->lineno = l->lineno; 14 else if(r) 15 n->lineno = r->lineno; 16 else 17 n->lineno = lineno; 18 newflag = 1; 19 return n; 20 } 21 22 Node* 23 new1(int o, Node *l, Node *r) 24 { 25 Node *n; 26 27 n = new(o, l, r); 28 n->lineno = nearln; 29 return n; 30 } 31 32 void 33 prtree(Node *n, char *s) 34 { 35 36 print(" == %s ==\n", s); 37 prtree1(n, 0, 0); 38 print("\n"); 39 } 40 41 void 42 prtree1(Node *n, int d, int f) 43 { 44 int i; 45 46 if(f) 47 for(i=0; i<d; i++) 48 print(" "); 49 if(n == Z) { 50 print("Z\n"); 51 return; 52 } 53 if(n->op == OLIST) { 54 prtree1(n->left, d, 0); 55 prtree1(n->right, d, 1); 56 return; 57 } 58 d++; 59 print("%O", n->op); 60 i = 3; 61 switch(n->op) 62 { 63 case ONAME: 64 print(" \"%F\"", n); 65 print(" %ld", n->xoffset); 66 i = 0; 67 break; 68 69 case OINDREG: 70 print(" %ld(R%d)", n->xoffset, n->reg); 71 i = 0; 72 break; 73 74 case OREGISTER: 75 if(n->xoffset) 76 print(" %ld+R%d", n->xoffset, n->reg); 77 else 78 print(" R%d", n->reg); 79 i = 0; 80 break; 81 82 case OSTRING: 83 print(" \"%s\"", n->cstring); 84 i = 0; 85 break; 86 87 case OLSTRING: 88 if(sizeof(TRune) == sizeof(Rune)) 89 print(" \"%S\"", (Rune*)n->rstring); 90 else 91 print(" \"...\""); 92 i = 0; 93 break; 94 95 case ODOT: 96 case OELEM: 97 print(" \"%F\"", n); 98 break; 99 100 case OCONST: 101 if(typefd[n->type->etype]) 102 print(" \"%.8e\"", n->fconst); 103 else 104 print(" \"%lld\"", n->vconst); 105 i = 0; 106 break; 107 } 108 if(n->addable != 0) 109 print(" <%d>", n->addable); 110 if(n->type != T) 111 print(" %T", n->type); 112 if(n->complex != 0) 113 print(" (%d)", n->complex); 114 print(" %L\n", n->lineno); 115 if(i & 2) 116 prtree1(n->left, d, 1); 117 if(i & 1) 118 prtree1(n->right, d, 1); 119 } 120 121 Type* 122 typ(int et, Type *d) 123 { 124 Type *t; 125 126 t = alloc(sizeof(*t)); 127 t->etype = et; 128 t->link = d; 129 t->down = T; 130 t->sym = S; 131 t->width = ewidth[et]; 132 t->offset = 0; 133 t->shift = 0; 134 t->nbits = 0; 135 t->garb = 0; 136 return t; 137 } 138 139 Type* 140 copytyp(Type *t) 141 { 142 Type *nt; 143 144 nt = typ(TXXX, T); 145 *nt = *t; 146 return nt; 147 } 148 149 Type* 150 garbt(Type *t, long b) 151 { 152 Type *t1; 153 154 if(b & BGARB) { 155 t1 = copytyp(t); 156 t1->garb = simpleg(b); 157 return t1; 158 } 159 return t; 160 } 161 162 int 163 simpleg(long b) 164 { 165 166 b &= BGARB; 167 switch(b) { 168 case BCONSTNT: 169 return GCONSTNT; 170 case BVOLATILE: 171 return GVOLATILE; 172 case BVOLATILE|BCONSTNT: 173 return GCONSTNT|GVOLATILE; 174 } 175 return GXXX; 176 } 177 178 int 179 simplec(long b) 180 { 181 182 b &= BCLASS; 183 switch(b) { 184 case 0: 185 case BREGISTER: 186 return CXXX; 187 case BAUTO: 188 case BAUTO|BREGISTER: 189 return CAUTO; 190 case BEXTERN: 191 return CEXTERN; 192 case BEXTERN|BREGISTER: 193 return CEXREG; 194 case BSTATIC: 195 return CSTATIC; 196 case BTYPEDEF: 197 return CTYPEDEF; 198 case BTYPESTR: 199 return CTYPESTR; 200 } 201 diag(Z, "illegal combination of classes %Q", b); 202 return CXXX; 203 } 204 205 Type* 206 simplet(long b) 207 { 208 209 b &= ~BCLASS & ~BGARB; 210 switch(b) { 211 case BCHAR: 212 case BCHAR|BSIGNED: 213 return types[TCHAR]; 214 215 case BCHAR|BUNSIGNED: 216 return types[TUCHAR]; 217 218 case BSHORT: 219 case BSHORT|BINT: 220 case BSHORT|BSIGNED: 221 case BSHORT|BINT|BSIGNED: 222 return types[TSHORT]; 223 224 case BUNSIGNED|BSHORT: 225 case BUNSIGNED|BSHORT|BINT: 226 return types[TUSHORT]; 227 228 case 0: 229 case BINT: 230 case BINT|BSIGNED: 231 case BSIGNED: 232 return types[TINT]; 233 234 case BUNSIGNED: 235 case BUNSIGNED|BINT: 236 return types[TUINT]; 237 238 case BLONG: 239 case BLONG|BINT: 240 case BLONG|BSIGNED: 241 case BLONG|BINT|BSIGNED: 242 return types[TLONG]; 243 244 case BUNSIGNED|BLONG: 245 case BUNSIGNED|BLONG|BINT: 246 return types[TULONG]; 247 248 case BVLONG|BLONG: 249 case BVLONG|BLONG|BINT: 250 case BVLONG|BLONG|BSIGNED: 251 case BVLONG|BLONG|BINT|BSIGNED: 252 return types[TVLONG]; 253 254 case BVLONG|BLONG|BUNSIGNED: 255 case BVLONG|BLONG|BINT|BUNSIGNED: 256 return types[TUVLONG]; 257 258 case BFLOAT: 259 return types[TFLOAT]; 260 261 case BDOUBLE: 262 case BDOUBLE|BLONG: 263 case BFLOAT|BLONG: 264 return types[TDOUBLE]; 265 266 case BVOID: 267 return types[TVOID]; 268 } 269 270 diag(Z, "illegal combination of types %Q", b); 271 return types[TINT]; 272 } 273 274 int 275 stcompat(Node *n, Type *t1, Type *t2, long ttab[]) 276 { 277 int i; 278 ulong b; 279 280 i = 0; 281 if(t2 != T) 282 i = t2->etype; 283 b = 1L << i; 284 i = 0; 285 if(t1 != T) 286 i = t1->etype; 287 if(b & ttab[i]) { 288 if(ttab == tasign) 289 if(b == BSTRUCT || b == BUNION) 290 if(!sametype(t1, t2)) 291 return 1; 292 if(n->op != OCAST) 293 if(b == BIND && i == TIND) 294 if(!sametype(t1, t2)) 295 return 1; 296 return 0; 297 } 298 return 1; 299 } 300 301 int 302 tcompat(Node *n, Type *t1, Type *t2, long ttab[]) 303 { 304 305 if(stcompat(n, t1, t2, ttab)) { 306 if(t1 == T) 307 diag(n, "incompatible type: \"%T\" for op \"%O\"", 308 t2, n->op); 309 else 310 diag(n, "incompatible types: \"%T\" and \"%T\" for op \"%O\"", 311 t1, t2, n->op); 312 return 1; 313 } 314 return 0; 315 } 316 317 void 318 makedot(Node *n, Type *t, long o) 319 { 320 Node *n1, *n2; 321 322 if(t->nbits) { 323 n1 = new(OXXX, Z, Z); 324 *n1 = *n; 325 n->op = OBIT; 326 n->left = n1; 327 n->right = Z; 328 n->type = t; 329 n->addable = n1->left->addable; 330 n = n1; 331 } 332 n->addable = n->left->addable; 333 if(n->addable == 0) { 334 n1 = new1(OCONST, Z, Z); 335 n1->vconst = o; 336 n1->type = types[TLONG]; 337 n->right = n1; 338 n->type = t; 339 return; 340 } 341 n->left->type = t; 342 if(o == 0) { 343 *n = *n->left; 344 return; 345 } 346 n->type = t; 347 n1 = new1(OCONST, Z, Z); 348 n1->vconst = o; 349 t = typ(TIND, t); 350 t->width = types[TIND]->width; 351 n1->type = t; 352 353 n2 = new1(OADDR, n->left, Z); 354 n2->type = t; 355 356 n1 = new1(OADD, n1, n2); 357 n1->type = t; 358 359 n->op = OIND; 360 n->left = n1; 361 n->right = Z; 362 } 363 364 Type* 365 dotsearch(Sym *s, Type *t, Node *n, long *off) 366 { 367 Type *t1, *xt, *rt; 368 369 xt = T; 370 371 /* 372 * look it up by name 373 */ 374 for(t1 = t; t1 != T; t1 = t1->down) 375 if(t1->sym == s) { 376 if(xt != T) 377 goto ambig; 378 xt = t1; 379 } 380 381 /* 382 * look it up by type 383 */ 384 if(s->class == CTYPEDEF || s->class == CTYPESTR) 385 for(t1 = t; t1 != T; t1 = t1->down) 386 if(t1->sym == S && typesu[t1->etype]) 387 if(sametype(s->type, t1)) { 388 if(xt != T) 389 goto ambig; 390 xt = t1; 391 } 392 if(xt != T) { 393 *off = xt->offset; 394 return xt; 395 } 396 397 /* 398 * look it up in unnamed substructures 399 */ 400 for(t1 = t; t1 != T; t1 = t1->down) 401 if(t1->sym == S && typesu[t1->etype]){ 402 rt = dotsearch(s, t1->link, n, off); 403 if(rt != T) { 404 if(xt != T) 405 goto ambig; 406 xt = rt; 407 *off += t1->offset; 408 } 409 } 410 return xt; 411 412 ambig: 413 diag(n, "ambiguous structure element: %s", s->name); 414 return xt; 415 } 416 417 long 418 dotoffset(Type *st, Type *lt, Node *n) 419 { 420 Type *t; 421 Sym *g; 422 long o, o1; 423 424 o = -1; 425 /* 426 * first try matching at the top level 427 * for matching tag names 428 */ 429 g = st->tag; 430 if(g != S) 431 for(t=lt->link; t!=T; t=t->down) 432 if(t->sym == S) 433 if(g == t->tag) { 434 if(o >= 0) 435 goto ambig; 436 o = t->offset; 437 } 438 if(o >= 0) 439 return o; 440 441 /* 442 * second try matching at the top level 443 * for similar types 444 */ 445 for(t=lt->link; t!=T; t=t->down) 446 if(t->sym == S) 447 if(sametype(st, t)) { 448 if(o >= 0) 449 goto ambig; 450 o = t->offset; 451 } 452 if(o >= 0) 453 return o; 454 455 /* 456 * last try matching sub-levels 457 */ 458 for(t=lt->link; t!=T; t=t->down) 459 if(t->sym == S) 460 if(typesu[t->etype]) { 461 o1 = dotoffset(st, t, n); 462 if(o1 >= 0) { 463 if(o >= 0) 464 goto ambig; 465 o = o1 + t->offset; 466 } 467 } 468 return o; 469 470 ambig: 471 diag(n, "ambiguous unnamed structure element"); 472 return o; 473 } 474 475 /* 476 * look into tree for floating point constant expressions 477 */ 478 int 479 allfloat(Node *n, int flag) 480 { 481 482 if(n != Z) { 483 if(n->type->etype != TDOUBLE) 484 return 1; 485 switch(n->op) { 486 case OCONST: 487 if(flag) 488 n->type = types[TFLOAT]; 489 return 1; 490 case OADD: /* no need to get more exotic than this */ 491 case OSUB: 492 case OMUL: 493 case ODIV: 494 if(!allfloat(n->right, flag)) 495 break; 496 case OCAST: 497 if(!allfloat(n->left, flag)) 498 break; 499 if(flag) 500 n->type = types[TFLOAT]; 501 return 1; 502 } 503 } 504 return 0; 505 } 506 507 void 508 constas(Node *n, Type *il, Type *ir) 509 { 510 Type *l, *r; 511 512 l = il; 513 r = ir; 514 515 if(l == T) 516 return; 517 if(l->garb & GCONSTNT) { 518 warn(n, "assignment to a constant type (%T)", il); 519 return; 520 } 521 if(r == T) 522 return; 523 for(;;) { 524 if(l->etype != TIND || r->etype != TIND) 525 break; 526 l = l->link; 527 r = r->link; 528 if(l == T || r == T) 529 break; 530 if(r->garb & GCONSTNT) 531 if(!(l->garb & GCONSTNT)) { 532 warn(n, "assignment of a constant pointer type (%T)", ir); 533 break; 534 } 535 } 536 } 537 538 void 539 typeext1(Type *st, Node *l) 540 { 541 if(st->etype == TFLOAT && allfloat(l, 0)) 542 allfloat(l, 1); 543 } 544 545 void 546 typeext(Type *st, Node *l) 547 { 548 Type *lt; 549 Node *n1, *n2; 550 long o; 551 552 lt = l->type; 553 if(lt == T) 554 return; 555 if(st->etype == TIND && vconst(l) == 0) { 556 l->type = st; 557 l->vconst = 0; 558 return; 559 } 560 typeext1(st, l); 561 562 /* 563 * extension of C 564 * if assign of struct containing unnamed sub-struct 565 * to type of sub-struct, insert the DOT. 566 * if assign of *struct containing unnamed substruct 567 * to type of *sub-struct, insert the add-offset 568 */ 569 if(typesu[st->etype] && typesu[lt->etype]) { 570 o = dotoffset(st, lt, l); 571 if(o >= 0) { 572 n1 = new1(OXXX, Z, Z); 573 *n1 = *l; 574 l->op = ODOT; 575 l->left = n1; 576 l->right = Z; 577 makedot(l, st, o); 578 } 579 return; 580 } 581 if(st->etype == TIND && typesu[st->link->etype]) 582 if(lt->etype == TIND && typesu[lt->link->etype]) { 583 o = dotoffset(st->link, lt->link, l); 584 if(o >= 0) { 585 l->type = st; 586 if(o == 0) 587 return; 588 n1 = new1(OXXX, Z, Z); 589 *n1 = *l; 590 n2 = new1(OCONST, Z, Z); 591 n2->vconst = o; 592 n2->type = st; 593 l->op = OADD; 594 l->left = n1; 595 l->right = n2; 596 } 597 return; 598 } 599 } 600 601 /* 602 * a cast that generates no code 603 * (same size move) 604 */ 605 int 606 nocast(Type *t1, Type *t2) 607 { 608 int i, b; 609 610 if(t1->nbits) 611 return 0; 612 i = 0; 613 if(t2 != T) 614 i = t2->etype; 615 b = 1<<i; 616 i = 0; 617 if(t1 != T) 618 i = t1->etype; 619 if(b & ncast[i]) 620 return 1; 621 return 0; 622 } 623 624 /* 625 * a cast that has a noop semantic 626 * (small to large, convert) 627 */ 628 int 629 nilcast(Type *t1, Type *t2) 630 { 631 int et1, et2; 632 633 if(t1 == T) 634 return 0; 635 if(t1->nbits) 636 return 0; 637 if(t2 == T) 638 return 0; 639 et1 = t1->etype; 640 et2 = t2->etype; 641 if(et1 == et2) 642 return 1; 643 if(typefd[et1] && typefd[et2]) { 644 if(ewidth[et1] < ewidth[et2]) 645 return 1; 646 return 0; 647 } 648 if(typechlp[et1] && typechlp[et2]) { 649 if(ewidth[et1] < ewidth[et2]) 650 return 1; 651 return 0; 652 } 653 return 0; 654 } 655 656 /* 657 * "the usual arithmetic conversions are performed" 658 */ 659 void 660 arith(Node *n, int f) 661 { 662 Type *t1, *t2; 663 int i, j, k; 664 Node *n1; 665 long w; 666 667 t1 = n->left->type; 668 if(n->right == Z) 669 t2 = t1; 670 else 671 t2 = n->right->type; 672 i = TXXX; 673 if(t1 != T) 674 i = t1->etype; 675 j = TXXX; 676 if(t2 != T) 677 j = t2->etype; 678 k = tab[i][j]; 679 if(k == TIND) { 680 if(i == TIND) 681 n->type = t1; 682 else 683 if(j == TIND) 684 n->type = t2; 685 } else { 686 /* convert up to at least int */ 687 if(f == 1) 688 while(k < TINT) 689 k += 2; 690 n->type = types[k]; 691 } 692 if(n->op == OSUB) 693 if(i == TIND && j == TIND) { 694 w = n->right->type->link->width; 695 if(w < 1 || n->left->type->link == T || n->left->type->link->width < 1) 696 goto bad; 697 n->type = types[ewidth[TIND] <= ewidth[TLONG]? TLONG: TVLONG]; 698 if(1 && ewidth[TIND] > ewidth[TLONG]){ 699 n1 = new1(OXXX, Z, Z); 700 *n1 = *n; 701 n->op = OCAST; 702 n->left = n1; 703 n->right = Z; 704 n->type = types[TLONG]; 705 } 706 if(w > 1) { 707 n1 = new1(OXXX, Z, Z); 708 *n1 = *n; 709 n->op = ODIV; 710 n->left = n1; 711 n1 = new1(OCONST, Z, Z); 712 n1->vconst = w; 713 n1->type = n->type; 714 n->right = n1; 715 w = vlog(n1); 716 if(w >= 0) { 717 n->op = OASHR; 718 n1->vconst = w; 719 } 720 } 721 return; 722 } 723 if(!sametype(n->type, n->left->type)) { 724 n->left = new1(OCAST, n->left, Z); 725 n->left->type = n->type; 726 if(n->type->etype == TIND) { 727 w = n->type->link->width; 728 if(w < 1) { 729 snap(n->type->link); 730 w = n->type->link->width; 731 if(w < 1) 732 goto bad; 733 } 734 if(w > 1) { 735 n1 = new1(OCONST, Z, Z); 736 n1->vconst = w; 737 n1->type = n->type; 738 n->left = new1(OMUL, n->left, n1); 739 n->left->type = n->type; 740 } 741 } 742 } 743 if(n->right != Z) 744 if(!sametype(n->type, n->right->type)) { 745 n->right = new1(OCAST, n->right, Z); 746 n->right->type = n->type; 747 if(n->type->etype == TIND) { 748 w = n->type->link->width; 749 if(w < 1) { 750 snap(n->type->link); 751 w = n->type->link->width; 752 if(w < 1) 753 goto bad; 754 } 755 if(w != 1) { 756 n1 = new1(OCONST, Z, Z); 757 n1->vconst = w; 758 n1->type = n->type; 759 n->right = new1(OMUL, n->right, n1); 760 n->right->type = n->type; 761 } 762 } 763 } 764 return; 765 bad: 766 diag(n, "pointer addition not fully declared: %T", n->type->link); 767 } 768 769 /* 770 * try to rewrite shift & mask 771 */ 772 void 773 simplifyshift(Node *n) 774 { 775 ulong c3; 776 int o, s1, s2, c1, c2; 777 778 if(!typechlp[n->type->etype]) 779 return; 780 switch(n->op) { 781 default: 782 return; 783 case OASHL: 784 s1 = 0; 785 break; 786 case OLSHR: 787 s1 = 1; 788 break; 789 case OASHR: 790 s1 = 2; 791 break; 792 } 793 if(n->right->op != OCONST) 794 return; 795 if(n->left->op != OAND) 796 return; 797 if(n->left->right->op != OCONST) 798 return; 799 switch(n->left->left->op) { 800 default: 801 return; 802 case OASHL: 803 s2 = 0; 804 break; 805 case OLSHR: 806 s2 = 1; 807 break; 808 case OASHR: 809 s2 = 2; 810 break; 811 } 812 if(n->left->left->right->op != OCONST) 813 return; 814 815 c1 = n->right->vconst; 816 c2 = n->left->left->right->vconst; 817 c3 = n->left->right->vconst; 818 819 /* 820 if(debug['h']) 821 print("%.3o %ld %ld %d #%.lux\n", 822 (s1<<3)|s2, c1, c2, topbit(c3), c3); 823 */ 824 825 o = n->op; 826 switch((s1<<3)|s2) { 827 case 000: /* (((e <<u c2) & c3) <<u c1) */ 828 c3 >>= c2; 829 c1 += c2; 830 if(c1 >= 32) 831 break; 832 goto rewrite1; 833 834 case 002: /* (((e >>s c2) & c3) <<u c1) */ 835 if(topbit(c3) >= (32-c2)) 836 break; 837 case 001: /* (((e >>u c2) & c3) <<u c1) */ 838 if(c1 > c2) { 839 c3 <<= c2; 840 c1 -= c2; 841 o = OASHL; 842 goto rewrite1; 843 } 844 c3 <<= c1; 845 if(c1 == c2) 846 goto rewrite0; 847 c1 = c2-c1; 848 o = OLSHR; 849 goto rewrite2; 850 851 case 022: /* (((e >>s c2) & c3) >>s c1) */ 852 if(c2 <= 0) 853 break; 854 case 012: /* (((e >>s c2) & c3) >>u c1) */ 855 if(topbit(c3) >= (32-c2)) 856 break; 857 goto s11; 858 case 021: /* (((e >>u c2) & c3) >>s c1) */ 859 if(topbit(c3) >= 31 && c2 <= 0) 860 break; 861 goto s11; 862 case 011: /* (((e >>u c2) & c3) >>u c1) */ 863 s11: 864 c3 <<= c2; 865 c1 += c2; 866 if(c1 >= 32) 867 break; 868 o = OLSHR; 869 goto rewrite1; 870 871 case 020: /* (((e <<u c2) & c3) >>s c1) */ 872 if(topbit(c3) >= 31) 873 break; 874 case 010: /* (((e <<u c2) & c3) >>u c1) */ 875 c3 >>= c1; 876 if(c1 == c2) 877 goto rewrite0; 878 if(c1 > c2) { 879 c1 -= c2; 880 goto rewrite2; 881 } 882 c1 = c2 - c1; 883 o = OASHL; 884 goto rewrite2; 885 } 886 return; 887 888 rewrite0: /* get rid of both shifts */ 889 if(debug['<'])prtree(n, "rewrite0"); 890 *n = *n->left; 891 n->left = n->left->left; 892 n->right->vconst = c3; 893 return; 894 rewrite1: /* get rid of lower shift */ 895 if(debug['<'])prtree(n, "rewrite1"); 896 n->left->left = n->left->left->left; 897 n->left->right->vconst = c3; 898 n->right->vconst = c1; 899 n->op = o; 900 return; 901 rewrite2: /* get rid of upper shift */ 902 if(debug['<'])prtree(n, "rewrite2"); 903 *n = *n->left; 904 n->right->vconst = c3; 905 n->left->right->vconst = c1; 906 n->left->op = o; 907 } 908 909 int 910 side(Node *n) 911 { 912 913 loop: 914 if(n != Z) 915 switch(n->op) { 916 case OCAST: 917 case ONOT: 918 case OADDR: 919 case OIND: 920 case OCOM: 921 case ONEG: 922 case OPOS: 923 case OTST: 924 n = n->left; 925 goto loop; 926 927 case OCOND: 928 if(side(n->left)) 929 break; 930 n = n->right; 931 932 case OEQ: 933 case ONE: 934 case OLT: 935 case OGE: 936 case OGT: 937 case OLE: 938 case OADD: 939 case OSUB: 940 case OMUL: 941 case OLMUL: 942 case ODIV: 943 case OLDIV: 944 case OLSHR: 945 case OASHL: 946 case OASHR: 947 case OAND: 948 case OOR: 949 case OXOR: 950 case OMOD: 951 case OLMOD: 952 case OANDAND: 953 case OOROR: 954 case OCOMMA: 955 case ODOT: 956 if(side(n->left)) 957 break; 958 n = n->right; 959 goto loop; 960 961 case OSIGN: 962 case OSIZE: 963 case OCONST: 964 case OSTRING: 965 case OLSTRING: 966 case ONAME: 967 return 0; 968 } 969 return 1; 970 } 971 972 int 973 vconst(Node *n) 974 { 975 int i; 976 977 if(n == Z) 978 goto no; 979 if(n->op != OCONST) 980 goto no; 981 if(n->type == T) 982 goto no; 983 switch(n->type->etype) 984 { 985 case TFLOAT: 986 case TDOUBLE: 987 i = 100; 988 if(n->fconst > i || n->fconst < -i) 989 goto no; 990 i = n->fconst; 991 if(i != n->fconst) 992 goto no; 993 return i; 994 995 case TVLONG: 996 case TUVLONG: 997 i = n->vconst; 998 if(i != n->vconst) 999 goto no; 1000 return i; 1001 1002 case TCHAR: 1003 case TUCHAR: 1004 case TSHORT: 1005 case TUSHORT: 1006 case TINT: 1007 case TUINT: 1008 case TLONG: 1009 case TULONG: 1010 case TIND: 1011 i = n->vconst; 1012 if(i != n->vconst) 1013 goto no; 1014 return i; 1015 } 1016 no: 1017 return -159; /* first uninteresting constant */ 1018 } 1019 1020 /* 1021 * return log(n) if n is a power of 2 constant 1022 */ 1023 int 1024 log2(uvlong v) 1025 { 1026 int s, i; 1027 uvlong m; 1028 1029 s = 0; 1030 m = MASK(8*sizeof(uvlong)); 1031 for(i=32; i; i>>=1) { 1032 m >>= i; 1033 if(!(v & m)) { 1034 v >>= i; 1035 s += i; 1036 } 1037 } 1038 if(v == 1) 1039 return s; 1040 return -1; 1041 } 1042 1043 int 1044 vlog(Node *n) 1045 { 1046 if(n->op != OCONST) 1047 goto bad; 1048 if(typefd[n->type->etype]) 1049 goto bad; 1050 1051 return log2(n->vconst); 1052 1053 bad: 1054 return -1; 1055 } 1056 1057 int 1058 topbit(ulong v) 1059 { 1060 int i; 1061 1062 for(i = -1; v; i++) 1063 v >>= 1; 1064 return i; 1065 } 1066 1067 /* 1068 * try to cast a constant down 1069 * rather than cast a variable up 1070 * example: 1071 * if(c == 'a') 1072 */ 1073 void 1074 relcon(Node *l, Node *r) 1075 { 1076 vlong v; 1077 1078 if(l->op != OCONST) 1079 return; 1080 if(r->op != OCAST) 1081 return; 1082 if(!nilcast(r->left->type, r->type)) 1083 return; 1084 switch(r->type->etype) { 1085 default: 1086 return; 1087 case TCHAR: 1088 case TUCHAR: 1089 case TSHORT: 1090 case TUSHORT: 1091 v = convvtox(l->vconst, r->type->etype); 1092 if(v != l->vconst) 1093 return; 1094 break; 1095 } 1096 l->type = r->left->type; 1097 *r = *r->left; 1098 } 1099 1100 int 1101 relindex(int o) 1102 { 1103 1104 switch(o) { 1105 default: 1106 diag(Z, "bad in relindex: %O", o); 1107 case OEQ: return 0; 1108 case ONE: return 1; 1109 case OLE: return 2; 1110 case OLS: return 3; 1111 case OLT: return 4; 1112 case OLO: return 5; 1113 case OGE: return 6; 1114 case OHS: return 7; 1115 case OGT: return 8; 1116 case OHI: return 9; 1117 } 1118 } 1119 1120 Node* 1121 invert(Node *n) 1122 { 1123 Node *i; 1124 1125 if(n == Z || n->op != OLIST) 1126 return n; 1127 i = n; 1128 for(n = n->left; n != Z; n = n->left) { 1129 if(n->op != OLIST) 1130 break; 1131 i->left = n->right; 1132 n->right = i; 1133 i = n; 1134 } 1135 i->left = n; 1136 return i; 1137 } 1138 1139 int 1140 bitno(long b) 1141 { 1142 int i; 1143 1144 for(i=0; i<32; i++) 1145 if(b & (1L<<i)) 1146 return i; 1147 diag(Z, "bad in bitno"); 1148 return 0; 1149 } 1150 1151 long 1152 typebitor(long a, long b) 1153 { 1154 long c; 1155 1156 c = a | b; 1157 if(a & b) 1158 if((a & b) == BLONG) 1159 c |= BVLONG; /* long long => vlong */ 1160 else 1161 warn(Z, "once is enough: %Q", a & b); 1162 return c; 1163 } 1164 1165 void 1166 diag(Node *n, char *fmt, ...) 1167 { 1168 char buf[STRINGSZ]; 1169 va_list arg; 1170 1171 va_start(arg, fmt); 1172 vseprint(buf, buf+sizeof(buf), fmt, arg); 1173 va_end(arg); 1174 Bprint(&diagbuf, "%L %s\n", (n==Z)? nearln: n->lineno, buf); 1175 1176 if(debug['X']){ 1177 Bflush(&diagbuf); 1178 abort(); 1179 } 1180 if(n != Z) 1181 if(debug['v']) 1182 prtree(n, "diagnostic"); 1183 1184 nerrors++; 1185 if(nerrors > 10) { 1186 Bprint(&diagbuf, "too many errors\n"); 1187 errorexit(); 1188 } 1189 } 1190 1191 void 1192 warn(Node *n, char *fmt, ...) 1193 { 1194 char buf[STRINGSZ]; 1195 va_list arg; 1196 1197 if(debug['w'] || debug['W']) { 1198 va_start(arg, fmt); 1199 vseprint(buf, buf+sizeof(buf), fmt, arg); 1200 va_end(arg); 1201 if(debug['W']) { 1202 diag(n, "%s", buf); 1203 return; 1204 } 1205 Bprint(&diagbuf, "warning: %L %s\n", (n==Z)? nearln: n->lineno, buf); 1206 1207 if(n != Z) 1208 if(debug['v']) 1209 prtree(n, "warning"); 1210 } 1211 } 1212 1213 void 1214 yyerror(char *fmt, ...) 1215 { 1216 char buf[STRINGSZ]; 1217 va_list arg; 1218 1219 /* 1220 * hack to intercept message from yaccpar 1221 */ 1222 if(strcmp(fmt, "syntax error") == 0) { 1223 yyerror("syntax error, last name: %s", symb); 1224 return; 1225 } 1226 va_start(arg, fmt); 1227 vseprint(buf, buf+sizeof(buf), fmt, arg); 1228 va_end(arg); 1229 Bprint(&diagbuf, "%L %s\n", lineno, buf); 1230 nerrors++; 1231 if(nerrors > 10) { 1232 Bprint(&diagbuf, "too many errors\n"); 1233 errorexit(); 1234 } 1235 } 1236 1237 void 1238 fatal(Node *n, char *fmt, ...) 1239 { 1240 char buf[STRINGSZ]; 1241 va_list arg; 1242 1243 va_start(arg, fmt); 1244 vseprint(buf, buf+sizeof(buf), fmt, arg); 1245 va_end(arg); 1246 Bprint(&diagbuf, "%L %s\n", (n==Z)? nearln: n->lineno, buf); 1247 1248 if(debug['X']){ 1249 Bflush(&diagbuf); 1250 abort(); 1251 } 1252 if(n != Z) 1253 if(debug['v']) 1254 prtree(n, "diagnostic"); 1255 1256 nerrors++; 1257 errorexit(); 1258 } 1259 1260 ulong thash1 = 0x2edab8c9; 1261 ulong thash2 = 0x1dc74fb8; 1262 ulong thash3 = 0x1f241331; 1263 ulong thash[NALLTYPES]; 1264 Init thashinit[] = 1265 { 1266 TXXX, 0x17527bbd, 0, 1267 TCHAR, 0x5cedd32b, 0, 1268 TUCHAR, 0x552c4454, 0, 1269 TSHORT, 0x63040b4b, 0, 1270 TUSHORT, 0x32a45878, 0, 1271 TINT, 0x4151d5bd, 0, 1272 TUINT, 0x5ae707d6, 0, 1273 TLONG, 0x5ef20f47, 0, 1274 TULONG, 0x36d8eb8f, 0, 1275 TVLONG, 0x6e5e9590, 0, 1276 TUVLONG, 0x75910105, 0, 1277 TFLOAT, 0x25fd7af1, 0, 1278 TDOUBLE, 0x7c40a1b2, 0, 1279 TIND, 0x1b832357, 0, 1280 TFUNC, 0x6babc9cb, 0, 1281 TARRAY, 0x7c50986d, 0, 1282 TVOID, 0x44112eff, 0, 1283 TSTRUCT, 0x7c2da3bf, 0, 1284 TUNION, 0x3eb25e98, 0, 1285 TENUM, 0x44b54f61, 0, 1286 TFILE, 0x19242ac3, 0, 1287 TOLD, 0x22b15988, 0, 1288 TDOT, 0x0204f6b3, 0, 1289 -1, 0, 0, 1290 }; 1291 1292 char* bnames[NALIGN]; 1293 Init bnamesinit[] = 1294 { 1295 Axxx, 0, "Axxx", 1296 Ael1, 0, "el1", 1297 Ael2, 0, "el2", 1298 Asu2, 0, "su2", 1299 Aarg0, 0, "arg0", 1300 Aarg1, 0, "arg1", 1301 Aarg2, 0, "arg2", 1302 Aaut3, 0, "aut3", 1303 -1, 0, 0, 1304 }; 1305 1306 char* tnames[NALLTYPES]; 1307 Init tnamesinit[] = 1308 { 1309 TXXX, 0, "TXXX", 1310 TCHAR, 0, "CHAR", 1311 TUCHAR, 0, "UCHAR", 1312 TSHORT, 0, "SHORT", 1313 TUSHORT, 0, "USHORT", 1314 TINT, 0, "INT", 1315 TUINT, 0, "UINT", 1316 TLONG, 0, "LONG", 1317 TULONG, 0, "ULONG", 1318 TVLONG, 0, "VLONG", 1319 TUVLONG, 0, "UVLONG", 1320 TFLOAT, 0, "FLOAT", 1321 TDOUBLE, 0, "DOUBLE", 1322 TIND, 0, "IND", 1323 TFUNC, 0, "FUNC", 1324 TARRAY, 0, "ARRAY", 1325 TVOID, 0, "VOID", 1326 TSTRUCT, 0, "STRUCT", 1327 TUNION, 0, "UNION", 1328 TENUM, 0, "ENUM", 1329 TFILE, 0, "FILE", 1330 TOLD, 0, "OLD", 1331 TDOT, 0, "DOT", 1332 -1, 0, 0, 1333 }; 1334 1335 char* gnames[NGTYPES]; 1336 Init gnamesinit[] = 1337 { 1338 GXXX, 0, "GXXX", 1339 GCONSTNT, 0, "CONST", 1340 GVOLATILE, 0, "VOLATILE", 1341 GVOLATILE|GCONSTNT, 0, "CONST-VOLATILE", 1342 -1, 0, 0, 1343 }; 1344 1345 char* qnames[NALLTYPES]; 1346 Init qnamesinit[] = 1347 { 1348 TXXX, 0, "TXXX", 1349 TCHAR, 0, "CHAR", 1350 TUCHAR, 0, "UCHAR", 1351 TSHORT, 0, "SHORT", 1352 TUSHORT, 0, "USHORT", 1353 TINT, 0, "INT", 1354 TUINT, 0, "UINT", 1355 TLONG, 0, "LONG", 1356 TULONG, 0, "ULONG", 1357 TVLONG, 0, "VLONG", 1358 TUVLONG, 0, "UVLONG", 1359 TFLOAT, 0, "FLOAT", 1360 TDOUBLE, 0, "DOUBLE", 1361 TIND, 0, "IND", 1362 TFUNC, 0, "FUNC", 1363 TARRAY, 0, "ARRAY", 1364 TVOID, 0, "VOID", 1365 TSTRUCT, 0, "STRUCT", 1366 TUNION, 0, "UNION", 1367 TENUM, 0, "ENUM", 1368 1369 TAUTO, 0, "AUTO", 1370 TEXTERN, 0, "EXTERN", 1371 TSTATIC, 0, "STATIC", 1372 TTYPEDEF, 0, "TYPEDEF", 1373 TTYPESTR, 0, "TYPESTR", 1374 TREGISTER, 0, "REGISTER", 1375 TCONSTNT, 0, "CONSTNT", 1376 TVOLATILE, 0, "VOLATILE", 1377 TUNSIGNED, 0, "UNSIGNED", 1378 TSIGNED, 0, "SIGNED", 1379 TDOT, 0, "DOT", 1380 TFILE, 0, "FILE", 1381 TOLD, 0, "OLD", 1382 -1, 0, 0, 1383 }; 1384 char* cnames[NCTYPES]; 1385 Init cnamesinit[] = 1386 { 1387 CXXX, 0, "CXXX", 1388 CAUTO, 0, "AUTO", 1389 CEXTERN, 0, "EXTERN", 1390 CGLOBL, 0, "GLOBL", 1391 CSTATIC, 0, "STATIC", 1392 CLOCAL, 0, "LOCAL", 1393 CTYPEDEF, 0, "TYPEDEF", 1394 CTYPESTR, 0, "TYPESTR", 1395 CPARAM, 0, "PARAM", 1396 CSELEM, 0, "SELEM", 1397 CLABEL, 0, "LABEL", 1398 CEXREG, 0, "EXREG", 1399 -1, 0, 0, 1400 }; 1401 1402 char* onames[OEND+1]; 1403 Init onamesinit[] = 1404 { 1405 OXXX, 0, "OXXX", 1406 OADD, 0, "ADD", 1407 OADDR, 0, "ADDR", 1408 OAND, 0, "AND", 1409 OANDAND, 0, "ANDAND", 1410 OARRAY, 0, "ARRAY", 1411 OAS, 0, "AS", 1412 OASI, 0, "ASI", 1413 OASADD, 0, "ASADD", 1414 OASAND, 0, "ASAND", 1415 OASASHL, 0, "ASASHL", 1416 OASASHR, 0, "ASASHR", 1417 OASDIV, 0, "ASDIV", 1418 OASHL, 0, "ASHL", 1419 OASHR, 0, "ASHR", 1420 OASLDIV, 0, "ASLDIV", 1421 OASLMOD, 0, "ASLMOD", 1422 OASLMUL, 0, "ASLMUL", 1423 OASLSHR, 0, "ASLSHR", 1424 OASMOD, 0, "ASMOD", 1425 OASMUL, 0, "ASMUL", 1426 OASOR, 0, "ASOR", 1427 OASSUB, 0, "ASSUB", 1428 OASXOR, 0, "ASXOR", 1429 OBIT, 0, "BIT", 1430 OBREAK, 0, "BREAK", 1431 OCASE, 0, "CASE", 1432 OCAST, 0, "CAST", 1433 OCOMMA, 0, "COMMA", 1434 OCOND, 0, "COND", 1435 OCONST, 0, "CONST", 1436 OCONTINUE, 0, "CONTINUE", 1437 ODIV, 0, "DIV", 1438 ODOT, 0, "DOT", 1439 ODOTDOT, 0, "DOTDOT", 1440 ODWHILE, 0, "DWHILE", 1441 OENUM, 0, "ENUM", 1442 OEQ, 0, "EQ", 1443 OFOR, 0, "FOR", 1444 OFUNC, 0, "FUNC", 1445 OGE, 0, "GE", 1446 OGOTO, 0, "GOTO", 1447 OGT, 0, "GT", 1448 OHI, 0, "HI", 1449 OHS, 0, "HS", 1450 OIF, 0, "IF", 1451 OIND, 0, "IND", 1452 OINDREG, 0, "INDREG", 1453 OINIT, 0, "INIT", 1454 OLABEL, 0, "LABEL", 1455 OLDIV, 0, "LDIV", 1456 OLE, 0, "LE", 1457 OLIST, 0, "LIST", 1458 OLMOD, 0, "LMOD", 1459 OLMUL, 0, "LMUL", 1460 OLO, 0, "LO", 1461 OLS, 0, "LS", 1462 OLSHR, 0, "LSHR", 1463 OLT, 0, "LT", 1464 OMOD, 0, "MOD", 1465 OMUL, 0, "MUL", 1466 ONAME, 0, "NAME", 1467 ONE, 0, "NE", 1468 ONOT, 0, "NOT", 1469 OOR, 0, "OR", 1470 OOROR, 0, "OROR", 1471 OPOSTDEC, 0, "POSTDEC", 1472 OPOSTINC, 0, "POSTINC", 1473 OPREDEC, 0, "PREDEC", 1474 OPREINC, 0, "PREINC", 1475 OPROTO, 0, "PROTO", 1476 OREGISTER, 0, "REGISTER", 1477 ORETURN, 0, "RETURN", 1478 OSET, 0, "SET", 1479 OSIGN, 0, "SIGN", 1480 OSIZE, 0, "SIZE", 1481 OSTRING, 0, "STRING", 1482 OLSTRING, 0, "LSTRING", 1483 OSTRUCT, 0, "STRUCT", 1484 OSUB, 0, "SUB", 1485 OSWITCH, 0, "SWITCH", 1486 OUNION, 0, "UNION", 1487 OUSED, 0, "USED", 1488 OWHILE, 0, "WHILE", 1489 OXOR, 0, "XOR", 1490 OPOS, 0, "POS", 1491 ONEG, 0, "NEG", 1492 OCOM, 0, "COM", 1493 OELEM, 0, "ELEM", 1494 OTST, 0, "TST", 1495 OINDEX, 0, "INDEX", 1496 OFAS, 0, "FAS", 1497 OREGPAIR, 0, "REGPAIR", 1498 OEXREG, 0, "EXREG", 1499 OEND, 0, "END", 1500 -1, 0, 0, 1501 }; 1502 1503 /* OEQ, ONE, OLE, OLS, OLT, OLO, OGE, OHS, OGT, OHI */ 1504 char comrel[12] = 1505 { 1506 ONE, OEQ, OGT, OHI, OGE, OHS, OLT, OLO, OLE, OLS, 1507 }; 1508 char invrel[12] = 1509 { 1510 OEQ, ONE, OGE, OHS, OGT, OHI, OLE, OLS, OLT, OLO, 1511 }; 1512 char logrel[12] = 1513 { 1514 OEQ, ONE, OLS, OLS, OLO, OLO, OHS, OHS, OHI, OHI, 1515 }; 1516 1517 char typei[NTYPE]; 1518 int typeiinit[] = 1519 { 1520 TCHAR, TUCHAR, TSHORT, TUSHORT, TINT, TUINT, TLONG, TULONG, TVLONG, TUVLONG, -1, 1521 }; 1522 char typeu[NTYPE]; 1523 int typeuinit[] = 1524 { 1525 TUCHAR, TUSHORT, TUINT, TULONG, TUVLONG, TIND, -1, 1526 }; 1527 1528 char typesuv[NTYPE]; 1529 int typesuvinit[] = 1530 { 1531 TVLONG, TUVLONG, TSTRUCT, TUNION, -1, 1532 }; 1533 1534 char typeilp[NTYPE]; 1535 int typeilpinit[] = 1536 { 1537 TINT, TUINT, TLONG, TULONG, TIND, -1 1538 }; 1539 1540 char typechl[NTYPE]; 1541 char typechlv[NTYPE]; 1542 char typechlvp[NTYPE]; 1543 int typechlinit[] = 1544 { 1545 TCHAR, TUCHAR, TSHORT, TUSHORT, TINT, TUINT, TLONG, TULONG, -1, 1546 }; 1547 1548 char typechlp[NTYPE]; 1549 int typechlpinit[] = 1550 { 1551 TCHAR, TUCHAR, TSHORT, TUSHORT, TINT, TUINT, TLONG, TULONG, TIND, -1, 1552 }; 1553 1554 char typechlpfd[NTYPE]; 1555 int typechlpfdinit[] = 1556 { 1557 TCHAR, TUCHAR, TSHORT, TUSHORT, TINT, TUINT, TLONG, TULONG, TFLOAT, TDOUBLE, TIND, -1, 1558 }; 1559 1560 char typec[NTYPE]; 1561 int typecinit[] = 1562 { 1563 TCHAR, TUCHAR, -1 1564 }; 1565 1566 char typeh[NTYPE]; 1567 int typehinit[] = 1568 { 1569 TSHORT, TUSHORT, -1, 1570 }; 1571 1572 char typeil[NTYPE]; 1573 int typeilinit[] = 1574 { 1575 TINT, TUINT, TLONG, TULONG, -1, 1576 }; 1577 1578 char typev[NTYPE]; 1579 int typevinit[] = 1580 { 1581 TVLONG, TUVLONG, -1, 1582 }; 1583 1584 char typefd[NTYPE]; 1585 int typefdinit[] = 1586 { 1587 TFLOAT, TDOUBLE, -1, 1588 }; 1589 1590 char typeaf[NTYPE]; 1591 int typeafinit[] = 1592 { 1593 TFUNC, TARRAY, -1, 1594 }; 1595 1596 char typesu[NTYPE]; 1597 int typesuinit[] = 1598 { 1599 TSTRUCT, TUNION, -1, 1600 }; 1601 1602 long tasign[NTYPE]; 1603 Init tasigninit[] = 1604 { 1605 TCHAR, BNUMBER, 0, 1606 TUCHAR, BNUMBER, 0, 1607 TSHORT, BNUMBER, 0, 1608 TUSHORT, BNUMBER, 0, 1609 TINT, BNUMBER, 0, 1610 TUINT, BNUMBER, 0, 1611 TLONG, BNUMBER, 0, 1612 TULONG, BNUMBER, 0, 1613 TVLONG, BNUMBER, 0, 1614 TUVLONG, BNUMBER, 0, 1615 TFLOAT, BNUMBER, 0, 1616 TDOUBLE, BNUMBER, 0, 1617 TIND, BIND, 0, 1618 TSTRUCT, BSTRUCT, 0, 1619 TUNION, BUNION, 0, 1620 -1, 0, 0, 1621 }; 1622 1623 long tasadd[NTYPE]; 1624 Init tasaddinit[] = 1625 { 1626 TCHAR, BNUMBER, 0, 1627 TUCHAR, BNUMBER, 0, 1628 TSHORT, BNUMBER, 0, 1629 TUSHORT, BNUMBER, 0, 1630 TINT, BNUMBER, 0, 1631 TUINT, BNUMBER, 0, 1632 TLONG, BNUMBER, 0, 1633 TULONG, BNUMBER, 0, 1634 TVLONG, BNUMBER, 0, 1635 TUVLONG, BNUMBER, 0, 1636 TFLOAT, BNUMBER, 0, 1637 TDOUBLE, BNUMBER, 0, 1638 TIND, BINTEGER, 0, 1639 -1, 0, 0, 1640 }; 1641 1642 long tcast[NTYPE]; 1643 Init tcastinit[] = 1644 { 1645 TCHAR, BNUMBER|BIND|BVOID, 0, 1646 TUCHAR, BNUMBER|BIND|BVOID, 0, 1647 TSHORT, BNUMBER|BIND|BVOID, 0, 1648 TUSHORT, BNUMBER|BIND|BVOID, 0, 1649 TINT, BNUMBER|BIND|BVOID, 0, 1650 TUINT, BNUMBER|BIND|BVOID, 0, 1651 TLONG, BNUMBER|BIND|BVOID, 0, 1652 TULONG, BNUMBER|BIND|BVOID, 0, 1653 TVLONG, BNUMBER|BIND|BVOID, 0, 1654 TUVLONG, BNUMBER|BIND|BVOID, 0, 1655 TFLOAT, BNUMBER|BVOID, 0, 1656 TDOUBLE, BNUMBER|BVOID, 0, 1657 TIND, BINTEGER|BIND|BVOID, 0, 1658 TVOID, BVOID, 0, 1659 TSTRUCT, BSTRUCT|BVOID, 0, 1660 TUNION, BUNION|BVOID, 0, 1661 -1, 0, 0, 1662 }; 1663 1664 long tadd[NTYPE]; 1665 Init taddinit[] = 1666 { 1667 TCHAR, BNUMBER|BIND, 0, 1668 TUCHAR, BNUMBER|BIND, 0, 1669 TSHORT, BNUMBER|BIND, 0, 1670 TUSHORT, BNUMBER|BIND, 0, 1671 TINT, BNUMBER|BIND, 0, 1672 TUINT, BNUMBER|BIND, 0, 1673 TLONG, BNUMBER|BIND, 0, 1674 TULONG, BNUMBER|BIND, 0, 1675 TVLONG, BNUMBER|BIND, 0, 1676 TUVLONG, BNUMBER|BIND, 0, 1677 TFLOAT, BNUMBER, 0, 1678 TDOUBLE, BNUMBER, 0, 1679 TIND, BINTEGER, 0, 1680 -1, 0, 0, 1681 }; 1682 1683 long tsub[NTYPE]; 1684 Init tsubinit[] = 1685 { 1686 TCHAR, BNUMBER, 0, 1687 TUCHAR, BNUMBER, 0, 1688 TSHORT, BNUMBER, 0, 1689 TUSHORT, BNUMBER, 0, 1690 TINT, BNUMBER, 0, 1691 TUINT, BNUMBER, 0, 1692 TLONG, BNUMBER, 0, 1693 TULONG, BNUMBER, 0, 1694 TVLONG, BNUMBER, 0, 1695 TUVLONG, BNUMBER, 0, 1696 TFLOAT, BNUMBER, 0, 1697 TDOUBLE, BNUMBER, 0, 1698 TIND, BINTEGER|BIND, 0, 1699 -1, 0, 0, 1700 }; 1701 1702 long tmul[NTYPE]; 1703 Init tmulinit[] = 1704 { 1705 TCHAR, BNUMBER, 0, 1706 TUCHAR, BNUMBER, 0, 1707 TSHORT, BNUMBER, 0, 1708 TUSHORT, BNUMBER, 0, 1709 TINT, BNUMBER, 0, 1710 TUINT, BNUMBER, 0, 1711 TLONG, BNUMBER, 0, 1712 TULONG, BNUMBER, 0, 1713 TVLONG, BNUMBER, 0, 1714 TUVLONG, BNUMBER, 0, 1715 TFLOAT, BNUMBER, 0, 1716 TDOUBLE, BNUMBER, 0, 1717 -1, 0, 0, 1718 }; 1719 1720 long tand[NTYPE]; 1721 Init tandinit[] = 1722 { 1723 TCHAR, BINTEGER, 0, 1724 TUCHAR, BINTEGER, 0, 1725 TSHORT, BINTEGER, 0, 1726 TUSHORT, BINTEGER, 0, 1727 TINT, BNUMBER, 0, 1728 TUINT, BNUMBER, 0, 1729 TLONG, BINTEGER, 0, 1730 TULONG, BINTEGER, 0, 1731 TVLONG, BINTEGER, 0, 1732 TUVLONG, BINTEGER, 0, 1733 -1, 0, 0, 1734 }; 1735 1736 long trel[NTYPE]; 1737 Init trelinit[] = 1738 { 1739 TCHAR, BNUMBER, 0, 1740 TUCHAR, BNUMBER, 0, 1741 TSHORT, BNUMBER, 0, 1742 TUSHORT, BNUMBER, 0, 1743 TINT, BNUMBER, 0, 1744 TUINT, BNUMBER, 0, 1745 TLONG, BNUMBER, 0, 1746 TULONG, BNUMBER, 0, 1747 TVLONG, BNUMBER, 0, 1748 TUVLONG, BNUMBER, 0, 1749 TFLOAT, BNUMBER, 0, 1750 TDOUBLE, BNUMBER, 0, 1751 TIND, BIND, 0, 1752 -1, 0, 0, 1753 }; 1754 1755 long tfunct[1] = 1756 { 1757 BFUNC, 1758 }; 1759 1760 long tindir[1] = 1761 { 1762 BIND, 1763 }; 1764 1765 long tdot[1] = 1766 { 1767 BSTRUCT|BUNION, 1768 }; 1769 1770 long tnot[1] = 1771 { 1772 BNUMBER|BIND, 1773 }; 1774 1775 long targ[1] = 1776 { 1777 BNUMBER|BIND|BSTRUCT|BUNION, 1778 }; 1779 1780 char tab[NTYPE][NTYPE] = 1781 { 1782 /*TXXX*/ { 0, 1783 }, 1784 1785 /*TCHAR*/ { 0, TCHAR, TUCHAR, TSHORT, TUSHORT, TINT, TUINT, TLONG, 1786 TULONG, TVLONG, TUVLONG, TFLOAT, TDOUBLE, TIND, 1787 }, 1788 /*TUCHAR*/ { 0, TUCHAR, TUCHAR, TUSHORT, TUSHORT, TUINT, TUINT, TULONG, 1789 TULONG, TUVLONG, TUVLONG, TFLOAT, TDOUBLE, TIND, 1790 }, 1791 /*TSHORT*/ { 0, TSHORT, TUSHORT, TSHORT, TUSHORT, TINT, TUINT, TLONG, 1792 TULONG, TVLONG, TUVLONG, TFLOAT, TDOUBLE, TIND, 1793 }, 1794 /*TUSHORT*/ { 0, TUSHORT, TUSHORT, TUSHORT, TUSHORT, TUINT, TUINT, TULONG, 1795 TULONG, TUVLONG, TUVLONG, TFLOAT, TDOUBLE, TIND, 1796 }, 1797 /*TINT*/ { 0, TINT, TUINT, TINT, TUINT, TINT, TUINT, TLONG, 1798 TULONG, TVLONG, TUVLONG, TFLOAT, TDOUBLE, TIND, 1799 }, 1800 /*TUINT*/ { 0, TUINT, TUINT, TUINT, TUINT, TUINT, TUINT, TULONG, 1801 TULONG, TUVLONG, TUVLONG, TFLOAT, TDOUBLE, TIND, 1802 }, 1803 /*TLONG*/ { 0, TLONG, TULONG, TLONG, TULONG, TLONG, TULONG, TLONG, 1804 TULONG, TVLONG, TUVLONG, TFLOAT, TDOUBLE, TIND, 1805 }, 1806 /*TULONG*/ { 0, TULONG, TULONG, TULONG, TULONG, TULONG, TULONG, TULONG, 1807 TULONG, TUVLONG, TUVLONG, TFLOAT, TDOUBLE, TIND, 1808 }, 1809 /*TVLONG*/ { 0, TVLONG, TUVLONG, TVLONG, TUVLONG, TVLONG, TUVLONG, TVLONG, 1810 TUVLONG, TVLONG, TUVLONG, TFLOAT, TDOUBLE, TIND, 1811 }, 1812 /*TUVLONG*/ { 0, TUVLONG, TUVLONG, TUVLONG, TUVLONG, TUVLONG, TUVLONG, TUVLONG, 1813 TUVLONG, TUVLONG, TUVLONG, TFLOAT, TDOUBLE, TIND, 1814 }, 1815 /*TFLOAT*/ { 0, TFLOAT, TFLOAT, TFLOAT, TFLOAT, TFLOAT, TFLOAT, TFLOAT, 1816 TFLOAT, TFLOAT, TFLOAT, TFLOAT, TDOUBLE, TIND, 1817 }, 1818 /*TDOUBLE*/ { 0, TDOUBLE, TDOUBLE, TDOUBLE, TDOUBLE, TDOUBLE, TDOUBLE, TDOUBLE, 1819 TDOUBLE, TDOUBLE, TDOUBLE, TFLOAT, TDOUBLE, TIND, 1820 }, 1821 /*TIND*/ { 0, TIND, TIND, TIND, TIND, TIND, TIND, TIND, 1822 TIND, TIND, TIND, TIND, TIND, TIND, 1823 }, 1824 }; 1825 1826 void 1827 urk(char *name, int max, int i) 1828 { 1829 if(i >= max) { 1830 fprint(2, "bad tinit: %s %d>=%d\n", name, i, max); 1831 exits("init"); 1832 } 1833 } 1834 1835 void 1836 tinit(void) 1837 { 1838 int *ip; 1839 Init *p; 1840 1841 for(p=thashinit; p->code >= 0; p++) { 1842 urk("thash", nelem(thash), p->code); 1843 thash[p->code] = p->value; 1844 } 1845 for(p=bnamesinit; p->code >= 0; p++) { 1846 urk("bnames", nelem(bnames), p->code); 1847 bnames[p->code] = p->s; 1848 } 1849 for(p=tnamesinit; p->code >= 0; p++) { 1850 urk("tnames", nelem(tnames), p->code); 1851 tnames[p->code] = p->s; 1852 } 1853 for(p=gnamesinit; p->code >= 0; p++) { 1854 urk("gnames", nelem(gnames), p->code); 1855 gnames[p->code] = p->s; 1856 } 1857 for(p=qnamesinit; p->code >= 0; p++) { 1858 urk("qnames", nelem(qnames), p->code); 1859 qnames[p->code] = p->s; 1860 } 1861 for(p=cnamesinit; p->code >= 0; p++) { 1862 urk("cnames", nelem(cnames), p->code); 1863 cnames[p->code] = p->s; 1864 } 1865 for(p=onamesinit; p->code >= 0; p++) { 1866 urk("onames", nelem(onames), p->code); 1867 onames[p->code] = p->s; 1868 } 1869 for(ip=typeiinit; *ip>=0; ip++) { 1870 urk("typei", nelem(typei), *ip); 1871 typei[*ip] = 1; 1872 } 1873 for(ip=typeuinit; *ip>=0; ip++) { 1874 urk("typeu", nelem(typeu), *ip); 1875 typeu[*ip] = 1; 1876 } 1877 for(ip=typesuvinit; *ip>=0; ip++) { 1878 urk("typesuv", nelem(typesuv), *ip); 1879 typesuv[*ip] = 1; 1880 } 1881 for(ip=typeilpinit; *ip>=0; ip++) { 1882 urk("typeilp", nelem(typeilp), *ip); 1883 typeilp[*ip] = 1; 1884 } 1885 for(ip=typechlinit; *ip>=0; ip++) { 1886 urk("typechl", nelem(typechl), *ip); 1887 typechl[*ip] = 1; 1888 typechlv[*ip] = 1; 1889 typechlvp[*ip] = 1; 1890 } 1891 for(ip=typechlpinit; *ip>=0; ip++) { 1892 urk("typechlp", nelem(typechlp), *ip); 1893 typechlp[*ip] = 1; 1894 typechlvp[*ip] = 1; 1895 } 1896 for(ip=typechlpfdinit; *ip>=0; ip++) { 1897 urk("typechlpfd", nelem(typechlpfd), *ip); 1898 typechlpfd[*ip] = 1; 1899 } 1900 for(ip=typecinit; *ip>=0; ip++) { 1901 urk("typec", nelem(typec), *ip); 1902 typec[*ip] = 1; 1903 } 1904 for(ip=typehinit; *ip>=0; ip++) { 1905 urk("typeh", nelem(typeh), *ip); 1906 typeh[*ip] = 1; 1907 } 1908 for(ip=typeilinit; *ip>=0; ip++) { 1909 urk("typeil", nelem(typeil), *ip); 1910 typeil[*ip] = 1; 1911 } 1912 for(ip=typevinit; *ip>=0; ip++) { 1913 urk("typev", nelem(typev), *ip); 1914 typev[*ip] = 1; 1915 typechlv[*ip] = 1; 1916 typechlvp[*ip] = 1; 1917 } 1918 for(ip=typefdinit; *ip>=0; ip++) { 1919 urk("typefd", nelem(typefd), *ip); 1920 typefd[*ip] = 1; 1921 } 1922 for(ip=typeafinit; *ip>=0; ip++) { 1923 urk("typeaf", nelem(typeaf), *ip); 1924 typeaf[*ip] = 1; 1925 } 1926 for(ip=typesuinit; *ip >= 0; ip++) { 1927 urk("typesu", nelem(typesu), *ip); 1928 typesu[*ip] = 1; 1929 } 1930 for(p=tasigninit; p->code >= 0; p++) { 1931 urk("tasign", nelem(tasign), p->code); 1932 tasign[p->code] = p->value; 1933 } 1934 for(p=tasaddinit; p->code >= 0; p++) { 1935 urk("tasadd", nelem(tasadd), p->code); 1936 tasadd[p->code] = p->value; 1937 } 1938 for(p=tcastinit; p->code >= 0; p++) { 1939 urk("tcast", nelem(tcast), p->code); 1940 tcast[p->code] = p->value; 1941 } 1942 for(p=taddinit; p->code >= 0; p++) { 1943 urk("tadd", nelem(tadd), p->code); 1944 tadd[p->code] = p->value; 1945 } 1946 for(p=tsubinit; p->code >= 0; p++) { 1947 urk("tsub", nelem(tsub), p->code); 1948 tsub[p->code] = p->value; 1949 } 1950 for(p=tmulinit; p->code >= 0; p++) { 1951 urk("tmul", nelem(tmul), p->code); 1952 tmul[p->code] = p->value; 1953 } 1954 for(p=tandinit; p->code >= 0; p++) { 1955 urk("tand", nelem(tand), p->code); 1956 tand[p->code] = p->value; 1957 } 1958 for(p=trelinit; p->code >= 0; p++) { 1959 urk("trel", nelem(trel), p->code); 1960 trel[p->code] = p->value; 1961 } 1962 1963 /* 32-bit defaults */ 1964 typeword = typechlp; 1965 typeswitch = typechl; 1966 typecmplx = typesuv; 1967 } 1968 1969 /* 1970 * return 1 if it is impossible to jump into the middle of n. 1971 */ 1972 static int 1973 deadhead(Node *n, int caseok) 1974 { 1975 loop: 1976 if(n == Z) 1977 return 1; 1978 switch(n->op) { 1979 case OLIST: 1980 if(!deadhead(n->left, caseok)) 1981 return 0; 1982 rloop: 1983 n = n->right; 1984 goto loop; 1985 1986 case ORETURN: 1987 break; 1988 1989 case OLABEL: 1990 return 0; 1991 1992 case OGOTO: 1993 break; 1994 1995 case OCASE: 1996 if(!caseok) 1997 return 0; 1998 goto rloop; 1999 2000 case OSWITCH: 2001 return deadhead(n->right, 1); 2002 2003 case OWHILE: 2004 case ODWHILE: 2005 goto rloop; 2006 2007 case OFOR: 2008 goto rloop; 2009 2010 case OCONTINUE: 2011 break; 2012 2013 case OBREAK: 2014 break; 2015 2016 case OIF: 2017 return deadhead(n->right->left, caseok) && deadhead(n->right->right, caseok); 2018 2019 case OSET: 2020 case OUSED: 2021 break; 2022 } 2023 return 1; 2024 } 2025 2026 int 2027 deadheads(Node *c) 2028 { 2029 return deadhead(c->left, 0) && deadhead(c->right, 0); 2030 } 2031 2032 int 2033 mixedasop(Type *l, Type *r) 2034 { 2035 return !typefd[l->etype] && typefd[r->etype]; 2036 } 2037 2038 2039 /* 2040 * (uvlong)~ul creates a ul mask with top bits zero, which is usually wrong 2041 * an explicit cast to ulong after ~ suppresses the diagnostic 2042 */ 2043 int 2044 castucom(Node *r) 2045 { 2046 Node *rl; 2047 2048 if(r->op == OCAST && 2049 (rl = r->left)->op == OCOM && 2050 (r->type->etype == TVLONG || r->type->etype == TUVLONG) && 2051 typeu[rl->type->etype] && typechl[rl->type->etype]) 2052 return 1; 2053 return 0; 2054 } 2055