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