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