![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to output.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 output.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: #include "y.tab.h"
9:
10: static int slot;
11:
12: char *itab[] =
13: {
14: "XXX",
15: "ADD",
16: "ADDCC",
17: "ADDX",
18: "ADDXCC",
19: "AND",
20: "ANDCC",
21: "ANDN",
22: "ANDNCC",
23: "BA",
24: "BCC",
25: "BCS",
26: "BE",
27: "BG",
28: "BGE",
29: "BGU",
30: "BL",
31: "BLE",
32: "BLEU",
33: "BN",
34: "BNE",
35: "BNEG",
36: "BPOS",
37: "BVC",
38: "BVS",
39: "CB0",
40: "CB01",
41: "CB012",
42: "CB013",
43: "CB02",
44: "CB023",
45: "CB03",
46: "CB1",
47: "CB12",
48: "CB123",
49: "CB13",
50: "CB2",
51: "CB23",
52: "CB3",
53: "CBA",
54: "CBN",
55: "CMP",
56: "CPOP1",
57: "CPOP2",
58: "DATA",
59: "DIV",
60: "DIVL",
61: "FABSD",
62: "FABSF",
63: "FABSX",
64: "FADDD",
65: "FADDF",
66: "FADDX",
67: "FBA",
68: "FBE",
69: "FBG",
70: "FBGE",
71: "FBL",
72: "FBLE",
73: "FBLG",
74: "FBN",
75: "FBNE",
76: "FBO",
77: "FBU",
78: "FBUE",
79: "FBUG",
80: "FBUGE",
81: "FBUL",
82: "FBULE",
83: "FCMPD",
84: "FCMPED",
85: "FCMPEF",
86: "FCMPEX",
87: "FCMPF",
88: "FCMPX",
89: "FDIVD",
90: "FDIVF",
91: "FDIVX",
92: "FMOVD",
93: "FMOVDF",
94: "FMOVDW",
95: "FMOVDX",
96: "FMOVF",
97: "FMOVFD",
98: "FMOVFW",
99: "FMOVFX",
100: "FMOVWD",
101: "FMOVWF",
102: "FMOVWX",
103: "FMOVX",
104: "FMOVXD",
105: "FMOVXF",
106: "FMOVXW",
107: "FMULD",
108: "FMULF",
109: "FMULX",
110: "FNEGD",
111: "FNEGF",
112: "FNEGX",
113: "FSQRTD",
114: "FSQRTF",
115: "FSQRTX",
116: "FSUBD",
117: "FSUBF",
118: "FSUBX",
119: "GLOBL",
120: "GOK",
121: "HISTORY",
122: "IFLUSH",
123: "JMPL",
124: "JMP",
125: "MOD",
126: "MODL",
127: "MOVB",
128: "MOVBU",
129: "MOVD",
130: "MOVH",
131: "MOVHU",
132: "MOVW",
133: "MUL",
134: "MULSCC",
135: "NAME",
136: "NOP",
137: "OR",
138: "ORCC",
139: "ORN",
140: "ORNCC",
141: "RESTORE",
142: "RETT",
143: "RETURN",
144: "SAVE",
145: "SLL",
146: "SRA",
147: "SRL",
148: "SUB",
149: "SUBCC",
150: "SUBX",
151: "SUBXCC",
152: "SWAP",
153: "TA",
154: "TADDCC",
155: "TADDCCTV",
156: "TAS",
157: "TCC",
158: "TCS",
159: "TE",
160: "TEXT",
161: "TG",
162: "TGE",
163: "TGU",
164: "TL",
165: "TLE",
166: "TLEU",
167: "TN",
168: "TNE",
169: "TNEG",
170: "TPOS",
171: "TSUBCC",
172: "TSUBCCTV",
173: "TVC",
174: "TVS",
175: "UNIMP",
176: "WORD",
177: "XNOR",
178: "XNORCC",
179: "XOR",
180: "XORCC",
181: "END",
182: "DYNT",
183: "INIT",
184: "LAST",
185: };
186:
187: char rcmap[256] =
188: {
189: ['\0'] 'z',
190: ['\n'] 'n',
191: ['\r'] 'r',
192: ['\t'] 't',
193: ['\b'] 'b',
194: ['\f'] 'f',
195: ['\a'] 'a',
196: ['\v'] 'v',
197: ['\\'] '\\',
198: ['"'] '"',
199: };
200:
201: void
202: vwrite(Biobuf *b, Inst *i, int sf, int st)
203: {
204: char io[100], *bp;
205:
206: io[0] = i->op;
207: if(i->reg == Nreg)
208: io[1] = NREG;
209: else
210: io[1] = i->reg;
211:
212: io[2] = i->lineno;
213: io[3] = i->lineno>>8;
214: io[4] = i->lineno>>16;
215: io[5] = i->lineno>>24;
216:
217: bp = vaddr(io+6, &i->src1, sf);
218: bp = vaddr(bp, &i->dst, st);
219:
220: Bwrite(b, io, bp-io);
221: }
222:
223: void
224: outhist(Biobuf *b)
225: {
226: Hist *h;
227: char *p, *q;
228: Inst pg;
229: int n;
230:
231: pg.op = AHISTORY;
232: pg.src1.type = A_NONE;
233: pg.dst.reg = Nreg;
234: pg.reg = Nreg;
235: for(h = hist; h != H; h = h->link) {
236: p = h->name;
237: while(p) {
238: q = strchr(p, '/');
239: if(q) {
240: n = q-p;
241: if(n == 0)
242: n = 1; /* leading "/" */
243: q++;
244: } else {
245: n = strlen(p);
246: q = 0;
247: }
248: if(n) {
249: Bputc(b, ANAME);
250: Bputc(b, D_FILE);
251: Bputc(b, 1);
252: Bputc(b, '<');
253: Bwrite(b, p, n);
254: Bputc(b, 0);
255: }
256: p = q;
257: }
258: pg.lineno = h->line;
259: pg.dst.ival = h->offset;
260: pg.dst.type = A_NONE;
261: if(h->offset)
262: pg.dst.type = A_CONST;
263:
264: vwrite(b, &pg, 0, 0);
265: }
266: }
267:
268: void
269: sfile(char *name)
270: {
271: int f;
272: Inst *i;
273: Biobuf b;
274:
275: f = create(name, OWRITE|OTRUNC, 0666);
276: if(f < 0) {
277: diag(ZeroN, "cannot open %s: %r", name);
278: return;
279: }
280: Binit(&b, f, OWRITE);
281:
282: for(i = proghead; i; i = i->next) {
283: if(i->dst.type == A_BRANCH)
284: i->dst.ival -= i->pc;
285:
286: Bprint(&b, "%i\n", i);
287: }
288:
289: Bflush(&b);
290: close(f);
291: }
292:
293: void
294: objfile(char *name)
295: {
296: Inst *i;
297: Biobuf b;
298: Inst end;
299: int f, sfrom, sto;
300:
301: f = create(name, OWRITE|OTRUNC, 0666);
302: if(f < 0) {
303: diag(ZeroN, "cannot open %s: %r", name);
304: return;
305: }
306: Binit(&b, f, OWRITE);
307: Bseek(&b, 0L, 2);
308:
309: outhist(&b);
310:
311: memset(scache, 0, sizeof(scache));
312:
313: for(i = proghead; i; i = i->next) {
314: sto = 0;
315: sfrom = 0;
316: do{
317: switch(i->src1.type) {
318: case A_CONST:
319: case A_INDREG:
320: if(i->src1.class)
321: sfrom = vcache(&b, &i->src1);
322: }
323: switch(i->dst.type) {
324: case A_CONST:
325: case A_INDREG:
326: if(i->dst.class)
327: sto = vcache(&b, &i->dst);
328: }
329: }while(sfrom == sto && sfrom != 0);
330:
331: vwrite(&b, i, sfrom, sto);
332: }
333:
334: end = zprog;
335: end.op = AEND;
336: vwrite(&b, &end, 0, 0);
337:
338: Bflush(&b);
339: close(f);
340: }
341:
342: int
343: vcache(Biobuf *b, Adres *a)
344: {
345: Sym *s;
346: Scache *c;
347:
348: s = a->sym;
349:
350: if(s->slot) {
351: c = &scache[s->slot];
352: if(c->s == s)
353: if(c->class == a->class)
354: return s->slot;
355: }
356:
357: slot++;
358: if(slot >= NSYM)
359: slot = 1;
360:
361: c = &scache[slot];
362: c->s = s;
363: c->class = a->class;
364:
365: vname(b, a->class, s->name, slot);
366:
367: return slot;
368: }
369:
370: void
371: vname(Biobuf *b, char class, char *name, int slot)
372: {
373: char io[4];
374:
375: io[0] = ANAME;
376: switch(class) {
377: default:
378: fatal("vcache %d", class);
379: case Dfile:
380: io[1] = D_FILE;
381: break;
382: case Internal:
383: io[1] = D_STATIC;
384: break;
385: case External:
386: case Global:
387: io[1] = D_EXTERN;
388: break;
389: case Parameter:
390: io[1] = D_PARAM;
391: break;
392: case Automatic:
393: io[1] = D_AUTO;
394: break;
395: }
396: io[2] = slot;
397:
398: Bwrite(b, io, 3);
399: Bwrite(b, name, strlen(name)+1);
400: }
401:
402: char*
403: vaddr(char *bp, Adres *a, int s)
404: {
405: long l;
406: Ieee e;
407:
408: bp[0] = D_NONE;
409: bp[1] = NREG;
410: bp[2] = 0;
411: bp[3] = D_NONE;
412:
413: switch(a->type) {
414: default:
415: fatal("vaddr %a", a);
416:
417: case A_NONE:
418: bp += 4;
419: break;
420:
421: case A_CONST:
422: bp[0] = D_CONST;
423: if(a->reg != Nreg)
424: bp[1] = a->reg;
425: bp[2] = s;
426: l = a->ival;
427: switch(a->class) {
428: default:
429: bp[3] = D_NONE;
430: break;
431: case Internal:
432: bp[3] = D_STATIC;
433: break;
434: case External:
435: case Global:
436: bp[3] = D_EXTERN;
437: break;
438: case Parameter:
439: bp[3] = D_PARAM;
440: break;
441: case Automatic:
442: bp[3] = D_AUTO;
443: break;
444: }
445: bp[4] = l;
446: bp[5] = l>>8;
447: bp[6] = l>>16;
448: bp[7] = l>>24;
449: bp += 8;
450: break;
451:
452: case A_FCONST:
453: bp[0] = D_FCONST;
454: ieeedtod(&e, a->fval);
455: l = e.l;
456: bp[4] = l;
457: bp[5] = l>>8;
458: bp[6] = l>>16;
459: bp[7] = l>>24;
460: l = e.h;
461: bp[8] = l;
462: bp[9] = l>>8;
463: bp[10] = l>>16;
464: bp[11] = l>>24;
465: bp += 12;
466: break;
467:
468: case A_REG:
469: bp[0] = D_REG;
470: bp[1] = a->reg;
471: bp += 4;
472: break;
473:
474: case A_FREG:
475: bp[0] = D_FREG;
476: bp[1] = a->reg;
477: bp += 4;
478: break;
479:
480: case A_INDREG:
481: bp[0] = D_OREG;
482: bp[2] = s;
483: l = a->ival;
484: switch(a->class) {
485: default:
486: bp[1] = a->reg;
487: bp[3] = D_NONE;
488: break;
489: case Internal:
490: bp[1] = NREG;
491: bp[3] = D_STATIC;
492: break;
493: case External:
494: case Global:
495: bp[1] = NREG;
496: bp[3] = D_EXTERN;
497: break;
498: case Parameter:
499: bp[1] = NREG;
500: bp[3] = D_PARAM;
501: break;
502: case Automatic:
503: bp[1] = NREG;
504: bp[3] = D_AUTO;
505: break;
506: }
507: bp[4] = l;
508: bp[5] = l>>8;
509: bp[6] = l>>16;
510: bp[7] = l>>24;
511: bp += 8;
512: break;
513:
514: case A_BRANCH:
515: bp[0] = D_BRANCH;
516: l = a->ival;
517: bp[4] = l;
518: bp[5] = l>>8;
519: bp[6] = l>>16;
520: bp[7] = l>>24;
521: bp += 8;
522: break;
523:
524: case A_STRING:
525: bp[0] = D_SCONST;
526: memmove(bp+4, a->str, NSNAME);
527: bp += 4+NSNAME;
528: break;
529: }
530: return bp;
531: }
532:
533: /* Quoted string printer */
534: int
535: qconv(void *o, Fconv *f)
536: {
537: char buf[64], *b;
538: char *p;
539: int i;
540:
541: p = *((char**)o);
542: b = buf;
543: for(i = 0; i < 8; i++) {
544: if(rcmap[*p]) {
545: b[0] = '\\';
546: b[1] = rcmap[*p++];
547: b += 2;
548: }
549: else
550: *b++ = *p++;
551: }
552: *b = '\0';
553: strconv(buf, f);
554: return sizeof(p);
555: }
556:
557: /* Instruction printer */
558: int
559: iconv(void *o, Fconv *f)
560: {
561: Inst *i;
562: char c, buf[128];
563:
564: i = *((Inst **)o);
565:
566: if(i->op == ADATA || i->op == AINIT || i->op == ADYNT)
567: sprint(buf, "\t%s\t%a/%d,%a", itab[i->op], &i->src1, i->reg, &i->dst);
568: else
569: if(i->reg == Nreg) {
570: if(i->dst.type == A_NONE)
571: sprint(buf, "\t%s\t%a", itab[i->op], &i->src1);
572: else
573: sprint(buf, "\t%s\t%a,%a", itab[i->op], &i->src1, &i->dst);
574: }
575: else {
576: c = 'R';
577: if(i->src1.type == A_FREG)
578: c = 'F';
579: sprint(buf, "\t%s\t%a,%c%d,%a", itab[i->op],
580: &i->src1, c, i->reg, &i->dst);
581: }
582:
583: strconv(buf, f);
584: return sizeof(i);
585: }
586:
587: int
588: mconv(void *o, Fconv *f)
589: {
590: Adres *adr;
591: char buf[128];
592:
593: adr = *((Adres **)o);
594:
595: switch(adr->class) {
596: default:
597: sprint(buf, "Addr(%d/%d)", adr->class, adr->ival);
598: break;
599:
600: case External:
601: case Global:
602: sprint(buf, "%s+%d(SB)", adr->sym->name, adr->ival);
603: break;
604:
605: case Internal:
606: sprint(buf, "%s<>+%d(SB)", adr->sym->name, adr->ival);
607: break;
608:
609: case Parameter:
610: sprint(buf, "%s+%d(FP)", adr->sym->name, adr->ival);
611: break;
612:
613: case Automatic:
614: sprint(buf, "%s%d(SP)", adr->sym->name, adr->ival);
615: break;
616: }
617:
618: strconv(buf, f);
619: return sizeof(adr);
620:
621: }
622:
623: /* Address syllable printer */
624: int
625: aconv(void *o, Fconv *f)
626: {
627: char buf[128];
628: Adres *adr;
629:
630: adr = *((Adres **)o);
631: switch(adr->type) {
632: default:
633: sprint(buf, "Addr(%d)", adr->type);
634: break;
635:
636: case A_NONE:
637: buf[0] = 0;
638: break;
639:
640: case A_BRANCH:
641: sprint(buf, "%d(PC)", adr->ival);
642: break;
643:
644: case A_STRING:
645: sprint(buf, "$\"%q\"", adr->str);
646: break;
647:
648: case A_CONST:
649: if(adr->class)
650: sprint(buf, "$%m", adr);
651: else
652: if(adr->reg != Nreg)
653: sprint(buf, "$%d(R%d)", adr->ival, adr->reg);
654: else
655: sprint(buf, "$%d", adr->ival);
656: break;
657:
658: case A_FCONST:
659: sprint(buf, "$%#g", adr->fval);
660: break;
661:
662: case A_REG:
663: sprint(buf, "R%d", adr->reg);
664: break;
665:
666: case A_FREG:
667: sprint(buf, "F%d", adr->reg);
668: break;
669:
670: case A_INDREG:
671: if(adr->class)
672: sprint(buf, "%m", adr);
673: else
674: if(adr->ival == 0)
675: sprint(buf, "(R%d)", adr->reg);
676: else
677: sprint(buf, "%d(R%d)", adr->ival, adr->reg);
678: break;
679: }
680:
681: strconv(buf, f);
682: return sizeof(adr);
683: }
684:
685: typedef struct runtime Runtime;
686: struct runtime
687: {
688: char *name;
689: Node **p;
690: }runtime[] = {
691: "ALEF_proc", &procnode,
692: "ALEF_task", &tasknode,
693: "ALEF_send", &sendnode,
694: "ALEF_exit", &exitnode,
695: "ALEF_selrecv", &selrecv,
696: "ALEF_selsend", &selsend,
697: "ALEF_doselect", &doselect,
698: "ALEF_varselect", &varselect,
699: "ALEF_pfork", &pforknode,
700: "ALEF_pexit", &pexitnode,
701: "ALEF_pdone", &pdonenode,
702: "ALEF_csnd", &csndnode,
703: "ALEF_crcv", &crcvnode,
704: "ALEF_chana", &challocnode,
705: "ALEF_chanu", &chunallocnode,
706: "malloc", &allocnode,
707: "free", &unallocnode,
708: "ALEF_gin", &ginode,
709: "ALEF_gou", &gonode,
710: "memmove", &movenode,
711: "ALEFcheck", &checknode,
712: 0, 0,
713: };
714:
715: void
716: outinit(void)
717: {
718: Node *n;
719: Type *t;
720: Runtime *rp;
721:
722: fmtinstall('i', iconv); /* Instructions */
723: fmtinstall('a', aconv); /* Addresses */
724: fmtinstall('q', qconv); /* Data */
725: fmtinstall('m', mconv); /* Memeory addresses */
726: fmtinstall('B', Bconv); /* Memeory addresses */
727:
728: for(rp = runtime; rp->name; rp++) {
729: n = an(ONAME, nil, nil);
730: n->sym = enter(rp->name, Tid);
731:
732: t = builtype[TVOID];
733: if(rp->p == &allocnode)
734: t = at(TIND, t);
735: t = at(TFUNC, t);
736: t->proto = an(ONAME, an(OVARARG, nil, nil), nil);
737: t->proto->sym = n->sym;
738: if(rp->p == &checknode)
739: t = at(TIND, t);
740:
741: n->t = t;
742: n->ti = ati(t, Global);
743: sucalc(n);
744: *(rp->p) = n;
745: }
746:
747: zprog.next = 0;
748: zprog.src1.type = A_NONE;
749: zprog.dst.type = A_NONE;
750: zprog.op = AGOK;
751: zprog.reg = Nreg;
752: }
753:
754: void
755: ieeedtod(Ieee *ieee, double native)
756: {
757: double fr, ho, f;
758: int exp;
759:
760: if(native < 0) {
761: ieeedtod(ieee, -native);
762: ieee->h |= 0x80000000L;
763: return;
764: }
765: if(native == 0) {
766: ieee->l = 0;
767: ieee->h = 0;
768: return;
769: }
770: fr = frexp(native, &exp);
771: f = 2097152L; /* shouldnt use fp constants here */
772: fr = modf(fr*f, &ho);
773: ieee->h = ho;
774: ieee->h &= 0xfffffL;
775: ieee->h |= (exp+1022L) << 20;
776: f = 65536L;
777: fr = modf(fr*f, &ho);
778: ieee->l = ho;
779: ieee->l <<= 16;
780: ieee->l |= (long)(fr*f);
781: }
782:
783: void
784: init(Node *tab, Node *v)
785: {
786: Inst *i;
787:
788: i = ai();
789: i->op = AINIT;
790: i->reg = builtype[TIND]->size;
791: mkaddr(tab, &i->src1, 0);
792: mkaddr(v, &i->dst, 0);
793: ilink(i);
794: }
795:
796: void
797: dynt(Node *tab, Node *ind)
798: {
799: Inst *i;
800:
801: i = ai();
802: i->op = ADYNT;
803: if(tab)
804: mkaddr(tab, &i->src1, 0);
805: mkaddr(ind, &i->dst, 0);
806: ilink(i);
807: }
808:
809: void
810: dupok(void)
811: {
812: if(ipc->reg == Nreg)
813: ipc->reg = DUPOK;
814: else
815: ipc->reg |= DUPOK;
816: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.