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