![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to gbitblt.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 / libgnot|
Return to gbitblt.c CVS log | Up to [Plan 9 NeXT] / lucent / sys / src / libgnot |
1.1 root 1: #include <u.h>
2: #include <libc.h>
3: #include <libg.h>
4: #include "/sys/include/gnot.h"
5: /*
6: * Compiling bitblt - for each call of gbitblt, generate
7: * machine code for the specific arguments passed in,
8: * then execute that code as a subroutine call.
9: *
10: * The files bb?.h (where ? is replaced by the
11: * architectures single-letter code: v, k, etc., depending
12: * on which of Tmips, Tsparc, etc., is defined) define macros
13: * which define operations on an abstract machine.
14: * If there is no architecture-specific file, bbc.h is used,
15: * which interprets a program with the same operations as
16: * the assumed abstract machine. See bbc.h for a description
17: * of the machine's registers and operations, and for the
18: * macros that must be defined to make a new bb?.h
19: *
20: * The code will work for bitblts to and from any bitmaps
21: * with ldepths 0, 1, 2, or 3. Some of those conversions
22: * may be #ifdef'd out, because no Plan 9 code currently
23: * uses them, and the tables take up space. The converting
24: * bitblts will need work if they are to work with ldepths > 3.
25: *
26: * This file also contains a thorough bitblt tester.
27: * When TEST is defined, a main program is created to
28: * try forward and backward cases for all bitblt opcodes,
29: * first on single pixels, and then on parts of the middle two rows
30: * of random 4-row bitmaps. If anything fails, it prints information
31: * about the case that failed (or perhaps it will just die,
32: * if bad code has been generated).
33: * The testing programs takes as arguments two numbers: the source
34: * and destination ldepths (both 0 by default). A -s flag says to
35: * use simpler, repeatable tests. A -i num flag says how many
36: * iterations to do for each opcode.
37: */
38:
39: /* Bitblt cases:
40: * - bitmap overlap sometimes dictates that you go forward (f) through
41: * the bitmaps, sometimes backwards (b)
42: * - different relative alignments of the source and destination
43: * starting points within a word require different code:
44: * the bit offsets may be the same (e), the source may start
45: * later in the word (g), or the source may start earlier in the word (l)
46: * - when a row of the destination is all within one word (o), better
47: * code can be generated
48: * - when the object machine has bitfield extraction/insertion instructions,
49: * it is better to do < 32bit wide bitblts using them (bf)
50: * - if the source and destination bitmaps have different depths,
51: * it is either and expansion (exp) or a contraction (con) of pixels.
52: * These two cases aren't further differentiated into f vs. b, etc.
53: */
54:
55: /*
56: * To calculate the potential size of the bitblt program, use the following
57: * formulas:
58: * nonconverting max (bshg): X + 10L + 6S + 2F + 3E + 8LX + 3SX
59: * converting max (contracting by factor of 8, 32-bit memory accesses):
60: * X + XT + 46L + 48S + 96T + 64A + 32AX + 2F + 3E + 30LX + 48SX
61: *
62: * where X = Initsd+Extrainit+Iloop+Oloop+Rts ; XT = Inittab
63: * E = Emitop ; F = Field
64: * L = load, fetch or store ; LX = extra if pre or post decrement
65: * S = shift (sha or shb) ; SX = extra if OR too
66: * T = Table ; A = Assemble ; AX = Assemblex
67: */
68: enum
69: {
70: Tfshe = 0, /* each of the triples must be in order e, l, g */
71: Tfshl,
72: Tfshg,
73:
74: Tbshe,
75: Tbshl,
76: Tbshg,
77:
78: Toshe,
79: Toshl,
80: Toshg,
81:
82: Tobf,
83:
84: Texp,
85:
86: Tcon,
87:
88: Tlast, /* total number of cases */
89: };
90:
91: #ifdef TEST
92: /*
93: * globals used for testing
94: */
95: int FORCEFORW;
96: int FORCEBAKW;
97: GBitmap *curdm, *cursm;
98: Point curpt;
99: Rectangle curr;
100: Fcode curf;
101: void *mem;
102: #endif
103:
104: /*
105: * set up to compile -DT$objtype
106: */
107: #ifdef Tmips
108: #include "bbv.h"
109: #else
110: #ifdef T68020
111: #include "bb2.h"
112: #else
113: #ifdef Tsparc
114: #include "bbk.h"
115: #else
116: #ifdef T386
117: #include "bb8l.h"
118: #else
119: #ifdef Thobbit
120: #include "bbcl.h"
121: #else
122: #include "bbc.h"
123: #endif
124: #endif
125: #endif
126: #endif
127: #endif
128:
129: /*
130: * bitblt operates a 'word' at a time.
131: * WBITS is the number of bits in a word
132: * LWBITS=log2(WBITS),
133: * W2L is the number of words in a long
134: * WMASK has bits set for the low order word of a long
135: * WType is a pointer to a word
136: * if LENDIAN is true, then left-to-right in bitmap
137: * means low-order-bit to high-order-bit within a word,
138: * otherwise it is high-order-bit to low-order-bit.
139: */
140: #ifndef WBITS
141: #define WBITS 32
142: #define LWBITS 5
143: #define W2L 1
144: #define WMASK ~0UL
145: typedef ulong *WType;
146: #endif
147: /*
148: * scrshl(v,o) shifts a word v by o bits screen-leftward
149: * scrshr(v,o) shifts a word v by o bits screen-rightward
150: * scrpix(v,i,l) gets the value of pixel i within word v when ldepth is l
151: * scrmask(i,l) has ones for pixel i when ldepth is l
152: */
153: #define scrshl(v,o) (LENDIAN? ((v)>>(o)) : ((v)<<(o)))
154: #define scrshr(v,o) (LENDIAN? ((v)<<(o)) : ((v)>>(o)))
155: #define scrpix(v,i,l) (LENDIAN? (((v)>>((i)<<(l)))&((1<<(1<<(l)))-1)) : (((v)>>(32-(((i)+1)<<(l))))&((1<<(1<<(l)))-1)))
156: #define scrmask(i,l) (LENDIAN? (((1<<(1<<(l)))-1)<<((i)<<(l))) : (((1<<(1<<(l)))-1)<<(32-(((i)+1)<<l))))
157:
158: void
159: gbitblt(GBitmap *dm, Point pt, GBitmap *sm, Rectangle r, Fcode fcode)
160: {
161: int type; /* category of bitblt: Tfshe or ... */
162: int width; /* width in bits of dst */
163: int height; /* height in pixels minus 1 */
164: int sh; /* left shift of src to align with dst */
165: int soff; /* bit offset of src start point */
166: int doff; /* bit offset of dst start point */
167: int sc; /* src words used so far */
168: int dc; /* dst words used so far */
169: int le; /* log expansion factor */
170: int sspan; /* words between scanlines in src */
171: int dspan; /* words between scanlines in dst */
172: int sdep; /* src ldepth */
173: int ddep; /* dst ldepth */
174: int onstack; /* compiling to stack arena */
175: int backward; /* does bitblt have to go backwards? */
176: ulong* saddr; /* addr of word in src containing start point */
177: ulong* daddr; /* addr of word in dst containing start point */
178: ulong lmask; /* affected pixels in leftmost dst word */
179: ulong rmask; /* affected pixels in rightmost dst word */
180: Type* lo; /* addr in program for beginning of outer loop */
181: Type* li; /* addr in program for beginning of inner loop */
182: uchar *tab; /* conversion table */
183: int osiz; /* size of table entries, in bytes */
184: Type* memstart; /* start of program */
185: Type* p; /* next free address in program */
186: Type* fi; /* pointer to beginning of instrs for Rs f= Rd */
187: int fin; /* number of Types to copy after fi */
188: long v; /* for use in Emitop macro */
189: int c; /* a count */
190: int fs; /* if need to fetch source */
191: int fd; /* if need to fetch dest */
192: int b; /* for expansion: take b bits at a time from src */
193: int db; /* number of bits yielded by table lookup */
194: int dl; /* log2 number of bytes yielded by table lookup */
195: int sf; /* a bit offset in src */
196: int df; /* a bit offset in dst */
197: int firstd; /* doing first part of dst ? */
198: int firsts; /* doing first part of src ? */
199: int f; /* int version of fcode */
200: long tmp; /* for use by some macros */
201: int sha; /* |sh|%32 */
202: int shb; /* WBITS-sha, if sha!=0 */
203: int sfo; /* bit offset origin (needed if WBITS==8) */
204: Fstr *pf;
205: Type arena[Progmaxnoconv]; /* for non-converting bitblts */
206:
207: onstack = bbonstack();
208: gbitbltclip(&dm);
209:
210: #ifdef TEST
211: curdm = dm;
212: cursm = sm;
213: curpt = pt;
214: curr = r;
215: curf = fcode;
216: #endif
217:
218: width = r.max.x - r.min.x;
219: if(width <= 0)
220: return;
221: height = r.max.y - r.min.y - 1;
222: if(height < 0)
223: return;
224: ddep = dm->ldepth;
225: pt.x <<= ddep;
226: width <<= ddep;
227:
228: sdep = sm->ldepth;
229: r.min.x <<= sdep;
230: r.max.x <<= sdep;
231:
232: dspan = dm->width * W2L;
233: sspan = sm->width * W2L;
234:
235: daddr = (ulong*)((WType)dm->base
236: + dm->zero*W2L + pt.y*dspan
237: + (pt.x >> LWBITS));
238: saddr = (ulong*)((WType)sm->base
239: + sm->zero*W2L + r.min.y*sspan
240: + (r.min.x >> LWBITS));
241:
242: c = doff = pt.x & (WBITS-1);
243: soff = r.min.x & (WBITS-1);
244:
245: pf = &fstr[(f = fcode&0xF)];
246: fs = pf->fetchs;
247: fd = pf->fetchd;
248: fin = pf->n;
249: fi = (Type *)pf->instr;
250:
251: if(ddep == sdep || !fs) {
252: #ifdef TEST
253: if(!FORCEBAKW &&
254: (FORCEFORW || sm != dm || !fs || saddr > daddr ||
255: (saddr == daddr && soff > doff)))
256: backward = 0;
257: else
258: backward = 1;
259: #else
260: if(sm != dm || !fs || saddr > daddr ||
261: (saddr == daddr && soff > doff))
262: backward = 0;
263: else
264: backward = 1;
265: #endif
266: #ifdef HAVEBF
267: if(width <= WBITS) {
268: sh = 0;
269: type = Tobf;
270: if(backward) {
271: daddr = (ulong *)((WType)daddr + height*dspan);
272: saddr = (ulong *)((WType)saddr + height*sspan);
273: }
274: goto init;
275: }
276: #else
277: if(doff+width <= WBITS) {
278: type = Toshe;
279: if(backward) {
280: daddr = (ulong *)((WType)daddr + height*dspan);
281: saddr = (ulong *)((WType)saddr + height*sspan);
282: }
283: }
284: #endif
285: else {
286: if(!backward)
287: type = Tfshe;
288: else {
289: type = Tbshe;
290: doff = (WBITS-(doff+width)) & (WBITS-1);
291: soff = (WBITS-(soff+width)) & (WBITS-1);
292: daddr = (ulong*)((WType)dm->base
293: + dm->zero*W2L + (pt.y+height)*dspan
294: + ((pt.x + width+(WBITS-1))>>LWBITS));
295: saddr = (ulong*)((WType)sm->base
296: + sm->zero*W2L + (r.max.y-1)*sspan
297: + ((r.max.x + (WBITS-1))>>LWBITS));
298: }
299: }
300: if(fs) {
301: if((sh = soff - doff) != 0) {
302: if(sh < 0)
303: type += Tbshl-Tbshe;
304: else
305: type += Tbshg-Tbshe;
306: }
307: } else
308: sh = 0;
309: } else {
310: if(sdep < 0 || sdep > 3 ||
311: ddep < 0 || ddep > 3 ||
312: (tab = tabs[sdep][ddep]) == 0)
313: return; /* sorry, conversion not enabled */
314:
315: osiz = tabosiz[sdep][ddep];
316: le = ddep - sdep;
317: if(le > 0) {
318: type = Texp;
319: sh = soff - (doff >> le);
320: } else {
321: type = Tcon;
322: sh = soff - (doff << -le);
323: }
324: onstack = 0;
325: backward = 0;
326: }
327:
328: /* c has original doff (relative to beginning) */
329: lmask = scrshr(WMASK,c);
330: rmask = scrshl(WMASK,(WBITS - ((c+width) & (WBITS-1))))&WMASK;
331: if(!rmask)
332: rmask = WMASK;
333: if(sh != 0) {
334: if(sh > 0)
335: sha = sh;
336: else
337: sha = (-sh)&(WBITS-1);
338: shb = WBITS - sha;
339: }
340:
341: /* init: set up constant regs and outer loop */
342: init:
343: if(onstack)
344: memstart = arena;
345: else
346: memstart = (Type*)bbmalloc(Progmax * sizeof(Type));
347: p = memstart;
348: Initsd(saddr,daddr);
349: if(sh) {
350: Initsh(sha,shb);
351: }
352: Extrainit;
353:
354: if(height > 0) {
355: Olabel(height+1);
356: lo = p;
357: }
358: sc = 0;
359: dc = 0;
360:
361: /* emit inner loop */
362: switch(type){
363: #ifdef HAVEBF
364: case Tobf:
365: if(fd) {
366: Bfextu_RdAd(doff,width);
367: }
368: if(fs) {
369: Bfextu_RsAs(soff,width);
370: }
371: Emitop;
372: Bfins_AdRs(doff,width);
373: break;
374: #else
375: case Toshe:
376: /* one word dest, src and dest offsets same (or src not involved) */
377: lmask &= rmask;
378: if(fs) {
379: Load_Rs(0);
380: }
381: Fetch_Rd(1);
382: Emitop;
383: Ofield(lmask);
384: Store_Rs;
385: break;
386:
387: case Toshl:
388: /* one word dest, src offset less than dest offset */
389: lmask &= rmask;
390: Loadzx_Rt(0);
391: Fetch_Rd(0);
392: Orsha_RsRt;
393: Emitop;
394: Ofield(lmask);
395: Store_Rs;
396: break;
397:
398: case Toshg:
399: /* one word dest, src offset greater than dest offset */
400: lmask &= rmask;
401: if(sha+doff+width > WBITS) {
402: Load_Rt_P;
403: Olsha_RsRt;
404: Loadzx_Rt(0);
405: Fetch_Rd(0);
406: Oorrshb_RsRt;
407: if(backward)
408: sc--;
409: else
410: sc++;
411: } else {
412: Load_Rt(0);
413: Fetch_Rd(0);
414: Olsha_RsRt;
415: }
416: Emitop;
417: Ofield(lmask);
418: Store_Rs;
419: break;
420: #endif /* HAVEBF */
421:
422: case Tfshe:
423: /* forward, src and dest offsets same (or src not involved) */
424: Fetch_Rd(0);
425: if(fs) {
426: Load_Rs_P;
427: sc++;
428: } else {
429: Nop;
430: }
431: Emitop;
432: Ofield(lmask);
433: Store_Rs_P;
434: dc++;
435: width -= WBITS - doff;
436:
437: c = width >> LWBITS;
438: if(c) {
439: if(f == Zero || f == F) {
440: /* set up Rs outside loop */
441: Emitop;
442: }
443: li = 0;
444: if(c > 1) {
445: Ilabel(c);
446: li = p;
447: }
448: if(fd) {
449: Fetch_Rd(!fs);
450: }
451: if(fs) {
452: Load_Rs_P;
453: sc += c;
454: }
455: if(!(f == Zero || f == F)) {
456: Emitop;
457: }
458: Store_Rs_P;
459: dc += c;
460: if(c > 1) {
461: Iloop(li);
462: }
463: }
464:
465: if(width & (WBITS-1)) {
466: if(fs) {
467: Load_Rs(0);
468: }
469: Fetch_Rd(1);
470: Emitop;
471: Ofield(rmask);
472: Store_Rs;
473: }
474: break;
475:
476: case Tfshl:
477: /* forward, src offset less than dest offset */
478: Loadzx_Rt_P;
479: Fetch_Rd(0);
480: Orsha_RsRt;
481: sc++;
482: Emitop;
483: Ofield(lmask);
484: Store_Rs_P;
485: dc++;
486: width -= WBITS - doff;
487:
488: c = width >> LWBITS;
489: if(c) {
490: li = 0;
491: if(c > 1) {
492: Ilabel(c);
493: li = p;
494: }
495: Olshb_RsRt;
496: Loadzx_Rt_P;
497: if(fd) {
498: Fetch_Rd(0);
499: }
500: Oorrsha_RsRt;
501: sc += c;
502: Emitop;
503: Store_Rs_P;
504: dc += c;
505: if(c > 1) {
506: Iloop(li);
507: }
508: }
509:
510: width &= (WBITS-1);
511: if(width) {
512: Olshb_RsRt;
513: if(width > sha) {
514: Loadzx_Rt(0);
515: Fetch_Rd(0);
516: Oorrsha_RsRt;
517: } else {
518: Fetch_Rd(1);
519: }
520: Emitop;
521: Ofield(rmask);
522: Store_Rs;
523: }
524: break;
525:
526: case Tfshg:
527: /* forward, src offset greater than dest offset */
528: Load_Rt_P;
529: Olsha_RsRt;
530: Loadzx_Rt_P;
531: Fetch_Rd(0);
532: Oorrshb_RsRt;
533: sc += 2;
534: Emitop;
535: Ofield(lmask);
536: Store_Rs_P;
537: dc++;
538: width -= WBITS - doff;
539:
540: c = width >> LWBITS;
541: if(c) {
542: li = 0;
543: if(c > 1) {
544: Ilabel(c);
545: li = p;
546: }
547: Olsha_RsRt;
548: Loadzx_Rt_P;
549: if(fd) {
550: Fetch_Rd(0);
551: }
552: Oorrshb_RsRt;
553: sc += c;
554: Emitop;
555: Store_Rs_P;
556: dc += c;
557: if(c > 1) {
558: Iloop(li);
559: }
560: }
561:
562: width &= WBITS-1;
563: if(width) {
564: Olsha_RsRt;
565: if(width > shb) {
566: Loadzx_Rt(0);
567: Fetch_Rd(0);
568: Oorrshb_RsRt;
569: } else {
570: Fetch_Rd(1);
571: }
572: Emitop;
573: Ofield(rmask);
574: Store_Rs;
575: }
576: break;
577:
578: case Tbshe:
579: /* backward, src and dest offsets same (or src not involved) */
580: Load_Rs_D(0);
581: sc++;
582: Fetch_Rd_D(1);
583: Emitop;
584: Ofield(rmask);
585: Store_Rs;
586: dc++;
587: width -= WBITS - doff;
588:
589: c = width >> LWBITS;
590: if(c) {
591: li = 0;
592: if(c > 1) {
593: Ilabel(c);
594: li = p;
595: }
596: Load_Rs_D(0);
597: sc += c;
598: if(fd) {
599: Fetch_Rd_D(1);
600: Emitop;
601: Store_Rs;
602: } else {
603: Nop;
604: Emitop;
605: Store_Rs_D;
606: }
607: dc += c;
608: if(c > 1) {
609: Iloop(li);
610: }
611: }
612:
613: if(width & (WBITS-1)) {
614: Load_Rs_D(0);
615: sc++;
616: Fetch_Rd_D(1);
617: dc++;
618: Emitop;
619: Ofield(lmask);
620: Store_Rs;
621: }
622: break;
623:
624: case Tbshl:
625: /* backward, src offset less than dest offset */
626: Loadzx_Rt_D(0);
627: Fetch_Rd_D(0);
628: Olsha_RsRt;
629: sc++;
630: Emitop;
631: Ofield(rmask);
632: Store_Rs;
633: dc++;
634: width -= WBITS - doff;
635:
636: c = width >> LWBITS;
637: if(c) {
638: li = 0;
639: if(c > 1) {
640: Ilabel(c);
641: li = p;
642: }
643: Orshb_RsRt;
644: Loadzx_Rt_D(0);
645: if(fd) {
646: Fetch_Rd_D(0);
647: } else {
648: Nop;
649: }
650: Oorlsha_RsRt;
651: sc += c;
652: Emitop;
653: if(fd) {
654: Store_Rs;
655: } else {
656: Store_Rs_D;
657: }
658: dc += c;
659: if(c > 1) {
660: Iloop(li);
661: }
662: }
663:
664: width &= (WBITS-1);
665: if(width) {
666: Orshb_RsRt;
667: if(width > sha) {
668: Load_Rt_D(0);
669: Fetch_Rd_D(0);
670: Oorlsha_RsRt;
671: sc++;
672: } else {
673: Fetch_Rd_D(1);
674: }
675: dc++;
676: Emitop;
677: Ofield(lmask);
678: Store_Rs;
679: }
680: break;
681:
682: case Tbshg:
683: /* backward, src offset greater than dest offset */
684: Loadzx_Rt_D(0);
685: Fetch_Rd_D(0);
686: Orsha_RsRt;
687: Loadzx_Rt_D(1);
688: Oorlshb_RsRt;
689: sc += 2;
690: Emitop;
691: Ofield(rmask);
692: Store_Rs;
693: dc++;
694: width -= WBITS - doff;
695:
696: c = width >> LWBITS;
697: if(c) {
698: li = 0;
699: if(c > 1) {
700: Ilabel(c);
701: li = p;
702: }
703: Orsha_RsRt;
704: Loadzx_Rt_D(0);
705: if(fd) {
706: Fetch_Rd_D(0);
707: } else {
708: Nop;
709: }
710: Oorlshb_RsRt;
711: sc += c;
712: Emitop;
713: if(fd) {
714: Store_Rs;
715: } else {
716: Store_Rs_D;
717: }
718: dc += c;
719: if(c > 1) {
720: Iloop(li);
721: }
722: }
723:
724: width &= WBITS-1;
725: if(width) {
726: Orsha_RsRt;
727: if(width > shb) {
728: Loadzx_Rt_D(0);
729: Fetch_Rd_D(0);
730: sc++;
731: } else {
732: Fetch_Rd_D(1);
733: }
734: dc++;
735: Oorlshb_RsRt;
736: Emitop;
737: Ofield(lmask);
738: Store_Rs;
739: }
740: break;
741:
742: case Texp:
743: /* expansion: dest ldepth > src ldepth */
744: if(WBITS == 8) {
745: b = 8 >> le;
746: /* db == 8, dl == 0 */
747: } else {
748: b = (le <= 2) ? 8 : 32 / (1 << le);
749: db = b << le;
750: dl = (le <= 2) ? le : 2;
751: }
752: Inittab(tab,osiz);
753:
754: /*
755: * method:
756: * load the source a word at a time, into Rt;
757: * (if there is a shift, use Ru to hold next or last partial word,
758: * or, if WBITS == 8, it is <<8 in Rt)
759: * take b bits at a time from source and convert via table into Rd
760: * (each table lookup yields db bits, in 1<<dl bytes);
761: * assemble into Rs until have WBITS bits;
762: * fetch dest word into Rd, operate into Rs, store in dest
763: *
764: * this code needs reworking for expansion factor > 8
765: */
766:
767: if(WBITS == 8) {
768: if(sh == 0) {
769: Load_Rt_P;
770: sfo = 24;
771: } else if(sh > 0) {
772: Load_Rt_P;
773: Olsh_RtRt(8);
774: if((doff+width)>>le > shb) {
775: Loador_Rt_P;
776: sc++;
777: }
778: /* relevant source bits: Rt[16+sh..23+sh] */
779: sfo = 16 + sh;
780: } else {
781: Load_Rt_P;
782: /* relevant source bits: Rt[16+(8+sh)..23+(8+sh) */
783: sfo = 24 + sh;
784: }
785: sf = 0;
786: firstd = 1;
787: } else {
788: if(sh == 0) {
789: Load_Rt_P;
790: } else if(sh > 0) {
791: Load_Rt_P;
792:
793: Olsha_RtRt;
794: if((doff+width)>>le > shb) {
795: Load_Ru_P;
796: Oorrshb_RtRu;
797: sc++;
798: }
799: } else {
800: Load_Ru_P;
801: Orsha_RtRu;
802: }
803: sf = (soff - sh) & ~(b-1);
804: firstd = 1;
805: firsts = 1;
806: }
807: sc++;
808: while(sf < WBITS && width > 0) {
809: if(WBITS == 8) {
810: Table_RsRt(sf+sfo,b,0);
811: sf += b;
812: } else {
813: if(firstd)
814: df = (sf << le) & (WBITS-1);
815: else
816: df = 0;
817: while(df < WBITS) {
818: Table_RdRt(sf,b,dl);
819: if(df==0 || firsts) {
820: c = WBITS - (df + db);
821: Olsh_RsRd(c);
822: } else if(df == WBITS - db) {
823: Oor_RsRd;
824: } else {
825: c = WBITS - (df + db);
826: Oorlsh_RsRd(c);
827: }
828: sf += b;
829: df += db;
830: firsts = 0;
831: }
832: }
833: Fetch_Rd(1);
834: Emitop;
835: if(firstd) {
836: width -= WBITS - doff;
837: if(width > 0 && lmask != WMASK) {
838: Ofield(lmask);
839: } else if(width <= 0) {
840: lmask &= rmask;
841: Ofield(lmask);
842: }
843: } else {
844: width -= WBITS;
845: if(width < 0) {
846: Ofield(rmask);
847: }
848: }
849: Store_Rs_P;
850: dc++;
851: firstd = 0;
852: }
853: if(width <= 0)
854: break;
855:
856: c = width >> (LWBITS+le);
857: if(c) {
858: li = 0;
859: if(c > 1) {
860: Ilabel(c);
861: li = p;
862: }
863: if(WBITS == 8) {
864: Olsh_RtRt(8);
865: Loador_Rt_P;
866: } else {
867: if(sh == 0) {
868: Load_Rt_P;
869: } else if(sh > 0) {
870: Olsha_RtRu;
871: Load_Ru_P;
872: Oorrshb_RtRu;
873: } else {
874: Olshb_RtRu;
875: Load_Ru_P;
876: Oorrsha_RtRu;
877: }
878: }
879: sc += c;
880: for(sf = 0; sf < WBITS;) {
881: if(WBITS == 8) {
882: Table_RsRt(sf+sfo,b,0);
883: sf += b;
884: } else {
885: for(df = 0; df < WBITS;) {
886: Table_RdRt(sf,b,dl);
887: Assemblex(df,db);
888: sf += b;
889: df += db;
890: }
891: }
892: if(fd) {
893: Fetch_Rd(1);
894: }
895: Emitop;
896: Store_Rs_P;
897: dc += c;
898: }
899: if(c > 1) {
900: Iloop(li);
901: }
902: }
903: width -= c << (LWBITS+le);
904: if(width <= 0)
905: break;
906:
907: if(WBITS == 8) {
908: if(sh == 0) {
909: Load_Rt_P;
910: sc++;
911: } else if(sh > 0) {
912: Olsh_RtRt(8);
913: if(width>>le > shb) {
914: Loador_Rt_P;
915: sc++;
916: }
917: } else {
918: Olsh_RtRt(8);
919: if(width>>le > sha) {
920: Loador_Rt_P;
921: sc++;
922: }
923: }
924: } else {
925: if(sh == 0) {
926: Load_Rt_P;
927: sc++;
928: } else if(sh > 0) {
929: Olsha_RtRu;
930: if(width>>le > shb) {
931: Load_Ru_P;
932: Oorrshb_RtRu;
933: sc++;
934: }
935: } else {
936: Olshb_RtRu;
937: if(width>>le > sha) {
938: Load_Ru_P;
939: Oorrsha_RtRu;
940: sc++;
941: }
942: }
943: }
944: for(sf = 0; sf < WBITS && width > 0; ) {
945: if(WBITS == 8) {
946: Table_RsRt(sf+sfo,b,0);
947: sf += b;
948: } else {
949: for(df = 0; df < WBITS;) {
950: Table_RdRt(sf,b,dl);
951: Assemblex(df,db);
952: sf += b;
953: df += db;
954: }
955: }
956: Fetch_Rd(1);
957: Emitop;
958: width -= WBITS;
959: if(width < 0) {
960: Ofield(rmask);
961: }
962: Store_Rs_P;
963: dc++;
964: }
965: break;
966:
967: case Tcon:
968: /* contraction: dest ldepth < src ldepth */
969: db = 8 >> -le;
970: Inittab(tab,osiz);
971:
972: /*
973: * method:
974: * load the source a word at a time, into Rt;
975: * (if there is a shift, use Ru to hold next or last partial word,
976: * or, if WBITS==8, it is <<8 in Rt)
977: * take 8 bits at a time from source and convert via table into Rd
978: * (each table lookup yields db bits, in 1 byte);
979: * assemble into Rs until have WBITS bits (takes several src words);
980: * fetch dest word into Rd, operate into Rs, store in dest
981: *
982: * Something should be done to improve this code, but
983: * it isn't used much.
984: */
985:
986: if(sh < 0) {
987: c = (-sh)/WBITS;
988: sh += c*WBITS;
989: if(WBITS == 8) sfo = 24 + sh;
990: } else {
991: c = 0;
992: if(WBITS == 8) sfo = sh ? 16 + sh : 24;
993: }
994: firstd = 1;
995: firsts = 1;
996: for(df = c*db*(4/W2L); df < WBITS && df < doff + width; ) {
997: c = (doff + width - df) << -le;
998: /* c = number of source bits needed to fill rest */
999: if(WBITS == 8) {
1000: if(sh == 0) {
1001: Load_Rt_P;
1002: sc++;
1003: } else if(sh > 0) {
1004: if(firsts) {
1005: Load_Rt_P;
1006: Olsh_RtRt(8);
1007: sc++;
1008: } else {
1009: Olsh_RtRt(8);
1010: }
1011: if(shb < c) {
1012: Loador_Rt_P;
1013: sc++;
1014: }
1015: } else {
1016: if(firsts) {
1017: Load_Rt_P;
1018: sc++;
1019: } else {
1020: Olsh_RtRt(8);
1021: if(sha < c) {
1022: Loador_Rt_P;
1023: sc++;
1024: }
1025: }
1026: }
1027: } else {
1028: if(sh == 0) {
1029: Load_Rt_P;
1030: sc++;
1031: } else if(sh > 0) {
1032: if(firsts) {
1033: Load_Rt_P;
1034: Olsha_RtRt;
1035: sc++;
1036: } else {
1037: Olsha_RtRu;
1038: }
1039: if(shb < c) {
1040: Load_Ru_P;
1041: sc++;
1042: Oorrshb_RtRu;
1043: }
1044: } else {
1045: if(!firsts) {
1046: Olshb_RtRu;
1047: }
1048: if(sha < c) {
1049: Load_Ru_P;
1050: sc++;
1051: if(firsts) {
1052: Orsha_RtRu;
1053: } else {
1054: Oorrsha_RtRu;
1055: }
1056: }
1057: }
1058: }
1059: firsts = 0;
1060: if(WBITS == 8) {
1061: Table_RdRt(sfo,8,0);
1062: if(firstd) {
1063: Olsh_RsRd(8-(df+db));
1064: } else {
1065: Assemble(df,db);
1066: }
1067: df += db;
1068: firstd = 0;
1069: } else {
1070: for(sf = 0; sf < WBITS; ) {
1071: Table_RdRt(sf,8,0);
1072: if(firstd) {
1073: c = WBITS-(df+db);
1074: Olsh_RsRd(c);
1075: } else {
1076: Assemble(df,db);
1077: }
1078: df += db;
1079: sf += 8;
1080: firstd = 0;
1081: }
1082: }
1083: }
1084: Fetch_Rd(1);
1085: Emitop;
1086: width -= WBITS - doff;
1087: if(width > 0 && lmask != WMASK) {
1088: Ofield(lmask);
1089: } else if(width <= 0) {
1090: lmask &= rmask;
1091: Ofield(lmask);
1092: }
1093: Store_Rs_P;
1094: dc++;
1095: if(width <= 0)
1096: break;
1097:
1098: c = width >> LWBITS;
1099: if(c) {
1100: li = 0;
1101: if(c > 1) {
1102: Ilabel(c);
1103: li = p;
1104: }
1105: for(df = 0; df < WBITS; ) {
1106: if(WBITS == 8) {
1107: if(sh == 0) {
1108: Load_Rt_P;
1109: } else {
1110: Olsh_RtRt(8);
1111: Loador_Rt_P;
1112: }
1113: sc += c;
1114: Table_RdRt(sfo,8,0);
1115: Assemble(df,db);
1116: df += db;
1117: } else {
1118: if(sh == 0) {
1119: Load_Rt_P;
1120: } else if(sh > 0) {
1121: Olsha_RtRu;
1122: Load_Ru_P;
1123: Oorrshb_RtRu;
1124: } else {
1125: Olshb_RtRu;
1126: Load_Ru_P;
1127: Oorrsha_RtRu;
1128: }
1129: sc += c;
1130: for(sf = 0; sf < WBITS; ) {
1131: Table_RdRt(sf,8,0);
1132: Assemblex(df,db);
1133: df += db;
1134: sf += 8;
1135: }
1136: }
1137: }
1138: if(fd) {
1139: Fetch_Rd(1);
1140: }
1141: Emitop;
1142: Store_Rs_P;
1143: dc += c;
1144: if(c > 1) {
1145: Iloop(li);
1146: }
1147: }
1148:
1149: width -= c << LWBITS;
1150: if(width <= 0)
1151: break;
1152:
1153: for(df = 0; df < width; ) {
1154: c = (width - df) << -le;
1155: if(WBITS == 8) {
1156: if(sh == 0) {
1157: Load_Rt_P;
1158: sc++;
1159: } else if(sh > 0) {
1160: Olsh_RtRt(8);
1161: if(shb < c) {
1162: sc++;
1163: Loador_Rt_P;
1164: }
1165: } else {
1166: Olsh_RtRt(8);
1167: if(sha < c) {
1168: Loador_Rt_P;
1169: sc++;
1170: }
1171: }
1172: Table_RdRt(sfo,8,0);
1173: Assemble(df,db);
1174: df += db;
1175: } else {
1176: if(sh == 0) {
1177: Load_Rt_P;
1178: sc++;
1179: } else if(sh > 0) {
1180: Olsha_RtRu;
1181: if(shb < c) {
1182: Load_Ru_P;
1183: Oorrshb_RtRu;
1184: sc++;
1185: }
1186: } else {
1187: Olshb_RtRu;
1188: if(sha < c) {
1189: Load_Ru_P;
1190: Oorrsha_RtRu;
1191: sc++;
1192: }
1193: }
1194: for(sf = 0; sf < 32; ) {
1195: Table_RdRt(sf,8,0);
1196: Assemble(df,db);
1197: df += db;
1198: sf += 8;
1199: }
1200: }
1201: }
1202: Fetch_Rd(1);
1203: Emitop;
1204: Ofield(rmask);
1205: Store_Rs_P;
1206: dc++;
1207: break;
1208:
1209: }
1210:
1211: /* finish outer loop, put in rts, and execute */
1212:
1213: if(height > 0) {
1214: if(backward)
1215: c = (dc - dspan) * (WBITS/8);
1216: else
1217: c = (dspan - dc) * (WBITS/8);
1218: if(c) {
1219: Add_Ad(c);
1220: }
1221: if(fs) {
1222: if(backward)
1223: c = (sc - sspan) * (WBITS/8);
1224: else
1225: c = (sspan - sc) * (WBITS/8);
1226: if(c) {
1227: Add_As(c);
1228: }
1229: }
1230: Oloop(lo);
1231: }
1232: Orts;
1233: #ifdef TEST
1234: if(onstack && p - memstart > Progmaxnoconv)
1235: print("Increase Progmaxnoconv to at least %d!\n", p - memstart);
1236: else if(p - memstart > Progmax)
1237: print("Increase Progmax to at least %d!\n", p - memstart);
1238: mem = memstart;
1239: #endif
1240: bbexec((void*)memstart, (p-memstart)*sizeof(Type), onstack);
1241: }
1242:
1243: #ifdef TEST
1244: void prprog(void);
1245: GBitmap *bb1, *bb2;
1246: ulong *src, *dst, *xdst, *xans;
1247: int swds, dwds;
1248: long ticks;
1249: int timeit;
1250:
1251: #ifdef BYTEREV
1252: ulong
1253: byterev(ulong v)
1254: {
1255: return (v>>24)|((v>>8)&0x0000FF00)|((v<<8)&0x00FF0000)|(v<<24);
1256: }
1257: #endif
1258: #ifdef T386
1259: long _clock;
1260: #endif
1261:
1262: long
1263: func(int f, long s, int sld, long d, int dld)
1264: {
1265: long a;
1266: int sh, i, db, sb;
1267:
1268: db = 1 << dld;
1269: sb = 1 << sld;
1270: sh = db - sb;
1271: if(sh > 0) {
1272: a = s;
1273: for(i = sb; i<db; i += sb){
1274: a <<= sb;
1275: s |= a;
1276: }
1277: } else if(sh < 0)
1278: s >>= -sh;
1279:
1280: switch(f){
1281: case Zero: d = 0; break;
1282: case DnorS: d = ~(d|s); break;
1283: case DandnotS: d = d & ~s; break;
1284: case notS: d = ~s; break;
1285: case notDandS: d = ~d & s; break;
1286: case notD: d = ~d; break;
1287: case DxorS: d = d ^ s; break;
1288: case DnandS: d = ~(d&s); break;
1289: case DandS: d = d & s; break;
1290: case DxnorS: d = ~(d^s); break;
1291: case S: d = s; break;
1292: case DornotS: d = d | ~s; break;
1293: case D: d = d; break;
1294: case notDorS: d = ~d | s; break;
1295: case DorS: d = d | s; break;
1296: case F: d = ~0; break;
1297: }
1298:
1299: d &= ((1<<db)-1);
1300: return d;
1301: }
1302:
1303: void
1304: run(int fr, int to, int w, int op)
1305: {
1306: int i, j, f, t, fy, ty;
1307: extern long *_clock;
1308:
1309: fr += bb2->r.min.x;
1310: to += bb1->r.min.x;
1311: fy = bb2->r.min.y + 1;
1312: ty = bb1->r.min.y + 1;
1313: if(timeit) {
1314: memcpy(dst, xdst, dwds * sizeof(long));
1315: ticks -= *_clock;
1316: gbitblt(bb1, Pt(to,ty), bb2, Rect(fr,fy,fr+w,fy+2), op);
1317: ticks += *_clock;
1318: return;
1319: }
1320: f = fr;
1321: t = to;
1322: memcpy(dst, xdst, dwds * sizeof(long));
1323: for(i=0; i<w; i++) {
1324: gbitblt(bb1, Pt(t,ty), bb2, Rect(f,fy,f+1,fy+1), op);
1325: gbitblt(bb1, Pt(t,ty+1), bb2, Rect(f,fy+1,f+1,fy+2), op);
1326: f++;
1327: t++;
1328: }
1329: memcpy(xans, dst, dwds * sizeof(long));
1330:
1331: memcpy(dst, xdst, dwds * sizeof(long));
1332: gbitblt(bb1, Pt(to,ty), bb2, Rect(fr,fy,fr+w,fy+2), op);
1333:
1334: if(memcmp(xans, dst, dwds * sizeof(long))) {
1335: /*
1336: * print src and dst row offset, width in bits, and forw/back
1337: * then print for each of the four rows: the source (s),
1338: * the dest (d), the good value of the answer (g),
1339: * and the actual bad value of the answer (b)
1340: */
1341: print("fr=%d to=%d w=%d fb=%d%d\n",
1342: fr, to, w, FORCEFORW, FORCEBAKW);
1343: print("dst bitmap b %#lux, z %d, w %d, ld %d, r [%d,%d][%d,%d]\n",
1344: bb1->base, bb1->zero, bb1->width, bb1->ldepth,
1345: bb1->r.min.x, bb1->r.min.y, bb1->r.max.x, bb1->r.max.y);
1346: print("src bitmap b %#lux, z %d, w %d, ld %d, r [%d,%d][%d,%d]\n",
1347: bb2->base, bb2->zero, bb2->width, bb2->ldepth,
1348: bb2->r.min.x, bb2->r.min.y, bb2->r.max.x, bb2->r.max.y);
1349: for(j=0; 7*j < dwds; j++) {
1350: print("\ns");
1351: for(i=0; i<7 && 7*j+i < dwds; i++)
1352: print(" %.8lux", src[7*j + i]);
1353: print("\nd");
1354: for(i=0; i<7 && 7*j+i < dwds; i++)
1355: print(" %.8lux", xdst[7*j + i]);
1356: print("\ng");
1357: for(i=0; i<7 && 7*j+i < dwds; i++)
1358: print(" %.8lux", xans[7*j + i]);
1359: print("\nb");
1360: for(i=0; i<7 && 7*j+i < dwds; i++)
1361: print(" %.8lux", dst[7*j + i]);
1362: print("\n");
1363: }
1364: prprog();
1365: }
1366: }
1367:
1368: void
1369: main(int argc, char *argv[])
1370: {
1371: int f, t, w, i, sld, dld, op, iters, simple;
1372: ulong s, d, spix, dpix, apix, fpix, m, *ps, *pd;
1373: Point sorg, dorg;
1374: GBitmap *bs, *bd;
1375: long seed;
1376: char *ct;
1377:
1378: sld = 0;
1379: dld = 0;
1380: timeit = 0;
1381: iters = 200;
1382: simple = 0;
1383: ARGBEGIN {
1384: case 'i':
1385: iters = atoi(ARGF());
1386: break;
1387: case 's':
1388: simple = 1;
1389: break;
1390: case 't':
1391: timeit = 1;
1392: ct = ARGF();
1393: if(ct)
1394: iters = atoi(ct);
1395: break;
1396: } ARGEND
1397: if(argc > 0)
1398: sld = atoi(argv[0]);
1399: if(argc > 1)
1400: dld = atoi(argv[1]);
1401: if(sld < 0 || sld > 3 || dld < 0 || dld > 3 ||
1402: (sld != dld && !tabs[sld][dld])){
1403: print("conversion from ldepth %d to %d not enabled\n",
1404: sld, dld);
1405: exits(0);
1406: }
1407: if(!timeit && !simple) {
1408: seed = time(0);
1409: print("seed %lux\n", seed); srand(seed); /**/
1410: }
1411:
1412: print("sld %d dld %d\n", sld, dld);
1413: op = 1/*Zero*/;
1414:
1415: /* bitmaps for 1-bit tests */
1416: bd = gballoc(Rect(0,0,32,1), dld);
1417: bs = gballoc(Rect(0,0,32,1), sld);
1418: for(i=0; i<bs->width; i++)
1419: bs->base[i] = lrand();
1420:
1421: /* bitmaps for rect tests */
1422: if(simple) {
1423: dorg = Pt(0,0);
1424: sorg = Pt(0,0);
1425: } else {
1426: dorg = Pt(nrand(63)-31,nrand(63)-31);
1427: sorg = Pt(nrand(63)-31,nrand(63)-31);
1428: }
1429: bb1 = gballoc(Rpt(dorg,add(dorg,Pt(200,4))), dld);
1430: bb2 = gballoc(Rpt(sorg,add(sorg,Pt(200,4))), sld);
1431: dwds = bb1->width * Dy(bb1->r);
1432: swds = bb2->width * Dy(bb2->r);
1433: dst = bb1->base;
1434: src = bb2->base;
1435: xdst = malloc(dwds * sizeof(long));
1436: xans = malloc(dwds * sizeof(long));
1437: for(i=0; i<swds; i++)
1438: src[i] = lrand();
1439: for(i=0; i<dwds; i++)
1440: xdst[i] = lrand();
1441: loop:
1442: print("Op %d\n", op);
1443: if(!timeit) {
1444: print("one pixel\n");
1445: ps = bs->base;
1446: pd = bd->base;
1447: FORCEFORW = 1;
1448: FORCEBAKW = 0;
1449: for(i=0; i<1000; i++, FORCEFORW = !FORCEFORW, FORCEBAKW = !FORCEBAKW) {
1450: f = nrand(32 >> sld);
1451: t = nrand(32 >> dld);
1452: s = lrand();
1453: d = lrand();
1454: ps[0] = s;
1455: pd[0] = d;
1456: #ifdef BYTEREV
1457: spix = scrpix(byterev(s),f,sld);
1458: dpix = scrpix(byterev(d),t,dld);
1459: #else
1460: spix = scrpix(s,f,sld);
1461: dpix = scrpix(d,t,dld);
1462: #endif
1463: apix = func(op, spix, sld, dpix, dld);
1464: gbitblt(bd, Pt(t,0), bs, Rect(f,0,f+1,1), op);
1465: if(ps[0] != s) {
1466: print("bb src %.8lux %.8lux %d %d\n", ps[0], s, f, t);
1467: exits("error");
1468: }
1469: m = scrmask(t,dld);
1470: #ifdef BYTEREV
1471: m = byterev(m);
1472: #endif
1473: if((pd[0] & ~m) != (d & ~m)) {
1474: print("bb dst1 %.8lux %.8lux\n",
1475: s, d);
1476: print("bb %.8lux %.8lux %d %d\n",
1477: ps[0], pd[0], f, t);
1478: prprog();
1479: exits("error");
1480: }
1481: #ifdef BYTEREV
1482: fpix = scrpix(byterev(pd[0]),t,dld);
1483: #else
1484: fpix = scrpix(pd[0],t,dld);
1485: #endif
1486: if(apix != fpix) {
1487: print("bb dst2 %.8lux %.8lux\n",
1488: s, d);
1489: print("bb %.8lux %.8lux %d %d\n",
1490: ps[0], pd[0], f, t);
1491: print("bb %.8lux %.8lux %.8lux %.8lux\n",
1492: spix, dpix, apix, fpix);
1493: prprog();
1494: exits("error");
1495: }
1496: }
1497: }
1498:
1499: print("for\n");
1500: FORCEFORW = 1;
1501: FORCEBAKW = 0;
1502:
1503: for(i=0; i<iters; i++) {
1504: f = nrand(64);
1505: t = nrand(64);
1506: w = nrand(130);
1507: run(f, t, w, op);
1508: }
1509:
1510: if(sld == dld) {
1511: print("bak\n");
1512: FORCEFORW = 0;
1513: FORCEBAKW = 1;
1514:
1515: for(i=0; i<iters; i++) {
1516: f = nrand(64);
1517: t = nrand(64);
1518: w = nrand(130);
1519: run(f, t, w, op);
1520: }
1521: }
1522:
1523: if(op < F) {
1524: op++;
1525: goto loop;
1526: }
1527: if(timeit)
1528: print("time: %d ticks\n", ticks);
1529: exits(0);
1530: }
1531:
1532:
1533: #endif
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.