![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to sugen.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [Plan 9 NeXT] / lucent / sys / src / alef / k|
Return to sugen.c CVS log | Up to [Plan 9 NeXT] / lucent / sys / src / alef / k |
1.1 root 1: #include <u.h>
2: #include <libc.h>
3: #include <bio.h>
4: #include <ctype.h>
5: #define Extern extern
6: #include "parl.h"
7: #include "globl.h"
8:
9: static Glab *gotos;
10: static Glab *labels;
11: static Jmps *contstack;
12: static Jmps *brkstack;
13: static Jmps *retstack;
14: static Jmps *rescues;
15: static Node *lstmnt;
16:
17: /* Compile a function */
18: void
19: fungen(Node *code, Node *args)
20: {
21: int l;
22: Type *t;
23: Node n1;
24: ulong rpc;
25: Inst *fcode;
26:
27: l = line;
28: fcode = ipc;
29:
30: iter(code, 1);
31: typechk(code, 0);
32: rewrite(code);
33:
34: args->left->right = code;
35:
36: if(code)
37: sucalc(code);
38:
39: if(opt('t')) {
40: print("\nTree:\n");
41: ptree(code, 0);
42: }
43:
44: /* Clear the label stack */
45: labels = 0;
46: gotos = 0;
47: rescues = 0;
48:
49: if(opt('q') == 0 && nerr == 0) {
50: t = curfunc->t->next;
51: switch(t->type) {
52: case TPOLY:
53: curfunc = dupn(curfunc);
54: curfunc->t = at(TFUNC, polyshape);
55: /* No Break */
56: case TADT:
57: case TUNION:
58: case TAGGREGATE:
59: t = at(TIND, t);
60: regret(&n1, t);
61: rnode = stknode(n1.t);
62: assign(&n1, rnode);
63: regfree(&n1);
64: becomentry = ipc;
65: }
66:
67: lstmnt = nil;
68: if(code)
69: stmnt(code);
70:
71: if(t->type != TVOID)
72: if(lstmnt == 0 ||
73: (lstmnt->type != ORET && lstmnt->type != OBECOME))
74: diag(lstmnt, "typed function has no return");
75:
76: rpc = ipc->pc+1;
77: /* Improve optimiser by using non return register */
78: switch(t->type) {
79: case TVOID:
80: instruction(ANOP, ZeroN, ZeroN, regn(Freg));
81: instruction(ANOP, ZeroN, ZeroN, regn(Retireg));
82: break;
83: case TFLOAT:
84: instruction(ANOP, ZeroN, ZeroN, regn(Retireg));
85: break;
86: default:
87: instruction(ANOP, ZeroN, ZeroN, regn(Freg));
88: break;
89: }
90:
91: instruction(ARETURN, ZeroN, ZeroN, ZeroN);
92:
93: /* Patch in all the returns */
94: while(retstack) {
95: label(retstack->i, rpc);
96: popjmp(&retstack);
97: }
98:
99: /* Back patch the entry */
100: resolvegoto();
101:
102: /* Patch in the frame size */
103: funentry->dst.ival = maxframe + frame;
104: }
105:
106: leaveblock();
107:
108: regcheck();
109:
110: if(opt('N') || opt('R') || opt('P'))
111: regopt(fcode);
112:
113: line = l;
114: }
115:
116: void
117: bstmnt(Node *n)
118: {
119: Node *tmp;
120:
121: tmp = lstmnt;
122: stmnt(n);
123: lstmnt = tmp;
124: }
125:
126: /* Compile code for a statement */
127: void
128: stmnt(Node *n)
129: {
130: Jmps *p;
131: Node *l, *r, n1, com;
132: Inst *false, *truedone, *loop, *enter;
133:
134: if(n == ZeroN)
135: return;
136:
137: l = n->left;
138: r = n->right;
139: iline = n->srcline;
140: lstmnt = n;
141:
142: switch(n->type) {
143: default:
144: genexp(n, ZeroN);
145: break;
146:
147: case OLIST:
148: stmnt(l);
149: stmnt(r);
150: break;
151:
152: case OBLOCK:
153: stmnt(l);
154: break;
155:
156: case OLBLOCK:
157: if(l == ZeroN) {
158: warn(n, "empty guarded block");
159: break;
160: }
161: lblock(l);
162: break;
163:
164: case OPAR:
165: parcode(l->left);
166: break;
167:
168: case OSWITCH:
169: switchcode(n);
170: break;
171:
172: case OSELECT:
173: selcode(n);
174: break;
175:
176: case OGOTO:
177: instruction(AJMP, ZeroN, ZeroN, ZeroN);
178: setgoto(n, ipc);
179: break;
180:
181: case OLABEL:
182: setlabel(n, ipc->pc+1);
183: break;
184:
185: case OCASE:
186: case ODEFAULT:
187: n->pc = ipc->pc+1;
188:
189: if(l && l->type != OCONST)
190: stmnt(l);
191:
192: if(r)
193: stmnt(r);
194: break;
195:
196: case OIF:
197: gencond(l, ZeroN, True);
198: false = ipc;
199: if(r && r->type == OELSE) {
200: stmnt(r->left);
201: truedone = instruction(AJMP, ZeroN, ZeroN, ZeroN);
202: label(false, ipc->pc+1);
203: stmnt(r->right);
204: label(truedone, ipc->pc+1);
205: break;
206: }
207:
208: if(r)
209: stmnt(r);
210:
211: label(false, ipc->pc+1);
212: break;
213:
214: case ORET:
215: if(l) {
216: switch(l->t->type) {
217: default:
218: regret(&n1, l->t);
219: genexp(l, &n1);
220: regfree(&n1);
221: break;
222:
223: case TADT:
224: case TUNION:
225: case TAGGREGATE:
226: com.type = OASGN;
227: com.t = l->t;
228: com.left = an(OIND, rnode, ZeroN);
229: com.left->t = rnode->t->next;
230: com.right = l;
231: sucalc(&com);
232: genexp(&com, ZeroN);
233: break;
234: }
235: }
236:
237: instruction(AJMP, ZeroN, ZeroN, ZeroN);
238: pushjmp(&retstack);
239: break;
240:
241: case ODWHILE:
242: instruction(AJMP, ZeroN, ZeroN, ZeroN);
243: enter = ipc;
244: instruction(AJMP, ZeroN, ZeroN, ZeroN); /* Continue */
245: pushjmp(&contstack);
246: instruction(AJMP, ZeroN, ZeroN, ZeroN); /* Break */
247: pushjmp(&brkstack);
248:
249: label(enter, ipc->pc+1);
250: loop = ipc;
251: if(r)
252: stmnt(r);
253:
254: label(contstack->i, ipc->pc+1);
255: if(l) {
256: gencond(l, ZeroN, True);
257: label(ipc, brkstack->i->pc);
258: }
259: instruction(AJMP, ZeroN, ZeroN, ZeroN); /* Loop */
260: label(ipc, loop->pc+1);
261:
262: label(brkstack->i, ipc->pc+1);
263: popjmp(&contstack);
264: popjmp(&brkstack);
265: break;
266:
267: case OWHILE:
268: instruction(AJMP, ZeroN, ZeroN, ZeroN); /* Continue */
269: pushjmp(&contstack);
270: instruction(AJMP, ZeroN, ZeroN, ZeroN); /* Break */
271: pushjmp(&brkstack);
272:
273: label(contstack->i, ipc->pc+1);
274: loop = ipc;
275: if(l) { /* Cond */
276: gencond(l, ZeroN, True);
277: label(ipc, brkstack->i->pc);
278: }
279:
280: if(r)
281: stmnt(r);
282:
283: instruction(AJMP, ZeroN, ZeroN, ZeroN); /* Loop */
284: label(ipc, loop->pc+1);
285:
286: label(brkstack->i, ipc->pc+1);
287: popjmp(&contstack);
288: popjmp(&brkstack);
289: break;
290:
291: case OFOR:
292: if(l->left) /* Assign */
293: genexp(l->left, ZeroN);
294:
295: l = l->right;
296:
297: instruction(AJMP, ZeroN, ZeroN, ZeroN);
298: enter = ipc;
299: instruction(AJMP, ZeroN, ZeroN, ZeroN); /* Continue */
300: pushjmp(&contstack);
301: instruction(AJMP, ZeroN, ZeroN, ZeroN); /* Break */
302: pushjmp(&brkstack);
303: label(enter, ipc->pc+1);
304:
305: if(l->left) { /* Cond */
306: gencond(l->left, ZeroN, True);
307: label(ipc, brkstack->i->pc);
308: }
309: if(r)
310: stmnt(r);
311: label(contstack->i, ipc->pc+1);
312: if(l->right) /* Action */
313: genexp(l->right, ZeroN);
314:
315: instruction(AJMP, ZeroN, ZeroN, ZeroN);
316: label(ipc, enter->pc);
317:
318: label(brkstack->i, ipc->pc+1);
319: popjmp(&contstack);
320: popjmp(&brkstack);
321: break;
322:
323: case ORAISE:
324: if(l) {
325: instruction(AJMP, ZeroN, ZeroN, ZeroN);
326: setgoto(l, ipc);
327: break;
328: }
329: if(rescues == 0) {
330: diag(n, "raise without rescue");
331: break;
332: }
333: instruction(AJMP, ZeroN, ZeroN, ZeroN);
334: label(ipc, rescues->i->pc+1);
335: if(rescues->par != inpar)
336: diag(n, "raise breaks join in par");
337: if(rescues->crit != incrit)
338: diag(n, "raise breaks critical section");
339: break;
340:
341: case ORESCUE:
342: instruction(AJMP, ZeroN, ZeroN, ZeroN);
343: enter = ipc;
344: if(l->type == OLABEL) {
345: setlabel(l, ipc->pc+1);
346: l = l->left;
347: }
348: stmnt(l);
349: label(enter, ipc->pc+1);
350: pushlab(&rescues, enter);
351: break;
352:
353: case OBREAK:
354: p = brkstack;
355: while(p) {
356: n->ival--;
357: if(n->ival == 0)
358: break;
359: p = p->next;
360: }
361: if(p) {
362: if(p->par != inpar)
363: diag(n, "break breaks join in par");
364: if(p->crit != incrit)
365: diag(n, "break breaks critical section");
366: instruction(AJMP, ZeroN, ZeroN, ZeroN);
367: label(ipc, p->i->pc);
368: break;
369: }
370: diag(n, "break not in loop/switch/select");
371: break;
372:
373: case OCONT:
374: p = contstack;
375: while(p) {
376: n->ival--;
377: if(n->ival == 0)
378: break;
379: p = p->next;
380: }
381: if(p) {
382: if(p->par != inpar)
383: diag(n, "continue breaks join in par");
384: if(p->crit != incrit)
385: diag(n, "continue breaks critical section");
386: instruction(AJMP, ZeroN, ZeroN, ZeroN);
387: label(ipc, p->i->pc);
388: break;
389: }
390: diag(n, "continue not in loop");
391: break;
392: }
393: }
394:
395: int
396: cascmp(Node **a, Node **b)
397: {
398: int av, bv;
399:
400: av = (*a)->left->ival;
401: bv = (*b)->left->ival;
402: if(av < bv)
403: return -1;
404: return av > bv;
405: }
406:
407: void
408: casecount(Node *n, Node **vec)
409: {
410: if(n == ZeroN)
411: return;
412:
413: switch(n->type) {
414: case ODEFAULT:
415: case OCASE:
416: if(vec)
417: vec[veccnt] = n;
418: veccnt++;
419: break;
420:
421: default:
422: casecount(n->left, vec);
423: casecount(n->right, vec);
424: break;
425: }
426: }
427:
428: void
429: switchcode(Node *n)
430: {
431: Node val;
432: long defpc;
433: Inst *enter;
434: int i, r, safe;
435: Node **cases, *defl, *c, *il, com;
436:
437: c = n->right;
438: if(c == ZeroN) {
439: warn(n, "empty switch statement");
440: return;
441: }
442:
443: instruction(AJMP, ZeroN, ZeroN, ZeroN); /* Entry */
444: enter = ipc;
445: instruction(AJMP, ZeroN, ZeroN, ZeroN); /* Break */
446: pushjmp(&brkstack);
447:
448: safe = 0;
449: if(c->type == OLBLOCK) {
450: incrit++;
451: safe = 1;
452: c = c->left;
453: }
454: /* Generate the code */
455: stmnt(c);
456:
457: instruction(AJMP, ZeroN, ZeroN, ZeroN); /* Done break */
458: label(ipc, brkstack->i->pc);
459:
460: /* Count */
461: veccnt = 0;
462: casecount(c, 0);
463:
464: /* Save */
465: cases = malloc(sizeof(Node*)*veccnt);
466: veccnt = 0;
467: casecount(c, cases);
468:
469: defl = 0;
470: for(i = 0; i < veccnt; i++) {
471: c = cases[i];
472: switch(c->type) {
473: case OCASE:
474: if(c->left->type != OCONST) {
475: diag(c, "case must be constant");
476: cases[i] = ZeroN;
477: }
478: break;
479:
480: case ODEFAULT:
481: if(defl)
482: diag(c, "switch already has default");
483: defl = c;
484: cases[i] = ZeroN;
485: break;
486: }
487: }
488:
489: /* Close up the table */
490: for(i = 0; i < veccnt; i++) {
491: if(cases[i] == ZeroN) {
492: veccnt--;
493: memmove(cases+i, cases+i+1, (veccnt-i)*sizeof(Node*));
494: }
495: }
496:
497: qsort(cases, veccnt, sizeof(Node*), cascmp);
498:
499: for(i = 0; i < veccnt-1; i++) {
500: r = cases[i]->left->ival;
501: if(r == cases[i+1]->left->ival)
502: diag(cases[i+1], "duplicate case %d in switch", r);
503: }
504:
505: label(enter, ipc->pc+1);
506: SET(il);
507: if(safe) {
508: il = internnode(builtype[TIND]);
509: il = an(OADDR, il, ZeroN);
510: il->t = builtype[TIND];
511:
512: com.type = OCALL;
513: com.t = builtype[TVOID];
514: com.left = ginode;
515: com.right = il;
516:
517: sucalc(&com);
518: stmnt(&com);
519: }
520:
521: reg(&val, builtype[TINT], ZeroN);
522: genexp(n->left, &val);
523:
524: defpc = brkstack->i->pc;
525: if(defl)
526: defpc = defl->pc;
527:
528: gencmps(cases, veccnt, defpc, &val);
529:
530: regfree(&val);
531: label(brkstack->i, ipc->pc+1);
532:
533: if(safe) {
534: com.type = OCALL;
535: com.t = builtype[TVOID];
536: com.left = gonode;
537: com.right = il;
538:
539: sucalc(&com);
540: stmnt(&com);
541: incrit--;
542: }
543: popjmp(&brkstack);
544: }
545:
546: Node*
547: gcom(Node *n)
548: {
549: Node *l;
550:
551: if(n == 0)
552: return ZeroN;
553:
554: switch(n->type) {
555: case ORECV:
556: return n;
557: case OCALL:
558: if(issend(n->left))
559: return n;
560: /* Fall through */
561: default:
562: l = gcom(n->left);
563: if(l == 0)
564: l = gcom(n->right);
565: return l;
566: }
567: }
568:
569: int
570: regcode(Node **cases, int cnt)
571: {
572: int i, var;
573: Node *l, *c;
574:
575: var = 0;
576: for(i = 0; i < cnt; i++) {
577: c = cases[i];
578: switch(c->type) {
579: case OCASE:
580: l = gcom(c->left);
581: if(l == 0) {
582: diag(c, "case expr needs send/receive");
583: cases[i] = ZeroN;
584: break;
585: }
586: if(l->t->variant)
587: var++;
588: switch(l->type) {
589: default: /* Catch the send rewrites */
590: l->left = selsend;
591: c->t = l->t;
592: l->t = builtype[TVOID];
593: break;
594: case ORECV:
595: case OCRCV:
596: c->left = l;
597: l->type = OCALL;
598: c->t = l->t;
599: l->t = builtype[TVOID];
600: l->left = selrecv;
601: break;
602: }
603: /* Only the channel argument */
604: while(l->right->type == OLIST)
605: l->right = l->right->left;
606: break;
607: case ODEFAULT:
608: diag(c, "alt already has default");
609: cases[i] = ZeroN;
610: break;
611: }
612: }
613: return var;
614: }
615:
616: void
617: selcode(Node *n)
618: {
619: Inst *enter;
620: Node val, com;
621: int i, x, safe, var;
622: Node **cases, *c, *il;
623:
624: safe = 0;
625:
626: val.srcline = n->srcline;
627: com.srcline = n->srcline;
628:
629: instruction(AJMP, ZeroN, ZeroN, ZeroN); /* Entry */
630: enter = ipc;
631: instruction(AJMP, ZeroN, ZeroN, ZeroN); /* Break */
632: pushjmp(&brkstack);
633:
634: c = n->left;
635: if(c == nil)
636: return;
637: if(c->type == OLBLOCK) {
638: incrit++;
639: safe = 1;
640: c = c->left;
641: }
642: stmnt(c);
643:
644: instruction(AJMP, ZeroN, ZeroN, ZeroN); /* Done break */
645: label(ipc, brkstack->i->pc);
646:
647: veccnt = 0;
648: casecount(n->left, 0);
649: cases = malloc(sizeof(Node*)*veccnt);
650: veccnt = 0;
651: casecount(n->left, cases);
652:
653: /* Convert expression to register channels for select */
654: var = regcode(cases, veccnt);
655:
656: for(i = 0; i < veccnt; i++) {
657: if(cases[i] == ZeroN) {
658: veccnt--;
659: memmove(cases+i, cases+i+1, (veccnt-i)*sizeof(Node*));
660: }
661: }
662: if(veccnt == 0)
663: return;
664:
665: label(enter, ipc->pc+1);
666: SET(il);
667: if(safe) {
668: il = internnode(builtype[TIND]);
669: il = an(OADDR, il, ZeroN);
670: il->t = builtype[TIND];
671:
672: com.type = OCALL;
673: com.t = builtype[TVOID];
674: com.left = ginode;
675: com.right = il;
676:
677: sucalc(&com);
678: stmnt(&com);
679: }
680:
681: /* Assign values */
682: for(i = 0; i < veccnt; i++) {
683: c = cases[i];
684: x = i;
685: if(var)
686: x = typesig(c->t);
687: c->left->ival = x;
688: }
689:
690: /* Sort if type match */
691: if(var)
692: qsort(cases, veccnt, sizeof(Node*), cascmp);
693:
694: /* Detect type clashes */
695: for(i = 0; i < veccnt-1; i++) {
696: c = cases[i];
697: if(c->left->ival == cases[i+1]->left->ival)
698: diag(c, "duplicate variant type %V", c->t);
699: }
700:
701: /* Code the selsend/selrecv expressions */
702: for(i = 0; i < veccnt; i++)
703: genexp(cases[i]->left, ZeroN);
704:
705: com.type = OCALL;
706: com.t = builtype[TVOID];
707: com.left = doselect;
708: if(var)
709: com.left = varselect;
710: com.right = ZeroN;
711: sucalc(&com);
712: stmnt(&com);
713:
714: regret(&val, builtype[TINT]);
715: gencmps(cases, veccnt, -1, &val);
716: regfree(&val);
717:
718: label(brkstack->i, ipc->pc+1);
719: if(safe) {
720: com.type = OCALL;
721: com.t = builtype[TVOID];
722: com.left = gonode;
723: com.right = il;
724: sucalc(&com);
725: stmnt(&com);
726: incrit--;
727: }
728: popjmp(&brkstack);
729: }
730:
731: void
732: gencmps(Node **c, int cnt, long defpc, Node *val)
733: {
734: Node n, con, **r;
735: int i;
736: Inst *patch;
737:
738: con.type = OCONST;
739: con.t = builtype[TINT];
740:
741: if(cnt < 4) {
742: for(i = 0; i < cnt; i++) {
743: con.ival = (*c)->left->ival;
744: reg(&n, builtype[TINT], ZeroN);
745: assign(&con, &n);
746: codcond(OEQ, &n, val);
747: label(ipc, (*c)->pc);
748: regfree(&n);
749: c++;
750: }
751: if(defpc != -1) {
752: instruction(AJMP, ZeroN, ZeroN, ZeroN);
753: label(ipc, defpc);
754: }
755: return;
756: }
757: i = cnt/2;
758: r = c+i;
759:
760: con.ival = (*r)->left->ival;
761: reg(&n, builtype[TINT], ZeroN);
762: assign(&con, &n);
763: codcond(OLT, &n, val);
764: patch = ipc;
765: codcond(OEQ, &n, val);
766: label(ipc, (*r)->pc);
767: regfree(&n);
768: gencmps(c, i, defpc, val);
769:
770: label(patch, ipc->pc+1);
771: gencmps(r+1, cnt-i-1, defpc, val);
772: }
773:
774: ulong
775: framefind(Node *n)
776: {
777: ulong l, r;
778:
779: if(n == ZeroN)
780: return 0;
781:
782: switch(n->type) {
783: default:
784: l = framefind(n->left);
785: r = framefind(n->right);
786: if(r > l)
787: l = r;
788: break;
789: case OCALL:
790: frsize = 0;
791: framesize(n->right);
792: l = frsize;
793: }
794: return l;
795: }
796:
797: void
798: parcode(Node *n)
799: {
800: Type *t;
801: ulong frs;
802: int i, cnt;
803: Inst *loop;
804: Node *barrier, **slist, com, retr;
805: Node *stv, *stvp, *oatv, *p;
806:
807: veccnt = 0;
808: listcount(n, 0);
809: slist = malloc(sizeof(Node*)*veccnt);
810: veccnt = 0;
811: listcount(n, slist);
812:
813: if(opt('O')) {
814: for(i = 0; i < veccnt; i++) {
815: ptree(slist[i], 0);
816: print("*\n");
817: }
818: }
819:
820: if(veccnt < 2) {
821: warn(n, "only one statement in par");
822: stmnt(slist[0]);
823: return;
824: }
825:
826: inpar++;
827: oatv = atv;
828: cnt = veccnt;
829:
830: /*
831: * This slime is Parrend in the runtime
832: */
833: t = at(TAGGREGATE, 0);
834: t->size = SZPAREND*builtype[TINT]->size;
835: barrier = an(OADDR, stknode(t), ZeroN);
836: barrier->t = at(TIND, t);
837:
838: /*
839: * Build activation vector
840: */
841: t = at(TIND, builtype[TIND]);
842: t->size = t->next->size * cnt;
843: stv = stknode(t);
844: stv->ti->t = at(TARRAY, 0);
845:
846: /*
847: * craft: pid = pfork(cnt, stv)
848: */
849: com.type = OCALL;
850: com.t = builtype[TINT];
851: com.left = pforknode;
852: stvp = an(OADDR, stv, ZeroN);
853: stvp->t = builtype[TIND];
854: com.right = an(OLIST, con(veccnt-1), an(OLIST, stvp, barrier));
855:
856: sucalc(&com);
857: genexp(&com, ZeroN);
858:
859: for(i = 0; i < cnt-1; i++) {
860: regret(&retr, builtype[TINT]);
861: instruction(ACMP, con(i), ZeroN, &retr);
862: instruction(ABNE, ZeroN, ZeroN, ZeroN);
863: loop = ipc;
864: regfree(&retr);
865:
866: /*
867: * find the largest frame in this activation
868: */
869: frs = framefind(slist[i]);
870: /* ensure enough space for ALEF_pexit args */
871: if(frs < 2*builtype[TIND]->size) {
872: frs = 2*builtype[TIND]->size;
873: frs = align(frs, builtype[TIND]);
874: }
875: if(opt('O'))
876: print("%d: frame %d\n", i, frs);
877:
878: /*
879: * Compute my activation from stack vector: atv = stv[pid]
880: */
881: t = builtype[TIND];
882: atv = stknode(t);
883: p = an(OADD, stvp, con(i*builtype[TIND]->size));
884: p->t = t;
885: p = an(OIND, p, ZeroN);
886: p->t = t;
887: /*
888: * 2*sizeof(*) is enough for save SP at activation top plus hole
889: * for the saved activation pc
890: */
891: p = an(OSUB, p, con(frs+2*builtype[TIND]->size));
892: p->t = t;
893: /*
894: * word used for activation link
895: */
896: atv->atvsafe = frs+builtype[TIND]->size;
897: p = an(OASGN, atv, p);
898: p->t = t;
899:
900: sucalc(p);
901: genexp(p, ZeroN);
902:
903: stmnt(slist[i]);
904:
905: com.type = OCALL;
906: com.t = builtype[TVOID];
907: com.left = pexitnode;
908: com.right = barrier;
909:
910: sucalc(&com);
911: stmnt(&com);
912:
913: label(loop, ipc->pc+1);
914: }
915: atv = oatv;
916:
917: stmnt(slist[i]);
918:
919: /*
920: * craft terminator: ALEF_pdone(&barrier, stv);
921: */
922: com.type = OCALL;
923: com.t = builtype[TINT];
924: com.left = pdonenode;
925: stvp = an(OADDR, stv, ZeroN);
926: stvp->t = builtype[TIND];
927: com.right = an(OLIST, barrier, stvp);
928:
929: sucalc(&com);
930: stmnt(&com);
931:
932: inpar--;
933: }
934:
935: void
936: lblock(Node *n)
937: {
938: Node com, *i;
939:
940: i = internnode(builtype[TIND]);
941: i = an(OADDR, i, ZeroN);
942: i->t = builtype[TIND];
943:
944: com.type = OCALL;
945: com.t = builtype[TVOID];
946: com.left = ginode;
947: com.right = i;
948: sucalc(&com);
949: stmnt(&com);
950:
951: incrit++;
952: stmnt(n);
953: incrit--;
954:
955: com.type = OCALL;
956: com.t = builtype[TVOID];
957: com.left = gonode;
958: com.right = i;
959: sucalc(&com);
960: stmnt(&com);
961: }
962:
963: /* determine addressablility and number of registers */
964: void
965: sucalc(Node *n)
966: {
967: Node *l, *r;
968:
969: if(n == 0)
970: return;
971:
972: l = n->left;
973: r = n->right;
974: n->sun = 0;
975: n->islval = 0;
976:
977: /* Addressability */
978: switch(n->type) {
979: case OBECOME:
980: sucalc(l);
981: if(l->type == OCALL)
982: n->right = paramdep(l->right);
983: return;
984:
985: case OCONST:
986: n->islval = 20;
987: return;
988:
989: case OREGISTER:
990: n->islval = 11;
991: return;
992:
993: case OINDREG:
994: n->islval = 12;
995: return;
996:
997: case ONAME:
998: n->islval = 10;
999: return;
1000:
1001: case OADDR:
1002: sucalc(l);
1003: if(l->islval == 10)
1004: n->islval = 2;
1005: if(l->islval == 12)
1006: n->islval = 3;
1007: break;
1008:
1009: case OIND:
1010: sucalc(l);
1011: if(l->islval == 11)
1012: n->islval = 12;
1013: if(l->islval == 3)
1014: n->islval = 12;
1015: if(l->islval == 2)
1016: n->islval = 10;
1017: break;
1018:
1019: case OADD:
1020: sucalc(l);
1021: sucalc(r);
1022: if(l->islval == 20) {
1023: if(r->islval == 2)
1024: n->islval = 2;
1025: if(r->islval == 3)
1026: n->islval = 3;
1027: }
1028: if(r->islval == 20) {
1029: if(l->islval == 2)
1030: n->islval = 2;
1031: if(l->islval == 3)
1032: n->islval = 3;
1033: }
1034: break;
1035:
1036: default:
1037: sucalc(l);
1038: sucalc(r);
1039: break;
1040: }
1041:
1042: /* Number of registers */
1043: switch(n->type) {
1044: default:
1045: if(l != ZeroN)
1046: n->sun = l->sun;
1047: if(r != ZeroN) {
1048: if(n->sun == r->sun)
1049: n->sun = n->sun + 1;
1050: else if(r->sun > n->sun)
1051: n->sun = r->sun;
1052: }
1053: if(n->sun == 0)
1054: n->sun = 1;
1055: break;
1056:
1057: case OCALL:
1058: case OSEND:
1059: case ORECV:
1060: n->sun = Sucall;
1061: break;
1062: }
1063: }
1064:
1065: void
1066: setlabel(Node *n, ulong pc)
1067: {
1068: Glab *i;
1069:
1070: for(i = labels; i; i = i->next) {
1071: if(i->n->sym == n->sym) {
1072: diag(n, "label %s used twice", n->sym->name);
1073: return;
1074: }
1075: }
1076: i = malloc(sizeof(Glab));
1077: i->n = n;
1078: i->par = inpar;
1079: i->crit = incrit;
1080: i->pc = pc;
1081: i->next = labels;
1082: labels = i;
1083: }
1084:
1085: void
1086: setgoto(Node *n, Inst *i)
1087: {
1088: Glab *g;
1089:
1090: g = malloc(sizeof(Glab));
1091: g->n = n;
1092: g->i = i;
1093: g->par = inpar;
1094: g->crit = incrit;
1095: g->next = gotos;
1096: gotos = g;
1097: }
1098:
1099: Glab*
1100: findlab(Node *n)
1101: {
1102: Glab *i;
1103:
1104: for(i = labels; i; i = i->next)
1105: if(i->n->sym == n->sym)
1106: return i;
1107:
1108: return 0;
1109: }
1110:
1111: void
1112: resolvegoto(void)
1113: {
1114: Glab *g, *l;
1115:
1116: for(g = gotos; g; g = g->next) {
1117: l = findlab(g->n);
1118: if(l == 0) {
1119: diag(g->n, "no label called %s", g->n->sym->name);
1120: continue;
1121: }
1122:
1123: if(g->par != l->par)
1124: diag(g->n, "raise/goto breaks join from par");
1125: if(g->crit != l->crit)
1126: diag(g->n, "raise/goto breaks critical section");
1127:
1128: label(g->i, l->pc);
1129: }
1130: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.