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 n = n->left; 921 goto loop; 922 923 case OCOND: 924 if(side(n->left)) 925 break; 926 n = n->right; 927 928 case OEQ: 929 case ONE: 930 case OLT: 931 case OGE: 932 case OGT: 933 case OLE: 934 case OADD: 935 case OSUB: 936 case OMUL: 937 case OLMUL: 938 case ODIV: 939 case OLDIV: 940 case OLSHR: 941 case OASHL: 942 case OASHR: 943 case OAND: 944 case OOR: 945 case OXOR: 946 case OMOD: 947 case OLMOD: 948 case OANDAND: 949 case OOROR: 950 case OCOMMA: 951 case ODOT: 952 if(side(n->left)) 953 break; 954 n = n->right; 955 goto loop; 956 957 case OSIGN: 958 case OSIZE: 959 case OCONST: 960 case OSTRING: 961 case OLSTRING: 962 case ONAME: 963 return 0; 964 } 965 return 1; 966 } 967 968 int 969 vconst(Node *n) 970 { 971 int i; 972 973 if(n == Z) 974 goto no; 975 if(n->op != OCONST) 976 goto no; 977 if(n->type == T) 978 goto no; 979 switch(n->type->etype) 980 { 981 case TFLOAT: 982 case TDOUBLE: 983 i = 100; 984 if(n->fconst > i || n->fconst < -i) 985 goto no; 986 i = n->fconst; 987 if(i != n->fconst) 988 goto no; 989 return i; 990 991 case TVLONG: 992 case TUVLONG: 993 i = n->vconst; 994 if(i != n->vconst) 995 goto no; 996 return i; 997 998 case TCHAR: 999 case TUCHAR: 1000 case TSHORT: 1001 case TUSHORT: 1002 case TINT: 1003 case TUINT: 1004 case TLONG: 1005 case TULONG: 1006 case TIND: 1007 i = n->vconst; 1008 if(i != n->vconst) 1009 goto no; 1010 return i; 1011 } 1012 no: 1013 return -159; /* first uninteresting constant */ 1014 } 1015 1016 /* 1017 * return log(n) if n is a power of 2 constant 1018 */ 1019 int 1020 log2(uvlong v) 1021 { 1022 int s, i; 1023 uvlong m; 1024 1025 s = 0; 1026 m = MASK(8*sizeof(uvlong)); 1027 for(i=32; i; i>>=1) { 1028 m >>= i; 1029 if(!(v & m)) { 1030 v >>= i; 1031 s += i; 1032 } 1033 } 1034 if(v == 1) 1035 return s; 1036 return -1; 1037 } 1038 1039 int 1040 vlog(Node *n) 1041 { 1042 if(n->op != OCONST) 1043 goto bad; 1044 if(typefd[n->type->etype]) 1045 goto bad; 1046 1047 return log2(n->vconst); 1048 1049 bad: 1050 return -1; 1051 } 1052 1053 int 1054 topbit(ulong v) 1055 { 1056 int i; 1057 1058 for(i = -1; v; i++) 1059 v >>= 1; 1060 return i; 1061 } 1062 1063 /* 1064 * try to cast a constant down 1065 * rather than cast a variable up 1066 * example: 1067 * if(c == 'a') 1068 */ 1069 void 1070 relcon(Node *l, Node *r) 1071 { 1072 vlong v; 1073 1074 if(l->op != OCONST) 1075 return; 1076 if(r->op != OCAST) 1077 return; 1078 if(!nilcast(r->left->type, r->type)) 1079 return; 1080 switch(r->type->etype) { 1081 default: 1082 return; 1083 case TCHAR: 1084 case TUCHAR: 1085 case TSHORT: 1086 case TUSHORT: 1087 v = convvtox(l->vconst, r->type->etype); 1088 if(v != l->vconst) 1089 return; 1090 break; 1091 } 1092 l->type = r->left->type; 1093 *r = *r->left; 1094 } 1095 1096 int 1097 relindex(int o) 1098 { 1099 1100 switch(o) { 1101 default: 1102 diag(Z, "bad in relindex: %O", o); 1103 case OEQ: return 0; 1104 case ONE: return 1; 1105 case OLE: return 2; 1106 case OLS: return 3; 1107 case OLT: return 4; 1108 case OLO: return 5; 1109 case OGE: return 6; 1110 case OHS: return 7; 1111 case OGT: return 8; 1112 case OHI: return 9; 1113 } 1114 } 1115 1116 Node* 1117 invert(Node *n) 1118 { 1119 Node *i; 1120 1121 if(n == Z || n->op != OLIST) 1122 return n; 1123 i = n; 1124 for(n = n->left; n != Z; n = n->left) { 1125 if(n->op != OLIST) 1126 break; 1127 i->left = n->right; 1128 n->right = i; 1129 i = n; 1130 } 1131 i->left = n; 1132 return i; 1133 } 1134 1135 int 1136 bitno(long b) 1137 { 1138 int i; 1139 1140 for(i=0; i<32; i++) 1141 if(b & (1L<<i)) 1142 return i; 1143 diag(Z, "bad in bitno"); 1144 return 0; 1145 } 1146 1147 long 1148 typebitor(long a, long b) 1149 { 1150 long c; 1151 1152 c = a | b; 1153 if(a & b) 1154 if((a & b) == BLONG) 1155 c |= BVLONG; /* long long => vlong */ 1156 else 1157 warn(Z, "once is enough: %Q", a & b); 1158 return c; 1159 } 1160 1161 void 1162 diag(Node *n, char *fmt, ...) 1163 { 1164 char buf[STRINGSZ]; 1165 va_list arg; 1166 1167 va_start(arg, fmt); 1168 vseprint(buf, buf+sizeof(buf), fmt, arg); 1169 va_end(arg); 1170 Bprint(&diagbuf, "%L %s\n", (n==Z)? nearln: n->lineno, buf); 1171 1172 if(debug['X']){ 1173 Bflush(&diagbuf); 1174 abort(); 1175 } 1176 if(n != Z) 1177 if(debug['v']) 1178 prtree(n, "diagnostic"); 1179 1180 nerrors++; 1181 if(nerrors > 10) { 1182 Bprint(&diagbuf, "too many errors\n"); 1183 errorexit(); 1184 } 1185 } 1186 1187 void 1188 warn(Node *n, char *fmt, ...) 1189 { 1190 char buf[STRINGSZ]; 1191 va_list arg; 1192 1193 if(debug['w'] || debug['W']) { 1194 va_start(arg, fmt); 1195 vseprint(buf, buf+sizeof(buf), fmt, arg); 1196 va_end(arg); 1197 if(debug['W']) { 1198 diag(n, "%s", buf); 1199 return; 1200 } 1201 Bprint(&diagbuf, "warning: %L %s\n", (n==Z)? nearln: n->lineno, buf); 1202 1203 if(n != Z) 1204 if(debug['v']) 1205 prtree(n, "warning"); 1206 } 1207 } 1208 1209 void 1210 yyerror(char *fmt, ...) 1211 { 1212 char buf[STRINGSZ]; 1213 va_list arg; 1214 1215 /* 1216 * hack to intercept message from yaccpar 1217 */ 1218 if(strcmp(fmt, "syntax error") == 0) { 1219 yyerror("syntax error, last name: %s", symb); 1220 return; 1221 } 1222 va_start(arg, fmt); 1223 vseprint(buf, buf+sizeof(buf), fmt, arg); 1224 va_end(arg); 1225 Bprint(&diagbuf, "%L %s\n", lineno, buf); 1226 nerrors++; 1227 if(nerrors > 10) { 1228 Bprint(&diagbuf, "too many errors\n"); 1229 errorexit(); 1230 } 1231 } 1232 1233 void 1234 fatal(Node *n, char *fmt, ...) 1235 { 1236 char buf[STRINGSZ]; 1237 va_list arg; 1238 1239 va_start(arg, fmt); 1240 vseprint(buf, buf+sizeof(buf), fmt, arg); 1241 va_end(arg); 1242 Bprint(&diagbuf, "%L %s\n", (n==Z)? nearln: n->lineno, buf); 1243 1244 if(debug['X']){ 1245 Bflush(&diagbuf); 1246 abort(); 1247 } 1248 if(n != Z) 1249 if(debug['v']) 1250 prtree(n, "diagnostic"); 1251 1252 nerrors++; 1253 errorexit(); 1254 } 1255 1256 ulong thash1 = 0x2edab8c9; 1257 ulong thash2 = 0x1dc74fb8; 1258 ulong thash3 = 0x1f241331; 1259 ulong thash[NALLTYPES]; 1260 Init thashinit[] = 1261 { 1262 TXXX, 0x17527bbd, 0, 1263 TCHAR, 0x5cedd32b, 0, 1264 TUCHAR, 0x552c4454, 0, 1265 TSHORT, 0x63040b4b, 0, 1266 TUSHORT, 0x32a45878, 0, 1267 TINT, 0x4151d5bd, 0, 1268 TUINT, 0x5ae707d6, 0, 1269 TLONG, 0x5ef20f47, 0, 1270 TULONG, 0x36d8eb8f, 0, 1271 TVLONG, 0x6e5e9590, 0, 1272 TUVLONG, 0x75910105, 0, 1273 TFLOAT, 0x25fd7af1, 0, 1274 TDOUBLE, 0x7c40a1b2, 0, 1275 TIND, 0x1b832357, 0, 1276 TFUNC, 0x6babc9cb, 0, 1277 TARRAY, 0x7c50986d, 0, 1278 TVOID, 0x44112eff, 0, 1279 TSTRUCT, 0x7c2da3bf, 0, 1280 TUNION, 0x3eb25e98, 0, 1281 TENUM, 0x44b54f61, 0, 1282 TFILE, 0x19242ac3, 0, 1283 TOLD, 0x22b15988, 0, 1284 TDOT, 0x0204f6b3, 0, 1285 -1, 0, 0, 1286 }; 1287 1288 char* bnames[NALIGN]; 1289 Init bnamesinit[] = 1290 { 1291 Axxx, 0, "Axxx", 1292 Ael1, 0, "el1", 1293 Ael2, 0, "el2", 1294 Asu2, 0, "su2", 1295 Aarg0, 0, "arg0", 1296 Aarg1, 0, "arg1", 1297 Aarg2, 0, "arg2", 1298 Aaut3, 0, "aut3", 1299 -1, 0, 0, 1300 }; 1301 1302 char* tnames[NALLTYPES]; 1303 Init tnamesinit[] = 1304 { 1305 TXXX, 0, "TXXX", 1306 TCHAR, 0, "CHAR", 1307 TUCHAR, 0, "UCHAR", 1308 TSHORT, 0, "SHORT", 1309 TUSHORT, 0, "USHORT", 1310 TINT, 0, "INT", 1311 TUINT, 0, "UINT", 1312 TLONG, 0, "LONG", 1313 TULONG, 0, "ULONG", 1314 TVLONG, 0, "VLONG", 1315 TUVLONG, 0, "UVLONG", 1316 TFLOAT, 0, "FLOAT", 1317 TDOUBLE, 0, "DOUBLE", 1318 TIND, 0, "IND", 1319 TFUNC, 0, "FUNC", 1320 TARRAY, 0, "ARRAY", 1321 TVOID, 0, "VOID", 1322 TSTRUCT, 0, "STRUCT", 1323 TUNION, 0, "UNION", 1324 TENUM, 0, "ENUM", 1325 TFILE, 0, "FILE", 1326 TOLD, 0, "OLD", 1327 TDOT, 0, "DOT", 1328 -1, 0, 0, 1329 }; 1330 1331 char* gnames[NGTYPES]; 1332 Init gnamesinit[] = 1333 { 1334 GXXX, 0, "GXXX", 1335 GCONSTNT, 0, "CONST", 1336 GVOLATILE, 0, "VOLATILE", 1337 GVOLATILE|GCONSTNT, 0, "CONST-VOLATILE", 1338 -1, 0, 0, 1339 }; 1340 1341 char* qnames[NALLTYPES]; 1342 Init qnamesinit[] = 1343 { 1344 TXXX, 0, "TXXX", 1345 TCHAR, 0, "CHAR", 1346 TUCHAR, 0, "UCHAR", 1347 TSHORT, 0, "SHORT", 1348 TUSHORT, 0, "USHORT", 1349 TINT, 0, "INT", 1350 TUINT, 0, "UINT", 1351 TLONG, 0, "LONG", 1352 TULONG, 0, "ULONG", 1353 TVLONG, 0, "VLONG", 1354 TUVLONG, 0, "UVLONG", 1355 TFLOAT, 0, "FLOAT", 1356 TDOUBLE, 0, "DOUBLE", 1357 TIND, 0, "IND", 1358 TFUNC, 0, "FUNC", 1359 TARRAY, 0, "ARRAY", 1360 TVOID, 0, "VOID", 1361 TSTRUCT, 0, "STRUCT", 1362 TUNION, 0, "UNION", 1363 TENUM, 0, "ENUM", 1364 1365 TAUTO, 0, "AUTO", 1366 TEXTERN, 0, "EXTERN", 1367 TSTATIC, 0, "STATIC", 1368 TTYPEDEF, 0, "TYPEDEF", 1369 TTYPESTR, 0, "TYPESTR", 1370 TREGISTER, 0, "REGISTER", 1371 TCONSTNT, 0, "CONSTNT", 1372 TVOLATILE, 0, "VOLATILE", 1373 TUNSIGNED, 0, "UNSIGNED", 1374 TSIGNED, 0, "SIGNED", 1375 TDOT, 0, "DOT", 1376 TFILE, 0, "FILE", 1377 TOLD, 0, "OLD", 1378 -1, 0, 0, 1379 }; 1380 char* cnames[NCTYPES]; 1381 Init cnamesinit[] = 1382 { 1383 CXXX, 0, "CXXX", 1384 CAUTO, 0, "AUTO", 1385 CEXTERN, 0, "EXTERN", 1386 CGLOBL, 0, "GLOBL", 1387 CSTATIC, 0, "STATIC", 1388 CLOCAL, 0, "LOCAL", 1389 CTYPEDEF, 0, "TYPEDEF", 1390 CTYPESTR, 0, "TYPESTR", 1391 CPARAM, 0, "PARAM", 1392 CSELEM, 0, "SELEM", 1393 CLABEL, 0, "LABEL", 1394 CEXREG, 0, "EXREG", 1395 -1, 0, 0, 1396 }; 1397 1398 char* onames[OEND+1]; 1399 Init onamesinit[] = 1400 { 1401 OXXX, 0, "OXXX", 1402 OADD, 0, "ADD", 1403 OADDR, 0, "ADDR", 1404 OAND, 0, "AND", 1405 OANDAND, 0, "ANDAND", 1406 OARRAY, 0, "ARRAY", 1407 OAS, 0, "AS", 1408 OASI, 0, "ASI", 1409 OASADD, 0, "ASADD", 1410 OASAND, 0, "ASAND", 1411 OASASHL, 0, "ASASHL", 1412 OASASHR, 0, "ASASHR", 1413 OASDIV, 0, "ASDIV", 1414 OASHL, 0, "ASHL", 1415 OASHR, 0, "ASHR", 1416 OASLDIV, 0, "ASLDIV", 1417 OASLMOD, 0, "ASLMOD", 1418 OASLMUL, 0, "ASLMUL", 1419 OASLSHR, 0, "ASLSHR", 1420 OASMOD, 0, "ASMOD", 1421 OASMUL, 0, "ASMUL", 1422 OASOR, 0, "ASOR", 1423 OASSUB, 0, "ASSUB", 1424 OASXOR, 0, "ASXOR", 1425 OBIT, 0, "BIT", 1426 OBREAK, 0, "BREAK", 1427 OCASE, 0, "CASE", 1428 OCAST, 0, "CAST", 1429 OCOMMA, 0, "COMMA", 1430 OCOND, 0, "COND", 1431 OCONST, 0, "CONST", 1432 OCONTINUE, 0, "CONTINUE", 1433 ODIV, 0, "DIV", 1434 ODOT, 0, "DOT", 1435 ODOTDOT, 0, "DOTDOT", 1436 ODWHILE, 0, "DWHILE", 1437 OENUM, 0, "ENUM", 1438 OEQ, 0, "EQ", 1439 OFOR, 0, "FOR", 1440 OFUNC, 0, "FUNC", 1441 OGE, 0, "GE", 1442 OGOTO, 0, "GOTO", 1443 OGT, 0, "GT", 1444 OHI, 0, "HI", 1445 OHS, 0, "HS", 1446 OIF, 0, "IF", 1447 OIND, 0, "IND", 1448 OINDREG, 0, "INDREG", 1449 OINIT, 0, "INIT", 1450 OLABEL, 0, "LABEL", 1451 OLDIV, 0, "LDIV", 1452 OLE, 0, "LE", 1453 OLIST, 0, "LIST", 1454 OLMOD, 0, "LMOD", 1455 OLMUL, 0, "LMUL", 1456 OLO, 0, "LO", 1457 OLS, 0, "LS", 1458 OLSHR, 0, "LSHR", 1459 OLT, 0, "LT", 1460 OMOD, 0, "MOD", 1461 OMUL, 0, "MUL", 1462 ONAME, 0, "NAME", 1463 ONE, 0, "NE", 1464 ONOT, 0, "NOT", 1465 OOR, 0, "OR", 1466 OOROR, 0, "OROR", 1467 OPOSTDEC, 0, "POSTDEC", 1468 OPOSTINC, 0, "POSTINC", 1469 OPREDEC, 0, "PREDEC", 1470 OPREINC, 0, "PREINC", 1471 OPROTO, 0, "PROTO", 1472 OREGISTER, 0, "REGISTER", 1473 ORETURN, 0, "RETURN", 1474 OSET, 0, "SET", 1475 OSIGN, 0, "SIGN", 1476 OSIZE, 0, "SIZE", 1477 OSTRING, 0, "STRING", 1478 OLSTRING, 0, "LSTRING", 1479 OSTRUCT, 0, "STRUCT", 1480 OSUB, 0, "SUB", 1481 OSWITCH, 0, "SWITCH", 1482 OUNION, 0, "UNION", 1483 OUSED, 0, "USED", 1484 OWHILE, 0, "WHILE", 1485 OXOR, 0, "XOR", 1486 OPOS, 0, "POS", 1487 ONEG, 0, "NEG", 1488 OCOM, 0, "COM", 1489 OELEM, 0, "ELEM", 1490 OTST, 0, "TST", 1491 OINDEX, 0, "INDEX", 1492 OFAS, 0, "FAS", 1493 OREGPAIR, 0, "REGPAIR", 1494 OEXREG, 0, "EXREG", 1495 OEND, 0, "END", 1496 -1, 0, 0, 1497 }; 1498 1499 /* OEQ, ONE, OLE, OLS, OLT, OLO, OGE, OHS, OGT, OHI */ 1500 char comrel[12] = 1501 { 1502 ONE, OEQ, OGT, OHI, OGE, OHS, OLT, OLO, OLE, OLS, 1503 }; 1504 char invrel[12] = 1505 { 1506 OEQ, ONE, OGE, OHS, OGT, OHI, OLE, OLS, OLT, OLO, 1507 }; 1508 char logrel[12] = 1509 { 1510 OEQ, ONE, OLS, OLS, OLO, OLO, OHS, OHS, OHI, OHI, 1511 }; 1512 1513 char typei[NTYPE]; 1514 int typeiinit[] = 1515 { 1516 TCHAR, TUCHAR, TSHORT, TUSHORT, TINT, TUINT, TLONG, TULONG, TVLONG, TUVLONG, -1, 1517 }; 1518 char typeu[NTYPE]; 1519 int typeuinit[] = 1520 { 1521 TUCHAR, TUSHORT, TUINT, TULONG, TUVLONG, TIND, -1, 1522 }; 1523 1524 char typesuv[NTYPE]; 1525 int typesuvinit[] = 1526 { 1527 TVLONG, TUVLONG, TSTRUCT, TUNION, -1, 1528 }; 1529 1530 char typeilp[NTYPE]; 1531 int typeilpinit[] = 1532 { 1533 TINT, TUINT, TLONG, TULONG, TIND, -1 1534 }; 1535 1536 char typechl[NTYPE]; 1537 char typechlv[NTYPE]; 1538 char typechlvp[NTYPE]; 1539 int typechlinit[] = 1540 { 1541 TCHAR, TUCHAR, TSHORT, TUSHORT, TINT, TUINT, TLONG, TULONG, -1, 1542 }; 1543 1544 char typechlp[NTYPE]; 1545 int typechlpinit[] = 1546 { 1547 TCHAR, TUCHAR, TSHORT, TUSHORT, TINT, TUINT, TLONG, TULONG, TIND, -1, 1548 }; 1549 1550 char typechlpfd[NTYPE]; 1551 int typechlpfdinit[] = 1552 { 1553 TCHAR, TUCHAR, TSHORT, TUSHORT, TINT, TUINT, TLONG, TULONG, TFLOAT, TDOUBLE, TIND, -1, 1554 }; 1555 1556 char typec[NTYPE]; 1557 int typecinit[] = 1558 { 1559 TCHAR, TUCHAR, -1 1560 }; 1561 1562 char typeh[NTYPE]; 1563 int typehinit[] = 1564 { 1565 TSHORT, TUSHORT, -1, 1566 }; 1567 1568 char typeil[NTYPE]; 1569 int typeilinit[] = 1570 { 1571 TINT, TUINT, TLONG, TULONG, -1, 1572 }; 1573 1574 char typev[NTYPE]; 1575 int typevinit[] = 1576 { 1577 TVLONG, TUVLONG, -1, 1578 }; 1579 1580 char typefd[NTYPE]; 1581 int typefdinit[] = 1582 { 1583 TFLOAT, TDOUBLE, -1, 1584 }; 1585 1586 char typeaf[NTYPE]; 1587 int typeafinit[] = 1588 { 1589 TFUNC, TARRAY, -1, 1590 }; 1591 1592 char typesu[NTYPE]; 1593 int typesuinit[] = 1594 { 1595 TSTRUCT, TUNION, -1, 1596 }; 1597 1598 long tasign[NTYPE]; 1599 Init tasigninit[] = 1600 { 1601 TCHAR, BNUMBER, 0, 1602 TUCHAR, BNUMBER, 0, 1603 TSHORT, BNUMBER, 0, 1604 TUSHORT, BNUMBER, 0, 1605 TINT, BNUMBER, 0, 1606 TUINT, BNUMBER, 0, 1607 TLONG, BNUMBER, 0, 1608 TULONG, BNUMBER, 0, 1609 TVLONG, BNUMBER, 0, 1610 TUVLONG, BNUMBER, 0, 1611 TFLOAT, BNUMBER, 0, 1612 TDOUBLE, BNUMBER, 0, 1613 TIND, BIND, 0, 1614 TSTRUCT, BSTRUCT, 0, 1615 TUNION, BUNION, 0, 1616 -1, 0, 0, 1617 }; 1618 1619 long tasadd[NTYPE]; 1620 Init tasaddinit[] = 1621 { 1622 TCHAR, BNUMBER, 0, 1623 TUCHAR, BNUMBER, 0, 1624 TSHORT, BNUMBER, 0, 1625 TUSHORT, BNUMBER, 0, 1626 TINT, BNUMBER, 0, 1627 TUINT, BNUMBER, 0, 1628 TLONG, BNUMBER, 0, 1629 TULONG, BNUMBER, 0, 1630 TVLONG, BNUMBER, 0, 1631 TUVLONG, BNUMBER, 0, 1632 TFLOAT, BNUMBER, 0, 1633 TDOUBLE, BNUMBER, 0, 1634 TIND, BINTEGER, 0, 1635 -1, 0, 0, 1636 }; 1637 1638 long tcast[NTYPE]; 1639 Init tcastinit[] = 1640 { 1641 TCHAR, BNUMBER|BIND|BVOID, 0, 1642 TUCHAR, BNUMBER|BIND|BVOID, 0, 1643 TSHORT, BNUMBER|BIND|BVOID, 0, 1644 TUSHORT, BNUMBER|BIND|BVOID, 0, 1645 TINT, BNUMBER|BIND|BVOID, 0, 1646 TUINT, BNUMBER|BIND|BVOID, 0, 1647 TLONG, BNUMBER|BIND|BVOID, 0, 1648 TULONG, BNUMBER|BIND|BVOID, 0, 1649 TVLONG, BNUMBER|BIND|BVOID, 0, 1650 TUVLONG, BNUMBER|BIND|BVOID, 0, 1651 TFLOAT, BNUMBER|BVOID, 0, 1652 TDOUBLE, BNUMBER|BVOID, 0, 1653 TIND, BINTEGER|BIND|BVOID, 0, 1654 TVOID, BVOID, 0, 1655 TSTRUCT, BSTRUCT|BVOID, 0, 1656 TUNION, BUNION|BVOID, 0, 1657 -1, 0, 0, 1658 }; 1659 1660 long tadd[NTYPE]; 1661 Init taddinit[] = 1662 { 1663 TCHAR, BNUMBER|BIND, 0, 1664 TUCHAR, BNUMBER|BIND, 0, 1665 TSHORT, BNUMBER|BIND, 0, 1666 TUSHORT, BNUMBER|BIND, 0, 1667 TINT, BNUMBER|BIND, 0, 1668 TUINT, BNUMBER|BIND, 0, 1669 TLONG, BNUMBER|BIND, 0, 1670 TULONG, BNUMBER|BIND, 0, 1671 TVLONG, BNUMBER|BIND, 0, 1672 TUVLONG, BNUMBER|BIND, 0, 1673 TFLOAT, BNUMBER, 0, 1674 TDOUBLE, BNUMBER, 0, 1675 TIND, BINTEGER, 0, 1676 -1, 0, 0, 1677 }; 1678 1679 long tsub[NTYPE]; 1680 Init tsubinit[] = 1681 { 1682 TCHAR, BNUMBER, 0, 1683 TUCHAR, BNUMBER, 0, 1684 TSHORT, BNUMBER, 0, 1685 TUSHORT, BNUMBER, 0, 1686 TINT, BNUMBER, 0, 1687 TUINT, BNUMBER, 0, 1688 TLONG, BNUMBER, 0, 1689 TULONG, BNUMBER, 0, 1690 TVLONG, BNUMBER, 0, 1691 TUVLONG, BNUMBER, 0, 1692 TFLOAT, BNUMBER, 0, 1693 TDOUBLE, BNUMBER, 0, 1694 TIND, BINTEGER|BIND, 0, 1695 -1, 0, 0, 1696 }; 1697 1698 long tmul[NTYPE]; 1699 Init tmulinit[] = 1700 { 1701 TCHAR, BNUMBER, 0, 1702 TUCHAR, BNUMBER, 0, 1703 TSHORT, BNUMBER, 0, 1704 TUSHORT, BNUMBER, 0, 1705 TINT, BNUMBER, 0, 1706 TUINT, BNUMBER, 0, 1707 TLONG, BNUMBER, 0, 1708 TULONG, BNUMBER, 0, 1709 TVLONG, BNUMBER, 0, 1710 TUVLONG, BNUMBER, 0, 1711 TFLOAT, BNUMBER, 0, 1712 TDOUBLE, BNUMBER, 0, 1713 -1, 0, 0, 1714 }; 1715 1716 long tand[NTYPE]; 1717 Init tandinit[] = 1718 { 1719 TCHAR, BINTEGER, 0, 1720 TUCHAR, BINTEGER, 0, 1721 TSHORT, BINTEGER, 0, 1722 TUSHORT, BINTEGER, 0, 1723 TINT, BNUMBER, 0, 1724 TUINT, BNUMBER, 0, 1725 TLONG, BINTEGER, 0, 1726 TULONG, BINTEGER, 0, 1727 TVLONG, BINTEGER, 0, 1728 TUVLONG, BINTEGER, 0, 1729 -1, 0, 0, 1730 }; 1731 1732 long trel[NTYPE]; 1733 Init trelinit[] = 1734 { 1735 TCHAR, BNUMBER, 0, 1736 TUCHAR, BNUMBER, 0, 1737 TSHORT, BNUMBER, 0, 1738 TUSHORT, BNUMBER, 0, 1739 TINT, BNUMBER, 0, 1740 TUINT, BNUMBER, 0, 1741 TLONG, BNUMBER, 0, 1742 TULONG, BNUMBER, 0, 1743 TVLONG, BNUMBER, 0, 1744 TUVLONG, BNUMBER, 0, 1745 TFLOAT, BNUMBER, 0, 1746 TDOUBLE, BNUMBER, 0, 1747 TIND, BIND, 0, 1748 -1, 0, 0, 1749 }; 1750 1751 long tfunct[1] = 1752 { 1753 BFUNC, 1754 }; 1755 1756 long tindir[1] = 1757 { 1758 BIND, 1759 }; 1760 1761 long tdot[1] = 1762 { 1763 BSTRUCT|BUNION, 1764 }; 1765 1766 long tnot[1] = 1767 { 1768 BNUMBER|BIND, 1769 }; 1770 1771 long targ[1] = 1772 { 1773 BNUMBER|BIND|BSTRUCT|BUNION, 1774 }; 1775 1776 char tab[NTYPE][NTYPE] = 1777 { 1778 /*TXXX*/ { 0, 1779 }, 1780 1781 /*TCHAR*/ { 0, TCHAR, TUCHAR, TSHORT, TUSHORT, TINT, TUINT, TLONG, 1782 TULONG, TVLONG, TUVLONG, TFLOAT, TDOUBLE, TIND, 1783 }, 1784 /*TUCHAR*/ { 0, TUCHAR, TUCHAR, TUSHORT, TUSHORT, TUINT, TUINT, TULONG, 1785 TULONG, TUVLONG, TUVLONG, TFLOAT, TDOUBLE, TIND, 1786 }, 1787 /*TSHORT*/ { 0, TSHORT, TUSHORT, TSHORT, TUSHORT, TINT, TUINT, TLONG, 1788 TULONG, TVLONG, TUVLONG, TFLOAT, TDOUBLE, TIND, 1789 }, 1790 /*TUSHORT*/ { 0, TUSHORT, TUSHORT, TUSHORT, TUSHORT, TUINT, TUINT, TULONG, 1791 TULONG, TUVLONG, TUVLONG, TFLOAT, TDOUBLE, TIND, 1792 }, 1793 /*TINT*/ { 0, TINT, TUINT, TINT, TUINT, TINT, TUINT, TLONG, 1794 TULONG, TVLONG, TUVLONG, TFLOAT, TDOUBLE, TIND, 1795 }, 1796 /*TUINT*/ { 0, TUINT, TUINT, TUINT, TUINT, TUINT, TUINT, TULONG, 1797 TULONG, TUVLONG, TUVLONG, TFLOAT, TDOUBLE, TIND, 1798 }, 1799 /*TLONG*/ { 0, TLONG, TULONG, TLONG, TULONG, TLONG, TULONG, TLONG, 1800 TULONG, TVLONG, TUVLONG, TFLOAT, TDOUBLE, TIND, 1801 }, 1802 /*TULONG*/ { 0, TULONG, TULONG, TULONG, TULONG, TULONG, TULONG, TULONG, 1803 TULONG, TUVLONG, TUVLONG, TFLOAT, TDOUBLE, TIND, 1804 }, 1805 /*TVLONG*/ { 0, TVLONG, TUVLONG, TVLONG, TUVLONG, TVLONG, TUVLONG, TVLONG, 1806 TUVLONG, TVLONG, TUVLONG, TFLOAT, TDOUBLE, TIND, 1807 }, 1808 /*TUVLONG*/ { 0, TUVLONG, TUVLONG, TUVLONG, TUVLONG, TUVLONG, TUVLONG, TUVLONG, 1809 TUVLONG, TUVLONG, TUVLONG, TFLOAT, TDOUBLE, TIND, 1810 }, 1811 /*TFLOAT*/ { 0, TFLOAT, TFLOAT, TFLOAT, TFLOAT, TFLOAT, TFLOAT, TFLOAT, 1812 TFLOAT, TFLOAT, TFLOAT, TFLOAT, TDOUBLE, TIND, 1813 }, 1814 /*TDOUBLE*/ { 0, TDOUBLE, TDOUBLE, TDOUBLE, TDOUBLE, TDOUBLE, TDOUBLE, TDOUBLE, 1815 TDOUBLE, TDOUBLE, TDOUBLE, TFLOAT, TDOUBLE, TIND, 1816 }, 1817 /*TIND*/ { 0, TIND, TIND, TIND, TIND, TIND, TIND, TIND, 1818 TIND, TIND, TIND, TIND, TIND, TIND, 1819 }, 1820 }; 1821 1822 void 1823 urk(char *name, int max, int i) 1824 { 1825 if(i >= max) { 1826 fprint(2, "bad tinit: %s %d>=%d\n", name, i, max); 1827 exits("init"); 1828 } 1829 } 1830 1831 void 1832 tinit(void) 1833 { 1834 int *ip; 1835 Init *p; 1836 1837 for(p=thashinit; p->code >= 0; p++) { 1838 urk("thash", nelem(thash), p->code); 1839 thash[p->code] = p->value; 1840 } 1841 for(p=bnamesinit; p->code >= 0; p++) { 1842 urk("bnames", nelem(bnames), p->code); 1843 bnames[p->code] = p->s; 1844 } 1845 for(p=tnamesinit; p->code >= 0; p++) { 1846 urk("tnames", nelem(tnames), p->code); 1847 tnames[p->code] = p->s; 1848 } 1849 for(p=gnamesinit; p->code >= 0; p++) { 1850 urk("gnames", nelem(gnames), p->code); 1851 gnames[p->code] = p->s; 1852 } 1853 for(p=qnamesinit; p->code >= 0; p++) { 1854 urk("qnames", nelem(qnames), p->code); 1855 qnames[p->code] = p->s; 1856 } 1857 for(p=cnamesinit; p->code >= 0; p++) { 1858 urk("cnames", nelem(cnames), p->code); 1859 cnames[p->code] = p->s; 1860 } 1861 for(p=onamesinit; p->code >= 0; p++) { 1862 urk("onames", nelem(onames), p->code); 1863 onames[p->code] = p->s; 1864 } 1865 for(ip=typeiinit; *ip>=0; ip++) { 1866 urk("typei", nelem(typei), *ip); 1867 typei[*ip] = 1; 1868 } 1869 for(ip=typeuinit; *ip>=0; ip++) { 1870 urk("typeu", nelem(typeu), *ip); 1871 typeu[*ip] = 1; 1872 } 1873 for(ip=typesuvinit; *ip>=0; ip++) { 1874 urk("typesuv", nelem(typesuv), *ip); 1875 typesuv[*ip] = 1; 1876 } 1877 for(ip=typeilpinit; *ip>=0; ip++) { 1878 urk("typeilp", nelem(typeilp), *ip); 1879 typeilp[*ip] = 1; 1880 } 1881 for(ip=typechlinit; *ip>=0; ip++) { 1882 urk("typechl", nelem(typechl), *ip); 1883 typechl[*ip] = 1; 1884 typechlv[*ip] = 1; 1885 typechlvp[*ip] = 1; 1886 } 1887 for(ip=typechlpinit; *ip>=0; ip++) { 1888 urk("typechlp", nelem(typechlp), *ip); 1889 typechlp[*ip] = 1; 1890 typechlvp[*ip] = 1; 1891 } 1892 for(ip=typechlpfdinit; *ip>=0; ip++) { 1893 urk("typechlpfd", nelem(typechlpfd), *ip); 1894 typechlpfd[*ip] = 1; 1895 } 1896 for(ip=typecinit; *ip>=0; ip++) { 1897 urk("typec", nelem(typec), *ip); 1898 typec[*ip] = 1; 1899 } 1900 for(ip=typehinit; *ip>=0; ip++) { 1901 urk("typeh", nelem(typeh), *ip); 1902 typeh[*ip] = 1; 1903 } 1904 for(ip=typeilinit; *ip>=0; ip++) { 1905 urk("typeil", nelem(typeil), *ip); 1906 typeil[*ip] = 1; 1907 } 1908 for(ip=typevinit; *ip>=0; ip++) { 1909 urk("typev", nelem(typev), *ip); 1910 typev[*ip] = 1; 1911 typechlv[*ip] = 1; 1912 typechlvp[*ip] = 1; 1913 } 1914 for(ip=typefdinit; *ip>=0; ip++) { 1915 urk("typefd", nelem(typefd), *ip); 1916 typefd[*ip] = 1; 1917 } 1918 for(ip=typeafinit; *ip>=0; ip++) { 1919 urk("typeaf", nelem(typeaf), *ip); 1920 typeaf[*ip] = 1; 1921 } 1922 for(ip=typesuinit; *ip >= 0; ip++) { 1923 urk("typesu", nelem(typesu), *ip); 1924 typesu[*ip] = 1; 1925 } 1926 for(p=tasigninit; p->code >= 0; p++) { 1927 urk("tasign", nelem(tasign), p->code); 1928 tasign[p->code] = p->value; 1929 } 1930 for(p=tasaddinit; p->code >= 0; p++) { 1931 urk("tasadd", nelem(tasadd), p->code); 1932 tasadd[p->code] = p->value; 1933 } 1934 for(p=tcastinit; p->code >= 0; p++) { 1935 urk("tcast", nelem(tcast), p->code); 1936 tcast[p->code] = p->value; 1937 } 1938 for(p=taddinit; p->code >= 0; p++) { 1939 urk("tadd", nelem(tadd), p->code); 1940 tadd[p->code] = p->value; 1941 } 1942 for(p=tsubinit; p->code >= 0; p++) { 1943 urk("tsub", nelem(tsub), p->code); 1944 tsub[p->code] = p->value; 1945 } 1946 for(p=tmulinit; p->code >= 0; p++) { 1947 urk("tmul", nelem(tmul), p->code); 1948 tmul[p->code] = p->value; 1949 } 1950 for(p=tandinit; p->code >= 0; p++) { 1951 urk("tand", nelem(tand), p->code); 1952 tand[p->code] = p->value; 1953 } 1954 for(p=trelinit; p->code >= 0; p++) { 1955 urk("trel", nelem(trel), p->code); 1956 trel[p->code] = p->value; 1957 } 1958 1959 /* 32-bit defaults */ 1960 typeword = typechlp; 1961 typeswitch = typechl; 1962 typecmplx = typesuv; 1963 } 1964 1965 /* 1966 * return 1 if it is impossible to jump into the middle of n. 1967 */ 1968 static int 1969 deadhead(Node *n, int caseok) 1970 { 1971 loop: 1972 if(n == Z) 1973 return 1; 1974 switch(n->op) { 1975 case OLIST: 1976 if(!deadhead(n->left, caseok)) 1977 return 0; 1978 rloop: 1979 n = n->right; 1980 goto loop; 1981 1982 case ORETURN: 1983 break; 1984 1985 case OLABEL: 1986 return 0; 1987 1988 case OGOTO: 1989 break; 1990 1991 case OCASE: 1992 if(!caseok) 1993 return 0; 1994 goto rloop; 1995 1996 case OSWITCH: 1997 return deadhead(n->right, 1); 1998 1999 case OWHILE: 2000 case ODWHILE: 2001 goto rloop; 2002 2003 case OFOR: 2004 goto rloop; 2005 2006 case OCONTINUE: 2007 break; 2008 2009 case OBREAK: 2010 break; 2011 2012 case OIF: 2013 return deadhead(n->right->left, caseok) && deadhead(n->right->right, caseok); 2014 2015 case OSET: 2016 case OUSED: 2017 break; 2018 } 2019 return 1; 2020 } 2021 2022 int 2023 deadheads(Node *c) 2024 { 2025 return deadhead(c->left, 0) && deadhead(c->right, 0); 2026 } 2027 2028 int 2029 mixedasop(Type *l, Type *r) 2030 { 2031 return !typefd[l->etype] && typefd[r->etype]; 2032 } 2033