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