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