![[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.