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