sys/src/cmd/cc/sub.c

   1 #include        "cc.h"
   2
   3 Node*
   4 new(int t, Node *l, Node *r)
   5 {
   6         Node *n;
   7
   8         n = alloc(sizeof(*n));
   9         n->op = t;
  10         n->left = l;
  11         n->right = r;
  12         if(l && t != OGOTO)
  13                 n->lineno = l->lineno;
  14         else if(r)
  15                 n->lineno = r->lineno;
  16         else
  17                 n->lineno = lineno;
  18         newflag = 1;
  19         return n;
  20 }
  21
  22 Node*
  23 new1(int o, Node *l, Node *r)
  24 {
  25         Node *n;
  26
  27         n = new(o, l, r);
  28         n->lineno = nearln;
  29         return n;
  30 }
  31
  32 void
  33 prtree(Node *n, char *s)
  34 {
  35
  36         print(" == %s ==\n", s);
  37         prtree1(n, 0, 0);
  38         print("\n");
  39 }
  40
  41 void
  42 prtree1(Node *n, int d, int f)
  43 {
  44         int i;
  45
  46         if(f)
  47         for(i=0; i<d; i++)
  48                 print("   ");
  49         if(n == Z) {
  50                 print("Z\n");
  51                 return;
  52         }
  53         if(n->op == OLIST) {
  54                 prtree1(n->left, d, 0);
  55                 prtree1(n->right, d, 1);
  56                 return;
  57         }
  58         d++;
  59         print("%O", n->op);
  60         i = 3;
  61         switch(n->op)
  62         {
  63         case ONAME:
  64                 print(" \"%F\"", n);
  65                 print(" %ld", n->xoffset);
  66                 i = 0;
  67                 break;
  68
  69         case OINDREG:
  70                 print(" %ld(R%d)", n->xoffset, n->reg);
  71                 i = 0;
  72                 break;
  73
  74         case OREGISTER:
  75                 if(n->xoffset)
  76                         print(" %ld+R%d", n->xoffset, n->reg);
  77                 else
  78                         print(" R%d", n->reg);
  79                 i = 0;
  80                 break;
  81
  82         case OSTRING:
  83                 print(" \"%s\"", n->cstring);
  84                 i = 0;
  85                 break;
  86
  87         case OLSTRING:
  88                 print(" \"%S\"", n->rstring);
  89                 i = 0;
  90                 break;
  91
  92         case ODOT:
  93         case OELEM:
  94                 print(" \"%F\"", n);
  95                 break;
  96
  97         case OCONST:
  98                 if(typefd[n->type->etype])
  99                         print(" \"%.8e\"", n->fconst);
 100                 else
 101                         print(" \"%lld\"", n->vconst);
 102                 i = 0;
 103                 break;
 104         }
 105         if(n->addable != 0)
 106                 print(" <%d>", n->addable);
 107         if(n->type != T)
 108                 print(" %T", n->type);
 109         if(n->complex != 0)
 110                 print(" (%d)", n->complex);
 111         print(" %L\n", n->lineno);
 112         if(i & 2)
 113                 prtree1(n->left, d, 1);
 114         if(i & 1)
 115                 prtree1(n->right, d, 1);
 116 }
 117
 118 Type*
 119 typ(int et, Type *d)
 120 {
 121         Type *t;
 122
 123         t = alloc(sizeof(*t));
 124         t->etype = et;
 125         t->link = d;
 126         t->down = T;
 127         t->sym = S;
 128         t->width = ewidth[et];
 129         t->offset = 0;
 130         t->shift = 0;
 131         t->nbits = 0;
 132         t->garb = 0;
 133         return t;
 134 }
 135
 136 Type*
 137 copytyp(Type *t)
 138 {
 139         Type *nt;
 140
 141         nt = typ(TXXX, T);
 142         *nt = *t;
 143         return nt;
 144 }
 145
 146 Type*
 147 garbt(Type *t, long b)
 148 {
 149         Type *t1;
 150
 151         if(b & BGARB) {
 152                 t1 = copytyp(t);
 153                 t1->garb = simpleg(b);
 154                 return t1;
 155         }
 156         return t;
 157 }
 158
 159 int
 160 simpleg(long b)
 161 {
 162
 163         b &= BGARB;
 164         switch(b) {
 165         case BCONSTNT:
 166                 return GCONSTNT;
 167         case BVOLATILE:
 168                 return GVOLATILE;
 169         case BVOLATILE|BCONSTNT:
 170                 return GCONSTNT|GVOLATILE;
 171         }
 172         return GXXX;
 173 }
 174
 175 int
 176 simplec(long b)
 177 {
 178
 179         b &= BCLASS;
 180         switch(b) {
 181         case 0:
 182         case BREGISTER:
 183                 return CXXX;
 184         case BAUTO:
 185         case BAUTO|BREGISTER:
 186                 return CAUTO;
 187         case BEXTERN:
 188                 return CEXTERN;
 189         case BEXTERN|BREGISTER:
 190                 return CEXREG;
 191         case BSTATIC:
 192                 return CSTATIC;
 193         case BTYPEDEF:
 194                 return CTYPEDEF;
 195         case BTYPESTR:
 196                 return CTYPESTR;
 197         }
 198         diag(Z, "illegal combination of classes %Q", b);
 199         return CXXX;
 200 }
 201
 202 Type*
 203 simplet(long b)
 204 {
 205
 206         b &= ~BCLASS & ~BGARB;
 207         switch(b) {
 208         case BCHAR:
 209         case BCHAR|BSIGNED:
 210                 return types[TCHAR];
 211
 212         case BCHAR|BUNSIGNED:
 213                 return types[TUCHAR];
 214
 215         case BSHORT:
 216         case BSHORT|BINT:
 217         case BSHORT|BSIGNED:
 218         case BSHORT|BINT|BSIGNED:
 219                 return types[TSHORT];
 220
 221         case BUNSIGNED|BSHORT:
 222         case BUNSIGNED|BSHORT|BINT:
 223                 return types[TUSHORT];
 224
 225         case 0:
 226         case BINT:
 227         case BINT|BSIGNED:
 228         case BSIGNED:
 229                 return types[TINT];
 230
 231         case BUNSIGNED:
 232         case BUNSIGNED|BINT:
 233                 return types[TUINT];
 234
 235         case BLONG:
 236         case BLONG|BINT:
 237         case BLONG|BSIGNED:
 238         case BLONG|BINT|BSIGNED:
 239                 return types[TLONG];
 240
 241         case BUNSIGNED|BLONG:
 242         case BUNSIGNED|BLONG|BINT:
 243                 return types[TULONG];
 244
 245         case BVLONG|BLONG:
 246         case BVLONG|BLONG|BINT:
 247         case BVLONG|BLONG|BSIGNED:
 248         case BVLONG|BLONG|BINT|BSIGNED:
 249                 return types[TVLONG];
 250
 251         case BVLONG|BLONG|BUNSIGNED:
 252         case BVLONG|BLONG|BINT|BUNSIGNED:
 253                 return types[TUVLONG];
 254
 255         case BFLOAT:
 256                 return types[TFLOAT];
 257
 258         case BDOUBLE:
 259         case BDOUBLE|BLONG:
 260         case BFLOAT|BLONG:
 261                 return types[TDOUBLE];
 262
 263         case BVOID:
 264                 return types[TVOID];
 265         }
 266
 267         diag(Z, "illegal combination of types %Q", b);
 268         return types[TINT];
 269 }
 270
 271 int
 272 stcompat(Node *n, Type *t1, Type *t2, long ttab[])
 273 {
 274         int i;
 275         ulong b;
 276
 277         i = 0;
 278         if(t2 != T)
 279                 i = t2->etype;
 280         b = 1L << i;
 281         i = 0;
 282         if(t1 != T)
 283                 i = t1->etype;
 284         if(b & ttab[i]) {
 285                 if(ttab == tasign)
 286                         if(b == BSTRUCT || b == BUNION)
 287                                 if(!sametype(t1, t2))
 288                                         return 1;
 289                 if(n->op != OCAST)
 290                         if(b == BIND && i == TIND)
 291                                 if(!sametype(t1, t2))
 292                                         return 1;
 293                 return 0;
 294         }
 295         return 1;
 296 }
 297
 298 int
 299 tcompat(Node *n, Type *t1, Type *t2, long ttab[])
 300 {
 301
 302         if(stcompat(n, t1, t2, ttab)) {
 303                 if(t1 == T)
 304                         diag(n, "incompatible type: \"%T\" for op \"%O\"",
 305                                 t2, n->op);
 306                 else
 307                         diag(n, "incompatible types: \"%T\" and \"%T\" for op \"%O\"",
 308                                 t1, t2, n->op);
 309                 return 1;
 310         }
 311         return 0;
 312 }
 313
 314 void
 315 makedot(Node *n, Type *t, long o)
 316 {
 317         Node *n1, *n2;
 318
 319         if(t->nbits) {
 320                 n1 = new(OXXX, Z, Z);
 321                 *n1 = *n;
 322                 n->op = OBIT;
 323                 n->left = n1;
 324                 n->right = Z;
 325                 n->type = t;
 326                 n->addable = n1->left->addable;
 327                 n = n1;
 328         }
 329         n->addable = n->left->addable;
 330         if(n->addable == 0) {
 331                 n1 = new1(OCONST, Z, Z);
 332                 n1->vconst = o;
 333                 n1->type = types[TLONG];
 334                 n->right = n1;
 335                 n->type = t;
 336                 return;
 337         }
 338         n->left->type = t;
 339         if(o == 0) {
 340                 *n = *n->left;
 341                 return;
 342         }
 343         n->type = t;
 344         n1 = new1(OCONST, Z, Z);
 345         n1->vconst = o;
 346         t = typ(TIND, t);
 347         t->width = types[TIND]->width;
 348         n1->type = t;
 349
 350         n2 = new1(OADDR, n->left, Z);
 351         n2->type = t;
 352
 353         n1 = new1(OADD, n1, n2);
 354         n1->type = t;
 355
 356         n->op = OIND;
 357         n->left = n1;
 358         n->right = Z;
 359 }
 360
 361 Type*
 362 dotsearch(Sym *s, Type *t, Node *n, long *off)
 363 {
 364         Type *t1, *xt, *rt;
 365
 366         xt = T;
 367
 368         /*
 369          * look it up by name
 370          */
 371         for(t1 = t; t1 != T; t1 = t1->down)
 372                 if(t1->sym == s) {
 373                         if(xt != T)
 374                                 goto ambig;
 375                         xt = t1;
 376                 }
 377
 378         /*
 379          * look it up by type
 380          */
 381         if(s->class == CTYPEDEF || s->class == CTYPESTR)
 382                 for(t1 = t; t1 != T; t1 = t1->down)
 383                         if(t1->sym == S && typesu[t1->etype])
 384                                 if(sametype(s->type, t1)) {
 385                                         if(xt != T)
 386                                                 goto ambig;
 387                                         xt = t1;
 388                                 }
 389         if(xt != T) {
 390                 *off = xt->offset;
 391                 return xt;
 392         }
 393
 394         /*
 395          * look it up in unnamed substructures
 396          */
 397         for(t1 = t; t1 != T; t1 = t1->down)
 398                 if(t1->sym == S && typesu[t1->etype]){
 399                         rt = dotsearch(s, t1->link, n, off);
 400                         if(rt != T) {
 401                                 if(xt != T)
 402                                         goto ambig;
 403                                 xt = rt;
 404                                 *off += t1->offset;
 405                         }
 406                 }
 407         return xt;
 408
 409 ambig:
 410         diag(n, "ambiguous structure element: %s", s->name);
 411         return xt;
 412 }
 413
 414 long
 415 dotoffset(Type *st, Type *lt, Node *n)
 416 {
 417         Type *t;
 418         Sym *g;
 419         long o, o1;
 420
 421         o = -1;
 422         /*
 423          * first try matching at the top level
 424          * for matching tag names
 425          */
 426         g = st->tag;
 427         if(g != S)
 428                 for(t=lt->link; t!=T; t=t->down)
 429                         if(t->sym == S)
 430                                 if(g == t->tag) {
 431                                         if(o >= 0)
 432                                                 goto ambig;
 433                                         o = t->offset;
 434                                 }
 435         if(o >= 0)
 436                 return o;
 437
 438         /*
 439          * second try matching at the top level
 440          * for similar types
 441          */
 442         for(t=lt->link; t!=T; t=t->down)
 443                 if(t->sym == S)
 444                         if(sametype(st, t)) {
 445                                 if(o >= 0)
 446                                         goto ambig;
 447                                 o = t->offset;
 448                         }
 449         if(o >= 0)
 450                 return o;
 451
 452         /*
 453          * last try matching sub-levels
 454          */
 455         for(t=lt->link; t!=T; t=t->down)
 456                 if(t->sym == S)
 457                 if(typesu[t->etype]) {
 458                         o1 = dotoffset(st, t, n);
 459                         if(o1 >= 0) {
 460                                 if(o >= 0)
 461                                         goto ambig;
 462                                 o = o1 + t->offset;
 463                         }
 464                 }
 465         return o;
 466
 467 ambig:
 468         diag(n, "ambiguous unnamed structure element");
 469         return o;
 470 }
 471
 472 /*
 473  * look into tree for floating point constant expressions
 474  */
 475 int
 476 allfloat(Node *n, int flag)
 477 {
 478
 479         if(n != Z) {
 480                 if(n->type->etype != TDOUBLE)
 481                         return 1;
 482                 switch(n->op) {
 483                 case OCONST:
 484                         if(flag)
 485                                 n->type = types[TFLOAT];
 486                         return 1;
 487                 case OADD:      /* no need to get more exotic than this */
 488                 case OSUB:
 489                 case OMUL:
 490                 case ODIV:
 491                         if(!allfloat(n->right, flag))
 492                                 break;
 493                 case OCAST:
 494                         if(!allfloat(n->left, flag))
 495                                 break;
 496                         if(flag)
 497                                 n->type = types[TFLOAT];
 498                         return 1;
 499                 }
 500         }
 501         return 0;
 502 }
 503
 504 void
 505 constas(Node *n, Type *il, Type *ir)
 506 {
 507         Type *l, *r;
 508
 509         l = il;
 510         r = ir;
 511
 512         if(l == T)
 513                 return;
 514         if(l->garb & GCONSTNT) {
 515                 warn(n, "assignment to a constant type (%T)", il);
 516                 return;
 517         }
 518         if(r == T)
 519                 return;
 520         for(;;) {
 521                 if(l->etype != TIND || r->etype != TIND)
 522                         break;
 523                 l = l->link;
 524                 r = r->link;
 525                 if(l == T || r == T)
 526                         break;
 527                 if(r->garb & GCONSTNT)
 528                         if(!(l->garb & GCONSTNT)) {
 529                                 warn(n, "assignment of a constant pointer type (%T)", ir);
 530                                 break;
 531                         }
 532         }
 533 }
 534
 535 void
 536 typeext1(Type *st, Node *l)
 537 {
 538         if(st->etype == TFLOAT && allfloat(l, 0))
 539                 allfloat(l, 1);
 540 }
 541
 542 void
 543 typeext(Type *st, Node *l)
 544 {
 545         Type *lt;
 546         Node *n1, *n2;
 547         long o;
 548
 549         lt = l->type;
 550         if(lt == T)
 551                 return;
 552         if(st->etype == TIND && vconst(l) == 0) {
 553                 l->type = st;
 554                 l->vconst = 0;
 555                 return;
 556         }
 557         typeext1(st, l);
 558
 559         /*
 560          * extension of C
 561          * if assign of struct containing unnamed sub-struct
 562          * to type of sub-struct, insert the DOT.
 563          * if assign of *struct containing unnamed substruct
 564          * to type of *sub-struct, insert the add-offset
 565          */
 566         if(typesu[st->etype] && typesu[lt->etype]) {
 567                 o = dotoffset(st, lt, l);
 568                 if(o >= 0) {
 569                         n1 = new1(OXXX, Z, Z);
 570                         *n1 = *l;
 571                         l->op = ODOT;
 572                         l->left = n1;
 573                         l->right = Z;
 574                         makedot(l, st, o);
 575                 }
 576                 return;
 577         }
 578         if(st->etype == TIND && typesu[st->link->etype])
 579         if(lt->etype == TIND && typesu[lt->link->etype]) {
 580                 o = dotoffset(st->link, lt->link, l);
 581                 if(o >= 0) {
 582                         l->type = st;
 583                         if(o == 0)
 584                                 return;
 585                         n1 = new1(OXXX, Z, Z);
 586                         *n1 = *l;
 587                         n2 = new1(OCONST, Z, Z);
 588                         n2->vconst = o;
 589                         n2->type = st;
 590                         l->op = OADD;
 591                         l->left = n1;
 592                         l->right = n2;
 593                 }
 594                 return;
 595         }
 596 }
 597
 598 /*
 599  * a cast that generates no code
 600  * (same size move)
 601  */
 602 int
 603 nocast(Type *t1, Type *t2)
 604 {
 605         int i, b;
 606
 607         if(t1->nbits)
 608                 return 0;
 609         i = 0;
 610         if(t2 != T)
 611                 i = t2->etype;
 612         b = 1<<i;
 613         i = 0;
 614         if(t1 != T)
 615                 i = t1->etype;
 616         if(b & ncast[i])
 617                 return 1;
 618         return 0;
 619 }
 620
 621 /*
 622  * a cast that has a noop semantic
 623  * (small to large, convert)
 624  */
 625 int
 626 nilcast(Type *t1, Type *t2)
 627 {
 628         int et1, et2;
 629
 630         if(t1 == T)
 631                 return 0;
 632         if(t1->nbits)
 633                 return 0;
 634         if(t2 == T)
 635                 return 0;
 636         et1 = t1->etype;
 637         et2 = t2->etype;
 638         if(et1 == et2)
 639                 return 1;
 640         if(typefd[et1] && typefd[et2]) {
 641                 if(ewidth[et1] < ewidth[et2])
 642                         return 1;
 643                 return 0;
 644         }
 645         if(typechlp[et1] && typechlp[et2]) {
 646                 if(ewidth[et1] < ewidth[et2])
 647                         return 1;
 648                 return 0;
 649         }
 650         return 0;
 651 }
 652
 653 /*
 654  * "the usual arithmetic conversions are performed"
 655  */
 656 void
 657 arith(Node *n, int f)
 658 {
 659         Type *t1, *t2;
 660         int i, j, k;
 661         Node *n1;
 662         long w;
 663
 664         t1 = n->left->type;
 665         if(n->right == Z)
 666                 t2 = t1;
 667         else
 668                 t2 = n->right->type;
 669         i = TXXX;
 670         if(t1 != T)
 671                 i = t1->etype;
 672         j = TXXX;
 673         if(t2 != T)
 674                 j = t2->etype;
 675         k = tab[i][j];
 676         if(k == TIND) {
 677                 if(i == TIND)
 678                         n->type = t1;
 679                 else
 680                 if(j == TIND)
 681                         n->type = t2;
 682         } else {
 683                 /* convert up to at least int */
 684                 if(f == 1)
 685                 while(k < TINT)
 686                         k += 2;
 687                 n->type = types[k];
 688         }
 689         if(n->op == OSUB)
 690         if(i == TIND && j == TIND) {
 691                 w = n->right->type->link->width;
 692                 if(w < 1 || n->left->type->link == T || n->left->type->link->width < 1)
 693                         goto bad;
 694                 n->type = types[ewidth[TIND] <= ewidth[TLONG]? TLONG: TVLONG];
 695                 if(1 && ewidth[TIND] > ewidth[TLONG]){
 696                         n1 = new1(OXXX, Z, Z);
 697                         *n1 = *n;
 698                         n->op = OCAST;
 699                         n->left = n1;
 700                         n->right = Z;
 701                         n->type = types[TLONG];
 702                 }
 703                 if(w > 1) {
 704                         n1 = new1(OXXX, Z, Z);
 705                         *n1 = *n;
 706                         n->op = ODIV;
 707                         n->left = n1;
 708                         n1 = new1(OCONST, Z, Z);
 709                         n1->vconst = w;
 710                         n1->type = n->type;
 711                         n->right = n1;
 712                         w = vlog(n1);
 713                         if(w >= 0) {
 714                                 n->op = OASHR;
 715                                 n1->vconst = w;
 716                         }
 717                 }
 718                 return;
 719         }
 720         if(!sametype(n->type, n->left->type)) {
 721                 n->left = new1(OCAST, n->left, Z);
 722                 n->left->type = n->type;
 723                 if(n->type->etype == TIND) {
 724                         w = n->type->link->width;
 725                         if(w < 1) {
 726                                 snap(n->type->link);
 727                                 w = n->type->link->width;
 728                                 if(w < 1)
 729                                         goto bad;
 730                         }
 731                         if(w > 1) {
 732                                 n1 = new1(OCONST, Z, Z);
 733                                 n1->vconst = w;
 734                                 n1->type = n->type;
 735                                 n->left = new1(OMUL, n->left, n1);
 736                                 n->left->type = n->type;
 737                         }
 738                 }
 739         }
 740         if(n->right != Z)
 741         if(!sametype(n->type, n->right->type)) {
 742                 n->right = new1(OCAST, n->right, Z);
 743                 n->right->type = n->type;
 744                 if(n->type->etype == TIND) {
 745                         w = n->type->link->width;
 746                         if(w < 1) {
 747                                 snap(n->type->link);
 748                                 w = n->type->link->width;
 749                                 if(w < 1)
 750                                         goto bad;
 751                         }
 752                         if(w != 1) {
 753                                 n1 = new1(OCONST, Z, Z);
 754                                 n1->vconst = w;
 755                                 n1->type = n->type;
 756                                 n->right = new1(OMUL, n->right, n1);
 757                                 n->right->type = n->type;
 758                         }
 759                 }
 760         }
 761         return;
 762 bad:
 763         diag(n, "pointer addition not fully declared: %T", n->type->link);
 764 }
 765
 766 /*
 767  * try to rewrite shift & mask
 768  */
 769 void
 770 simplifyshift(Node *n)
 771 {
 772         ulong c3;
 773         int o, s1, s2, c1, c2;
 774
 775         if(!typechlp[n->type->etype])
 776                 return;
 777         switch(n->op) {
 778         default:
 779                 return;
 780         case OASHL:
 781                 s1 = 0;
 782                 break;
 783         case OLSHR:
 784                 s1 = 1;
 785                 break;
 786         case OASHR:
 787                 s1 = 2;
 788                 break;
 789         }
 790         if(n->right->op != OCONST)
 791                 return;
 792         if(n->left->op != OAND)
 793                 return;
 794         if(n->left->right->op != OCONST)
 795                 return;
 796         switch(n->left->left->op) {
 797         default:
 798                 return;
 799         case OASHL:
 800                 s2 = 0;
 801                 break;
 802         case OLSHR:
 803                 s2 = 1;
 804                 break;
 805         case OASHR:
 806                 s2 = 2;
 807                 break;
 808         }
 809         if(n->left->left->right->op != OCONST)
 810                 return;
 811
 812         c1 = n->right->vconst;
 813         c2 = n->left->left->right->vconst;
 814         c3 = n->left->right->vconst;
 815
 816 /*
 817         if(debug['h'])
 818                 print("%.3o %ld %ld %d #%.lux\n",
 819                         (s1<<3)|s2, c1, c2, topbit(c3), c3);
 820 */
 821
 822         o = n->op;
 823         switch((s1<<3)|s2) {
 824         case 000:       /* (((e <<u c2) & c3) <<u c1) */
 825                 c3 >>= c2;
 826                 c1 += c2;
 827                 if(c1 >= 32)
 828                         break;
 829                 goto rewrite1;
 830
 831         case 002:       /* (((e >>s c2) & c3) <<u c1) */
 832                 if(topbit(c3) >= (32-c2))
 833                         break;
 834         case 001:       /* (((e >>u c2) & c3) <<u c1) */
 835                 if(c1 > c2) {
 836                         c3 <<= c2;
 837                         c1 -= c2;
 838                         o = OASHL;
 839                         goto rewrite1;
 840                 }
 841                 c3 <<= c1;
 842                 if(c1 == c2)
 843                         goto rewrite0;
 844                 c1 = c2-c1;
 845                 o = OLSHR;
 846                 goto rewrite2;
 847
 848         case 022:       /* (((e >>s c2) & c3) >>s c1) */
 849                 if(c2 <= 0)
 850                         break;
 851         case 012:       /* (((e >>s c2) & c3) >>u c1) */
 852                 if(topbit(c3) >= (32-c2))
 853                         break;
 854                 goto s11;
 855         case 021:       /* (((e >>u c2) & c3) >>s c1) */
 856                 if(topbit(c3) >= 31 && c2 <= 0)
 857                         break;
 858                 goto s11;
 859         case 011:       /* (((e >>u c2) & c3) >>u c1) */
 860         s11:
 861                 c3 <<= c2;
 862                 c1 += c2;
 863                 if(c1 >= 32)
 864                         break;
 865                 o = OLSHR;
 866                 goto rewrite1;
 867
 868         case 020:       /* (((e <<u c2) & c3) >>s c1) */
 869                 if(topbit(c3) >= 31)
 870                         break;
 871         case 010:       /* (((e <<u c2) & c3) >>u c1) */
 872                 c3 >>= c1;
 873                 if(c1 == c2)
 874                         goto rewrite0;
 875                 if(c1 > c2) {
 876                         c1 -= c2;
 877                         goto rewrite2;
 878                 }
 879                 c1 = c2 - c1;
 880                 o = OASHL;
 881                 goto rewrite2;
 882         }
 883         return;
 884
 885 rewrite0:       /* get rid of both shifts */
 886 if(debug['<'])prtree(n, "rewrite0");
 887         *n = *n->left;
 888         n->left = n->left->left;
 889         n->right->vconst = c3;
 890         return;
 891 rewrite1:       /* get rid of lower shift */
 892 if(debug['<'])prtree(n, "rewrite1");
 893         n->left->left = n->left->left->left;
 894         n->left->right->vconst = c3;
 895         n->right->vconst = c1;
 896         n->op = o;
 897         return;
 898 rewrite2:       /* get rid of upper shift */
 899 if(debug['<'])prtree(n, "rewrite2");
 900         *n = *n->left;
 901         n->right->vconst = c3;
 902         n->left->right->vconst = c1;
 903         n->left->op = o;
 904 }
 905
 906 int
 907 side(Node *n)
 908 {
 909
 910 loop:
 911         if(n != Z)
 912         switch(n->op) {
 913         case OCAST:
 914         case ONOT:
 915         case OADDR:
 916         case OIND:
 917                 n = n->left;
 918                 goto loop;
 919
 920         case OCOND:
 921                 if(side(n->left))
 922                         break;
 923                 n = n->right;
 924
 925         case OEQ:
 926         case ONE:
 927         case OLT:
 928         case OGE:
 929         case OGT:
 930         case OLE:
 931         case OADD:
 932         case OSUB:
 933         case OMUL:
 934         case OLMUL:
 935         case ODIV:
 936         case OLDIV:
 937         case OLSHR:
 938         case OASHL:
 939         case OASHR:
 940         case OAND:
 941         case OOR:
 942         case OXOR:
 943         case OMOD:
 944         case OLMOD:
 945         case OANDAND:
 946         case OOROR:
 947         case OCOMMA:
 948         case ODOT:
 949                 if(side(n->left))
 950                         break;
 951                 n = n->right;
 952                 goto loop;
 953
 954         case OSIGN:
 955         case OSIZE:
 956         case OCONST:
 957         case OSTRING:
 958         case OLSTRING:
 959         case ONAME:
 960                 return 0;
 961         }
 962         return 1;
 963 }
 964
 965 int
 966 vconst(Node *n)
 967 {
 968         int i;
 969
 970         if(n == Z)
 971                 goto no;
 972         if(n->op != OCONST)
 973                 goto no;
 974         if(n->type == T)
 975                 goto no;
 976         switch(n->type->etype)
 977         {
 978         case TFLOAT:
 979         case TDOUBLE:
 980                 i = 100;
 981                 if(n->fconst > i || n->fconst < -i)
 982                         goto no;
 983                 i = n->fconst;
 984                 if(i != n->fconst)
 985                         goto no;
 986                 return i;
 987
 988         case TVLONG:
 989         case TUVLONG:
 990                 i = n->vconst;
 991                 if(i != n->vconst)
 992                         goto no;
 993                 return i;
 994
 995         case TCHAR:
 996         case TUCHAR:
 997         case TSHORT:
 998         case TUSHORT:
 999         case TINT:
1000         case TUINT:
1001         case TLONG:
1002         case TULONG:
1003         case TIND:
1004                 i = n->vconst;
1005                 if(i != n->vconst)
1006                         goto no;
1007                 return i;
1008         }
1009 no:
1010         return -159;    /* first uninteresting constant */
1011 }
1012
1013 /*
1014  * return log(n) if n is a power of 2 constant
1015  */
1016 int
1017 log2(uvlong v)
1018 {
1019         int s, i;
1020         uvlong m;
1021
1022         s = 0;
1023         m = MASK(8*sizeof(uvlong));
1024         for(i=32; i; i>>=1) {
1025                 m >>= i;
1026                 if(!(v & m)) {
1027                         v >>= i;
1028                         s += i;
1029                 }
1030         }
1031         if(v == 1)
1032                 return s;
1033         return -1;
1034 }
1035
1036 int
1037 vlog(Node *n)
1038 {
1039         if(n->op != OCONST)
1040                 goto bad;
1041         if(typefd[n->type->etype])
1042                 goto bad;
1043
1044         return log2(n->vconst);
1045
1046 bad:
1047         return -1;
1048 }
1049
1050 int
1051 topbit(ulong v)
1052 {
1053         int i;
1054
1055         for(i = -1; v; i++)
1056                 v >>= 1;
1057         return i;
1058 }
1059
1060 /*
1061  * try to cast a constant down
1062  * rather than cast a variable up
1063  * example:
1064  *      if(c == 'a')
1065  */
1066 void
1067 relcon(Node *l, Node *r)
1068 {
1069         vlong v;
1070
1071         if(l->op != OCONST)
1072                 return;
1073         if(r->op != OCAST)
1074                 return;
1075         if(!nilcast(r->left->type, r->type))
1076                 return;
1077         switch(r->type->etype) {
1078         default:
1079                 return;
1080         case TCHAR:
1081         case TUCHAR:
1082         case TSHORT:
1083         case TUSHORT:
1084                 v = convvtox(l->vconst, r->type->etype);
1085                 if(v != l->vconst)
1086                         return;
1087                 break;
1088         }
1089         l->type = r->left->type;
1090         *r = *r->left;
1091 }
1092
1093 int
1094 relindex(int o)
1095 {
1096
1097         switch(o) {
1098         default:
1099                 diag(Z, "bad in relindex: %O", o);
1100         case OEQ: return 0;
1101         case ONE: return 1;
1102         case OLE: return 2;
1103         case OLS: return 3;
1104         case OLT: return 4;
1105         case OLO: return 5;
1106         case OGE: return 6;
1107         case OHS: return 7;
1108         case OGT: return 8;
1109         case OHI: return 9;
1110         }
1111 }
1112
1113 Node*
1114 invert(Node *n)
1115 {
1116         Node *i;
1117
1118         if(n == Z || n->op != OLIST)
1119                 return n;
1120         i = n;
1121         for(n = n->left; n != Z; n = n->left) {
1122                 if(n->op != OLIST)
1123                         break;
1124                 i->left = n->right;
1125                 n->right = i;
1126                 i = n;
1127         }
1128         i->left = n;
1129         return i;
1130 }
1131
1132 int
1133 bitno(long b)
1134 {
1135         int i;
1136
1137         for(i=0; i<32; i++)
1138                 if(b & (1L<<i))
1139                         return i;
1140         diag(Z, "bad in bitno");
1141         return 0;
1142 }
1143
1144 long
1145 typebitor(long a, long b)
1146 {
1147         long c;
1148
1149         c = a | b;
1150         if(a & b)
1151                 if((a & b) == BLONG)
1152                         c |= BVLONG;            /* long long => vlong */
1153                 else
1154                         warn(Z, "once is enough: %Q", a & b);
1155         return c;
1156 }
1157
1158 void
1159 diag(Node *n, char *fmt, ...)
1160 {
1161         char buf[STRINGSZ];
1162         va_list arg;
1163
1164         va_start(arg, fmt);
1165         vseprint(buf, buf+sizeof(buf), fmt, arg);
1166         va_end(arg);
1167         Bprint(&diagbuf, "%L %s\n", (n==Z)? nearln: n->lineno, buf);
1168
1169         if(debug['X']){
1170                 Bflush(&diagbuf);
1171                 abort();
1172         }
1173         if(n != Z)
1174         if(debug['v'])
1175                 prtree(n, "diagnostic");
1176
1177         nerrors++;
1178         if(nerrors > 10) {
1179                 Bprint(&diagbuf, "too many errors\n");
1180                 errorexit();
1181         }
1182 }
1183
1184 void
1185 warn(Node *n, char *fmt, ...)
1186 {
1187         char buf[STRINGSZ];
1188         va_list arg;
1189
1190         if(debug['w']) {
1191                 Bprint(&diagbuf, "warning: ");
1192                 va_start(arg, fmt);
1193                 vseprint(buf, buf+sizeof(buf), fmt, arg);
1194                 va_end(arg);
1195                 Bprint(&diagbuf, "%L %s\n", (n==Z)? nearln: n->lineno, buf);
1196
1197                 if(n != Z)
1198                 if(debug['v'])
1199                         prtree(n, "warning");
1200         }
1201 }
1202
1203 void
1204 yyerror(char *fmt, ...)
1205 {
1206         char buf[STRINGSZ];
1207         va_list arg;
1208
1209         /*
1210          * hack to intercept message from yaccpar
1211          */
1212         if(strcmp(fmt, "syntax error") == 0) {
1213                 yyerror("syntax error, last name: %s", symb);
1214                 return;
1215         }
1216         va_start(arg, fmt);
1217         vseprint(buf, buf+sizeof(buf), fmt, arg);
1218         va_end(arg);
1219         Bprint(&diagbuf, "%L %s\n", lineno, buf);
1220         nerrors++;
1221         if(nerrors > 10) {
1222                 Bprint(&diagbuf, "too many errors\n");
1223                 errorexit();
1224         }
1225 }
1226
1227 void
1228 fatal(Node *n, char *fmt, ...)
1229 {
1230         char buf[STRINGSZ];
1231         va_list arg;
1232
1233         va_start(arg, fmt);
1234         vseprint(buf, buf+sizeof(buf), fmt, arg);
1235         va_end(arg);
1236         Bprint(&diagbuf, "%L %s\n", (n==Z)? nearln: n->lineno, buf);
1237
1238         if(debug['X']){
1239                 Bflush(&diagbuf);
1240                 abort();
1241         }
1242         if(n != Z)
1243         if(debug['v'])
1244                 prtree(n, "diagnostic");
1245
1246         nerrors++;
1247         errorexit();
1248 }
1249
1250 ulong   thash1  = 0x2edab8c9;
1251 ulong   thash2  = 0x1dc74fb8;
1252 ulong   thash3  = 0x1f241331;
1253 ulong   thash[NALLTYPES];
1254 Init    thashinit[] =
1255 {
1256         TXXX,           0x17527bbd,     0,
1257         TCHAR,          0x5cedd32b,     0,
1258         TUCHAR,         0x552c4454,     0,
1259         TSHORT,         0x63040b4b,     0,
1260         TUSHORT,        0x32a45878,     0,
1261         TINT,           0x4151d5bd,     0,
1262         TUINT,          0x5ae707d6,     0,
1263         TLONG,          0x5ef20f47,     0,
1264         TULONG,         0x36d8eb8f,     0,
1265         TVLONG,         0x6e5e9590,     0,
1266         TUVLONG,        0x75910105,     0,
1267         TFLOAT,         0x25fd7af1,     0,
1268         TDOUBLE,        0x7c40a1b2,     0,
1269         TIND,           0x1b832357,     0,
1270         TFUNC,          0x6babc9cb,     0,
1271         TARRAY,         0x7c50986d,     0,
1272         TVOID,          0x44112eff,     0,
1273         TSTRUCT,        0x7c2da3bf,     0,
1274         TUNION,         0x3eb25e98,     0,
1275         TENUM,          0x44b54f61,     0,
1276         TFILE,          0x19242ac3,     0,
1277         TOLD,           0x22b15988,     0,
1278         TDOT,           0x0204f6b3,     0,
1279         -1,             0,              0,
1280 };
1281
1282 char*   bnames[NALIGN];
1283 Init    bnamesinit[] =
1284 {
1285         Axxx,   0,      "Axxx",
1286         Ael1,   0,      "el1",
1287         Ael2,   0,      "el2",
1288         Asu2,   0,      "su2",
1289         Aarg0,  0,      "arg0",
1290         Aarg1,  0,      "arg1",
1291         Aarg2,  0,      "arg2",
1292         Aaut3,  0,      "aut3",
1293         -1,     0,      0,
1294 };
1295
1296 char*   tnames[NALLTYPES];
1297 Init    tnamesinit[] =
1298 {
1299         TXXX,           0,      "TXXX",
1300         TCHAR,          0,      "CHAR",
1301         TUCHAR,         0,      "UCHAR",
1302         TSHORT,         0,      "SHORT",
1303         TUSHORT,        0,      "USHORT",
1304         TINT,           0,      "INT",
1305         TUINT,          0,      "UINT",
1306         TLONG,          0,      "LONG",
1307         TULONG,         0,      "ULONG",
1308         TVLONG,         0,      "VLONG",
1309         TUVLONG,        0,      "UVLONG",
1310         TFLOAT,         0,      "FLOAT",
1311         TDOUBLE,        0,      "DOUBLE",
1312         TIND,           0,      "IND",
1313         TFUNC,          0,      "FUNC",
1314         TARRAY,         0,      "ARRAY",
1315         TVOID,          0,      "VOID",
1316         TSTRUCT,        0,      "STRUCT",
1317         TUNION,         0,      "UNION",
1318         TENUM,          0,      "ENUM",
1319         TFILE,          0,      "FILE",
1320         TOLD,           0,      "OLD",
1321         TDOT,           0,      "DOT",
1322         -1,             0,      0,
1323 };
1324
1325 char*   gnames[NGTYPES];
1326 Init    gnamesinit[] =
1327 {
1328         GXXX,                   0,      "GXXX",
1329         GCONSTNT,               0,      "CONST",
1330         GVOLATILE,              0,      "VOLATILE",
1331         GVOLATILE|GCONSTNT,     0,      "CONST-VOLATILE",
1332         -1,                     0,      0,
1333 };
1334
1335 char*   qnames[NALLTYPES];
1336 Init    qnamesinit[] =
1337 {
1338         TXXX,           0,      "TXXX",
1339         TCHAR,          0,      "CHAR",
1340         TUCHAR,         0,      "UCHAR",
1341         TSHORT,         0,      "SHORT",
1342         TUSHORT,        0,      "USHORT",
1343         TINT,           0,      "INT",
1344         TUINT,          0,      "UINT",
1345         TLONG,          0,      "LONG",
1346         TULONG,         0,      "ULONG",
1347         TVLONG,         0,      "VLONG",
1348         TUVLONG,        0,      "UVLONG",
1349         TFLOAT,         0,      "FLOAT",
1350         TDOUBLE,        0,      "DOUBLE",
1351         TIND,           0,      "IND",
1352         TFUNC,          0,      "FUNC",
1353         TARRAY,         0,      "ARRAY",
1354         TVOID,          0,      "VOID",
1355         TSTRUCT,        0,      "STRUCT",
1356         TUNION,         0,      "UNION",
1357         TENUM,          0,      "ENUM",
1358
1359         TAUTO,          0,      "AUTO",
1360         TEXTERN,        0,      "EXTERN",
1361         TSTATIC,        0,      "STATIC",
1362         TTYPEDEF,       0,      "TYPEDEF",
1363         TTYPESTR,       0,      "TYPESTR",
1364         TREGISTER,      0,      "REGISTER",
1365         TCONSTNT,       0,      "CONSTNT",
1366         TVOLATILE,      0,      "VOLATILE",
1367         TUNSIGNED,      0,      "UNSIGNED",
1368         TSIGNED,        0,      "SIGNED",
1369         TDOT,           0,      "DOT",
1370         TFILE,          0,      "FILE",
1371         TOLD,           0,      "OLD",
1372         -1,             0,      0,
1373 };
1374 char*   cnames[NCTYPES];
1375 Init    cnamesinit[] =
1376 {
1377         CXXX,           0,      "CXXX",
1378         CAUTO,          0,      "AUTO",
1379         CEXTERN,        0,      "EXTERN",
1380         CGLOBL,         0,      "GLOBL",
1381         CSTATIC,        0,      "STATIC",
1382         CLOCAL,         0,      "LOCAL",
1383         CTYPEDEF,       0,      "TYPEDEF",
1384         CTYPESTR,       0,      "TYPESTR",
1385         CPARAM,         0,      "PARAM",
1386         CSELEM,         0,      "SELEM",
1387         CLABEL,         0,      "LABEL",
1388         CEXREG,         0,      "EXREG",
1389         -1,             0,      0,
1390 };
1391
1392 char*   onames[OEND+1];
1393 Init    onamesinit[] =
1394 {
1395         OXXX,           0,      "OXXX",
1396         OADD,           0,      "ADD",
1397         OADDR,          0,      "ADDR",
1398         OAND,           0,      "AND",
1399         OANDAND,        0,      "ANDAND",
1400         OARRAY,         0,      "ARRAY",
1401         OAS,            0,      "AS",
1402         OASI,           0,      "ASI",
1403         OASADD,         0,      "ASADD",
1404         OASAND,         0,      "ASAND",
1405         OASASHL,        0,      "ASASHL",
1406         OASASHR,        0,      "ASASHR",
1407         OASDIV,         0,      "ASDIV",
1408         OASHL,          0,      "ASHL",
1409         OASHR,          0,      "ASHR",
1410         OASLDIV,        0,      "ASLDIV",
1411         OASLMOD,        0,      "ASLMOD",
1412         OASLMUL,        0,      "ASLMUL",
1413         OASLSHR,        0,      "ASLSHR",
1414         OASMOD,         0,      "ASMOD",
1415         OASMUL,         0,      "ASMUL",
1416         OASOR,          0,      "ASOR",
1417         OASSUB,         0,      "ASSUB",
1418         OASXOR,         0,      "ASXOR",
1419         OBIT,           0,      "BIT",
1420         OBREAK,         0,      "BREAK",
1421         OCASE,          0,      "CASE",
1422         OCAST,          0,      "CAST",
1423         OCOMMA,         0,      "COMMA",
1424         OCOND,          0,      "COND",
1425         OCONST,         0,      "CONST",
1426         OCONTINUE,      0,      "CONTINUE",
1427         ODIV,           0,      "DIV",
1428         ODOT,           0,      "DOT",
1429         ODOTDOT,        0,      "DOTDOT",
1430         ODWHILE,        0,      "DWHILE",
1431         OENUM,          0,      "ENUM",
1432         OEQ,            0,      "EQ",
1433         OFOR,           0,      "FOR",
1434         OFUNC,          0,      "FUNC",
1435         OGE,            0,      "GE",
1436         OGOTO,          0,      "GOTO",
1437         OGT,            0,      "GT",
1438         OHI,            0,      "HI",
1439         OHS,            0,      "HS",
1440         OIF,            0,      "IF",
1441         OIND,           0,      "IND",
1442         OINDREG,        0,      "INDREG",
1443         OINIT,          0,      "INIT",
1444         OLABEL,         0,      "LABEL",
1445         OLDIV,          0,      "LDIV",
1446         OLE,            0,      "LE",
1447         OLIST,          0,      "LIST",
1448         OLMOD,          0,      "LMOD",
1449         OLMUL,          0,      "LMUL",
1450         OLO,            0,      "LO",
1451         OLS,            0,      "LS",
1452         OLSHR,          0,      "LSHR",
1453         OLT,            0,      "LT",
1454         OMOD,           0,      "MOD",
1455         OMUL,           0,      "MUL",
1456         ONAME,          0,      "NAME",
1457         ONE,            0,      "NE",
1458         ONOT,           0,      "NOT",
1459         OOR,            0,      "OR",
1460         OOROR,          0,      "OROR",
1461         OPOSTDEC,       0,      "POSTDEC",
1462         OPOSTINC,       0,      "POSTINC",
1463         OPREDEC,        0,      "PREDEC",
1464         OPREINC,        0,      "PREINC",
1465         OPROTO,         0,      "PROTO",
1466         OREGISTER,      0,      "REGISTER",
1467         ORETURN,        0,      "RETURN",
1468         OSET,           0,      "SET",
1469         OSIGN,          0,      "SIGN",
1470         OSIZE,          0,      "SIZE",
1471         OSTRING,        0,      "STRING",
1472         OLSTRING,       0,      "LSTRING",
1473         OSTRUCT,        0,      "STRUCT",
1474         OSUB,           0,      "SUB",
1475         OSWITCH,        0,      "SWITCH",
1476         OUNION,         0,      "UNION",
1477         OUSED,          0,      "USED",
1478         OWHILE,         0,      "WHILE",
1479         OXOR,           0,      "XOR",
1480         OPOS,           0,      "POS",
1481         ONEG,           0,      "NEG",
1482         OCOM,           0,      "COM",
1483         OELEM,          0,      "ELEM",
1484         OTST,           0,      "TST",
1485         OINDEX,         0,      "INDEX",
1486         OFAS,           0,      "FAS",
1487         OREGPAIR,       0,      "REGPAIR",
1488         OEXREG,         0,      "EXREG",
1489         OEND,           0,      "END",
1490         -1,             0,      0,
1491 };
1492
1493 /*      OEQ, ONE, OLE, OLS, OLT, OLO, OGE, OHS, OGT, OHI */
1494 char    comrel[12] =
1495 {
1496         ONE, OEQ, OGT, OHI, OGE, OHS, OLT, OLO, OLE, OLS,
1497 };
1498 char    invrel[12] =
1499 {
1500         OEQ, ONE, OGE, OHS, OGT, OHI, OLE, OLS, OLT, OLO,
1501 };
1502 char    logrel[12] =
1503 {
1504         OEQ, ONE, OLS, OLS, OLO, OLO, OHS, OHS, OHI, OHI,
1505 };
1506
1507 char    typei[NTYPE];
1508 int     typeiinit[] =
1509 {
1510         TCHAR, TUCHAR, TSHORT, TUSHORT, TINT, TUINT, TLONG, TULONG, TVLONG, TUVLONG, -1,
1511 };
1512 char    typeu[NTYPE];
1513 int     typeuinit[] =
1514 {
1515         TUCHAR, TUSHORT, TUINT, TULONG, TUVLONG, TIND, -1,
1516 };
1517
1518 char    typesuv[NTYPE];
1519 int     typesuvinit[] =
1520 {
1521         TVLONG, TUVLONG, TSTRUCT, TUNION, -1,
1522 };
1523
1524 char    typeilp[NTYPE];
1525 int     typeilpinit[] =
1526 {
1527         TINT, TUINT, TLONG, TULONG, TIND, -1
1528 };
1529
1530 char    typechl[NTYPE];
1531 char    typechlv[NTYPE];
1532 char typechlvp[NTYPE];
1533 int     typechlinit[] =
1534 {
1535         TCHAR, TUCHAR, TSHORT, TUSHORT, TINT, TUINT, TLONG, TULONG, -1,
1536 };
1537
1538 char    typechlp[NTYPE];
1539 int     typechlpinit[] =
1540 {
1541         TCHAR, TUCHAR, TSHORT, TUSHORT, TINT, TUINT, TLONG, TULONG, TIND, -1,
1542 };
1543
1544 char    typechlpfd[NTYPE];
1545 int     typechlpfdinit[] =
1546 {
1547         TCHAR, TUCHAR, TSHORT, TUSHORT, TINT, TUINT, TLONG, TULONG, TFLOAT, TDOUBLE, TIND, -1,
1548 };
1549
1550 char    typec[NTYPE];
1551 int     typecinit[] =
1552 {
1553         TCHAR, TUCHAR, -1
1554 };
1555
1556 char    typeh[NTYPE];
1557 int     typehinit[] =
1558 {
1559         TSHORT, TUSHORT, -1,
1560 };
1561
1562 char    typeil[NTYPE];
1563 int     typeilinit[] =
1564 {
1565         TINT, TUINT, TLONG, TULONG, -1,
1566 };
1567
1568 char    typev[NTYPE];
1569 int     typevinit[] =
1570 {
1571         TVLONG, TUVLONG, -1,
1572 };
1573
1574 char    typefd[NTYPE];
1575 int     typefdinit[] =
1576 {
1577         TFLOAT, TDOUBLE, -1,
1578 };
1579
1580 char    typeaf[NTYPE];
1581 int     typeafinit[] =
1582 {
1583         TFUNC, TARRAY, -1,
1584 };
1585
1586 char    typesu[NTYPE];
1587 int     typesuinit[] =
1588 {
1589         TSTRUCT, TUNION, -1,
1590 };
1591
1592 long    tasign[NTYPE];
1593 Init    tasigninit[] =
1594 {
1595         TCHAR,          BNUMBER,        0,
1596         TUCHAR,         BNUMBER,        0,
1597         TSHORT,         BNUMBER,        0,
1598         TUSHORT,        BNUMBER,        0,
1599         TINT,           BNUMBER,        0,
1600         TUINT,          BNUMBER,        0,
1601         TLONG,          BNUMBER,        0,
1602         TULONG,         BNUMBER,        0,
1603         TVLONG,         BNUMBER,        0,
1604         TUVLONG,        BNUMBER,        0,
1605         TFLOAT,         BNUMBER,        0,
1606         TDOUBLE,        BNUMBER,        0,
1607         TIND,           BIND,           0,
1608         TSTRUCT,        BSTRUCT,        0,
1609         TUNION,         BUNION,         0,
1610         -1,             0,              0,
1611 };
1612
1613 long    tasadd[NTYPE];
1614 Init    tasaddinit[] =
1615 {
1616         TCHAR,          BNUMBER,        0,
1617         TUCHAR,         BNUMBER,        0,
1618         TSHORT,         BNUMBER,        0,
1619         TUSHORT,        BNUMBER,        0,
1620         TINT,           BNUMBER,        0,
1621         TUINT,          BNUMBER,        0,
1622         TLONG,          BNUMBER,        0,
1623         TULONG,         BNUMBER,        0,
1624         TVLONG,         BNUMBER,        0,
1625         TUVLONG,        BNUMBER,        0,
1626         TFLOAT,         BNUMBER,        0,
1627         TDOUBLE,        BNUMBER,        0,
1628         TIND,           BINTEGER,       0,
1629         -1,             0,              0,
1630 };
1631
1632 long    tcast[NTYPE];
1633 Init    tcastinit[] =
1634 {
1635         TCHAR,          BNUMBER|BIND|BVOID,     0,
1636         TUCHAR,         BNUMBER|BIND|BVOID,     0,
1637         TSHORT,         BNUMBER|BIND|BVOID,     0,
1638         TUSHORT,        BNUMBER|BIND|BVOID,     0,
1639         TINT,           BNUMBER|BIND|BVOID,     0,
1640         TUINT,          BNUMBER|BIND|BVOID,     0,
1641         TLONG,          BNUMBER|BIND|BVOID,     0,
1642         TULONG,         BNUMBER|BIND|BVOID,     0,
1643         TVLONG,         BNUMBER|BIND|BVOID,     0,
1644         TUVLONG,        BNUMBER|BIND|BVOID,     0,
1645         TFLOAT,         BNUMBER|BVOID,          0,
1646         TDOUBLE,        BNUMBER|BVOID,          0,
1647         TIND,           BINTEGER|BIND|BVOID,    0,
1648         TVOID,          BVOID,                  0,
1649         TSTRUCT,        BSTRUCT|BVOID,          0,
1650         TUNION,         BUNION|BVOID,           0,
1651         -1,             0,                      0,
1652 };
1653
1654 long    tadd[NTYPE];
1655 Init    taddinit[] =
1656 {
1657         TCHAR,          BNUMBER|BIND,   0,
1658         TUCHAR,         BNUMBER|BIND,   0,
1659         TSHORT,         BNUMBER|BIND,   0,
1660         TUSHORT,        BNUMBER|BIND,   0,
1661         TINT,           BNUMBER|BIND,   0,
1662         TUINT,          BNUMBER|BIND,   0,
1663         TLONG,          BNUMBER|BIND,   0,
1664         TULONG,         BNUMBER|BIND,   0,
1665         TVLONG,         BNUMBER|BIND,   0,
1666         TUVLONG,        BNUMBER|BIND,   0,
1667         TFLOAT,         BNUMBER,        0,
1668         TDOUBLE,        BNUMBER,        0,
1669         TIND,           BINTEGER,       0,
1670         -1,             0,              0,
1671 };
1672
1673 long    tsub[NTYPE];
1674 Init    tsubinit[] =
1675 {
1676         TCHAR,          BNUMBER,        0,
1677         TUCHAR,         BNUMBER,        0,
1678         TSHORT,         BNUMBER,        0,
1679         TUSHORT,        BNUMBER,        0,
1680         TINT,           BNUMBER,        0,
1681         TUINT,          BNUMBER,        0,
1682         TLONG,          BNUMBER,        0,
1683         TULONG,         BNUMBER,        0,
1684         TVLONG,         BNUMBER,        0,
1685         TUVLONG,        BNUMBER,        0,
1686         TFLOAT,         BNUMBER,        0,
1687         TDOUBLE,        BNUMBER,        0,
1688         TIND,           BINTEGER|BIND,  0,
1689         -1,             0,              0,
1690 };
1691
1692 long    tmul[NTYPE];
1693 Init    tmulinit[] =
1694 {
1695         TCHAR,          BNUMBER,        0,
1696         TUCHAR,         BNUMBER,        0,
1697         TSHORT,         BNUMBER,        0,
1698         TUSHORT,        BNUMBER,        0,
1699         TINT,           BNUMBER,        0,
1700         TUINT,          BNUMBER,        0,
1701         TLONG,          BNUMBER,        0,
1702         TULONG,         BNUMBER,        0,
1703         TVLONG,         BNUMBER,        0,
1704         TUVLONG,        BNUMBER,        0,
1705         TFLOAT,         BNUMBER,        0,
1706         TDOUBLE,        BNUMBER,        0,
1707         -1,             0,              0,
1708 };
1709
1710 long    tand[NTYPE];
1711 Init    tandinit[] =
1712 {
1713         TCHAR,          BINTEGER,       0,
1714         TUCHAR,         BINTEGER,       0,
1715         TSHORT,         BINTEGER,       0,
1716         TUSHORT,        BINTEGER,       0,
1717         TINT,           BNUMBER,        0,
1718         TUINT,          BNUMBER,        0,
1719         TLONG,          BINTEGER,       0,
1720         TULONG,         BINTEGER,       0,
1721         TVLONG,         BINTEGER,       0,
1722         TUVLONG,        BINTEGER,       0,
1723         -1,             0,              0,
1724 };
1725
1726 long    trel[NTYPE];
1727 Init    trelinit[] =
1728 {
1729         TCHAR,          BNUMBER,        0,
1730         TUCHAR,         BNUMBER,        0,
1731         TSHORT,         BNUMBER,        0,
1732         TUSHORT,        BNUMBER,        0,
1733         TINT,           BNUMBER,        0,
1734         TUINT,          BNUMBER,        0,
1735         TLONG,          BNUMBER,        0,
1736         TULONG,         BNUMBER,        0,
1737         TVLONG,         BNUMBER,        0,
1738         TUVLONG,        BNUMBER,        0,
1739         TFLOAT,         BNUMBER,        0,
1740         TDOUBLE,        BNUMBER,        0,
1741         TIND,           BIND,           0,
1742         -1,             0,              0,
1743 };
1744
1745 long    tfunct[1] =
1746 {
1747         BFUNC,
1748 };
1749
1750 long    tindir[1] =
1751 {
1752         BIND,
1753 };
1754
1755 long    tdot[1] =
1756 {
1757         BSTRUCT|BUNION,
1758 };
1759
1760 long    tnot[1] =
1761 {
1762         BNUMBER|BIND,
1763 };
1764
1765 long    targ[1] =
1766 {
1767         BNUMBER|BIND|BSTRUCT|BUNION,
1768 };
1769
1770 char    tab[NTYPE][NTYPE] =
1771 {
1772 /*TXXX*/        { 0,
1773                 },
1774
1775 /*TCHAR*/       { 0,    TCHAR, TUCHAR, TSHORT, TUSHORT, TINT, TUINT, TLONG,
1776                         TULONG, TVLONG, TUVLONG, TFLOAT, TDOUBLE, TIND,
1777                 },
1778 /*TUCHAR*/      { 0,    TUCHAR, TUCHAR, TUSHORT, TUSHORT, TUINT, TUINT, TULONG,
1779                         TULONG, TUVLONG, TUVLONG, TFLOAT, TDOUBLE, TIND,
1780                 },
1781 /*TSHORT*/      { 0,    TSHORT, TUSHORT, TSHORT, TUSHORT, TINT, TUINT, TLONG,
1782                         TULONG, TVLONG, TUVLONG, TFLOAT, TDOUBLE, TIND,
1783                 },
1784 /*TUSHORT*/     { 0,    TUSHORT, TUSHORT, TUSHORT, TUSHORT, TUINT, TUINT, TULONG,
1785                         TULONG, TUVLONG, TUVLONG, TFLOAT, TDOUBLE, TIND,
1786                 },
1787 /*TINT*/        { 0,    TINT, TUINT, TINT, TUINT, TINT, TUINT, TLONG,
1788                         TULONG, TVLONG, TUVLONG, TFLOAT, TDOUBLE, TIND,
1789                 },
1790 /*TUINT*/       { 0,    TUINT, TUINT, TUINT, TUINT, TUINT, TUINT, TULONG,
1791                         TULONG, TUVLONG, TUVLONG, TFLOAT, TDOUBLE, TIND,
1792                 },
1793 /*TLONG*/       { 0,    TLONG, TULONG, TLONG, TULONG, TLONG, TULONG, TLONG,
1794                         TULONG, TVLONG, TUVLONG, TFLOAT, TDOUBLE, TIND,
1795                 },
1796 /*TULONG*/      { 0,    TULONG, TULONG, TULONG, TULONG, TULONG, TULONG, TULONG,
1797                         TULONG, TUVLONG, TUVLONG, TFLOAT, TDOUBLE, TIND,
1798                 },
1799 /*TVLONG*/      { 0,    TVLONG, TUVLONG, TVLONG, TUVLONG, TVLONG, TUVLONG, TVLONG,
1800                         TUVLONG, TVLONG, TUVLONG, TFLOAT, TDOUBLE, TIND,
1801                 },
1802 /*TUVLONG*/     { 0,    TUVLONG, TUVLONG, TUVLONG, TUVLONG, TUVLONG, TUVLONG, TUVLONG,
1803                         TUVLONG, TUVLONG, TUVLONG, TFLOAT, TDOUBLE, TIND,
1804                 },
1805 /*TFLOAT*/      { 0,    TFLOAT, TFLOAT, TFLOAT, TFLOAT, TFLOAT, TFLOAT, TFLOAT,
1806                         TFLOAT, TFLOAT, TFLOAT, TFLOAT, TDOUBLE, TIND,
1807                 },
1808 /*TDOUBLE*/     { 0,    TDOUBLE, TDOUBLE, TDOUBLE, TDOUBLE, TDOUBLE, TDOUBLE, TDOUBLE,
1809                         TDOUBLE, TDOUBLE, TDOUBLE, TFLOAT, TDOUBLE, TIND,
1810                 },
1811 /*TIND*/        { 0,    TIND, TIND, TIND, TIND, TIND, TIND, TIND,
1812                          TIND, TIND, TIND, TIND, TIND, TIND,
1813                 },
1814 };
1815
1816 void
1817 urk(char *name, int max, int i)
1818 {
1819         if(i >= max) {
1820                 fprint(2, "bad tinit: %s %d>=%d\n", name, i, max);
1821                 exits("init");
1822         }
1823 }
1824
1825 void
1826 tinit(void)
1827 {
1828         int *ip;
1829         Init *p;
1830
1831         for(p=thashinit; p->code >= 0; p++) {
1832                 urk("thash", nelem(thash), p->code);
1833                 thash[p->code] = p->value;
1834         }
1835         for(p=bnamesinit; p->code >= 0; p++) {
1836                 urk("bnames", nelem(bnames), p->code);
1837                 bnames[p->code] = p->s;
1838         }
1839         for(p=tnamesinit; p->code >= 0; p++) {
1840                 urk("tnames", nelem(tnames), p->code);
1841                 tnames[p->code] = p->s;
1842         }
1843         for(p=gnamesinit; p->code >= 0; p++) {
1844                 urk("gnames", nelem(gnames), p->code);
1845                 gnames[p->code] = p->s;
1846         }
1847         for(p=qnamesinit; p->code >= 0; p++) {
1848                 urk("qnames", nelem(qnames), p->code);
1849                 qnames[p->code] = p->s;
1850         }
1851         for(p=cnamesinit; p->code >= 0; p++) {
1852                 urk("cnames", nelem(cnames), p->code);
1853                 cnames[p->code] = p->s;
1854         }
1855         for(p=onamesinit; p->code >= 0; p++) {
1856                 urk("onames", nelem(onames), p->code);
1857                 onames[p->code] = p->s;
1858         }
1859         for(ip=typeiinit; *ip>=0; ip++) {
1860                 urk("typei", nelem(typei), *ip);
1861                 typei[*ip] = 1;
1862         }
1863         for(ip=typeuinit; *ip>=0; ip++) {
1864                 urk("typeu", nelem(typeu), *ip);
1865                 typeu[*ip] = 1;
1866         }
1867         for(ip=typesuvinit; *ip>=0; ip++) {
1868                 urk("typesuv", nelem(typesuv), *ip);
1869                 typesuv[*ip] = 1;
1870         }
1871         for(ip=typeilpinit; *ip>=0; ip++) {
1872                 urk("typeilp", nelem(typeilp), *ip);
1873                 typeilp[*ip] = 1;
1874         }
1875         for(ip=typechlinit; *ip>=0; ip++) {
1876                 urk("typechl", nelem(typechl), *ip);
1877                 typechl[*ip] = 1;
1878                 typechlv[*ip] = 1;
1879                 typechlvp[*ip] = 1;
1880         }
1881         for(ip=typechlpinit; *ip>=0; ip++) {
1882                 urk("typechlp", nelem(typechlp), *ip);
1883                 typechlp[*ip] = 1;
1884                 typechlvp[*ip] = 1;
1885         }
1886         for(ip=typechlpfdinit; *ip>=0; ip++) {
1887                 urk("typechlpfd", nelem(typechlpfd), *ip);
1888                 typechlpfd[*ip] = 1;
1889         }
1890         for(ip=typecinit; *ip>=0; ip++) {
1891                 urk("typec", nelem(typec), *ip);
1892                 typec[*ip] = 1;
1893         }
1894         for(ip=typehinit; *ip>=0; ip++) {
1895                 urk("typeh", nelem(typeh), *ip);
1896                 typeh[*ip] = 1;
1897         }
1898         for(ip=typeilinit; *ip>=0; ip++) {
1899                 urk("typeil", nelem(typeil), *ip);
1900                 typeil[*ip] = 1;
1901         }
1902         for(ip=typevinit; *ip>=0; ip++) {
1903                 urk("typev", nelem(typev), *ip);
1904                 typev[*ip] = 1;
1905                 typechlv[*ip] = 1;
1906                 typechlvp[*ip] = 1;
1907         }
1908         for(ip=typefdinit; *ip>=0; ip++) {
1909                 urk("typefd", nelem(typefd), *ip);
1910                 typefd[*ip] = 1;
1911         }
1912         for(ip=typeafinit; *ip>=0; ip++) {
1913                 urk("typeaf", nelem(typeaf), *ip);
1914                 typeaf[*ip] = 1;
1915         }
1916         for(ip=typesuinit; *ip >= 0; ip++) {
1917                 urk("typesu", nelem(typesu), *ip);
1918                 typesu[*ip] = 1;
1919         }
1920         for(p=tasigninit; p->code >= 0; p++) {
1921                 urk("tasign", nelem(tasign), p->code);
1922                 tasign[p->code] = p->value;
1923         }
1924         for(p=tasaddinit; p->code >= 0; p++) {
1925                 urk("tasadd", nelem(tasadd), p->code);
1926                 tasadd[p->code] = p->value;
1927         }
1928         for(p=tcastinit; p->code >= 0; p++) {
1929                 urk("tcast", nelem(tcast), p->code);
1930                 tcast[p->code] = p->value;
1931         }
1932         for(p=taddinit; p->code >= 0; p++) {
1933                 urk("tadd", nelem(tadd), p->code);
1934                 tadd[p->code] = p->value;
1935         }
1936         for(p=tsubinit; p->code >= 0; p++) {
1937                 urk("tsub", nelem(tsub), p->code);
1938                 tsub[p->code] = p->value;
1939         }
1940         for(p=tmulinit; p->code >= 0; p++) {
1941                 urk("tmul", nelem(tmul), p->code);
1942                 tmul[p->code] = p->value;
1943         }
1944         for(p=tandinit; p->code >= 0; p++) {
1945                 urk("tand", nelem(tand), p->code);
1946                 tand[p->code] = p->value;
1947         }
1948         for(p=trelinit; p->code >= 0; p++) {
1949                 urk("trel", nelem(trel), p->code);
1950                 trel[p->code] = p->value;
1951         }
1952
1953         /* 32-bit defaults */
1954         typeword = typechlp;
1955         typeswitch = typechl;
1956         typecmplx = typesuv;
1957 }
1958
1959 /*
1960  * return 1 if it is impossible to jump into the middle of n.
1961  */
1962 static int
1963 deadhead(Node *n, int caseok)
1964 {
1965 loop:
1966         if(n == Z)
1967                 return 1;
1968         switch(n->op) {
1969         case OLIST:
1970                 if(!deadhead(n->left, caseok))
1971                         return 0;
1972         rloop:
1973                 n = n->right;
1974                 goto loop;
1975
1976         case ORETURN:
1977                 break;
1978
1979         case OLABEL:
1980                 return 0;
1981
1982         case OGOTO:
1983                 break;
1984
1985         case OCASE:
1986                 if(!caseok)
1987                         return 0;
1988                 goto rloop;
1989
1990         case OSWITCH:
1991                 return deadhead(n->right, 1);
1992
1993         case OWHILE:
1994         case ODWHILE:
1995                 goto rloop;
1996
1997         case OFOR:
1998                 goto rloop;
1999
2000         case OCONTINUE:
2001                 break;
2002
2003         case OBREAK:
2004                 break;
2005
2006         case OIF:
2007                 return deadhead(n->right->left, caseok) && deadhead(n->right->right, caseok);
2008
2009         case OSET:
2010         case OUSED:
2011                 break;
2012         }
2013         return 1;
2014 }
2015
2016 int
2017 deadheads(Node *c)
2018 {
2019         return deadhead(c->left, 0) && deadhead(c->right, 0);
2020 }
2021
2022 int
2023 mixedasop(Type *l, Type *r)
2024 {
2025         return !typefd[l->etype] && typefd[r->etype];
2026 }