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