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