![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to bbcl.h CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [Plan 9 NeXT] / lucent / sys / src / libgnot|
Return to bbcl.h CVS log | Up to [Plan 9 NeXT] / lucent / sys / src / libgnot |
1.1 root 1: typedef long Type;
2:
3: /*
4: * Little-endian byte and bit order of bbc.h.
5: * See comment there for general explanation.
6: * Differences: 'left' and 'right' shifts in the abstract
7: * machine are in screen direction, so turn into right and left shifts her;
8: * any 'offset' arguments are here taken to mean offset from the low order
9: * end of the word.
10: */
11: enum
12: {
13: field, /* arg = field mask */
14: lsha_RsRt,
15: lshb_RsRt,
16: lsh_RsRd, /* arg = shift amount */
17: lsh_RtRt, /* arg = shift amount */
18: lsha_RtRt,
19: lsha_RtRu,
20: lshb_RtRu,
21: rsha_RsRt,
22: rshb_RsRt,
23: rsha_RtRu,
24: rshb_RtRu,
25: orlsha_RsRt,
26: orlshb_RsRt,
27: orlsh_RsRd, /* arg = shift amount */
28: orrsha_RsRt,
29: orrshb_RsRt,
30: orrsha_RtRu,
31: orrshb_RtRu,
32: or_RsRd,
33: add_As, /* arg = add amount */
34: add_Ad, /* arg = add amount */
35: initsd, /* arg1 = value for As; arg2 = value for Ad */
36: ilabel, /* arg = inner loop count value for Ri */
37: olabel, /* arg = outer loop count value for Ro */
38: iloop, /* arg = pointer to beginning of inner loop */
39: oloop, /* arg = pointer to beginning of outer loop */
40: rts,
41: load_Rd_P,
42: load_Rs_P,
43: load_Rt_P,
44: load_Ru_P,
45: load_Rd_D,
46: load_Rs_D,
47: load_Rt_D,
48: load_Rd,
49: load_Rs,
50: load_Rt,
51: fetch_Rd_P,
52: fetch_Rd_D,
53: fetch_Rd,
54: store_Rs_P,
55: store_Rs_D,
56: store_Rs,
57: inittab, /* arg1 = table addr; arg2 = entry size (bytes) */
58: initsh, /* arg1 = shift amount a, arg2 = shift amount b */
59: table_RdRt, /* arg1 = offset, arg2 = nbits */
60: table_RsRt, /* arg1 = offset, arg2 = nbits */
61: assemble, /* arg1 = offset, arg2 = nbits */
62: Ozero,
63: ODnorS,
64: ODandnotS,
65: OnotS,
66: OnotDandS,
67: OnotD,
68: ODxorS,
69: ODnandS,
70: ODandS,
71: ODxnorS,
72: OD,
73: ODornotS,
74: OnotDorS,
75: ODorS,
76: OF,
77: };
78:
79: #define Ofield(c) *p++ = field; *p++ = (c)
80: #define Olsha_RsRt *p++ = lsha_RsRt
81: #define Olshb_RsRt *p++ = lshb_RsRt
82: #define Olsh_RsRd(c) *p++ = lsh_RsRd; *p++ = (c)
83: #define Olsh_RtRt(c) *p++ = lsh_RtRt; *p++ = (c)
84: #define Olsha_RtRt *p++ = lsha_RtRt
85: #define Olsha_RtRu *p++ = lsha_RtRu
86: #define Olshb_RtRu *p++ = lshb_RtRu
87: #define Orsha_RsRt *p++ = rsha_RsRt
88: #define Orshb_RsRt *p++ = rshb_RsRt
89: #define Orsha_RtRu *p++ = rsha_RtRu
90: #define Orshb_RtRu *p++ = rshb_RtRu
91: #define Oorlsha_RsRt *p++ = orlsha_RsRt
92: #define Oorlshb_RsRt *p++ = orlshb_RsRt
93: #define Oorlsh_RsRd(c) *p++ = orlsh_RsRd; *p++ = (c)
94: #define Oorrsha_RsRt *p++ = orrsha_RsRt
95: #define Oorrshb_RsRt *p++ = orrshb_RsRt
96: #define Oorrsha_RtRu *p++ = orrsha_RtRu
97: #define Oorrshb_RtRu *p++ = orrshb_RtRu
98: #define Oor_RsRd *p++ = or_RsRd
99: #define Add_As(c) *p++ = add_As; *p++ = (c)
100: #define Add_Ad(c) *p++ = add_Ad; *p++ = (c)
101: #define Initsd(s,d) *p++ = initsd; *p++ = ((ulong)(s)); *p++ = ((ulong)(d))
102: #define Initsh(a,b) *p++ = initsh; *p++ = (a); *p++ = (b)
103: #define Extrainit
104: #define Ilabel(c) *p++ = ilabel; *p++ = (c)
105: #define Olabel(c) *p++ = olabel; *p++ = (c)
106: #define Iloop(lp) *p++ = iloop; *p++ = ((ulong)(lp))
107: #define Oloop(lp) *p++ = oloop; *p++ = ((ulong)(lp))
108: #define Orts *p++ = rts
109: #define Load_Rs_P *p++ = load_Rs_P
110: #define Load_Rt_P *p++ = load_Rt_P
111: #define Loadzx_Rt_P *p++ = load_Rt_P
112: #define Loador_Rt_P *p++ = load_Rt_P
113: #define Load_Ru_P *p++ = load_Ru_P
114: #define Load_Rd_D(f) *p++ = load_Rd_D
115: #define Load_Rs_D(f) *p++ = load_Rs_D
116: #define Load_Rt_D(f) *p++ = load_Rt_D
117: #define Loadzx_Rt_D(f) *p++ = load_Rt_D
118: #define Load_Rd(f) *p++ = load_Rd
119: #define Load_Rs(f) *p++ = load_Rs
120: #define Load_Rt(f) *p++ = load_Rt
121: #define Loadzx_Rt(f) *p++ = load_Rt
122: #define Fetch_Rd_P(f) *p++ = fetch_Rd_P
123: #define Fetch_Rd_D(f) *p++ = fetch_Rd_D
124: #define Fetch_Rd(f) *p++ = fetch_Rd
125: #define Store_Rs_P *p++ = store_Rs_P
126: #define Store_Rs_D *p++ = store_Rs_D
127: #define Store_Rs *p++ = store_Rs
128: #define Nop
129: #define Inittab(t,s) *p++ = inittab; *p++ = ((ulong)(t)); *p++ = (s)
130: #define Table_RdRt(o,n,l) *p++ = table_RdRt; *p++ = (o); *p++ = (n)
131: #define Table_RsRt(o,n,l) *p++ = table_RsRt; *p++ = (o); *p++ = (n)
132: #define Assemble(o,n) *p++ = assemble; *p++ = (o); *p++ = (n)
133: #define Assemblex(o,n) *p++ = assemble; *p++ = (o); *p++ = (n)
134:
135: #define Execandfree(memstart,onstack) \
136: interpret(memstart); \
137: if(!onstack) \
138: bbfree(memstart, (p-memstart) * sizeof(Type));
139:
140:
141: /*
142: * Emitop can assume that fi points at &fstr[op].instr, and
143: * that fin contains fstr[op].n, where op is the desired
144: * bitblt opcode as declared in gnot.h
145: */
146:
147: #define Emitop if(fin) *p++ = *fi;
148:
149: typedef struct Fstr
150: {
151: char fetchs;
152: char fetchd;
153: short n;
154: Type instr[1];
155: } Fstr;
156:
157: Fstr fstr[16] =
158: {
159: [0] 0,0,1, /* Zero */
160: {Ozero},
161:
162: [1] 1,1,1, /* DnorS */
163: {ODnorS},
164:
165: [2] 1,1,1, /* DandnotS */
166: {ODandnotS},
167:
168: [3] 1,0,1, /* notS */
169: {OnotS},
170:
171: [4] 1,1,1, /* notDandS */
172: {OnotDandS},
173:
174: [5] 0,1,1, /* notD */
175: {OnotD},
176:
177: [6] 1,1,1, /* DxorS */
178: {ODxorS},
179:
180: [7] 1,1,1, /* DnandS */
181: {ODnandS},
182:
183: [8] 1,1,1, /* DandS */
184: {ODandS},
185:
186: [9] 1,1,1, /* DxnorS */
187: {ODxnorS},
188:
189: [10] 0,1,1, /* D */
190: {OD},
191:
192: [11] 1,1,1, /* DornotS */
193: {ODornotS},
194:
195: [12] 1,0,0, /* S */
196: {0},
197:
198: [13] 1,1,1, /* notDorS */
199: {OnotDorS},
200:
201: [14] 1,1,1, /* DorS */
202: {ODorS},
203:
204: [15] 0,0,1, /* F */
205: {OF},
206: };
207:
208: #include "tabs.h"
209: static uchar *tabs[4][4] =
210: {
211: { 0, (uchar*)tab01l, (uchar*)tab02l, (uchar*)tab03l},
212: {(uchar*)tab10l, 0, (uchar*)tab12l, (uchar*)tab13l},
213: {(uchar*)tab20l, (uchar*)tab21l, 0, (uchar*)tab23l},
214: {(uchar*)tab30l, (uchar*)tab31l, (uchar*)tab32l, 0},
215: };
216:
217: static uchar tabosiz[4][4] = /* size in bytes of entries */
218: {
219: { 0, 2, 4, 4},
220: { 1, 0, 2, 4},
221: { 1, 1, 0, 2},
222: { 1, 1, 1, 0},
223: };
224:
225: enum {
226: Progmax = 800, /* max number of words in a bitblt prog */
227: Progmaxnoconv = 50, /* max number of words when no conversion */
228: };
229:
230: static void
231: interpret(Type *pc)
232: {
233: ulong *As, *Ad;
234: ulong Rs, Rd, Rt, Ru;
235: long Ri, Ro;
236: ulong *AT;
237: int osiz, sha, shb, tmp;
238:
239: #ifdef TEST
240: ulong *Aslow, *Ashigh, *Adlow, *Adhigh;
241: void prprog(void);
242:
243: Rs = lrand();
244: Rd = lrand();
245: Rt = lrand();
246: Ru = lrand();
247: Ri = lrand();
248: Ro = lrand();
249: sha = lrand();
250: shb = lrand();
251: As = 0;
252: Ad = 0;
253: AT = 0;
254: Aslow = gaddr(cursm, curr.min);
255: Ashigh = gaddr(cursm, sub(curr.max, Pt(1,1)));
256: Adlow = gaddr(curdm, curpt);
257: Adhigh = gaddr(curdm, sub(add(curpt, sub(curr.max,curr.min)),Pt(1,1)));
258: #endif
259:
260: loop:
261: #ifdef TEST
262: switch(*pc) {
263: case load_Rd_P:
264: case load_Rs_P:
265: case load_Rt_P:
266: case load_Ru_P:
267: case load_Rd:
268: case load_Rs:
269: case load_Rt:
270: if(As < Aslow || As > Ashigh){
271: print("load from bad As %ux\n", As);
272: errplace:
273: print("src bitmap base %ux zero %d width %d r %d %d %d %d\n",
274: cursm->base, cursm->zero, cursm->width,
275: cursm->r.min.x, cursm->r.min.y,
276: cursm->r.max.x, cursm->r.max.y);
277: print("dst bitmap base %ux zero %d width %d r %d %d %d %d\n",
278: curdm->base, curdm->zero, curdm->width,
279: curdm->r.min.x, curdm->r.min.y,
280: curdm->r.max.x, curdm->r.max.y);
281: print("p %d %d r %d %d %d %d f %d\n",
282: curpt.x, curpt.y, curr.min.x, curr.min.y,
283: curr.max.x, curr.max.y, curf);
284: prprog();
285: exits("fail");
286: }
287: break;
288: case load_Rd_D:
289: case load_Rs_D:
290: case load_Rt_D:
291: if(As-1 < Aslow || As-1 > Ashigh){
292: print("load from bad As-1 %ux\n", As-1);
293: goto errplace;
294: }
295: break;
296: case fetch_Rd_P:
297: case fetch_Rd:
298: if(Ad < Adlow || Ad > Adhigh){
299: print("fetch from bad Ad %ux\n", Ad);
300: goto errplace;
301: }
302: break;
303: case store_Rs_P:
304: case store_Rs:
305: if(Ad < Adlow || Ad > Adhigh){
306: print("store to bad Ad %ux\n", Ad);
307: goto errplace;
308: }
309: break;
310: case fetch_Rd_D:
311: case store_Rs_D:
312: if(Ad-1 < Adlow || Ad-1 > Adhigh){
313: print("fetch from bad Ad-1 %ux\n", Ad-1);
314: prprog();
315: }
316: break;
317: }
318: #endif
319: switch(*pc++) {
320: default:
321: #ifdef TEST
322: print("unknown opcode %d\n", pc[-1]);
323: goto errplace;
324: #else
325: return;
326: #endif
327: case field:
328: /* Rs gets Rd where mask bits are 0s, Rs where mask bits are 1s */
329: Rs = ((Rs ^ Rd) & *pc++) ^ Rd;
330: break;
331:
332: case lsha_RsRt:
333: Rs = Rt >> sha;
334: break;
335:
336: case lshb_RsRt:
337: Rs = Rt >> shb;
338: break;
339:
340: case lsh_RsRd:
341: Rs = Rd >> *pc++;
342: break;
343:
344: case lsh_RtRt: /* arg = shift amount */
345: Rt >>= *pc++;
346: break;
347:
348: case lsha_RtRt:
349: Rt >>= sha;
350: break;
351:
352: case lsha_RtRu:
353: Rt = Ru >> sha;
354: break;
355:
356: case lshb_RtRu:
357: Rt = Ru >> shb;
358: break;
359:
360: case rsha_RsRt:
361: Rs = Rt << sha;
362: break;
363:
364: case rshb_RsRt:
365: Rs = Rt << shb;
366: break;
367:
368: case rsha_RtRu:
369: Rt = Ru << sha;
370: break;
371:
372: case rshb_RtRu:
373: Rt = Ru << shb;
374: break;
375:
376: case orlsha_RsRt:
377: Rs |= Rt >> sha;
378: break;
379:
380: case orlshb_RsRt:
381: Rs |= Rt >> shb;
382: break;
383:
384: case orlsh_RsRd: /* arg = shift amount */
385: Rs |= Rd >> *pc++;
386: break;
387:
388: case orrsha_RsRt:
389: Rs |= Rt << sha;
390: break;
391:
392: case orrshb_RsRt:
393: Rs |= Rt << shb;
394: break;
395:
396: case orrsha_RtRu:
397: Rt |= Ru << sha;
398: break;
399:
400: case orrshb_RtRu:
401: Rt |= Ru << shb;
402: break;
403:
404: case or_RsRd:
405: Rs |= Rd;
406: break;
407:
408: case add_As:
409: As = (ulong*)((char*)As + (long)*pc++);
410: break;
411:
412: case add_Ad:
413: Ad = (ulong*)((char*)Ad + (long)*pc++);
414: break;
415:
416: case initsd:
417: As = (ulong*)pc[0];
418: Ad = (ulong*)pc[1];
419: pc += 2;
420: break;
421:
422: case ilabel:
423: /* initialize inner loop count */
424: Ri = *pc++;
425: break;
426:
427: case olabel:
428: /* initialize outer loop count */
429: Ro = *pc++;
430: break;
431:
432: case iloop:
433: /* decrement inner loop count, loop back if still positive */
434: Ri--;
435: if(Ri > 0) {
436: pc = (Type*)pc[0];
437: break;
438: }
439: pc++;
440: break;
441:
442: case oloop:
443: /* decrement outer loop count, loop back if still positive */
444: Ro--;
445: if(Ro > 0) {
446: pc = (Type*)pc[0];
447: break;
448: }
449: pc++;
450: break;
451:
452: case rts:
453: return;
454:
455: case load_Rd_P:
456: Rd = *As++;
457: break;
458:
459: case load_Rs_P:
460: Rs = *As++;
461: break;
462:
463: case load_Rt_P:
464: Rt = *As++;
465: break;
466:
467: case load_Ru_P:
468: Ru = *As++;
469: break;
470:
471: case load_Rd_D:
472: Rd = *--As;
473: break;
474:
475: case load_Rs_D:
476: Rs = *--As;
477: break;
478:
479: case load_Rt_D:
480: Rt = *--As;
481: break;
482:
483: case load_Rd:
484: Rd = *As;
485: break;
486:
487: case load_Rs:
488: Rs = *As;
489: break;
490:
491: case load_Rt:
492: Rt = *As;
493: break;
494:
495: case fetch_Rd_P:
496: Rd = *Ad++;
497: break;
498:
499: case fetch_Rd_D:
500: Rd = *--Ad;
501: break;
502:
503: case fetch_Rd:
504: Rd = *Ad;
505: break;
506:
507: case store_Rs_P:
508: *Ad++ = Rs;
509: break;
510:
511: case store_Rs_D:
512: *--Ad = Rs;
513: break;
514:
515: case store_Rs:
516: *Ad = Rs;
517: break;
518:
519: case inittab:
520: AT = (ulong*)pc[0];
521: osiz = (long)pc[1];
522: pc += 2;
523: break;
524:
525: case initsh:
526: sha = (long)pc[0];
527: shb = (long)pc[1];
528: pc += 2;
529: break;
530:
531: case table_RdRt:
532: /*
533: * Starting at offset arg1 in Rt, take arg2 bits,
534: * and use it to look up in table AT, putting answer in Rd
535: */
536: Rd = (Rt >> ((long)pc[0])) & ((1<<((long)pc[1]))-1);
537: Rd = AT[Rd];
538: pc += 2;
539: break;
540:
541: case table_RsRt:
542: /* like table_RdRt, but answer goes in Rs */
543: tmp = (long)pc[1];
544: Rs = (Rt >> ((long)pc[0])) & ((1<<((long)pc[1]))-1);
545: Rs = AT[Rs];
546: pc += 2;
547: break;
548:
549:
550: case assemble:
551: /*
552: * Move high arg2 bits of Rd into offset arg1 in Rs.
553: * Can assume that low bits of Rd are zero,
554: * and target field of Rs is zero if offset != 0
555: */
556: tmp = (long)pc[0];
557: if(tmp == 0)
558: Rs = Rd >> (32-pc[1]);
559: else
560: Rs |= Rd >> (32-(tmp+pc[1]));
561: pc += 2;
562: break;
563:
564: case Ozero:
565: Rs = 0;
566: break;
567:
568: case ODnorS:
569: Rs = ~(Rd|Rs);
570: break;
571:
572: case ODandnotS:
573: Rs = Rd & ~Rs;
574: break;
575:
576: case OnotS:
577: Rs = ~Rs;
578: break;
579:
580: case OnotDandS:
581: Rs = ~Rd & Rs;
582: break;
583:
584: case OnotD:
585: Rs = ~Rd;
586: break;
587:
588: case ODxorS:
589: Rs ^= Rd;
590: break;
591:
592: case ODnandS:
593: Rs = ~(Rd & Rs);
594: break;
595:
596: case ODandS:
597: Rs &= Rd;
598: break;
599:
600: case ODxnorS:
601: Rs = ~(Rd ^ Rs);
602: break;
603:
604: case OD:
605: Rs = Rd;
606: break;
607:
608: case ODornotS:
609: Rs = Rd | ~Rs;
610: break;
611:
612: case OnotDorS:
613: Rs |= ~Rd;
614: break;
615:
616: case ODorS:
617: Rs |= Rd;
618: break;
619:
620: case OF:
621: Rs = ~0L;
622: break;
623: }
624: goto loop;
625: }
626:
627: #ifdef TEST
628: void
629: prprog(void)
630: {
631: int osiz;
632: Type *pc;
633: pc = (Type *)mem;
634:
635: loop:
636: switch(*pc++) {
637: default:
638: print("unknown opcode %d\n", pc[-1]);
639: exits("unknown opcode");
640: case field:
641: print("Rs = ((Rs ^ Rd) & 0x%lux) ^ Rd\n", *pc++);
642: break;
643:
644: case lsha_RsRt:
645: print("Rs = Rt >> sha\n");
646: break;
647:
648: case lshb_RsRt:
649: print("Rs = Rt >> shb\n");
650: break;
651:
652: case lsh_RsRd:
653: print("Rs = Rd >> %d\n", *pc++);
654: break;
655:
656: case lsh_RtRt:
657: print("Rt >>= %d\n", *pc++);
658: break;
659:
660: case lsha_RtRt:
661: print("Rt >>= sha\n");
662: break;
663:
664: case lsha_RtRu:
665: print("Rt = Ru >> sha\n");
666: break;
667:
668: case lshb_RtRu:
669: print("Rt = Ru >> shb\n");
670: break;
671:
672: case rsha_RsRt:
673: print("Rs = Rt << sha\n");
674: break;
675:
676: case rshb_RsRt:
677: print("Rs = Rt << shb\n");
678: break;
679:
680: case rsha_RtRu:
681: print("Rt = Ru << sha\n");
682: break;
683:
684: case rshb_RtRu:
685: print("Rt = Ru << shb\n");
686: break;
687:
688: case orlsha_RsRt:
689: print("Rs |= Rt >> sha\n");
690: break;
691:
692: case orlshb_RsRt:
693: print("Rs |= Rt >> shb\n");
694: break;
695:
696: case orlsh_RsRd:
697: print("Rs |= Rd >> %d\n", *pc++);
698: break;
699:
700: case orrsha_RsRt:
701: print("Rs |= Rt << sha\n");
702: break;
703:
704: case orrshb_RsRt:
705: print("Rs |= Rt << shb\n");
706: break;
707:
708: case orrsha_RtRu:
709: print("Rt |= Ru << sha\n");
710: break;
711:
712: case orrshb_RtRu:
713: print("Rt |= Ru << shb\n");
714: break;
715:
716: case or_RsRd:
717: print("Rs |= Rd\n");
718: break;
719:
720: case add_As:
721: print("As += %d\n", (long)*pc++);
722: break;
723:
724: case add_Ad:
725: print("Ad += %d\n", (long)*pc++);
726: break;
727:
728: case initsd:
729: print("As = 0x%lux\n", (ulong*)pc[0]);
730: print("Ad = 0x%lux\n", (ulong*)pc[1]);
731: pc += 2;
732: break;
733:
734: case ilabel:
735: print("Ri = %d\n", *pc++);
736: break;
737:
738: case olabel:
739: print("Ro = %d\n", *pc++);
740: break;
741:
742: case iloop:
743: print("if(--Ri > 0) goto 0x%lux\n", *pc++);
744: break;
745:
746: case oloop:
747: print("if(--Ro > 0) goto 0x%lux\n", *pc++);
748: break;
749:
750: case rts:
751: print("return\n");
752: return;
753:
754: case load_Rd_P:
755: print("Rd = *As++\n");
756: break;
757:
758: case load_Rs_P:
759: print("Rs = *As++\n");
760: break;
761:
762: case load_Rt_P:
763: print("Rt = *As++\n");
764: break;
765:
766: case load_Ru_P:
767: print("Ru = *As++\n");
768: break;
769:
770: case load_Rd_D:
771: print("Rd = *--As\n");
772: break;
773:
774: case load_Rs_D:
775: print("Rs = *--As\n");
776: break;
777:
778: case load_Rt_D:
779: print("Rt = *--As\n");
780: break;
781:
782: case load_Rd:
783: print("Rd = *As\n");
784: break;
785:
786: case load_Rs:
787: print("Rs = *As\n");
788: break;
789:
790: case load_Rt:
791: print("Rt = *As\n");
792: break;
793:
794: case fetch_Rd_P:
795: print("Rd = *Ad++\n");
796: break;
797:
798: case fetch_Rd_D:
799: print("Rd = *--Ad\n");
800: break;
801:
802: case fetch_Rd:
803: print("Rd = *Ad\n");
804: break;
805:
806: case store_Rs_P:
807: print("*Ad++ = Rs\n");
808: break;
809:
810: case store_Rs_D:
811: print("*--Ad = Rs\n");
812: break;
813:
814: case store_Rs:
815: print("*Ad = Rs\n");
816: break;
817:
818: case inittab:
819: print("AT = 0x%lux (%d byte entries)\n", pc[0],pc[1]);
820: osiz = pc[1];
821: pc += 2;
822: break;
823:
824: case initsh:
825: print("sha = %d\n", (long)pc[0]);
826: print("shb = %d\n", (long)pc[1]);
827: pc += 2;
828: break;
829:
830: case table_RdRt:
831: switch(osiz){
832: case 1:
833: print("Rd = ((char*)AT)[Rt{%d..%d}]\n", pc[0], pc[0]+pc[1]-1);
834: break;
835: case 2:
836: print("Rd = ((short*)AT)[Rt{%d..%d}]\n", pc[0], pc[0]+pc[1]-1);
837: break;
838: case 4:
839: print("Rd = ((long*)AT)[Rt{%d..%d}]\n", pc[0], pc[0]+pc[1]-1);
840: break;
841: default:
842: print("bad osiz for table_RdRt\n");
843: }
844: pc += 2;
845: break;
846:
847: case table_RsRt:
848: switch(osiz){
849: case 1:
850: print("Rs = ((char*)AT)[Rt{%d..%d}]\n", pc[0], pc[0]+pc[1]-1);
851: break;
852: case 2:
853: print("Rs = ((short*)AT)[Rt{%d..%d}]\n", pc[0], pc[0]+pc[1]-1);
854: break;
855: case 4:
856: print("Rs = ((long*)AT)[Rt{%d..%d}]\n", pc[0], pc[0]+pc[1]-1);
857: break;
858: default:
859: print("bad osiz for table_RdRt\n");
860: }
861: pc += 2;
862: break;
863:
864: case assemble:
865: /*
866: * Move low arg2 bits of Rd into offset arg1 in Rs.
867: * Can assume that high bits of Rd are zero,
868: * and target field of Rs is zero if offset != 0
869: */
870: if(pc[0] == 0)
871: print("Rs = Rd >> %d\n", (32-(long)pc[1]));
872: else
873: print("Rs |= Rd >> %d\n", (32-((long)pc[0]+(long)pc[1])));
874: pc += 2;
875: break;
876:
877: case Ozero:
878: print("Rs = 0\n");
879: break;
880:
881: case ODnorS:
882: print("Rs = ~(Rd|Rs)\n");
883: break;
884:
885: case ODandnotS:
886: print("Rs = Rd & ~Rs\n");
887: break;
888:
889: case OnotS:
890: print("Rs = ~Rs\n");
891: break;
892:
893: case OnotDandS:
894: print("Rs = ~Rd & Rs\n");
895: break;
896:
897: case OnotD:
898: print("Rs = ~Rd\n");
899: break;
900:
901: case ODxorS:
902: print("Rs ^= Rd\n");
903: break;
904:
905: case ODnandS:
906: print("Rs = ~(Rd & Rs)\n");
907: break;
908:
909: case ODandS:
910: print("Rs &= Rd\n");
911: break;
912:
913: case ODxnorS:
914: print("Rs = ~(Rd ^ Rs)\n");
915: break;
916:
917: case OD:
918: print("Rs = Rd\n");
919: break;
920:
921: case ODornotS:
922: print("Rs = Rd | ~Rs\n");
923: break;
924:
925: case OnotDorS:
926: print("Rs |= ~Rd\n");
927: break;
928:
929: case ODorS:
930: print("Rs |= Rd\n");
931: break;
932:
933: case OF:
934: print("Rs = ~0L\n");
935: break;
936: }
937: goto loop;
938: }
939: #endif
940:
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.