sys/src/cmd/cc/sub.c

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