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