![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to bitblt.out CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [Research Unix] / researchv9 / jerq / src / lib / j|
Return to bitblt.out CVS log | Up to [Research Unix] / researchv9 / jerq / src / lib / j |
1.1 root 1: # line 99999
2: .file "bitblt.c"
3: .data
4: .text
5: .align 4
6: .def bitblt; .val bitblt; .scl 2; .type 044; .endef
7: .globl bitblt
8: bitblt:
9: save &.R1
10: addw2 &.F1,%sp
11: # /* BITBLT() Moves bits around on the screen, and does a LOT of it
12: # *
13: # * WARNING
14: # * WARNING: to any future modifier of this code. This is highly
15: # * hand optimized code, it pushes the frame pointer and
16: # * references locals off the stack pointer,
17: # * and it even simulates register
18: # * allocation. Be very careful if you edit this.
19: # */
20: #
21: # #include <jerq.h>
22: # /* alignment codes for narrow rectangles */
23: # #define S_STRADDLE 0x4 /* source straddles a word boundary */
24: # #define D_STRADDLE 0x8 /* dest straddles a word boundary */
25: # #define LEFTDIR 8
26: # #define NOSHIFT 4
27: # #define DAMMIT 4 /* you'll see why */
28: # #undef sw
29: # #define DX1 m
30: #
31: # bitblt(sm,r,dm,p,fc)
32: # Bitmap *sm,*dm;
33: # Rectangle r;
34: # Point p;
35: # int fc;
36: # {
37: # register Word *source,*dest; /* %r8-%r7 */
38: # register Word sw, dw; /* %r6-%r5 */
39: # register UWord m; /* %r4 */
40: # register int i; /* %r3 */
41: #
42: # int a,b,j,h,w,dx1,px31,rx31;
43: # unsigned int mask1,mask2,mask3,mask4,ntmask1,ntmask2;
44: # int dummy1, dummy2; /* for future use, CANNOT CHANGE */
45: # /* NUMBER OF LOCALS DUE TO %fp */
46: # /* TRICKS */
47: # /* clip to the source Bitmap */
48: # if(r.origin.x < sm->rect.origin.x)
49: addw3 &8,0(%ap),%r0
50: cmph 4(%ap),0(%r0)
51: jge .L32
52: # r.origin.x=sm->rect.origin.x;
53: addw3 &8,0(%ap),%r0
54: movh 0(%r0),4(%ap)
55: .L32:
56: # if(r.corner.x > sm->rect.corner.x)
57: addw3 &12,0(%ap),%r0
58: cmph 8(%ap),0(%r0)
59: jle .L33
60: # r.corner.x=sm->rect.corner.x;
61: addw3 &12,0(%ap),%r0
62: movh 0(%r0),8(%ap)
63: .L33:
64: # if(r.origin.y < sm->rect.origin.y)
65: addw3 &10,0(%ap),%r0
66: cmph 6(%ap),0(%r0)
67: jge .L34
68: # r.origin.y=sm->rect.origin.y;
69: addw3 &10,0(%ap),%r0
70: movh 0(%r0),6(%ap)
71: .L34:
72: # if(r.corner.y > sm->rect.corner.y)
73: addw3 &14,0(%ap),%r0
74: cmph 10(%ap),0(%r0)
75: jle .L35
76: # r.corner.y=sm->rect.corner.y;
77: addw3 &14,0(%ap),%r0
78: movh 0(%r0),10(%ap)
79: .L35:
80: # /*
81: # * If the sm->rect and r are disjoint, r is now degenerate,
82: # * due to the clipping, and the next clipping code will reject it.
83: # * This is safe because we will only increase origin or decrease corner.
84: # */
85: # /* clip to the destination Bitmap */
86: # if(p.x < dm->rect.origin.x){
87: addw3 &8,12(%ap),%r0
88: cmph 16(%ap),0(%r0)
89: jge .L36
90: # r.origin.x+=dm->rect.origin.x-p.x;
91: addw3 &8,12(%ap),%r0
92: subh3 16(%ap),0(%r0),%r0
93: addh2 %r0,4(%ap)
94: # p.x=dm->rect.origin.x;
95: addw3 &8,12(%ap),%r0
96: movh 0(%r0),16(%ap)
97: .L36:
98: # }
99: # if(p.y < dm->rect.origin.y){
100: addw3 &10,12(%ap),%r0
101: cmph 18(%ap),0(%r0)
102: jge .L37
103: # r.origin.y+=dm->rect.origin.y-p.y;
104: addw3 &10,12(%ap),%r0
105: subh3 18(%ap),0(%r0),%r0
106: addh2 %r0,6(%ap)
107: # p.y=dm->rect.origin.y;
108: addw3 &10,12(%ap),%r0
109: movh 0(%r0),18(%ap)
110: .L37:
111: # }
112: # if(r.corner.x-r.origin.x > dm->rect.corner.x-p.x)
113: subh3 4(%ap),8(%ap),%r0
114: addw3 &12,12(%ap),%r1
115: subh3 16(%ap),0(%r1),%r1
116: cmpw %r0,%r1
117: jle .L38
118: # r.corner.x=r.origin.x+(dm->rect.corner.x-p.x);
119: addw3 &12,12(%ap),%r0
120: subh3 16(%ap),0(%r0),%r0
121: addh2 4(%ap),%r0
122: movh %r0,8(%ap)
123: .L38:
124: # if(r.corner.y-r.origin.y > dm->rect.corner.y-p.y)
125: subh3 6(%ap),10(%ap),%r0
126: addw3 &14,12(%ap),%r1
127: subh3 18(%ap),0(%r1),%r1
128: cmpw %r0,%r1
129: jle .L39
130: # r.corner.y=r.origin.y+(dm->rect.corner.y-p.y);
131: addw3 &14,12(%ap),%r0
132: subh3 18(%ap),0(%r0),%r0
133: addh2 6(%ap),%r0
134: movh %r0,10(%ap)
135: .L39:
136: # i = r.corner.y - r.origin.y; /* going to be h */
137: subh3 6(%ap),10(%ap),%r0
138: movw %r0,%r3
139: # dw = r.corner.x - r.origin.x - 1; /* going to be dx1 */
140: subh3 4(%ap),8(%ap),%r0
141: subw2 &1,%r0
142: movw %r0,%r5
143: # if (i <= 0 || dw < 0)
144: cmpw %r3,&0
145: jle .L41
146: cmpw %r5,&0
147: jge .L40
148: .L41:
149: jmp .L31
150: .L40:
151: # return;
152: # if (dw < 32)
153: cmpw %r5,&32
154: jge .L42
155: jmp .L43
156: .L42:
157: # goto narrow;
158: # DX1 = dw;
159: movw %r5,%r4
160: # h = i;
161: movw %r3,12(%fp)
162: # ntmask1 = topbits[p.x & 0x1f];
163: andh3 &31,16(%ap),%r0
164: LLSW3 &2,%r0,%r0
165: movw topbits(%r0),48(%fp)
166: # mask1 = ~ntmask1;
167: mcomw 48(%fp),%r0
168: movw %r0,32(%fp)
169: # mask2 = topbits[((p.x+DX1) & 31) + 1];
170: movbhw 16(%ap),%r0
171: addw2 %r4,%r0
172: andw2 &31,%r0
173: addw2 &1,%r0
174: LLSW3 &2,%r0,%r0
175: movw topbits(%r0),36(%fp)
176: # ntmask2 = ~mask2;
177: mcomw 36(%fp),%r0
178: movw %r0,52(%fp)
179: # w = ((p.x+DX1) >> 5) - (p.x >> 5); /* inner loop+1: sub 1 later*/
180: movbhw 16(%ap),%r0
181: addw2 %r4,%r0
182: LRSW3 &5,%r0,%r0
183: movbhw 16(%ap),%r1
184: LRSW3 &5,%r1,%r1
185: subw2 %r1,%r0
186: movw %r0,16(%fp)
187: # sw = ((sm->width - w) << 2); /* sleazy hack to avoid shift */
188: addw3 &4,0(%ap),%r0
189: subw3 16(%fp),0(%r0),%r0
190: LLSW3 &2,%r0,%r0
191: movw %r0,%r6
192: # dw = ((dm->width - w) << 2); /* in outer, inner loops */
193: addw3 &4,12(%ap),%r0
194: subw3 16(%fp),0(%r0),%r0
195: LLSW3 &2,%r0,%r0
196: movw %r0,%r5
197: # if (sm == dm) { /* may have to mess with loop order */
198: cmpw 0(%ap),12(%ap)
199: jne .L44
200: # if (r.origin.y < p.y) { /* swap top with bottom */
201: cmph 6(%ap),18(%ap)
202: jge .L45
203: # r.origin.y += i-1;
204: movtwh %r3,%r0
205: subh2 &1,%r0
206: addh2 %r0,6(%ap)
207: # p.y += i-1;
208: movtwh %r3,%r0
209: subh2 &1,%r0
210: addh2 %r0,18(%ap)
211: # if (r.origin.x < p.x) { /* swap left with right */
212: cmph 4(%ap),16(%ap)
213: jge .L46
214: # fc |= LEFTDIR;
215: orw2 &8,20(%ap)
216: # r.origin.x = r.origin.x + DX1;
217: movtwh %r4,%r0
218: addh2 4(%ap),%r0
219: movh %r0,4(%ap)
220: # p.x = p.x + DX1;
221: movtwh %r4,%r0
222: addh2 16(%ap),%r0
223: movh %r0,16(%ap)
224: # sw = -sw;
225: mnegw %r6,%r0
226: movw %r0,%r6
227: # dw = -dw;
228: mnegw %r5,%r0
229: movw %r0,%r5
230: jmp .L47
231: .L46:
232: # }
233: # else
234: # {
235: # sw -= (sm->width << 3); /* -(w+n) == (w-n) - 2*w */
236: addw3 &4,0(%ap),%r0
237: LLSW3 &3,0(%r0),%r0
238: subw2 %r0,%r6
239: # dw -= (dm->width << 3) ;
240: addw3 &4,12(%ap),%r0
241: LLSW3 &3,0(%r0),%r0
242: subw2 %r0,%r5
243: .L47:
244: jmp .L48
245: .L45:
246: # }
247: # }
248: # else
249: # {
250: # if (r.origin.x < p.x) { /* swap left with right */
251: cmph 4(%ap),16(%ap)
252: jge .L49
253: # fc |= LEFTDIR;
254: orw2 &8,20(%ap)
255: # r.origin.x = r.origin.x + DX1;
256: movtwh %r4,%r0
257: addh2 4(%ap),%r0
258: movh %r0,4(%ap)
259: # p.x = p.x + DX1;
260: movtwh %r4,%r0
261: addh2 16(%ap),%r0
262: movh %r0,16(%ap)
263: # sw = (sm->width + w) << 2;
264: addw3 &4,0(%ap),%r0
265: addw3 16(%fp),0(%r0),%r0
266: LLSW3 &2,%r0,%r0
267: movw %r0,%r6
268: # dw = (dm->width + w) << 2;
269: addw3 &4,12(%ap),%r0
270: addw3 16(%fp),0(%r0),%r0
271: LLSW3 &2,%r0,%r0
272: movw %r0,%r5
273: .L49:
274: .L48:
275: .L44:
276: # }
277: # }
278: # }
279: # w--; /* subtract the 1 like we promised */
280: subw2 &1,16(%fp)
281: # px31 = p.x & 0x1f; /* commonly used expression */
282: andh3 &31,16(%ap),%r0
283: movw %r0,24(%fp)
284: # rx31 = r.origin.x & 0x1f; /* commonly used expression */
285: andh3 &31,4(%ap),%r0
286: movw %r0,28(%fp)
287: # dest = addr(dm,p);
288: pushw 12(%ap)
289: pushw 16(%ap)
290: call &2,addr
291: movw %r0,%r7
292: # source = addr(sm,r.origin);
293: pushw 0(%ap)
294: pushw 4(%ap)
295: call &2,addr
296: movw %r0,%r8
297: # a = px31 - rx31;
298: subw3 28(%fp),24(%fp),%r0
299: movw %r0,0(%fp)
300: # if(a == 0)
301: cmpw 0(%fp),&0
302: jne .L50
303: # fc |= NOSHIFT;
304: orw2 &4,20(%ap)
305: jmp .L51
306: .L50:
307: # else if (a < 0)
308: cmpw 0(%fp),&0
309: jge .L52
310: # a += 32;
311: addw2 &32,0(%fp)
312: .L52:
313: .L51:
314: # /* a == 0 means no shift, remember that */
315: # b = 32 - a;
316: subw3 0(%fp),&32,%r0
317: movw %r0,4(%fp)
318: # switch (fc) {
319: movw 20(%ap),%r0
320: jmp .L54
321: .L55:
322: #
323: # case F_OR | NOSHIFT | LEFTDIR:
324: # b = w>>2;
325: LRSW3 &2,16(%fp),%r0
326: movw %r0,4(%fp)
327: # w = w&3;
328: andw3 &3,16(%fp),%r0
329: movw %r0,16(%fp)
330: # m = h; /* m is free => use it */
331: movw 12(%fp),%r4
332: .L58:
333: # do {
334: # *dest-- |= mask2 & *source--;
335: movw %r7,%r0
336: subw2 &4,%r7
337: movw %r8,%r1
338: subw2 &4,%r8
339: andw3 0(%r1),36(%fp),%r1
340: orw2 %r1,0(%r0)
341: # if ((i = b) > 0) do {
342: movw 4(%fp),%r3
343: jnpos .L59
344: .L62:
345: # *dest |= *source;
346: orw2 0(%r8),0(%r7)
347: # *(dest-1) |= *(source-1);
348: orw2 -4(%r8),-4(%r7)
349: # *(dest-2) |= *(source-2);
350: orw2 -8(%r8),-8(%r7)
351: # *(dest-3) |= *(source-3);
352: orw2 -12(%r8),-12(%r7)
353: # dest -= 4;
354: subw2 &16,%r7
355: # source -= 4;
356: subw2 &16,%r8
357: .L61:
358: # } while (--i > 0);
359: subw2 &1,%r3
360: jpos .L62
361: .L60:
362: .L59:
363: # if ((i = w) > 0) do {
364: movw 16(%fp),%r3
365: jnpos .L63
366: .L66:
367: # *dest-- |= *source--;
368: movw %r7,%r0
369: subw2 &4,%r7
370: movw %r8,%r1
371: subw2 &4,%r8
372: orw2 0(%r1),0(%r0)
373: .L65:
374: # } while (--i > 0);
375: subw2 &1,%r3
376: jpos .L66
377: .L64:
378: .L63:
379: # *dest |= mask1 & *source;
380: andw3 0(%r8),32(%fp),%r0
381: orw2 %r0,0(%r7)
382: ADDW2 %r6,%r8
383: ADDW2 %r5,%r7
384: .L57:
385: # asm(" ADDW2 %r6,%r8"); /*source += sw; */
386: # asm(" ADDW2 %r5,%r7"); /*dest += dw; */
387: # } while (--m != 0);
388: subw2 &1,%r4
389: jnz .L58
390: .L56:
391: jmp .L53
392: .L67:
393: # break;
394: # case F_OR | LEFTDIR:
395: # if ((px31) < (rx31))
396: cmpw 24(%fp),28(%fp)
397: jge .L68
398: # source++; /* adjust for pipeline */
399: addw2 &4,%r8
400: .L68:
401: .L71:
402: # do {
403: # m = *source--; /* m is a free register */
404: movw %r8,%r0
405: subw2 &4,%r8
406: movw 0(%r0),%r4
407: # *dest-- |= (((m >> a) | (*source << b)) & mask2);
408: movw %r7,%r0
409: subw2 &4,%r7
410: LRSW3 0(%fp),%r4,%r1
411: LLSW3 4(%fp),0(%r8),%r2
412: orw2 %r2,%r1
413: andw2 36(%fp),%r1
414: orw2 %r1,0(%r0)
415: # if ((i=w) > 0) do {
416: movw 16(%fp),%r3
417: jnpos .L72
418: .L75:
419: # m = (*source--) >> a;
420: movw %r8,%r0
421: subw2 &4,%r8
422: LRSW3 0(%fp),0(%r0),%r0
423: movw %r0,%r4
424: # *dest-- |= m | (*source << b);
425: movw %r7,%r0
426: subw2 &4,%r7
427: LLSW3 4(%fp),0(%r8),%r1
428: orw2 %r4,%r1
429: orw2 %r1,0(%r0)
430: .L74:
431: # } while (--i > 0);
432: subw2 &1,%r3
433: jpos .L75
434: .L73:
435: .L72:
436: # m = *source; /* m is a free register */
437: movw 0(%r8),%r4
438: # *dest |= (((m >> a) | (*(source-1) << b)) & mask1);
439: LRSW3 0(%fp),%r4,%r0
440: LLSW3 4(%fp),-4(%r8),%r1
441: orw2 %r1,%r0
442: andw2 32(%fp),%r0
443: orw2 %r0,0(%r7)
444: addw2 %r6,%r8
445: addw2 %r5,%r7
446: .L70:
447: # asm(" addw2 %r6,%r8"); /*source += sw; */
448: # asm(" addw2 %r5,%r7"); /*dest += dw; */
449: # } while (--h > 0);
450: subw2 &1,12(%fp)
451: jpos .L71
452: .L69:
453: jmp .L53
454: .L76:
455: # break;
456: # case F_OR | NOSHIFT:
457: # b = w>>2;
458: LRSW3 &2,16(%fp),%r0
459: movw %r0,4(%fp)
460: # w = w&3;
461: andw3 &3,16(%fp),%r0
462: movw %r0,16(%fp)
463: # m = h; /* m is free => use it */
464: movw 12(%fp),%r4
465: .L79:
466: # do {
467: # *dest++ |= (mask1 & *source++);
468: movw %r7,%r0
469: addw2 &4,%r7
470: movw %r8,%r1
471: addw2 &4,%r8
472: andw3 0(%r1),32(%fp),%r1
473: orw2 %r1,0(%r0)
474: # if ((i = b) > 0) do {
475: movw 4(%fp),%r3
476: jnpos .L80
477: .L83:
478: # *dest |= *source;
479: orw2 0(%r8),0(%r7)
480: # *(dest+1) |= *(source+1);
481: orw2 4(%r8),4(%r7)
482: # *(dest+2) |= *(source+2);
483: orw2 8(%r8),8(%r7)
484: # *(dest+3) |= *(source+3);
485: orw2 12(%r8),12(%r7)
486: # dest += 4;
487: addw2 &16,%r7
488: # source += 4;
489: addw2 &16,%r8
490: .L82:
491: # } while (--i > 0);
492: subw2 &1,%r3
493: jpos .L83
494: .L81:
495: .L80:
496: # if ((i = w) > 0) do {
497: movw 16(%fp),%r3
498: jnpos .L84
499: .L87:
500: # *dest++ |= *source++;
501: movw %r7,%r0
502: addw2 &4,%r7
503: movw %r8,%r1
504: addw2 &4,%r8
505: orw2 0(%r1),0(%r0)
506: .L86:
507: # } while (--i > 0);
508: subw2 &1,%r3
509: jpos .L87
510: .L85:
511: .L84:
512: # *dest |= (mask2 & *source);
513: andw3 0(%r8),36(%fp),%r0
514: orw2 %r0,0(%r7)
515: addw2 %r6,%r8
516: addw2 %r5,%r7
517: .L78:
518: # asm(" addw2 %r6,%r8"); /*source += sw; */
519: # asm(" addw2 %r5,%r7"); /*dest += dw; */
520: # } while (--m != 0);
521: subw2 &1,%r4
522: jnz .L79
523: .L77:
524: jmp .L53
525: .L88:
526: # break;
527: # case F_OR:
528: # if ((px31) > (rx31))
529: cmpw 24(%fp),28(%fp)
530: jle .L89
531: # source--; /* adjust for pipeline */
532: subw2 &4,%r8
533: .L89:
534: .L92:
535: # do {
536: # m = *source++; /* m is a free register */
537: movw %r8,%r0
538: addw2 &4,%r8
539: movw 0(%r0),%r4
540: # *dest++ |= (((m << b) | (*source >> a)) & mask1);
541: movw %r7,%r0
542: addw2 &4,%r7
543: LLSW3 4(%fp),%r4,%r1
544: LRSW3 0(%fp),0(%r8),%r2
545: orw2 %r2,%r1
546: andw2 32(%fp),%r1
547: orw2 %r1,0(%r0)
548: # if ((i=w) > 0) do {
549: movw 16(%fp),%r3
550: jnpos .L93
551: .L96:
552: # m = (*source++) << b;
553: movw %r8,%r0
554: addw2 &4,%r8
555: LLSW3 4(%fp),0(%r0),%r0
556: movw %r0,%r4
557: # *dest++ |= m | (*source >> a);
558: movw %r7,%r0
559: addw2 &4,%r7
560: LRSW3 0(%fp),0(%r8),%r1
561: orw2 %r4,%r1
562: orw2 %r1,0(%r0)
563: .L95:
564: # } while (--i > 0);
565: subw2 &1,%r3
566: jpos .L96
567: .L94:
568: .L93:
569: # m = *source; /* m is a free register */
570: movw 0(%r8),%r4
571: # *dest |= (((m << b) | (*(source+1) >> a)) & mask2);
572: LLSW3 4(%fp),%r4,%r0
573: LRSW3 0(%fp),4(%r8),%r1
574: orw2 %r1,%r0
575: andw2 36(%fp),%r0
576: orw2 %r0,0(%r7)
577: addw2 %r6,%r8
578: addw2 %r5,%r7
579: .L91:
580: # asm(" addw2 %r6,%r8"); /*source += sw; */
581: # asm(" addw2 %r5,%r7"); /*dest += dw; */
582: # } while (--h > 0);
583: subw2 &1,12(%fp)
584: jpos .L92
585: .L90:
586: jmp .L53
587: .L97:
588: # break;
589: # case F_CLR | NOSHIFT | LEFTDIR:
590: # b = w>>2;
591: LRSW3 &2,16(%fp),%r0
592: movw %r0,4(%fp)
593: # w = w&3;
594: andw3 &3,16(%fp),%r0
595: movw %r0,16(%fp)
596: # m = h; /* m is free => use it */
597: movw 12(%fp),%r4
598: .L100:
599: # do {
600: # *dest-- &= ~(mask2 & *source--);
601: movw %r7,%r0
602: subw2 &4,%r7
603: movw %r8,%r1
604: subw2 &4,%r8
605: andw3 0(%r1),36(%fp),%r1
606: mcomw %r1,%r1
607: andw2 %r1,0(%r0)
608: # if ((i = b) > 0) do {
609: movw 4(%fp),%r3
610: jnpos .L101
611: .L104:
612: # *dest &= ~(*source);
613: mcomw 0(%r8),%r0
614: andw2 %r0,0(%r7)
615: # *(dest-1) &= ~(*(source-1));
616: mcomw -4(%r8),%r0
617: andw2 %r0,-4(%r7)
618: # *(dest-2) &= ~(*(source-2));
619: mcomw -8(%r8),%r0
620: andw2 %r0,-8(%r7)
621: # *(dest-3) &= ~(*(source-3));
622: mcomw -12(%r8),%r0
623: andw2 %r0,-12(%r7)
624: # dest -= 4;
625: subw2 &16,%r7
626: # source -= 4;
627: subw2 &16,%r8
628: .L103:
629: # } while (--i > 0);
630: subw2 &1,%r3
631: jpos .L104
632: .L102:
633: .L101:
634: # if ((i = w) > 0) do {
635: movw 16(%fp),%r3
636: jnpos .L105
637: .L108:
638: # *dest-- &= ~(*source--);
639: movw %r7,%r0
640: subw2 &4,%r7
641: movw %r8,%r1
642: subw2 &4,%r8
643: mcomw 0(%r1),%r1
644: andw2 %r1,0(%r0)
645: .L107:
646: # } while (--i > 0);
647: subw2 &1,%r3
648: jpos .L108
649: .L106:
650: .L105:
651: # *dest &= ~(mask1 & *source);
652: andw3 0(%r8),32(%fp),%r0
653: mcomw %r0,%r0
654: andw2 %r0,0(%r7)
655: addw2 %r6,%r8
656: addw2 %r5,%r7
657: .L99:
658: # asm(" addw2 %r6,%r8"); /*source += sw; */
659: # asm(" addw2 %r5,%r7"); /*dest += dw; */
660: # } while (--m != 0);
661: subw2 &1,%r4
662: jnz .L100
663: .L98:
664: jmp .L53
665: .L109:
666: # break;
667: # case F_CLR | LEFTDIR:
668: # if ((px31) < (rx31))
669: cmpw 24(%fp),28(%fp)
670: jge .L110
671: # source++; /* adjust for pipeline */
672: addw2 &4,%r8
673: .L110:
674: .L113:
675: # do {
676: # m = *source--; /* m is a free register */
677: movw %r8,%r0
678: subw2 &4,%r8
679: movw 0(%r0),%r4
680: # *dest-- &= ~((((m >> a) | (*source << b)) & mask2));
681: movw %r7,%r0
682: subw2 &4,%r7
683: LRSW3 0(%fp),%r4,%r1
684: LLSW3 4(%fp),0(%r8),%r2
685: orw2 %r2,%r1
686: andw2 36(%fp),%r1
687: mcomw %r1,%r1
688: andw2 %r1,0(%r0)
689: # if ((i=w) > 0) do {
690: movw 16(%fp),%r3
691: jnpos .L114
692: .L117:
693: # m = (*source--) >> a;
694: movw %r8,%r0
695: subw2 &4,%r8
696: LRSW3 0(%fp),0(%r0),%r0
697: movw %r0,%r4
698: # *dest-- &= ~(m | (*source << b));
699: movw %r7,%r0
700: subw2 &4,%r7
701: LLSW3 4(%fp),0(%r8),%r1
702: orw2 %r4,%r1
703: mcomw %r1,%r1
704: andw2 %r1,0(%r0)
705: .L116:
706: # } while (--i > 0);
707: subw2 &1,%r3
708: jpos .L117
709: .L115:
710: .L114:
711: # m = *source; /* m is a free register */
712: movw 0(%r8),%r4
713: # *dest &= ~((((m >> a) | (*(source-1) << b)) & mask1));
714: LRSW3 0(%fp),%r4,%r0
715: LLSW3 4(%fp),-4(%r8),%r1
716: orw2 %r1,%r0
717: andw2 32(%fp),%r0
718: mcomw %r0,%r0
719: andw2 %r0,0(%r7)
720: addw2 %r6,%r8
721: addw2 %r5,%r7
722: .L112:
723: # asm(" addw2 %r6,%r8"); /*source += sw; */
724: # asm(" addw2 %r5,%r7"); /*dest += dw; */
725: # } while (--h > 0);
726: subw2 &1,12(%fp)
727: jpos .L113
728: .L111:
729: jmp .L53
730: .L118:
731: # break;
732: # case F_CLR | NOSHIFT:
733: # b = w>>2;
734: LRSW3 &2,16(%fp),%r0
735: movw %r0,4(%fp)
736: # w = w&3;
737: andw3 &3,16(%fp),%r0
738: movw %r0,16(%fp)
739: # m = h; /* m is free => use it */
740: movw 12(%fp),%r4
741: .L121:
742: # do {
743: # *dest++ &= ~((mask1 & *source++));
744: movw %r7,%r0
745: addw2 &4,%r7
746: movw %r8,%r1
747: addw2 &4,%r8
748: andw3 0(%r1),32(%fp),%r1
749: mcomw %r1,%r1
750: andw2 %r1,0(%r0)
751: # if ((i = b) > 0) do {
752: movw 4(%fp),%r3
753: jnpos .L122
754: .L125:
755: # *dest &= ~(*source);
756: mcomw 0(%r8),%r0
757: andw2 %r0,0(%r7)
758: # *(dest+1) &= ~(*(source+1));
759: mcomw 4(%r8),%r0
760: andw2 %r0,4(%r7)
761: # *(dest+2) &= ~(*(source+2));
762: mcomw 8(%r8),%r0
763: andw2 %r0,8(%r7)
764: # *(dest+3) &= ~(*(source+3));
765: mcomw 12(%r8),%r0
766: andw2 %r0,12(%r7)
767: # dest += 4;
768: addw2 &16,%r7
769: # source += 4;
770: addw2 &16,%r8
771: .L124:
772: # } while (--i > 0);
773: subw2 &1,%r3
774: jpos .L125
775: .L123:
776: .L122:
777: # if ((i = w) > 0) do {
778: movw 16(%fp),%r3
779: jnpos .L126
780: .L129:
781: # *dest++ &= ~(*source++);
782: movw %r7,%r0
783: addw2 &4,%r7
784: movw %r8,%r1
785: addw2 &4,%r8
786: mcomw 0(%r1),%r1
787: andw2 %r1,0(%r0)
788: .L128:
789: # } while (--i > 0);
790: subw2 &1,%r3
791: jpos .L129
792: .L127:
793: .L126:
794: # *dest &= ~((mask2 & *source));
795: andw3 0(%r8),36(%fp),%r0
796: mcomw %r0,%r0
797: andw2 %r0,0(%r7)
798: addw2 %r6,%r8
799: addw2 %r5,%r7
800: .L120:
801: # asm(" addw2 %r6,%r8"); /*source += sw; */
802: # asm(" addw2 %r5,%r7"); /*dest += dw; */
803: # } while (--m != 0);
804: subw2 &1,%r4
805: jnz .L121
806: .L119:
807: jmp .L53
808: .L130:
809: # break;
810: # case F_CLR:
811: # if ((px31) > (rx31))
812: cmpw 24(%fp),28(%fp)
813: jle .L131
814: # source--; /* adjust for pipeline */
815: subw2 &4,%r8
816: .L131:
817: .L134:
818: # do {
819: # m = *source++; /* m is a free register */
820: movw %r8,%r0
821: addw2 &4,%r8
822: movw 0(%r0),%r4
823: # *dest++ &= ~((((m << b) | (*source >> a)) & mask1));
824: movw %r7,%r0
825: addw2 &4,%r7
826: LLSW3 4(%fp),%r4,%r1
827: LRSW3 0(%fp),0(%r8),%r2
828: orw2 %r2,%r1
829: andw2 32(%fp),%r1
830: mcomw %r1,%r1
831: andw2 %r1,0(%r0)
832: # if ((i=w) > 0) do {
833: movw 16(%fp),%r3
834: jnpos .L135
835: .L138:
836: # m = (*source++) << b;
837: movw %r8,%r0
838: addw2 &4,%r8
839: LLSW3 4(%fp),0(%r0),%r0
840: movw %r0,%r4
841: # *dest++ &= ~(m | (*source >> a));
842: movw %r7,%r0
843: addw2 &4,%r7
844: LRSW3 0(%fp),0(%r8),%r1
845: orw2 %r4,%r1
846: mcomw %r1,%r1
847: andw2 %r1,0(%r0)
848: .L137:
849: # } while (--i > 0);
850: subw2 &1,%r3
851: jpos .L138
852: .L136:
853: .L135:
854: # m = *source; /* m is a free register */
855: movw 0(%r8),%r4
856: # *dest &= ~((((m << b) | (*(source+1) >> a)) & mask2));
857: LLSW3 4(%fp),%r4,%r0
858: LRSW3 0(%fp),4(%r8),%r1
859: orw2 %r1,%r0
860: andw2 36(%fp),%r0
861: mcomw %r0,%r0
862: andw2 %r0,0(%r7)
863: addw2 %r6,%r8
864: addw2 %r5,%r7
865: .L133:
866: # asm(" addw2 %r6,%r8"); /*source += sw; */
867: # asm(" addw2 %r5,%r7"); /*dest += dw; */
868: # } while (--h > 0);
869: subw2 &1,12(%fp)
870: jpos .L134
871: .L132:
872: jmp .L53
873: .L139:
874: # break;
875: # case F_XOR | NOSHIFT | LEFTDIR:
876: # b = w>>2;
877: LRSW3 &2,16(%fp),%r0
878: movw %r0,4(%fp)
879: # w = w&3;
880: andw3 &3,16(%fp),%r0
881: movw %r0,16(%fp)
882: # m = h; /* m is free => use it */
883: movw 12(%fp),%r4
884: .L142:
885: # do {
886: # *dest-- ^= mask2 & *source--;
887: movw %r7,%r0
888: subw2 &4,%r7
889: movw %r8,%r1
890: subw2 &4,%r8
891: andw3 0(%r1),36(%fp),%r1
892: xorw2 %r1,0(%r0)
893: # if ((i = b) > 0) do {
894: movw 4(%fp),%r3
895: jnpos .L143
896: .L146:
897: # *dest ^= *source;
898: xorw2 0(%r8),0(%r7)
899: # *(dest-1) ^= *(source-1);
900: xorw2 -4(%r8),-4(%r7)
901: # *(dest-2) ^= *(source-2);
902: xorw2 -8(%r8),-8(%r7)
903: # *(dest-3) ^= *(source-3);
904: xorw2 -12(%r8),-12(%r7)
905: # dest -= 4;
906: subw2 &16,%r7
907: # source -= 4;
908: subw2 &16,%r8
909: .L145:
910: # } while (--i > 0);
911: subw2 &1,%r3
912: jpos .L146
913: .L144:
914: .L143:
915: # if ((i = w) > 0) do {
916: movw 16(%fp),%r3
917: jnpos .L147
918: .L150:
919: # *dest-- ^= *source--;
920: movw %r7,%r0
921: subw2 &4,%r7
922: movw %r8,%r1
923: subw2 &4,%r8
924: xorw2 0(%r1),0(%r0)
925: .L149:
926: # } while (--i > 0);
927: subw2 &1,%r3
928: jpos .L150
929: .L148:
930: .L147:
931: # *dest ^= mask1 & *source;
932: andw3 0(%r8),32(%fp),%r0
933: xorw2 %r0,0(%r7)
934: addw2 %r6,%r8
935: addw2 %r5,%r7
936: .L141:
937: # asm(" addw2 %r6,%r8"); /*source += sw; */
938: # asm(" addw2 %r5,%r7"); /*dest += dw; */
939: # } while (--m != 0);
940: subw2 &1,%r4
941: jnz .L142
942: .L140:
943: jmp .L53
944: .L151:
945: # break;
946: # case F_XOR | LEFTDIR:
947: # if ((px31) < (rx31))
948: cmpw 24(%fp),28(%fp)
949: jge .L152
950: # source++; /* adjust for pipeline */
951: addw2 &4,%r8
952: .L152:
953: .L155:
954: # do {
955: # m = *source--; /* m is a free register */
956: movw %r8,%r0
957: subw2 &4,%r8
958: movw 0(%r0),%r4
959: # *dest-- ^= (((m >> a) | (*source << b)) & mask2);
960: movw %r7,%r0
961: subw2 &4,%r7
962: LRSW3 0(%fp),%r4,%r1
963: LLSW3 4(%fp),0(%r8),%r2
964: orw2 %r2,%r1
965: andw2 36(%fp),%r1
966: xorw2 %r1,0(%r0)
967: # if ((i=w) > 0) do {
968: movw 16(%fp),%r3
969: jnpos .L156
970: .L159:
971: # m = (*source--) >> a;
972: movw %r8,%r0
973: subw2 &4,%r8
974: LRSW3 0(%fp),0(%r0),%r0
975: movw %r0,%r4
976: # *dest-- ^= m | (*source << b);
977: movw %r7,%r0
978: subw2 &4,%r7
979: LLSW3 4(%fp),0(%r8),%r1
980: orw2 %r4,%r1
981: xorw2 %r1,0(%r0)
982: .L158:
983: # } while (--i > 0);
984: subw2 &1,%r3
985: jpos .L159
986: .L157:
987: .L156:
988: # m = *source; /* m is a free register */
989: movw 0(%r8),%r4
990: # *dest ^= (((m >> a) | (*(source-1) << b)) & mask1);
991: LRSW3 0(%fp),%r4,%r0
992: LLSW3 4(%fp),-4(%r8),%r1
993: orw2 %r1,%r0
994: andw2 32(%fp),%r0
995: xorw2 %r0,0(%r7)
996: addw2 %r6,%r8
997: addw2 %r5,%r7
998: .L154:
999: # asm(" addw2 %r6,%r8"); /*source += sw; */
1000: # asm(" addw2 %r5,%r7"); /*dest += dw; */
1001: # } while (--h > 0);
1002: subw2 &1,12(%fp)
1003: jpos .L155
1004: .L153:
1005: jmp .L53
1006: .L160:
1007: # break;
1008: # case F_XOR | NOSHIFT:
1009: # b = w>>2;
1010: LRSW3 &2,16(%fp),%r0
1011: movw %r0,4(%fp)
1012: # w = w&3;
1013: andw3 &3,16(%fp),%r0
1014: movw %r0,16(%fp)
1015: # m = h; /* m is free => use it */
1016: movw 12(%fp),%r4
1017: .L163:
1018: # do {
1019: # *dest++ ^= (mask1 & *source++);
1020: movw %r7,%r0
1021: addw2 &4,%r7
1022: movw %r8,%r1
1023: addw2 &4,%r8
1024: andw3 0(%r1),32(%fp),%r1
1025: xorw2 %r1,0(%r0)
1026: # if ((i = b) > 0) do {
1027: movw 4(%fp),%r3
1028: jnpos .L164
1029: .L167:
1030: # *dest ^= *source;
1031: xorw2 0(%r8),0(%r7)
1032: # *(dest+1) ^= *(source+1);
1033: xorw2 4(%r8),4(%r7)
1034: # *(dest+2) ^= *(source+2);
1035: xorw2 8(%r8),8(%r7)
1036: # *(dest+3) ^= *(source+3);
1037: xorw2 12(%r8),12(%r7)
1038: # dest += 4;
1039: addw2 &16,%r7
1040: # source += 4;
1041: addw2 &16,%r8
1042: .L166:
1043: # } while (--i > 0);
1044: subw2 &1,%r3
1045: jpos .L167
1046: .L165:
1047: .L164:
1048: # if ((i = w) > 0) do {
1049: movw 16(%fp),%r3
1050: jnpos .L168
1051: .L171:
1052: # *dest++ ^= *source++;
1053: movw %r7,%r0
1054: addw2 &4,%r7
1055: movw %r8,%r1
1056: addw2 &4,%r8
1057: xorw2 0(%r1),0(%r0)
1058: .L170:
1059: # } while (--i > 0);
1060: subw2 &1,%r3
1061: jpos .L171
1062: .L169:
1063: .L168:
1064: # *dest ^= (mask2 & *source);
1065: andw3 0(%r8),36(%fp),%r0
1066: xorw2 %r0,0(%r7)
1067: addw2 %r6,%r8
1068: addw2 %r5,%r7
1069: .L162:
1070: # asm(" addw2 %r6,%r8"); /*source += sw; */
1071: # asm(" addw2 %r5,%r7"); /*dest += dw; */
1072: # } while (--m != 0);
1073: subw2 &1,%r4
1074: jnz .L163
1075: .L161:
1076: jmp .L53
1077: .L172:
1078: # break;
1079: # case F_XOR:
1080: # if ((px31) > (rx31))
1081: cmpw 24(%fp),28(%fp)
1082: jle .L173
1083: # source--; /* adjust for pipeline */
1084: subw2 &4,%r8
1085: .L173:
1086: PUSHW %ap
1087: # asm(" PUSHW %ap");
1088: # m = topbits[a];
1089: LLSW3 &2,0(%fp),%r0
1090: movw topbits(%r0),%r4
1091: MCOMW %r4, %r1
1092: MOVW %r4, %r2
1093: MOVW 0(%fp),%ap
1094: PUSHW %fp
1095: BW_XORLOOP:
1096: ROTW %ap, 0(%r8), %r4
1097: ANDW2 %r2,%r4
1098: ADDW2 &4,%r8
1099: ROTW %ap,0(%r8),%r0
1100: ANDW3 %r0,%r1,%fp
1101: ORW2 %r4,%fp
1102: ANDW2 -0x28(%sp),%fp
1103: XORW2 %fp,0(%r7)
1104: ADDW2 &4,%r7
1105: MOVW -0x38(%sp),%r3
1106: BEB BW_XORINNER
1107: .L176:
1108: ANDW3 %r2,%r0,%r4
1109: ADDW2 &4,%r8
1110: ROTW %ap, 0(%r8),%r0
1111: ANDW3 %r0,%r1,%fp
1112: ORW2 %r4,%fp
1113: XORW2 %fp,0(%r7)
1114: ADDW2 &4, %r7
1115: .L175:
1116: # asm(" MCOMW %r4, %r1");
1117: # asm(" MOVW %r4, %r2");
1118: # asm(" MOVW 0(%fp),%ap");
1119: # asm(" PUSHW %fp");
1120: # asm("BW_XORLOOP:");
1121: # asm(" ROTW %ap, 0(%r8), %r4");
1122: # asm(" ANDW2 %r2,%r4");
1123: # asm(" ADDW2 &4,%r8");
1124: # asm(" ROTW %ap,0(%r8),%r0");
1125: # asm(" ANDW3 %r0,%r1,%fp");
1126: # asm(" ORW2 %r4,%fp");
1127: # asm(" ANDW2 -0x28(%sp),%fp");
1128: # asm(" XORW2 %fp,0(%r7)");
1129: # asm(" ADDW2 &4,%r7");
1130: # /* if (i = w) */
1131: # asm(" MOVW -0x38(%sp),%r3");
1132: # asm(" BEB BW_XORINNER");
1133: # do{
1134: # asm(" ANDW3 %r2,%r0,%r4");
1135: # asm(" ADDW2 &4,%r8");
1136: # asm(" ROTW %ap, 0(%r8),%r0");
1137: # asm(" ANDW3 %r0,%r1,%fp");
1138: # asm(" ORW2 %r4,%fp");
1139: # asm(" XORW2 %fp,0(%r7)");
1140: # asm(" ADDW2 &4, %r7");
1141: # } while (--i > 0);
1142: subw2 &1,%r3
1143: jpos .L176
1144: .L174:
1145: BW_XORINNER:
1146: ROTW %ap, 0(%r8),%r4
1147: ANDW2 %r2,%r4
1148: LRSW3 %ap, 4(%r8),%r0
1149: ORW2 %r4,%r0
1150: ANDW2 -0x24(%sp),%r0
1151: XORW2 %r0,0(%r7)
1152: ADDW2 %r6,%r8
1153: ADDW2 %r5,%r7
1154: DECW -0x3c(%sp)
1155: BGB BW_XORLOOP
1156: POPW %fp
1157: POPW %ap
1158: jmp .L53
1159: .L177:
1160: # asm("BW_XORINNER:");
1161: # asm(" ROTW %ap, 0(%r8),%r4");
1162: # asm(" ANDW2 %r2,%r4");
1163: # asm(" LRSW3 %ap, 4(%r8),%r0");
1164: # asm(" ORW2 %r4,%r0");
1165: # asm(" ANDW2 -0x24(%sp),%r0");
1166: # asm(" XORW2 %r0,0(%r7)");
1167: # asm(" ADDW2 %r6,%r8"); /*source += sw; */
1168: # asm(" ADDW2 %r5,%r7"); /*dest += dw; */
1169: # /* } while (--h > 0); */
1170: # asm(" DECW -0x3c(%sp)");
1171: # asm(" BGB BW_XORLOOP");
1172: #
1173: # asm(" POPW %fp");
1174: # asm(" POPW %ap");
1175: #
1176: # /* above is similar to:
1177: # /* do {
1178: # /* m = *source++ << b; /* m is a free register */
1179: # /* *dest++ ^= ((m & LMASK) | ((*source >> a)& RMASK) & mask1);
1180: # /* if ((i=w) > 0) do {
1181: # /* m = ((*source++) << b) & LMASK;
1182: # /* *dest++ ^= m | ((*source >> a)&RMASK);
1183: # /* } while (--i > 0);
1184: # /* m = *source; /* m is a free register */
1185: # /* *dest ^= (((m << b) | (*(source+1) >> a)) & mask2);
1186: # /* asm(" addw2 %r6,%r8"); /*source += sw; */
1187: # /* asm(" addw2 %r5,%r7"); /*dest += dw; */
1188: # /* } while (--h > 0); */
1189: # break;
1190: # case F_STORE | NOSHIFT | LEFTDIR:
1191: # b = w>>2;
1192: LRSW3 &2,16(%fp),%r0
1193: movw %r0,4(%fp)
1194: # w = w&3;
1195: andw3 &3,16(%fp),%r0
1196: movw %r0,16(%fp)
1197: # m = h; /* m is free => use it */
1198: movw 12(%fp),%r4
1199: .L180:
1200: # do {
1201: # *dest = (ntmask2 & *dest) | (mask2 & *source--);
1202: andw3 0(%r7),52(%fp),%r0
1203: movw %r8,%r1
1204: subw2 &4,%r8
1205: andw3 0(%r1),36(%fp),%r1
1206: orw2 %r1,%r0
1207: movw %r0,0(%r7)
1208: # --dest;
1209: subw2 &4,%r7
1210: # if ((i = b) > 0) do {
1211: movw 4(%fp),%r3
1212: jnpos .L181
1213: .L184:
1214: # *dest = *source;
1215: movw 0(%r8),0(%r7)
1216: # *(dest-1) = *(source-1);
1217: movw -4(%r8),-4(%r7)
1218: # *(dest-2) = *(source-2);
1219: movw -8(%r8),-8(%r7)
1220: # *(dest-3) = *(source-3);
1221: movw -12(%r8),-12(%r7)
1222: # dest -= 4;
1223: subw2 &16,%r7
1224: # source -= 4;
1225: subw2 &16,%r8
1226: .L183:
1227: # } while (--i > 0);
1228: subw2 &1,%r3
1229: jpos .L184
1230: .L182:
1231: .L181:
1232: # if ((i = w) > 0) do {
1233: movw 16(%fp),%r3
1234: jnpos .L185
1235: .L188:
1236: # *dest-- = *source--;
1237: movw %r7,%r0
1238: subw2 &4,%r7
1239: movw %r8,%r1
1240: subw2 &4,%r8
1241: movw 0(%r1),0(%r0)
1242: .L187:
1243: # } while (--i > 0);
1244: subw2 &1,%r3
1245: jpos .L188
1246: .L186:
1247: .L185:
1248: # *dest = (ntmask1 & *dest) | (mask1 & *source);
1249: andw3 0(%r7),48(%fp),%r0
1250: andw3 0(%r8),32(%fp),%r1
1251: orw2 %r1,%r0
1252: movw %r0,0(%r7)
1253: addw2 %r6,%r8
1254: addw2 %r5,%r7
1255: .L179:
1256: # asm(" addw2 %r6,%r8"); /*source += sw; */
1257: # asm(" addw2 %r5,%r7"); /*dest += dw; */
1258: # } while (--m != 0);
1259: subw2 &1,%r4
1260: jnz .L180
1261: .L178:
1262: jmp .L53
1263: .L189:
1264: # break;
1265: # case F_STORE | LEFTDIR:
1266: # if ((px31) < (rx31))
1267: cmpw 24(%fp),28(%fp)
1268: jge .L190
1269: # source++; /* adjust for pipeline */
1270: addw2 &4,%r8
1271: .L190:
1272: .L193:
1273: # do {
1274: # m = *source--; /* m is a free register */
1275: movw %r8,%r0
1276: subw2 &4,%r8
1277: movw 0(%r0),%r4
1278: # *dest = (((m >> a) | (*source << b)) & mask2) |
1279: # (*dest & ntmask2);
1280: LRSW3 0(%fp),%r4,%r0
1281: LLSW3 4(%fp),0(%r8),%r1
1282: orw2 %r1,%r0
1283: andw2 36(%fp),%r0
1284: andw3 52(%fp),0(%r7),%r1
1285: orw2 %r1,%r0
1286: movw %r0,0(%r7)
1287: # --dest;
1288: subw2 &4,%r7
1289: # if ((i=w) > 0) do {
1290: movw 16(%fp),%r3
1291: jnpos .L194
1292: .L197:
1293: # m = (*source--) >> a;
1294: movw %r8,%r0
1295: subw2 &4,%r8
1296: LRSW3 0(%fp),0(%r0),%r0
1297: movw %r0,%r4
1298: # *dest-- = m | (*source << b);
1299: movw %r7,%r0
1300: subw2 &4,%r7
1301: LLSW3 4(%fp),0(%r8),%r1
1302: orw2 %r4,%r1
1303: movw %r1,0(%r0)
1304: .L196:
1305: # } while (--i > 0);
1306: subw2 &1,%r3
1307: jpos .L197
1308: .L195:
1309: .L194:
1310: # m = *source; /* m is a free register */
1311: movw 0(%r8),%r4
1312: # *dest = (((m >> a) | (*(source-1) << b)) & mask1) |
1313: # (*dest & ntmask1);
1314: LRSW3 0(%fp),%r4,%r0
1315: LLSW3 4(%fp),-4(%r8),%r1
1316: orw2 %r1,%r0
1317: andw2 32(%fp),%r0
1318: andw3 48(%fp),0(%r7),%r1
1319: orw2 %r1,%r0
1320: movw %r0,0(%r7)
1321: addw2 %r6,%r8
1322: addw2 %r5,%r7
1323: .L192:
1324: # asm(" addw2 %r6,%r8"); /*source += sw; */
1325: # asm(" addw2 %r5,%r7"); /*dest += dw; */
1326: # } while (--h > 0);
1327: subw2 &1,12(%fp)
1328: jpos .L193
1329: .L191:
1330: jmp .L53
1331: .L198:
1332: # break;
1333: # case F_STORE | NOSHIFT:
1334: # if (w > 25)
1335: cmpw 16(%fp),&25
1336: jle .L199
1337: jmp .L200
1338: .L199:
1339: # goto widestore;
1340: # i = 25 - w;
1341: subw3 16(%fp),&25,%r0
1342: movw %r0,%r3
1343: # m = (i << 2) + (i << 1);
1344: LLSW3 &2,%r3,%r0
1345: LLSW3 &1,%r3,%r1
1346: addw2 %r1,%r0
1347: movw %r0,%r4
1348: LLSW3 &0x2,0x10(%fp),%r0
1349: ADDW2 &4,%r0
1350: MOVAW B_FS_N,%r1
1351: ADDW2 %r4,%r1
1352: #
1353: # asm(" LLSW3 &0x2,0x10(%fp),%r0"); /* bytewidth in r0*/
1354: # asm(" ADDW2 &4,%r0"); /* r0 +=4 for loop offsets */
1355: # asm(" MOVAW B_FS_N,%r1");
1356: # asm(" ADDW2 %r4,%r1"); /* r1 += &label, or jump addr*/
1357: # m = h; /* m is free reg, use it as height */
1358: movw 12(%fp),%r4
1359: MOVW 0x20(%fp),%r2
1360: PUSHW %ap
1361: MOVW 0x24(%fp),%ap
1362: PUSHW %fp
1363: MOVW %r1,%fp
1364: .L203:
1365: XORW3 0(%r7),0(%r8),%r1
1366: ANDW2 %r2,%r1
1367: XORW2 %r1,0(%r7)
1368: JMP 0(%fp)
1369: B_FS_N:
1370: MOVW 0x64(%r8),0x64(%r7)
1371: MOVW 0x60(%r8),0x60(%r7)
1372: MOVW 0x5c(%r8),0x5c(%r7)
1373: MOVW 0x58(%r8),0x58(%r7)
1374: MOVW 0x54(%r8),0x54(%r7)
1375: MOVW 0x50(%r8),0x50(%r7)
1376: MOVW 0x4c(%r8),0x4c(%r7)
1377: MOVW 0x48(%r8),0x48(%r7)
1378: MOVW 0x44(%r8),0x44(%r7)
1379: MOVW 0x40(%r8),0x40(%r7)
1380: MOVW 0x3c(%r8),0x3c(%r7)
1381: MOVW 0x38(%r8),0x38(%r7)
1382: MOVW 0x34(%r8),0x34(%r7)
1383: MOVW 0x30(%r8),0x30(%r7)
1384: MOVW 0x2c(%r8),0x2c(%r7)
1385: MOVW 0x28(%r8),0x28(%r7)
1386: MOVW 0x24(%r8),0x24(%r7)
1387: MOVW 0x20(%r8),0x20(%r7)
1388: MOVW 0x1c(%r8),0x1c(%r7)
1389: MOVW 0x18(%r8),0x18(%r7)
1390: MOVW 0x14(%r8),0x14(%r7)
1391: MOVW 0x10(%r8),0x10(%r7)
1392: MOVW 0xc(%r8),0xc(%r7)
1393: MOVW 0x8(%r8),0x8(%r7)
1394: MOVW 0x4(%r8),0x4(%r7)
1395: ADDW2 %r0,%r8
1396: ADDW2 %r0,%r7
1397: XORW3 0(%r7),0(%r8),%r1
1398: ANDW2 %ap,%r1
1399: XORW2 %r1,0(%r7)
1400: ADDW2 %r6,%r8
1401: ADDW2 %r5,%r7
1402: .L202:
1403: # asm(" MOVW 0x20(%fp),%r2"); /* r2 = mask1 */
1404: # asm(" PUSHW %ap"); /* save fp and ap */
1405: # asm(" MOVW 0x24(%fp),%ap"); /* ap = mask2 */
1406: # asm(" PUSHW %fp");
1407: # asm(" MOVW %r1,%fp"); /* put jump index into fp */
1408: #
1409: # do{
1410: #
1411: # asm(" XORW3 0(%r7),0(%r8),%r1");
1412: # asm(" ANDW2 %r2,%r1");
1413: # asm(" XORW2 %r1,0(%r7)");
1414: #
1415: # asm(" JMP 0(%fp)");
1416: # asm("B_FS_N: "); /* label */
1417: # asm(" MOVW 0x64(%r8),0x64(%r7)");
1418: # asm(" MOVW 0x60(%r8),0x60(%r7)"); asm(" MOVW 0x5c(%r8),0x5c(%r7)");
1419: # asm(" MOVW 0x58(%r8),0x58(%r7)"); asm(" MOVW 0x54(%r8),0x54(%r7)");
1420: # asm(" MOVW 0x50(%r8),0x50(%r7)"); asm(" MOVW 0x4c(%r8),0x4c(%r7)"); asm(" MOVW 0x48(%r8),0x48(%r7)"); asm(" MOVW 0x44(%r8),0x44(%r7)");
1421: # asm(" MOVW 0x40(%r8),0x40(%r7)"); asm(" MOVW 0x3c(%r8),0x3c(%r7)"); asm(" MOVW 0x38(%r8),0x38(%r7)"); asm(" MOVW 0x34(%r8),0x34(%r7)");
1422: # asm(" MOVW 0x30(%r8),0x30(%r7)"); asm(" MOVW 0x2c(%r8),0x2c(%r7)"); asm(" MOVW 0x28(%r8),0x28(%r7)"); asm(" MOVW 0x24(%r8),0x24(%r7)");
1423: # asm(" MOVW 0x20(%r8),0x20(%r7)"); asm(" MOVW 0x1c(%r8),0x1c(%r7)"); asm(" MOVW 0x18(%r8),0x18(%r7)");
1424: # asm(" MOVW 0x14(%r8),0x14(%r7)");
1425: # asm(" MOVW 0x10(%r8),0x10(%r7)");
1426: # asm(" MOVW 0xc(%r8),0xc(%r7)");
1427: # asm(" MOVW 0x8(%r8),0x8(%r7)");
1428: # asm(" MOVW 0x4(%r8),0x4(%r7)");
1429: # asm(" ADDW2 %r0,%r8");
1430: # asm(" ADDW2 %r0,%r7");
1431: # asm(" XORW3 0(%r7),0(%r8),%r1");
1432: # asm(" ANDW2 %ap,%r1"); /* ap has mask2 */
1433: # asm(" XORW2 %r1,0(%r7)");
1434: # asm(" ADDW2 %r6,%r8");
1435: # asm(" ADDW2 %r5,%r7");
1436: # } while (--m != 0);
1437: subw2 &1,%r4
1438: jnz .L203
1439: .L201:
1440: POPW %fp
1441: POPW %ap
1442: jmp .L53
1443: .L200:
1444: # asm(" POPW %fp");
1445: # asm(" POPW %ap");
1446: # break;
1447: # /* ABOVE ALMOST EQUAL TO : */
1448: # widestore:
1449: # b = w >> 2;
1450: LRSW3 &2,16(%fp),%r0
1451: movw %r0,4(%fp)
1452: # w = w & 3;
1453: andw3 &3,16(%fp),%r0
1454: movw %r0,16(%fp)
1455: # m = h;
1456: movw 12(%fp),%r4
1457: .L206:
1458: # do {
1459: # *dest = (ntmask1 & *dest) | (mask1 & *source++);
1460: andw3 0(%r7),48(%fp),%r0
1461: movw %r8,%r1
1462: addw2 &4,%r8
1463: andw3 0(%r1),32(%fp),%r1
1464: orw2 %r1,%r0
1465: movw %r0,0(%r7)
1466: # dest++;
1467: addw2 &4,%r7
1468: # if ((i = b) > 0) do {
1469: movw 4(%fp),%r3
1470: jnpos .L207
1471: .L210:
1472: # *dest = *source;
1473: movw 0(%r8),0(%r7)
1474: # *(dest+1) = *(source+1);
1475: movw 4(%r8),4(%r7)
1476: # *(dest+2) = *(source+2);
1477: movw 8(%r8),8(%r7)
1478: # *(dest+3) = *(source+3);
1479: movw 12(%r8),12(%r7)
1480: # dest += 4;
1481: addw2 &16,%r7
1482: # source += 4;
1483: addw2 &16,%r8
1484: .L209:
1485: # } while (--i > 0);
1486: subw2 &1,%r3
1487: jpos .L210
1488: .L208:
1489: .L207:
1490: # if ((i = w) > 0) do {
1491: movw 16(%fp),%r3
1492: jnpos .L211
1493: .L214:
1494: # *dest++ = *source++;
1495: movw %r7,%r0
1496: addw2 &4,%r7
1497: movw %r8,%r1
1498: addw2 &4,%r8
1499: movw 0(%r1),0(%r0)
1500: .L213:
1501: # } while (--i > 0);
1502: subw2 &1,%r3
1503: jpos .L214
1504: .L212:
1505: .L211:
1506: # *dest = (ntmask2 & *dest) | (mask2 & *source);
1507: andw3 0(%r7),52(%fp),%r0
1508: andw3 0(%r8),36(%fp),%r1
1509: orw2 %r1,%r0
1510: movw %r0,0(%r7)
1511: addw2 %r6,%r8
1512: addw2 %r5,%r7
1513: .L205:
1514: # asm(" addw2 %r6,%r8");
1515: # asm(" addw2 %r5,%r7");
1516: # } while (--m != 0);
1517: subw2 &1,%r4
1518: jnz .L206
1519: .L204:
1520: jmp .L53
1521: .L215:
1522: # break;
1523: # case F_STORE:
1524: # if ((px31) > (rx31))
1525: cmpw 24(%fp),28(%fp)
1526: jle .L216
1527: # source--; /* adjust for pipeline */
1528: subw2 &4,%r8
1529: .L216:
1530: .L219:
1531: # do {
1532: # m = *source++; /* m is a free register */
1533: movw %r8,%r0
1534: addw2 &4,%r8
1535: movw 0(%r0),%r4
1536: # *dest = (((m << b) | (*source >> a)) & mask1) |
1537: # (*dest & ntmask1);
1538: LLSW3 4(%fp),%r4,%r0
1539: LRSW3 0(%fp),0(%r8),%r1
1540: orw2 %r1,%r0
1541: andw2 32(%fp),%r0
1542: andw3 48(%fp),0(%r7),%r1
1543: orw2 %r1,%r0
1544: movw %r0,0(%r7)
1545: # dest++;
1546: addw2 &4,%r7
1547: # if ((i=w) > 0) do {
1548: movw 16(%fp),%r3
1549: jnpos .L220
1550: .L223:
1551: # m = (*source++) << b;
1552: movw %r8,%r0
1553: addw2 &4,%r8
1554: LLSW3 4(%fp),0(%r0),%r0
1555: movw %r0,%r4
1556: # *dest++ = m | (*source >> a);
1557: movw %r7,%r0
1558: addw2 &4,%r7
1559: LRSW3 0(%fp),0(%r8),%r1
1560: orw2 %r4,%r1
1561: movw %r1,0(%r0)
1562: .L222:
1563: # } while (--i > 0);
1564: subw2 &1,%r3
1565: jpos .L223
1566: .L221:
1567: .L220:
1568: # m = *source; /* m is a free register */
1569: movw 0(%r8),%r4
1570: # *dest = (((m << b) | (*(source+1) >> a)) & mask2) |
1571: # (*dest & ntmask2);
1572: LLSW3 4(%fp),%r4,%r0
1573: LRSW3 0(%fp),4(%r8),%r1
1574: orw2 %r1,%r0
1575: andw2 36(%fp),%r0
1576: andw3 52(%fp),0(%r7),%r1
1577: orw2 %r1,%r0
1578: movw %r0,0(%r7)
1579: addw2 %r6,%r8
1580: addw2 %r5,%r7
1581: .L218:
1582: # asm(" addw2 %r6,%r8"); /*source += sw; */
1583: # asm(" addw2 %r5,%r7"); /*dest += dw; */
1584: # } while (--h > 0);
1585: subw2 &1,12(%fp)
1586: jpos .L219
1587: .L217:
1588: jmp .L53
1589: .L54:
1590: cmpw %r0,&0
1591: jl .L224
1592: cmpw %r0,&15
1593: jg .L224
1594: ALSW3 &2,%r0,%r0
1595: jmp *.L225(%r0)
1596: .data
1597: .align 4
1598: #SWBEG
1599: .L225:
1600: .word .L215
1601: .word .L88
1602: .word .L130
1603: .word .L172
1604: .word .L198
1605: .word .L76
1606: .word .L118
1607: .word .L160
1608: .word .L189
1609: .word .L67
1610: .word .L109
1611: .word .L151
1612: .word .L177
1613: .word .L55
1614: .word .L97
1615: .word .L139
1616: #SWEND
1617: .text
1618: .L224:
1619: .L53:
1620: jmp .L31
1621: .L43:
1622: # break;
1623: # }
1624: #
1625: # return;
1626: # narrow:
1627: # /*
1628: # * width is 32 bits or less. There are four basic cases
1629: # * (in addition to the function code), which depend on whether
1630: # * the source and dest straddle word boundaries or not
1631: # */
1632: #
1633: # m = p.x & 31; /* commonly used expression */
1634: andh3 &31,16(%ap),%r0
1635: movw %r0,%r4
1636: # sw = r.origin.x & 31; /* commonly used expression */
1637: andh3 &31,4(%ap),%r0
1638: movw %r0,%r6
1639: # if (sw + dw > 31) /* if source is NOT aligned */
1640: addw3 %r5,%r6,%r0
1641: cmpw %r0,&31
1642: jle .L226
1643: # {
1644: # fc |= S_STRADDLE;
1645: orw2 &4,20(%ap)
1646: # mask1 = ONES >> sw;
1647: LRSW3 %r6,&-1,%r0
1648: movw %r0,32(%fp)
1649: # mask2 = topbits[((sw + dw) & 31) + 1];
1650: addw3 %r5,%r6,%r0
1651: andw2 &31,%r0
1652: addw2 &1,%r0
1653: LLSW3 &2,%r0,%r0
1654: movw topbits(%r0),36(%fp)
1655: .L226:
1656: # }
1657: #
1658: # if (m + dw > 31) /* if dest is NOT aligned */
1659: addw3 %r5,%r4,%r0
1660: cmpw %r0,&31
1661: jleu .L227
1662: # {
1663: # fc |= D_STRADDLE;
1664: orw2 &8,20(%ap)
1665: # mask3 = ONES >> m;
1666: LRSW3 %r4,&-1,%r0
1667: movw %r0,40(%fp)
1668: # mask4 = topbits[((m + dw) & 31) + 1];
1669: addw3 %r5,%r4,%r0
1670: andw2 &31,%r0
1671: addw2 &1,%r0
1672: LLSW3 &2,%r0,%r0
1673: movw topbits(%r0),44(%fp)
1674: .L227:
1675: # }
1676: # px31 = m;
1677: movw %r4,24(%fp)
1678: # m = m - sw;
1679: subw3 %r6,%r4,%r0
1680: movw %r0,%r4
1681: # a = dw;
1682: movw %r5,0(%fp)
1683: #
1684: # if ((sm == dm) && (r.origin.y < p.y))
1685: cmpw 0(%ap),12(%ap)
1686: jne .L228
1687: cmph 6(%ap),18(%ap)
1688: jge .L228
1689: .L229:
1690: # { /* may have to mess with loop order */
1691: # r.origin.y += i-1;
1692: movtwh %r3,%r0
1693: subh2 &1,%r0
1694: addh2 %r0,6(%ap)
1695: # p.y += i-1;
1696: movtwh %r3,%r0
1697: subh2 &1,%r0
1698: addh2 %r0,18(%ap)
1699: # sw = -(sm->width << 2); /* sleazy hack to avoid shift */
1700: addw3 &4,0(%ap),%r0
1701: LLSW3 &2,0(%r0),%r0
1702: mnegw %r0,%r0
1703: movw %r0,%r6
1704: # dw = -(dm->width << 2); /* in outer, inner loops */
1705: addw3 &4,12(%ap),%r0
1706: LLSW3 &2,0(%r0),%r0
1707: mnegw %r0,%r0
1708: movw %r0,%r5
1709: jmp .L230
1710: .L228:
1711: # }
1712: # else
1713: # {
1714: # sw = sm->width << 2;
1715: addw3 &4,0(%ap),%r0
1716: LLSW3 &2,0(%r0),%r0
1717: movw %r0,%r6
1718: # dw = dm->width << 2;
1719: addw3 &4,12(%ap),%r0
1720: LLSW3 &2,0(%r0),%r0
1721: movw %r0,%r5
1722: .L230:
1723: # }
1724: #
1725: # source = addr(sm,r.origin);
1726: pushw 0(%ap)
1727: pushw 4(%ap)
1728: call &2,addr
1729: movw %r0,%r8
1730: # dest = addr(dm,p);
1731: pushw 12(%ap)
1732: pushw 16(%ap)
1733: call &2,addr
1734: movw %r0,%r7
1735: #
1736: # switch(fc)
1737: movw 20(%ap),%r0
1738: jmp .L232
1739: .L233:
1740: # {
1741: # case F_STORE:
1742: # mask1 = topbits[a+1] >> (px31);
1743: addw3 &1,0(%fp),%r0
1744: LLSW3 &2,%r0,%r0
1745: LRSW3 24(%fp),topbits(%r0),%r0
1746: movw %r0,32(%fp)
1747: MOVW 0x20(%fp),%r1
1748: .L236:
1749: ROTW %r4,0(%r8),%r2
1750: XORW2 0(%r7),%r2
1751: ANDW2 %r1,%r2
1752: XORW2 %r2,0(%r7)
1753: ADDW2 %r6, %r8
1754: ADDW2 %r5, %r7
1755: .L235:
1756: # asm(" MOVW 0x20(%fp),%r1");
1757: # do {
1758: # asm(" ROTW %r4,0(%r8),%r2");
1759: # asm(" XORW2 0(%r7),%r2");
1760: # asm(" ANDW2 %r1,%r2");
1761: # asm(" XORW2 %r2,0(%r7)");
1762: # asm(" ADDW2 %r6, %r8");
1763: # asm(" ADDW2 %r5, %r7");
1764: # } while (--i > 0);
1765: subw2 &1,%r3
1766: jpos .L236
1767: .L234:
1768: jmp .L231
1769: .L237:
1770: # break;
1771: # case F_STORE | S_STRADDLE:
1772: # mask4 = 32 - m; /* REALLY the other shift count */
1773: subw3 %r4,&32,%r0
1774: movw %r0,44(%fp)
1775: # mask3 = topbits[a+1] >> px31;
1776: addw3 &1,0(%fp),%r0
1777: LLSW3 &2,%r0,%r0
1778: LRSW3 24(%fp),topbits(%r0),%r0
1779: movw %r0,40(%fp)
1780: PUSHW %ap
1781: MOVW 0x28(%fp),%r0
1782: MOVW 0x2c(%fp),%ap
1783: .L240:
1784: LLSW3 %ap,0(%r8),%r1
1785: LRSW3 %r4,4(%r8),%r2
1786: ORW2 %r2, %r1
1787: XORW2 0(%r7),%r1
1788: ANDW2 %r0,%r1
1789: XORW2 %r1,0(%r7)
1790: ADDW2 %r6, %r8
1791: ADDW2 %r5, %r7
1792: .L239:
1793: # asm(" PUSHW %ap"); /* store ap on stack */
1794: # asm(" MOVW 0x28(%fp),%r0"); /* put mask3 in r0 */
1795: # asm(" MOVW 0x2c(%fp),%ap"); /* put other shift in ap */
1796: #
1797: # do {
1798: # asm(" LLSW3 %ap,0(%r8),%r1"); /* 32-m,lft shft */
1799: # asm(" LRSW3 %r4,4(%r8),%r2"); /* m, right shift */
1800: # asm(" ORW2 %r2, %r1");
1801: # asm(" XORW2 0(%r7),%r1");
1802: # asm(" ANDW2 %r0,%r1");
1803: # asm(" XORW2 %r1,0(%r7)");
1804: # asm(" ADDW2 %r6, %r8");
1805: # asm(" ADDW2 %r5, %r7");
1806: # } while (--i > 0);
1807: subw2 &1,%r3
1808: jpos .L240
1809: .L238:
1810: POPW %ap
1811: jmp .L231
1812: .L241:
1813: PUSHW %ap
1814: MOVW 0x28(%fp),%r0
1815: MOVW 0x2c(%fp),%ap
1816: .L244:
1817: ROTW %r4,0(%r8),%r1
1818: XORW3 0(%r7),%r1,%r2
1819: ANDW2 %r0,%r2
1820: XORW2 %r2,0(%r7)
1821: XORW2 4(%r7),%r1
1822: ANDW2 %ap,%r1
1823: XORW2 %r1,4(%r7)
1824: ADDW2 %r6, %r8
1825: ADDW2 %r5, %r7
1826: .L243:
1827: # asm(" POPW %ap"); /* restore ap from stack */
1828: # break;
1829: # case F_STORE | D_STRADDLE:
1830: # asm(" PUSHW %ap"); /* store ap on stack */
1831: # asm(" MOVW 0x28(%fp),%r0"); /* put mask3 in r0 */
1832: # asm(" MOVW 0x2c(%fp),%ap"); /* put mask4 in ap */
1833: # do {
1834: # asm(" ROTW %r4,0(%r8),%r1");
1835: # asm(" XORW3 0(%r7),%r1,%r2");
1836: # asm(" ANDW2 %r0,%r2");
1837: # asm(" XORW2 %r2,0(%r7)");
1838: # asm(" XORW2 4(%r7),%r1");
1839: # asm(" ANDW2 %ap,%r1");
1840: # asm(" XORW2 %r1,4(%r7)");
1841: # asm(" ADDW2 %r6, %r8");
1842: # asm(" ADDW2 %r5, %r7");
1843: # } while (--i > 0);
1844: subw2 &1,%r3
1845: jpos .L244
1846: .L242:
1847: POPW %ap
1848: jmp .L231
1849: .L245:
1850: PUSHW %ap
1851: SUBW3 %r4,&0x20,%ap
1852: MOVW 0x20(%fp),%r0
1853: MOVW 0x24(%fp),%r2
1854: PUSHW %fp
1855: .L248:
1856: ANDW3 %r0, 0(%r8), %r1
1857: ANDW3 %r2, 4(%r8),%ap
1858: ORW2 %ap, %r1
1859: ROTW %r4, %r1, %r1
1860: XORW3 0(%r7), %r1, %ap
1861: ANDW2 0x28(%fp), %ap
1862: XORW2 %ap, 0(%r7)
1863: XORW2 4(%r7), %r1
1864: ANDW2 0x2c(%fp), %r1
1865: XORW2 %r1, 4(%r7)
1866: ADDW2 %r6, %r8
1867: ADDW2 %r5, %r7
1868: .L247:
1869: # asm(" POPW %ap"); /* restore ap from stack */
1870: # break;
1871: # case F_STORE | S_STRADDLE | D_STRADDLE:
1872: # asm(" PUSHW %ap"); /* store ap on stack */
1873: # asm(" SUBW3 %r4,&0x20,%ap"); /* right shift distance */
1874: # asm(" MOVW 0x20(%fp),%r0"); /* r0 <- mask1 */
1875: # asm(" MOVW 0x24(%fp),%r2"); /* r2 <- mask2 */
1876: # asm(" PUSHW %fp"); /* store fp on stack */
1877: # do {
1878: # asm(" ANDW3 %r0, 0(%r8), %r1");
1879: # asm(" ANDW3 %r2, 4(%r8),%ap");
1880: # asm(" ORW2 %ap, %r1");
1881: # asm(" ROTW %r4, %r1, %r1");
1882: # asm(" XORW3 0(%r7), %r1, %ap");
1883: # asm(" ANDW2 0x28(%fp), %ap");
1884: # asm(" XORW2 %ap, 0(%r7)");
1885: # asm(" XORW2 4(%r7), %r1");
1886: # asm(" ANDW2 0x2c(%fp), %r1");
1887: # asm(" XORW2 %r1, 4(%r7)");
1888: # asm(" ADDW2 %r6, %r8");
1889: # asm(" ADDW2 %r5, %r7");
1890: # } while (--i > 0);
1891: subw2 &1,%r3
1892: jpos .L248
1893: .L246:
1894: POPW %fp
1895: POPW %ap
1896: jmp .L231
1897: .L249:
1898: # asm(" POPW %fp"); /* restore fp from stack */
1899: # asm(" POPW %ap"); /* restore ap from stack */
1900: # break;
1901: # case F_OR:
1902: # mask1 = topbits[a+1] >> px31;
1903: addw3 &1,0(%fp),%r0
1904: LLSW3 &2,%r0,%r0
1905: LRSW3 24(%fp),topbits(%r0),%r0
1906: movw %r0,32(%fp)
1907: MOVW 0x20(%fp),%r1
1908: .L252:
1909: ROTW %r4,0(%r8),%r2
1910: ANDW2 %r1,%r2
1911: ORW2 %r2,0(%r7)
1912: ADDW2 %r6, %r8
1913: ADDW2 %r5, %r7
1914: .L251:
1915: # asm(" MOVW 0x20(%fp),%r1"); /* mask1 */
1916: # do {
1917: # asm(" ROTW %r4,0(%r8),%r2");
1918: # asm(" ANDW2 %r1,%r2");
1919: # asm(" ORW2 %r2,0(%r7)");
1920: # asm(" ADDW2 %r6, %r8");
1921: # asm(" ADDW2 %r5, %r7");
1922: # } while (--i > 0);
1923: subw2 &1,%r3
1924: jpos .L252
1925: .L250:
1926: jmp .L231
1927: .L253:
1928: MOVW 0x20(%fp),%r0
1929: PUSHW %ap
1930: MOVW 0x24(%fp),%ap
1931: .L256:
1932: ANDW3 %r0,0(%r8),%r2
1933: ANDW3 %ap,4(%r8),%r1
1934: ORW2 %r2,%r1
1935: ROTW %r4,%r1,%r1
1936: ORW2 %r1,0(%r7)
1937: ADDW2 %r6, %r8
1938: ADDW2 %r5, %r7
1939: .L255:
1940: # break;
1941: # case F_OR | S_STRADDLE:
1942: # asm(" MOVW 0x20(%fp),%r0"); /* store mask1 in a reg */
1943: # asm(" PUSHW %ap"); /* store ap on stack */
1944: # asm(" MOVW 0x24(%fp),%ap"); /* store mask1 in a reg */
1945: #
1946: # do {
1947: # asm(" ANDW3 %r0,0(%r8),%r2"); /* x20(fp)=mask1 */
1948: # asm(" ANDW3 %ap,4(%r8),%r1"); /* x24(fp)=mask2 */
1949: # asm(" ORW2 %r2,%r1");
1950: # asm(" ROTW %r4,%r1,%r1");
1951: # asm(" ORW2 %r1,0(%r7)");
1952: # asm(" ADDW2 %r6, %r8");
1953: # asm(" ADDW2 %r5, %r7");
1954: # } while (--i > 0);
1955: subw2 &1,%r3
1956: jpos .L256
1957: .L254:
1958: POPW %ap
1959: jmp .L231
1960: .L257:
1961: # asm(" POPW %ap"); /* restore ap from stack */
1962: # break;
1963: # case F_OR | D_STRADDLE:
1964: # if (a <= 16) /* very narrow, 17 bits max */
1965: cmpw 0(%fp),&16
1966: jg .L258
1967: MOVW &0xffff0000,%r2
1968: ORW3 0x28(%fp),0x2c(%fp),%r0
1969: .L261:
1970: ROTW %r4,0(%r8),%r1
1971: ANDW2 %r0,%r1
1972: ORH2 %r1,2(%r7)
1973: ANDW2 %r2, %r1
1974: ORW2 %r1, 4(%r7)
1975: ADDW2 %r6, %r8
1976: ADDW2 %r5, %r7
1977: .L260:
1978: # {
1979: # asm(" MOVW &0xffff0000,%r2");
1980: # asm(" ORW3 0x28(%fp),0x2c(%fp),%r0"); /* compute mask */
1981: # do {
1982: # asm(" ROTW %r4,0(%r8),%r1");
1983: # asm(" ANDW2 %r0,%r1"); /* mask */
1984: # asm(" ORH2 %r1,2(%r7)");
1985: # asm(" ANDW2 %r2, %r1");
1986: # asm(" ORW2 %r1, 4(%r7)");
1987: # asm(" ADDW2 %r6, %r8");
1988: # asm(" ADDW2 %r5, %r7");
1989: # } while (--i > 0);
1990: subw2 &1,%r3
1991: jpos .L261
1992: .L259:
1993: jmp .L262
1994: .L258:
1995: MOVW 0x28(%fp),%r0
1996: PUSHW %ap
1997: MOVW 0x2c(%fp),%ap
1998: .L265:
1999: ROTW %r4,0(%r8),%r1
2000: ANDW3 %r0,%r1,%r2
2001: ORW2 %r2,0(%r7)
2002: ANDW2 %ap,%r1
2003: ORW2 %r1,4(%r7)
2004: ADDW2 %r6, %r8
2005: ADDW2 %r5, %r7
2006: .L264:
2007: # }
2008: # else
2009: # {
2010: # asm(" MOVW 0x28(%fp),%r0"); /* store mask3 in a reg */
2011: # asm(" PUSHW %ap"); /* store ap on stack */
2012: # asm(" MOVW 0x2c(%fp),%ap"); /* store mask4 in a reg */
2013: # do {
2014: # asm(" ROTW %r4,0(%r8),%r1");
2015: # asm(" ANDW3 %r0,%r1,%r2");
2016: # asm(" ORW2 %r2,0(%r7)");
2017: # asm(" ANDW2 %ap,%r1");
2018: # asm(" ORW2 %r1,4(%r7)");
2019: # asm(" ADDW2 %r6, %r8");
2020: # asm(" ADDW2 %r5, %r7");
2021: # } while (--i > 0);
2022: subw2 &1,%r3
2023: jpos .L265
2024: .L263:
2025: POPW %ap
2026: .L262:
2027: jmp .L231
2028: .L266:
2029: MOVW 0x20(%fp),%r0
2030: PUSHW %ap
2031: MOVW 0x24(%fp),%ap
2032: # asm(" POPW %ap"); /* restore ap from stack */
2033: # }
2034: # break;
2035: # case F_OR | S_STRADDLE | D_STRADDLE:
2036: # asm(" MOVW 0x20(%fp),%r0"); /* store mask1 in a reg */
2037: # asm(" PUSHW %ap"); /* store ap on stack */
2038: # asm(" MOVW 0x24(%fp),%ap"); /* store mask2 in a reg */
2039: # if (a > 16){ /* not super narrow */
2040: cmpw 0(%fp),&16
2041: jle .L267
2042: .L270:
2043: ANDW3 %r0,0(%r8),%r1
2044: ANDW3 %ap,4(%r8),%r2
2045: ORW2 %r2,%r1
2046: ROTW %r4,%r1,%r1
2047: ANDW3 0x28(%fp),%r1,%r2
2048: ORW2 %r2,0(%r7)
2049: ANDW2 0x2c(%fp),%r1
2050: ORW2 %r1,4(%r7)
2051: ADDW2 %r6, %r8
2052: ADDW2 %r5, %r7
2053: .L269:
2054: # do {
2055: # asm(" ANDW3 %r0,0(%r8),%r1");
2056: # asm(" ANDW3 %ap,4(%r8),%r2");
2057: # asm(" ORW2 %r2,%r1");
2058: # asm(" ROTW %r4,%r1,%r1");
2059: # asm(" ANDW3 0x28(%fp),%r1,%r2");
2060: # asm(" ORW2 %r2,0(%r7)");
2061: # asm(" ANDW2 0x2c(%fp),%r1");
2062: # asm(" ORW2 %r1,4(%r7)");
2063: # asm(" ADDW2 %r6, %r8");
2064: # asm(" ADDW2 %r5, %r7");
2065: # } while (--i > 0);
2066: subw2 &1,%r3
2067: jpos .L270
2068: .L268:
2069: jmp .L271
2070: .L267:
2071: .L274:
2072: ANDW3 %r0,0(%r8),%r1
2073: ANDW3 %ap,4(%r8),%r2
2074: ORW2 %r2,%r1
2075: ROTW %r4,%r1,%r1
2076: ORH2 %r1,2(%r7)
2077: ANDW2 &0xffff0000,%r1
2078: ORW2 %r1,4(%r7)
2079: ADDW2 %r6, %r8
2080: ADDW2 %r5, %r7
2081: .L273:
2082: # }
2083: # else
2084: # {
2085: # do {
2086: # asm(" ANDW3 %r0,0(%r8),%r1");
2087: # asm(" ANDW3 %ap,4(%r8),%r2");
2088: # asm(" ORW2 %r2,%r1");
2089: # asm(" ROTW %r4,%r1,%r1");
2090: # asm(" ORH2 %r1,2(%r7)");
2091: # asm(" ANDW2 &0xffff0000,%r1");
2092: # asm(" ORW2 %r1,4(%r7)");
2093: # asm(" ADDW2 %r6, %r8");
2094: # asm(" ADDW2 %r5, %r7");
2095: # } while (--i > 0);
2096: subw2 &1,%r3
2097: jpos .L274
2098: .L272:
2099: .L271:
2100: POPW %ap
2101: jmp .L231
2102: .L275:
2103: # }
2104: # asm(" POPW %ap"); /* restore ap from stack */
2105: # break;
2106: # case F_CLR:
2107: # mask1 = topbits[a+1] >> px31;
2108: addw3 &1,0(%fp),%r0
2109: LLSW3 &2,%r0,%r0
2110: LRSW3 24(%fp),topbits(%r0),%r0
2111: movw %r0,32(%fp)
2112: MOVW 0x20(%fp),%r1
2113: .L278:
2114: ROTW %r4,0(%r8),%r2
2115: ANDW2 %r1,%r2
2116: MCOMW %r2,%r2
2117: ANDW2 %r2,0(%r7)
2118: ADDW2 %r6, %r8
2119: ADDW2 %r5, %r7
2120: .L277:
2121: # asm(" MOVW 0x20(%fp),%r1"); /* mask1 */
2122: # do {
2123: # asm(" ROTW %r4,0(%r8),%r2");
2124: # asm(" ANDW2 %r1,%r2");
2125: # asm(" MCOMW %r2,%r2");
2126: # asm(" ANDW2 %r2,0(%r7)");
2127: # asm(" ADDW2 %r6, %r8");
2128: # asm(" ADDW2 %r5, %r7");
2129: # } while (--i > 0);
2130: subw2 &1,%r3
2131: jpos .L278
2132: .L276:
2133: jmp .L231
2134: .L279:
2135: MOVW 0x20(%fp),%r0
2136: PUSHW %ap
2137: MOVW 0x24(%fp),%ap
2138: .L282:
2139: ANDW3 %r0,0(%r8),%r2
2140: ANDW3 %ap,4(%r8),%r1
2141: ORW2 %r2,%r1
2142: ROTW %r4,%r1,%r1
2143: MCOMW %r1,%r1
2144: ANDW2 %r1,0(%r7)
2145: ADDW2 %r6, %r8
2146: ADDW2 %r5, %r7
2147: .L281:
2148: # break;
2149: # case F_CLR | S_STRADDLE:
2150: # asm(" MOVW 0x20(%fp),%r0"); /* store mask1 in a reg */
2151: # asm(" PUSHW %ap"); /* store ap on stack */
2152: # asm(" MOVW 0x24(%fp),%ap"); /* store mask1 in a reg */
2153: #
2154: # do {
2155: # asm(" ANDW3 %r0,0(%r8),%r2"); /* x20(fp)=mask1 */
2156: # asm(" ANDW3 %ap,4(%r8),%r1"); /* x24(fp)=mask2 */
2157: # asm(" ORW2 %r2,%r1");
2158: # asm(" ROTW %r4,%r1,%r1");
2159: # asm(" MCOMW %r1,%r1");
2160: # asm(" ANDW2 %r1,0(%r7)");
2161: # asm(" ADDW2 %r6, %r8");
2162: # asm(" ADDW2 %r5, %r7");
2163: # } while (--i > 0);
2164: subw2 &1,%r3
2165: jpos .L282
2166: .L280:
2167: POPW %ap
2168: jmp .L231
2169: .L283:
2170: # asm(" POPW %ap"); /* restore ap from stack */
2171: # break;
2172: # case F_CLR | D_STRADDLE:
2173: # if (a <= 16) /* very narrow, 17 bits max */
2174: cmpw 0(%fp),&16
2175: jg .L284
2176: MOVW &0xffff,%r2
2177: ORW3 0x28(%fp),0x2c(%fp),%r0
2178: .L287:
2179: ROTW %r4,0(%r8),%r1
2180: ANDW2 %r0,%r1
2181: MCOMW %r1,%r1
2182: ANDH2 %r1,2(%r7)
2183: ORW2 %r2,%r1
2184: ANDW2 %r1,4(%r7)
2185: ADDW2 %r6, %r8
2186: ADDW2 %r5, %r7
2187: .L286:
2188: # {
2189: # asm(" MOVW &0xffff,%r2");
2190: # asm(" ORW3 0x28(%fp),0x2c(%fp),%r0"); /* compute mask */
2191: # do {
2192: # asm(" ROTW %r4,0(%r8),%r1");
2193: # asm(" ANDW2 %r0,%r1"); /* mask */
2194: # asm(" MCOMW %r1,%r1");
2195: # asm(" ANDH2 %r1,2(%r7)");
2196: # asm(" ORW2 %r2,%r1");
2197: # asm(" ANDW2 %r1,4(%r7)");
2198: # asm(" ADDW2 %r6, %r8");
2199: # asm(" ADDW2 %r5, %r7");
2200: # } while (--i > 0);
2201: subw2 &1,%r3
2202: jpos .L287
2203: .L285:
2204: jmp .L288
2205: .L284:
2206: MOVW 0x28(%fp),%r0
2207: PUSHW %ap
2208: MOVW 0x2c(%fp),%ap
2209: .L291:
2210: ROTW %r4,0(%r8),%r1
2211: ANDW3 %r0,%r1,%r2
2212: MCOMW %r2,%r2
2213: ANDW2 %r2,0(%r7)
2214: ANDW2 %ap,%r1
2215: MCOMW %r1,%r1
2216: ANDW2 %r1,4(%r7)
2217: ADDW2 %r6, %r8
2218: ADDW2 %r5, %r7
2219: .L290:
2220: # }
2221: # else
2222: # {
2223: # asm(" MOVW 0x28(%fp),%r0"); /* store mask3 in a reg */
2224: # asm(" PUSHW %ap"); /* store ap on stack */
2225: # asm(" MOVW 0x2c(%fp),%ap"); /* store mask4 in a reg */
2226: # do {
2227: # asm(" ROTW %r4,0(%r8),%r1");
2228: # asm(" ANDW3 %r0,%r1,%r2");
2229: # asm(" MCOMW %r2,%r2");
2230: # asm(" ANDW2 %r2,0(%r7)");
2231: # asm(" ANDW2 %ap,%r1");
2232: # asm(" MCOMW %r1,%r1");
2233: # asm(" ANDW2 %r1,4(%r7)");
2234: # asm(" ADDW2 %r6, %r8");
2235: # asm(" ADDW2 %r5, %r7");
2236: # } while (--i > 0);
2237: subw2 &1,%r3
2238: jpos .L291
2239: .L289:
2240: POPW %ap
2241: .L288:
2242: jmp .L231
2243: .L292:
2244: MOVW 0x20(%fp),%r0
2245: PUSHW %ap
2246: MOVW 0x24(%fp),%ap
2247: # asm(" POPW %ap"); /* restore ap from stack */
2248: # }
2249: # break;
2250: # case F_CLR | S_STRADDLE | D_STRADDLE:
2251: # asm(" MOVW 0x20(%fp),%r0"); /* store mask1 in a reg */
2252: # asm(" PUSHW %ap"); /* store ap on stack */
2253: # asm(" MOVW 0x24(%fp),%ap"); /* store mask2 in a reg */
2254: # if (a > 16){ /* not super narrow */
2255: cmpw 0(%fp),&16
2256: jle .L293
2257: .L296:
2258: ANDW3 %r0,0(%r8),%r1
2259: ANDW3 %ap,4(%r8),%r2
2260: ORW2 %r2,%r1
2261: ROTW %r4,%r1,%r1
2262: ANDW3 0x28(%fp),%r1,%r2
2263: MCOMW %r2,%r2
2264: ANDW2 %r2,0(%r7)
2265: ANDW2 0x2c(%fp),%r1
2266: MCOMW %r1,%r1
2267: ANDW2 %r1,4(%r7)
2268: ADDW2 %r6, %r8
2269: ADDW2 %r5, %r7
2270: .L295:
2271: # do {
2272: # asm(" ANDW3 %r0,0(%r8),%r1");
2273: # asm(" ANDW3 %ap,4(%r8),%r2");
2274: # asm(" ORW2 %r2,%r1");
2275: # asm(" ROTW %r4,%r1,%r1");
2276: # asm(" ANDW3 0x28(%fp),%r1,%r2");
2277: # asm(" MCOMW %r2,%r2");
2278: # asm(" ANDW2 %r2,0(%r7)");
2279: # asm(" ANDW2 0x2c(%fp),%r1");
2280: # asm(" MCOMW %r1,%r1");
2281: # asm(" ANDW2 %r1,4(%r7)");
2282: # asm(" ADDW2 %r6, %r8");
2283: # asm(" ADDW2 %r5, %r7");
2284: # } while (--i > 0);
2285: subw2 &1,%r3
2286: jpos .L296
2287: .L294:
2288: jmp .L297
2289: .L293:
2290: .L300:
2291: ANDW3 %r0,0(%r8),%r1
2292: ANDW3 %ap,4(%r8),%r2
2293: ORW2 %r2,%r1
2294: ROTW %r4,%r1,%r1
2295: MCOMW %r1,%r1
2296: ANDH2 %r1,2(%r7)
2297: ORW2 &0xffff,%r1
2298: ANDW2 %r1,4(%r7)
2299: ADDW2 %r6, %r8
2300: ADDW2 %r5, %r7
2301: .L299:
2302: # }
2303: # else
2304: # {
2305: # do {
2306: # asm(" ANDW3 %r0,0(%r8),%r1");
2307: # asm(" ANDW3 %ap,4(%r8),%r2");
2308: # asm(" ORW2 %r2,%r1");
2309: # asm(" ROTW %r4,%r1,%r1");
2310: # asm(" MCOMW %r1,%r1");
2311: # asm(" ANDH2 %r1,2(%r7)");
2312: # asm(" ORW2 &0xffff,%r1");
2313: # asm(" ANDW2 %r1,4(%r7)");
2314: # asm(" ADDW2 %r6, %r8");
2315: # asm(" ADDW2 %r5, %r7");
2316: # } while (--i > 0);
2317: subw2 &1,%r3
2318: jpos .L300
2319: .L298:
2320: .L297:
2321: POPW %ap
2322: jmp .L231
2323: .L301:
2324: # }
2325: # asm(" POPW %ap"); /* restore ap from stack */
2326: # break;
2327: # case F_XOR:
2328: # mask1 = topbits[a+1] >> px31;
2329: addw3 &1,0(%fp),%r0
2330: LLSW3 &2,%r0,%r0
2331: LRSW3 24(%fp),topbits(%r0),%r0
2332: movw %r0,32(%fp)
2333: MOVW 0x20(%fp),%r1
2334: .L304:
2335: ROTW %r4,0(%r8),%r2
2336: ANDW2 %r1,%r2
2337: XORW2 %r2,0(%r7)
2338: ADDW2 %r6, %r8
2339: ADDW2 %r5, %r7
2340: .L303:
2341: # asm(" MOVW 0x20(%fp),%r1"); /* mask1 */
2342: # do {
2343: # asm(" ROTW %r4,0(%r8),%r2");
2344: # asm(" ANDW2 %r1,%r2");
2345: # asm(" XORW2 %r2,0(%r7)");
2346: # asm(" ADDW2 %r6, %r8");
2347: # asm(" ADDW2 %r5, %r7");
2348: # } while (--i > 0);
2349: subw2 &1,%r3
2350: jpos .L304
2351: .L302:
2352: jmp .L231
2353: .L305:
2354: MOVW 0x20(%fp),%r0
2355: PUSHW %ap
2356: MOVW 0x24(%fp),%ap
2357: .L308:
2358: ANDW3 %r0,0(%r8),%r2
2359: ANDW3 %ap,4(%r8),%r1
2360: ORW2 %r2,%r1
2361: ROTW %r4,%r1,%r1
2362: XORW2 %r1,0(%r7)
2363: ADDW2 %r6, %r8
2364: ADDW2 %r5, %r7
2365: .L307:
2366: # break;
2367: # case F_XOR | S_STRADDLE:
2368: # asm(" MOVW 0x20(%fp),%r0"); /* store mask1 in a reg */
2369: # asm(" PUSHW %ap"); /* store ap on stack */
2370: # asm(" MOVW 0x24(%fp),%ap"); /* store mask1 in a reg */
2371: #
2372: # do {
2373: # asm(" ANDW3 %r0,0(%r8),%r2"); /* x20(fp)=mask1 */
2374: # asm(" ANDW3 %ap,4(%r8),%r1"); /* x24(fp)=mask2 */
2375: # asm(" ORW2 %r2,%r1");
2376: # asm(" ROTW %r4,%r1,%r1");
2377: # asm(" XORW2 %r1,0(%r7)");
2378: # asm(" ADDW2 %r6, %r8");
2379: # asm(" ADDW2 %r5, %r7");
2380: # } while (--i > 0);
2381: subw2 &1,%r3
2382: jpos .L308
2383: .L306:
2384: POPW %ap
2385: jmp .L231
2386: .L309:
2387: # asm(" POPW %ap"); /* restore ap from stack */
2388: # break;
2389: # case F_XOR | D_STRADDLE:
2390: # if (a <= 16) /* very narrow, 17 bits max */
2391: cmpw 0(%fp),&16
2392: jg .L310
2393: MOVW &0xffff0000,%r2
2394: ORW3 0x28(%fp),0x2c(%fp),%r0
2395: .L313:
2396: ROTW %r4,0(%r8),%r1
2397: ANDW2 %r0,%r1
2398: XORH2 %r1,2(%r7)
2399: ANDW2 %r2,%r1
2400: XORW2 %r1,4(%r7)
2401: ADDW2 %r6, %r8
2402: ADDW2 %r5, %r7
2403: .L312:
2404: # {
2405: # asm(" MOVW &0xffff0000,%r2");
2406: # asm(" ORW3 0x28(%fp),0x2c(%fp),%r0"); /* compute mask */
2407: # do {
2408: # asm(" ROTW %r4,0(%r8),%r1");
2409: # asm(" ANDW2 %r0,%r1"); /* mask */
2410: # asm(" XORH2 %r1,2(%r7)");
2411: # asm(" ANDW2 %r2,%r1");
2412: # asm(" XORW2 %r1,4(%r7)");
2413: # asm(" ADDW2 %r6, %r8");
2414: # asm(" ADDW2 %r5, %r7");
2415: # } while (--i > 0);
2416: subw2 &1,%r3
2417: jpos .L313
2418: .L311:
2419: jmp .L314
2420: .L310:
2421: MOVW 0x28(%fp),%r0
2422: PUSHW %ap
2423: MOVW 0x2c(%fp),%ap
2424: .L317:
2425: ROTW %r4,0(%r8),%r1
2426: ANDW3 %r0,%r1,%r2
2427: XORW2 %r2,0(%r7)
2428: ANDW2 %ap,%r1
2429: XORW2 %r1,4(%r7)
2430: ADDW2 %r6, %r8
2431: ADDW2 %r5, %r7
2432: .L316:
2433: # }
2434: # else
2435: # {
2436: # asm(" MOVW 0x28(%fp),%r0"); /* store mask3 in a reg */
2437: # asm(" PUSHW %ap"); /* store ap on stack */
2438: # asm(" MOVW 0x2c(%fp),%ap"); /* store mask4 in a reg */
2439: # do {
2440: # asm(" ROTW %r4,0(%r8),%r1");
2441: # asm(" ANDW3 %r0,%r1,%r2");
2442: # asm(" XORW2 %r2,0(%r7)");
2443: # asm(" ANDW2 %ap,%r1");
2444: # asm(" XORW2 %r1,4(%r7)");
2445: # asm(" ADDW2 %r6, %r8");
2446: # asm(" ADDW2 %r5, %r7");
2447: # } while (--i > 0);
2448: subw2 &1,%r3
2449: jpos .L317
2450: .L315:
2451: POPW %ap
2452: .L314:
2453: jmp .L231
2454: .L318:
2455: MOVW 0x20(%fp),%r0
2456: PUSHW %ap
2457: MOVW 0x24(%fp),%ap
2458: # asm(" POPW %ap"); /* restore ap from stack */
2459: # }
2460: # break;
2461: # case F_XOR | S_STRADDLE | D_STRADDLE:
2462: # asm(" MOVW 0x20(%fp),%r0"); /* store mask1 in a reg */
2463: # asm(" PUSHW %ap"); /* store ap on stack */
2464: # asm(" MOVW 0x24(%fp),%ap"); /* store mask2 in a reg */
2465: # if (a > 16){ /* not super narrow */
2466: cmpw 0(%fp),&16
2467: jle .L319
2468: .L322:
2469: ANDW3 %r0,0(%r8),%r1
2470: ANDW3 %ap,4(%r8),%r2
2471: ORW2 %r2,%r1
2472: ROTW %r4,%r1,%r1
2473: ANDW3 0x28(%fp),%r1,%r2
2474: XORW2 %r2,0(%r7)
2475: ANDW2 0x2c(%fp),%r1
2476: XORW2 %r1,4(%r7)
2477: ADDW2 %r6, %r8
2478: ADDW2 %r5, %r7
2479: .L321:
2480: # do {
2481: # asm(" ANDW3 %r0,0(%r8),%r1");
2482: # asm(" ANDW3 %ap,4(%r8),%r2");
2483: # asm(" ORW2 %r2,%r1");
2484: # asm(" ROTW %r4,%r1,%r1");
2485: # asm(" ANDW3 0x28(%fp),%r1,%r2");
2486: # asm(" XORW2 %r2,0(%r7)");
2487: # asm(" ANDW2 0x2c(%fp),%r1");
2488: # asm(" XORW2 %r1,4(%r7)");
2489: # asm(" ADDW2 %r6, %r8");
2490: # asm(" ADDW2 %r5, %r7");
2491: # } while (--i > 0);
2492: subw2 &1,%r3
2493: jpos .L322
2494: .L320:
2495: jmp .L323
2496: .L319:
2497: .L326:
2498: ANDW3 %r0,0(%r8),%r1
2499: ANDW3 %ap,4(%r8),%r2
2500: ORW2 %r2,%r1
2501: ROTW %r4,%r1,%r1
2502: XORH2 %r1,2(%r7)
2503: ANDW2 &0xffff0000,%r1
2504: XORW2 %r1,4(%r7)
2505: ADDW2 %r6, %r8
2506: ADDW2 %r5, %r7
2507: .L325:
2508: # }
2509: # else
2510: # {
2511: # do {
2512: # asm(" ANDW3 %r0,0(%r8),%r1");
2513: # asm(" ANDW3 %ap,4(%r8),%r2");
2514: # asm(" ORW2 %r2,%r1");
2515: # asm(" ROTW %r4,%r1,%r1");
2516: # asm(" XORH2 %r1,2(%r7)");
2517: # asm(" ANDW2 &0xffff0000,%r1");
2518: # asm(" XORW2 %r1,4(%r7)");
2519: # asm(" ADDW2 %r6, %r8");
2520: # asm(" ADDW2 %r5, %r7");
2521: # } while (--i > 0);
2522: subw2 &1,%r3
2523: jpos .L326
2524: .L324:
2525: .L323:
2526: POPW %ap
2527: jmp .L231
2528: .L232:
2529: cmpw %r0,&0
2530: jl .L327
2531: cmpw %r0,&15
2532: jg .L327
2533: ALSW3 &2,%r0,%r0
2534: jmp *.L328(%r0)
2535: .data
2536: .align 4
2537: #SWBEG
2538: .L328:
2539: .word .L233
2540: .word .L249
2541: .word .L275
2542: .word .L301
2543: .word .L237
2544: .word .L253
2545: .word .L279
2546: .word .L305
2547: .word .L241
2548: .word .L257
2549: .word .L283
2550: .word .L309
2551: .word .L245
2552: .word .L266
2553: .word .L292
2554: .word .L318
2555: #SWEND
2556: .text
2557: .L327:
2558: .L231:
2559: jmp .L31
2560: .L31:
2561: .def .ef; .val .; .scl 101; .line 909; .endef
2562: .ln 909
2563: .set .F1,64
2564: .set .R1,6
2565: ret &.R1
2566: .def bitblt; .val .; .scl -1; .endef
2567: .data
2568: # }
2569: # asm(" POPW %ap"); /* restore ap from stack */
2570: # break;
2571: # }
2572: # return;
2573: #}
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.