![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to bitblt.c 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.c CVS log | Up to [Research Unix] / researchv9 / jerq / src / lib / j |
1.1 ! root 1: /* BITBLT() Moves bits around on the screen, and does a LOT of it ! 2: * ! 3: * WARNING ! 4: * WARNING: to any future modifier of this code. This is highly ! 5: * hand optimized code, it pushes the frame pointer and ! 6: * references locals off the stack pointer, ! 7: * and it even simulates register ! 8: * allocation. Be very careful if you edit this. ! 9: */ ! 10: ! 11: #include <jerq.h> ! 12: /* alignment codes for narrow rectangles */ ! 13: #define S_STRADDLE 0x4 /* source straddles a word boundary */ ! 14: #define D_STRADDLE 0x8 /* dest straddles a word boundary */ ! 15: #define LEFTDIR 8 ! 16: #define NOSHIFT 4 ! 17: #define DAMMIT 4 /* you'll see why */ ! 18: #undef sw ! 19: #define DX1 m ! 20: ! 21: bitblt(sm,r,dm,p,fc) ! 22: Bitmap *sm,*dm; ! 23: Rectangle r; ! 24: Point p; ! 25: int fc; ! 26: { ! 27: register Word *source,*dest; /* %r8-%r7 */ ! 28: register Word sw, dw; /* %r6-%r5 */ ! 29: register UWord m; /* %r4 */ ! 30: register int i; /* %r3 */ ! 31: ! 32: int a,b,j,h,w,dx1,px31,rx31; ! 33: unsigned int mask1,mask2,mask3,mask4,ntmask1,ntmask2; ! 34: int dummy1, dummy2; /* for future use, CANNOT CHANGE */ ! 35: /* NUMBER OF LOCALS DUE TO %fp */ ! 36: /* TRICKS */ ! 37: /* clip to the source Bitmap */ ! 38: if(r.origin.x < sm->rect.origin.x) ! 39: r.origin.x=sm->rect.origin.x; ! 40: if(r.corner.x > sm->rect.corner.x) ! 41: r.corner.x=sm->rect.corner.x; ! 42: if(r.origin.y < sm->rect.origin.y) ! 43: r.origin.y=sm->rect.origin.y; ! 44: if(r.corner.y > sm->rect.corner.y) ! 45: r.corner.y=sm->rect.corner.y; ! 46: /* ! 47: * If the sm->rect and r are disjoint, r is now degenerate, ! 48: * due to the clipping, and the next clipping code will reject it. ! 49: * This is safe because we will only increase origin or decrease corner. ! 50: */ ! 51: /* clip to the destination Bitmap */ ! 52: if(p.x < dm->rect.origin.x){ ! 53: r.origin.x+=dm->rect.origin.x-p.x; ! 54: p.x=dm->rect.origin.x; ! 55: } ! 56: if(p.y < dm->rect.origin.y){ ! 57: r.origin.y+=dm->rect.origin.y-p.y; ! 58: p.y=dm->rect.origin.y; ! 59: } ! 60: if(r.corner.x-r.origin.x > dm->rect.corner.x-p.x) ! 61: r.corner.x=r.origin.x+(dm->rect.corner.x-p.x); ! 62: if(r.corner.y-r.origin.y > dm->rect.corner.y-p.y) ! 63: r.corner.y=r.origin.y+(dm->rect.corner.y-p.y); ! 64: i = r.corner.y - r.origin.y; /* going to be h */ ! 65: dw = r.corner.x - r.origin.x - 1; /* going to be dx1 */ ! 66: if (i <= 0 || dw < 0) ! 67: return; ! 68: if (dw < 32) ! 69: goto narrow; ! 70: DX1 = dw; ! 71: h = i; ! 72: ntmask1 = topbits[p.x & 0x1f]; ! 73: mask1 = ~ntmask1; ! 74: mask2 = topbits[((p.x+DX1) & 31) + 1]; ! 75: ntmask2 = ~mask2; ! 76: w = ((p.x+DX1) >> 5) - (p.x >> 5); /* inner loop+1: sub 1 later*/ ! 77: sw = ((sm->width - w) << 2); /* sleazy hack to avoid shift */ ! 78: dw = ((dm->width - w) << 2); /* in outer, inner loops */ ! 79: if (sm == dm) { /* may have to mess with loop order */ ! 80: if (r.origin.y < p.y) { /* swap top with bottom */ ! 81: r.origin.y += i-1; ! 82: p.y += i-1; ! 83: if (r.origin.x < p.x) { /* swap left with right */ ! 84: fc |= LEFTDIR; ! 85: r.origin.x = r.origin.x + DX1; ! 86: p.x = p.x + DX1; ! 87: sw = -sw; ! 88: dw = -dw; ! 89: } ! 90: else ! 91: { ! 92: sw -= (sm->width << 3); /* -(w+n) == (w-n) - 2*w */ ! 93: dw -= (dm->width << 3) ; ! 94: } ! 95: } ! 96: else ! 97: { ! 98: if (r.origin.x < p.x) { /* swap left with right */ ! 99: fc |= LEFTDIR; ! 100: r.origin.x = r.origin.x + DX1; ! 101: p.x = p.x + DX1; ! 102: sw = (sm->width + w) << 2; ! 103: dw = (dm->width + w) << 2; ! 104: } ! 105: } ! 106: } ! 107: w--; /* subtract the 1 like we promised */ ! 108: px31 = p.x & 0x1f; /* commonly used expression */ ! 109: rx31 = r.origin.x & 0x1f; /* commonly used expression */ ! 110: dest = addr(dm,p); ! 111: source = addr(sm,r.origin); ! 112: a = px31 - rx31; ! 113: if(a == 0) ! 114: fc |= NOSHIFT; ! 115: else if (a < 0) ! 116: a += 32; ! 117: /* a == 0 means no shift, remember that */ ! 118: b = 32 - a; ! 119: switch (fc) { ! 120: ! 121: case F_OR | NOSHIFT | LEFTDIR: ! 122: b = w>>2; ! 123: w = w&3; ! 124: m = h; /* m is free => use it */ ! 125: do { ! 126: *dest-- |= mask2 & *source--; ! 127: if ((i = b) > 0) do { ! 128: *dest |= *source; ! 129: *(dest-1) |= *(source-1); ! 130: *(dest-2) |= *(source-2); ! 131: *(dest-3) |= *(source-3); ! 132: dest -= 4; ! 133: source -= 4; ! 134: } while (--i > 0); ! 135: if ((i = w) > 0) do { ! 136: *dest-- |= *source--; ! 137: } while (--i > 0); ! 138: *dest |= mask1 & *source; ! 139: asm(" ADDW2 %r6,%r8"); /*source += sw; */ ! 140: asm(" ADDW2 %r5,%r7"); /*dest += dw; */ ! 141: } while (--m != 0); ! 142: break; ! 143: case F_OR | LEFTDIR: ! 144: if ((px31) < (rx31)) ! 145: source++; /* adjust for pipeline */ ! 146: do { ! 147: m = *source--; /* m is a free register */ ! 148: *dest-- |= (((m >> a) | (*source << b)) & mask2); ! 149: if ((i=w) > 0) do { ! 150: m = (*source--) >> a; ! 151: *dest-- |= m | (*source << b); ! 152: } while (--i > 0); ! 153: m = *source; /* m is a free register */ ! 154: *dest |= (((m >> a) | (*(source-1) << b)) & mask1); ! 155: asm(" addw2 %r6,%r8"); /*source += sw; */ ! 156: asm(" addw2 %r5,%r7"); /*dest += dw; */ ! 157: } while (--h > 0); ! 158: break; ! 159: case F_OR | NOSHIFT: ! 160: b = w>>2; ! 161: w = w&3; ! 162: m = h; /* m is free => use it */ ! 163: do { ! 164: *dest++ |= (mask1 & *source++); ! 165: if ((i = b) > 0) do { ! 166: *dest |= *source; ! 167: *(dest+1) |= *(source+1); ! 168: *(dest+2) |= *(source+2); ! 169: *(dest+3) |= *(source+3); ! 170: dest += 4; ! 171: source += 4; ! 172: } while (--i > 0); ! 173: if ((i = w) > 0) do { ! 174: *dest++ |= *source++; ! 175: } while (--i > 0); ! 176: *dest |= (mask2 & *source); ! 177: asm(" addw2 %r6,%r8"); /*source += sw; */ ! 178: asm(" addw2 %r5,%r7"); /*dest += dw; */ ! 179: } while (--m != 0); ! 180: break; ! 181: case F_OR: ! 182: if ((px31) > (rx31)) ! 183: source--; /* adjust for pipeline */ ! 184: do { ! 185: m = *source++; /* m is a free register */ ! 186: *dest++ |= (((m << b) | (*source >> a)) & mask1); ! 187: if ((i=w) > 0) do { ! 188: m = (*source++) << b; ! 189: *dest++ |= m | (*source >> a); ! 190: } while (--i > 0); ! 191: m = *source; /* m is a free register */ ! 192: *dest |= (((m << b) | (*(source+1) >> a)) & mask2); ! 193: asm(" addw2 %r6,%r8"); /*source += sw; */ ! 194: asm(" addw2 %r5,%r7"); /*dest += dw; */ ! 195: } while (--h > 0); ! 196: break; ! 197: case F_CLR | NOSHIFT | LEFTDIR: ! 198: b = w>>2; ! 199: w = w&3; ! 200: m = h; /* m is free => use it */ ! 201: do { ! 202: *dest-- &= ~(mask2 & *source--); ! 203: if ((i = b) > 0) do { ! 204: *dest &= ~(*source); ! 205: *(dest-1) &= ~(*(source-1)); ! 206: *(dest-2) &= ~(*(source-2)); ! 207: *(dest-3) &= ~(*(source-3)); ! 208: dest -= 4; ! 209: source -= 4; ! 210: } while (--i > 0); ! 211: if ((i = w) > 0) do { ! 212: *dest-- &= ~(*source--); ! 213: } while (--i > 0); ! 214: *dest &= ~(mask1 & *source); ! 215: asm(" addw2 %r6,%r8"); /*source += sw; */ ! 216: asm(" addw2 %r5,%r7"); /*dest += dw; */ ! 217: } while (--m != 0); ! 218: break; ! 219: case F_CLR | LEFTDIR: ! 220: if ((px31) < (rx31)) ! 221: source++; /* adjust for pipeline */ ! 222: do { ! 223: m = *source--; /* m is a free register */ ! 224: *dest-- &= ~((((m >> a) | (*source << b)) & mask2)); ! 225: if ((i=w) > 0) do { ! 226: m = (*source--) >> a; ! 227: *dest-- &= ~(m | (*source << b)); ! 228: } while (--i > 0); ! 229: m = *source; /* m is a free register */ ! 230: *dest &= ~((((m >> a) | (*(source-1) << b)) & mask1)); ! 231: asm(" addw2 %r6,%r8"); /*source += sw; */ ! 232: asm(" addw2 %r5,%r7"); /*dest += dw; */ ! 233: } while (--h > 0); ! 234: break; ! 235: case F_CLR | NOSHIFT: ! 236: b = w>>2; ! 237: w = w&3; ! 238: m = h; /* m is free => use it */ ! 239: do { ! 240: *dest++ &= ~((mask1 & *source++)); ! 241: if ((i = b) > 0) do { ! 242: *dest &= ~(*source); ! 243: *(dest+1) &= ~(*(source+1)); ! 244: *(dest+2) &= ~(*(source+2)); ! 245: *(dest+3) &= ~(*(source+3)); ! 246: dest += 4; ! 247: source += 4; ! 248: } while (--i > 0); ! 249: if ((i = w) > 0) do { ! 250: *dest++ &= ~(*source++); ! 251: } while (--i > 0); ! 252: *dest &= ~((mask2 & *source)); ! 253: asm(" addw2 %r6,%r8"); /*source += sw; */ ! 254: asm(" addw2 %r5,%r7"); /*dest += dw; */ ! 255: } while (--m != 0); ! 256: break; ! 257: case F_CLR: ! 258: if ((px31) > (rx31)) ! 259: source--; /* adjust for pipeline */ ! 260: do { ! 261: m = *source++; /* m is a free register */ ! 262: *dest++ &= ~((((m << b) | (*source >> a)) & mask1)); ! 263: if ((i=w) > 0) do { ! 264: m = (*source++) << b; ! 265: *dest++ &= ~(m | (*source >> a)); ! 266: } while (--i > 0); ! 267: m = *source; /* m is a free register */ ! 268: *dest &= ~((((m << b) | (*(source+1) >> a)) & mask2)); ! 269: asm(" addw2 %r6,%r8"); /*source += sw; */ ! 270: asm(" addw2 %r5,%r7"); /*dest += dw; */ ! 271: } while (--h > 0); ! 272: break; ! 273: case F_XOR | NOSHIFT | LEFTDIR: ! 274: b = w>>2; ! 275: w = w&3; ! 276: m = h; /* m is free => use it */ ! 277: do { ! 278: *dest-- ^= mask2 & *source--; ! 279: if ((i = b) > 0) do { ! 280: *dest ^= *source; ! 281: *(dest-1) ^= *(source-1); ! 282: *(dest-2) ^= *(source-2); ! 283: *(dest-3) ^= *(source-3); ! 284: dest -= 4; ! 285: source -= 4; ! 286: } while (--i > 0); ! 287: if ((i = w) > 0) do { ! 288: *dest-- ^= *source--; ! 289: } while (--i > 0); ! 290: *dest ^= mask1 & *source; ! 291: asm(" addw2 %r6,%r8"); /*source += sw; */ ! 292: asm(" addw2 %r5,%r7"); /*dest += dw; */ ! 293: } while (--m != 0); ! 294: break; ! 295: case F_XOR | LEFTDIR: ! 296: if ((px31) < (rx31)) ! 297: source++; /* adjust for pipeline */ ! 298: do { ! 299: m = *source--; /* m is a free register */ ! 300: *dest-- ^= (((m >> a) | (*source << b)) & mask2); ! 301: if ((i=w) > 0) do { ! 302: m = (*source--) >> a; ! 303: *dest-- ^= m | (*source << b); ! 304: } while (--i > 0); ! 305: m = *source; /* m is a free register */ ! 306: *dest ^= (((m >> a) | (*(source-1) << b)) & mask1); ! 307: asm(" addw2 %r6,%r8"); /*source += sw; */ ! 308: asm(" addw2 %r5,%r7"); /*dest += dw; */ ! 309: } while (--h > 0); ! 310: break; ! 311: case F_XOR | NOSHIFT: ! 312: b = w>>2; ! 313: w = w&3; ! 314: m = h; /* m is free => use it */ ! 315: do { ! 316: *dest++ ^= (mask1 & *source++); ! 317: if ((i = b) > 0) do { ! 318: *dest ^= *source; ! 319: *(dest+1) ^= *(source+1); ! 320: *(dest+2) ^= *(source+2); ! 321: *(dest+3) ^= *(source+3); ! 322: dest += 4; ! 323: source += 4; ! 324: } while (--i > 0); ! 325: if ((i = w) > 0) do { ! 326: *dest++ ^= *source++; ! 327: } while (--i > 0); ! 328: *dest ^= (mask2 & *source); ! 329: asm(" addw2 %r6,%r8"); /*source += sw; */ ! 330: asm(" addw2 %r5,%r7"); /*dest += dw; */ ! 331: } while (--m != 0); ! 332: break; ! 333: case F_XOR: ! 334: if ((px31) > (rx31)) ! 335: source--; /* adjust for pipeline */ ! 336: asm(" PUSHW %ap"); ! 337: m = topbits[a]; ! 338: asm(" MCOMW %r4, %r1"); ! 339: asm(" MOVW %r4, %r2"); ! 340: asm(" MOVW 0(%fp),%ap"); ! 341: asm(" PUSHW %fp"); ! 342: asm("BW_XORLOOP:"); ! 343: asm(" ROTW %ap, 0(%r8), %r4"); ! 344: asm(" ANDW2 %r2,%r4"); ! 345: asm(" ADDW2 &4,%r8"); ! 346: asm(" ROTW %ap,0(%r8),%r0"); ! 347: asm(" ANDW3 %r0,%r1,%fp"); ! 348: asm(" ORW2 %r4,%fp"); ! 349: asm(" ANDW2 -0x28(%sp),%fp"); ! 350: asm(" XORW2 %fp,0(%r7)"); ! 351: asm(" ADDW2 &4,%r7"); ! 352: /* if (i = w) */ ! 353: asm(" MOVW -0x38(%sp),%r3"); ! 354: asm(" BEB BW_XORINNER"); ! 355: do{ ! 356: asm(" ANDW3 %r2,%r0,%r4"); ! 357: asm(" ADDW2 &4,%r8"); ! 358: asm(" ROTW %ap, 0(%r8),%r0"); ! 359: asm(" ANDW3 %r0,%r1,%fp"); ! 360: asm(" ORW2 %r4,%fp"); ! 361: asm(" XORW2 %fp,0(%r7)"); ! 362: asm(" ADDW2 &4, %r7"); ! 363: } while (--i > 0); ! 364: asm("BW_XORINNER:"); ! 365: asm(" ROTW %ap, 0(%r8),%r4"); ! 366: asm(" ANDW2 %r2,%r4"); ! 367: asm(" LRSW3 %ap, 4(%r8),%r0"); ! 368: asm(" ORW2 %r4,%r0"); ! 369: asm(" ANDW2 -0x24(%sp),%r0"); ! 370: asm(" XORW2 %r0,0(%r7)"); ! 371: asm(" ADDW2 %r6,%r8"); /*source += sw; */ ! 372: asm(" ADDW2 %r5,%r7"); /*dest += dw; */ ! 373: /* } while (--h > 0); */ ! 374: asm(" DECW -0x3c(%sp)"); ! 375: asm(" BGB BW_XORLOOP"); ! 376: ! 377: asm(" POPW %fp"); ! 378: asm(" POPW %ap"); ! 379: ! 380: /* above is similar to: ! 381: /* do { ! 382: /* m = *source++ << b; /* m is a free register */ ! 383: /* *dest++ ^= ((m & LMASK) | ((*source >> a)& RMASK) & mask1); ! 384: /* if ((i=w) > 0) do { ! 385: /* m = ((*source++) << b) & LMASK; ! 386: /* *dest++ ^= m | ((*source >> a)&RMASK); ! 387: /* } while (--i > 0); ! 388: /* m = *source; /* m is a free register */ ! 389: /* *dest ^= (((m << b) | (*(source+1) >> a)) & mask2); ! 390: /* asm(" addw2 %r6,%r8"); /*source += sw; */ ! 391: /* asm(" addw2 %r5,%r7"); /*dest += dw; */ ! 392: /* } while (--h > 0); */ ! 393: break; ! 394: case F_STORE | NOSHIFT | LEFTDIR: ! 395: b = w>>2; ! 396: w = w&3; ! 397: m = h; /* m is free => use it */ ! 398: do { ! 399: *dest = (ntmask2 & *dest) | (mask2 & *source--); ! 400: --dest; ! 401: if ((i = b) > 0) do { ! 402: *dest = *source; ! 403: *(dest-1) = *(source-1); ! 404: *(dest-2) = *(source-2); ! 405: *(dest-3) = *(source-3); ! 406: dest -= 4; ! 407: source -= 4; ! 408: } while (--i > 0); ! 409: if ((i = w) > 0) do { ! 410: *dest-- = *source--; ! 411: } while (--i > 0); ! 412: *dest = (ntmask1 & *dest) | (mask1 & *source); ! 413: asm(" addw2 %r6,%r8"); /*source += sw; */ ! 414: asm(" addw2 %r5,%r7"); /*dest += dw; */ ! 415: } while (--m != 0); ! 416: break; ! 417: case F_STORE | LEFTDIR: ! 418: if ((px31) < (rx31)) ! 419: source++; /* adjust for pipeline */ ! 420: do { ! 421: m = *source--; /* m is a free register */ ! 422: *dest = (((m >> a) | (*source << b)) & mask2) | ! 423: (*dest & ntmask2); ! 424: --dest; ! 425: if ((i=w) > 0) do { ! 426: m = (*source--) >> a; ! 427: *dest-- = m | (*source << b); ! 428: } while (--i > 0); ! 429: m = *source; /* m is a free register */ ! 430: *dest = (((m >> a) | (*(source-1) << b)) & mask1) | ! 431: (*dest & ntmask1); ! 432: asm(" addw2 %r6,%r8"); /*source += sw; */ ! 433: asm(" addw2 %r5,%r7"); /*dest += dw; */ ! 434: } while (--h > 0); ! 435: break; ! 436: case F_STORE | NOSHIFT: ! 437: if (w > 25) ! 438: goto widestore; ! 439: i = 25 - w; ! 440: m = (i << 2) + (i << 1); ! 441: ! 442: asm(" LLSW3 &0x2,0x10(%fp),%r0"); /* bytewidth in r0*/ ! 443: asm(" ADDW2 &4,%r0"); /* r0 +=4 for loop offsets */ ! 444: asm(" MOVAW B_FS_N,%r1"); ! 445: asm(" ADDW2 %r4,%r1"); /* r1 += &label, or jump addr*/ ! 446: m = h; /* m is free reg, use it as height */ ! 447: asm(" MOVW 0x20(%fp),%r2"); /* r2 = mask1 */ ! 448: asm(" PUSHW %ap"); /* save fp and ap */ ! 449: asm(" MOVW 0x24(%fp),%ap"); /* ap = mask2 */ ! 450: asm(" PUSHW %fp"); ! 451: asm(" MOVW %r1,%fp"); /* put jump index into fp */ ! 452: ! 453: do{ ! 454: ! 455: asm(" XORW3 0(%r7),0(%r8),%r1"); ! 456: asm(" ANDW2 %r2,%r1"); ! 457: asm(" XORW2 %r1,0(%r7)"); ! 458: ! 459: asm(" JMP 0(%fp)"); ! 460: asm("B_FS_N: "); /* label */ ! 461: asm(" MOVW 0x64(%r8),0x64(%r7)"); ! 462: asm(" MOVW 0x60(%r8),0x60(%r7)"); asm(" MOVW 0x5c(%r8),0x5c(%r7)"); ! 463: asm(" MOVW 0x58(%r8),0x58(%r7)"); asm(" MOVW 0x54(%r8),0x54(%r7)"); ! 464: asm(" MOVW 0x50(%r8),0x50(%r7)"); asm(" MOVW 0x4c(%r8),0x4c(%r7)"); asm(" MOVW 0x48(%r8),0x48(%r7)"); asm(" MOVW 0x44(%r8),0x44(%r7)"); ! 465: asm(" MOVW 0x40(%r8),0x40(%r7)"); asm(" MOVW 0x3c(%r8),0x3c(%r7)"); asm(" MOVW 0x38(%r8),0x38(%r7)"); asm(" MOVW 0x34(%r8),0x34(%r7)"); ! 466: asm(" MOVW 0x30(%r8),0x30(%r7)"); asm(" MOVW 0x2c(%r8),0x2c(%r7)"); asm(" MOVW 0x28(%r8),0x28(%r7)"); asm(" MOVW 0x24(%r8),0x24(%r7)"); ! 467: asm(" MOVW 0x20(%r8),0x20(%r7)"); asm(" MOVW 0x1c(%r8),0x1c(%r7)"); asm(" MOVW 0x18(%r8),0x18(%r7)"); ! 468: asm(" MOVW 0x14(%r8),0x14(%r7)"); ! 469: asm(" MOVW 0x10(%r8),0x10(%r7)"); ! 470: asm(" MOVW 0xc(%r8),0xc(%r7)"); ! 471: asm(" MOVW 0x8(%r8),0x8(%r7)"); ! 472: asm(" MOVW 0x4(%r8),0x4(%r7)"); ! 473: asm(" ADDW2 %r0,%r8"); ! 474: asm(" ADDW2 %r0,%r7"); ! 475: asm(" XORW3 0(%r7),0(%r8),%r1"); ! 476: asm(" ANDW2 %ap,%r1"); /* ap has mask2 */ ! 477: asm(" XORW2 %r1,0(%r7)"); ! 478: asm(" ADDW2 %r6,%r8"); ! 479: asm(" ADDW2 %r5,%r7"); ! 480: } while (--m != 0); ! 481: asm(" POPW %fp"); ! 482: asm(" POPW %ap"); ! 483: break; ! 484: /* ABOVE ALMOST EQUAL TO : */ ! 485: widestore: ! 486: b = w >> 2; ! 487: w = w & 3; ! 488: m = h; ! 489: do { ! 490: *dest = (ntmask1 & *dest) | (mask1 & *source++); ! 491: dest++; ! 492: if ((i = b) > 0) do { ! 493: *dest = *source; ! 494: *(dest+1) = *(source+1); ! 495: *(dest+2) = *(source+2); ! 496: *(dest+3) = *(source+3); ! 497: dest += 4; ! 498: source += 4; ! 499: } while (--i > 0); ! 500: if ((i = w) > 0) do { ! 501: *dest++ = *source++; ! 502: } while (--i > 0); ! 503: *dest = (ntmask2 & *dest) | (mask2 & *source); ! 504: asm(" addw2 %r6,%r8"); ! 505: asm(" addw2 %r5,%r7"); ! 506: } while (--m != 0); ! 507: break; ! 508: case F_STORE: ! 509: if ((px31) > (rx31)) ! 510: source--; /* adjust for pipeline */ ! 511: do { ! 512: m = *source++; /* m is a free register */ ! 513: *dest = (((m << b) | (*source >> a)) & mask1) | ! 514: (*dest & ntmask1); ! 515: dest++; ! 516: if ((i=w) > 0) do { ! 517: m = (*source++) << b; ! 518: *dest++ = m | (*source >> a); ! 519: } while (--i > 0); ! 520: m = *source; /* m is a free register */ ! 521: *dest = (((m << b) | (*(source+1) >> a)) & mask2) | ! 522: (*dest & ntmask2); ! 523: asm(" addw2 %r6,%r8"); /*source += sw; */ ! 524: asm(" addw2 %r5,%r7"); /*dest += dw; */ ! 525: } while (--h > 0); ! 526: break; ! 527: } ! 528: ! 529: return; ! 530: narrow: ! 531: /* ! 532: * width is 32 bits or less. There are four basic cases ! 533: * (in addition to the function code), which depend on whether ! 534: * the source and dest straddle word boundaries or not ! 535: */ ! 536: ! 537: m = p.x & 31; /* commonly used expression */ ! 538: sw = r.origin.x & 31; /* commonly used expression */ ! 539: if (sw + dw > 31) /* if source is NOT aligned */ ! 540: { ! 541: fc |= S_STRADDLE; ! 542: mask1 = ONES >> sw; ! 543: mask2 = topbits[((sw + dw) & 31) + 1]; ! 544: } ! 545: ! 546: if (m + dw > 31) /* if dest is NOT aligned */ ! 547: { ! 548: fc |= D_STRADDLE; ! 549: mask3 = ONES >> m; ! 550: mask4 = topbits[((m + dw) & 31) + 1]; ! 551: } ! 552: px31 = m; ! 553: m = m - sw; ! 554: a = dw; ! 555: ! 556: if ((sm == dm) && (r.origin.y < p.y)) ! 557: { /* may have to mess with loop order */ ! 558: r.origin.y += i-1; ! 559: p.y += i-1; ! 560: sw = -(sm->width << 2); /* sleazy hack to avoid shift */ ! 561: dw = -(dm->width << 2); /* in outer, inner loops */ ! 562: } ! 563: else ! 564: { ! 565: sw = sm->width << 2; ! 566: dw = dm->width << 2; ! 567: } ! 568: ! 569: source = addr(sm,r.origin); ! 570: dest = addr(dm,p); ! 571: ! 572: switch(fc) ! 573: { ! 574: case F_STORE: ! 575: mask1 = topbits[a+1] >> (px31); ! 576: asm(" MOVW 0x20(%fp),%r1"); ! 577: do { ! 578: asm(" ROTW %r4,0(%r8),%r2"); ! 579: asm(" XORW2 0(%r7),%r2"); ! 580: asm(" ANDW2 %r1,%r2"); ! 581: asm(" XORW2 %r2,0(%r7)"); ! 582: asm(" ADDW2 %r6, %r8"); ! 583: asm(" ADDW2 %r5, %r7"); ! 584: } while (--i > 0); ! 585: break; ! 586: case F_STORE | S_STRADDLE: ! 587: mask4 = 32 - m; /* REALLY the other shift count */ ! 588: mask3 = topbits[a+1] >> px31; ! 589: asm(" PUSHW %ap"); /* store ap on stack */ ! 590: asm(" MOVW 0x28(%fp),%r0"); /* put mask3 in r0 */ ! 591: asm(" MOVW 0x2c(%fp),%ap"); /* put other shift in ap */ ! 592: ! 593: do { ! 594: asm(" LLSW3 %ap,0(%r8),%r1"); /* 32-m,lft shft */ ! 595: asm(" LRSW3 %r4,4(%r8),%r2"); /* m, right shift */ ! 596: asm(" ORW2 %r2, %r1"); ! 597: asm(" XORW2 0(%r7),%r1"); ! 598: asm(" ANDW2 %r0,%r1"); ! 599: asm(" XORW2 %r1,0(%r7)"); ! 600: asm(" ADDW2 %r6, %r8"); ! 601: asm(" ADDW2 %r5, %r7"); ! 602: } while (--i > 0); ! 603: asm(" POPW %ap"); /* restore ap from stack */ ! 604: break; ! 605: case F_STORE | D_STRADDLE: ! 606: asm(" PUSHW %ap"); /* store ap on stack */ ! 607: asm(" MOVW 0x28(%fp),%r0"); /* put mask3 in r0 */ ! 608: asm(" MOVW 0x2c(%fp),%ap"); /* put mask4 in ap */ ! 609: do { ! 610: asm(" ROTW %r4,0(%r8),%r1"); ! 611: asm(" XORW3 0(%r7),%r1,%r2"); ! 612: asm(" ANDW2 %r0,%r2"); ! 613: asm(" XORW2 %r2,0(%r7)"); ! 614: asm(" XORW2 4(%r7),%r1"); ! 615: asm(" ANDW2 %ap,%r1"); ! 616: asm(" XORW2 %r1,4(%r7)"); ! 617: asm(" ADDW2 %r6, %r8"); ! 618: asm(" ADDW2 %r5, %r7"); ! 619: } while (--i > 0); ! 620: asm(" POPW %ap"); /* restore ap from stack */ ! 621: break; ! 622: case F_STORE | S_STRADDLE | D_STRADDLE: ! 623: asm(" PUSHW %ap"); /* store ap on stack */ ! 624: asm(" SUBW3 %r4,&0x20,%ap"); /* right shift distance */ ! 625: asm(" MOVW 0x20(%fp),%r0"); /* r0 <- mask1 */ ! 626: asm(" MOVW 0x24(%fp),%r2"); /* r2 <- mask2 */ ! 627: asm(" PUSHW %fp"); /* store fp on stack */ ! 628: do { ! 629: asm(" ANDW3 %r0, 0(%r8), %r1"); ! 630: asm(" ANDW3 %r2, 4(%r8),%ap"); ! 631: asm(" ORW2 %ap, %r1"); ! 632: asm(" ROTW %r4, %r1, %r1"); ! 633: asm(" XORW3 0(%r7), %r1, %ap"); ! 634: asm(" ANDW2 0x28(%fp), %ap"); ! 635: asm(" XORW2 %ap, 0(%r7)"); ! 636: asm(" XORW2 4(%r7), %r1"); ! 637: asm(" ANDW2 0x2c(%fp), %r1"); ! 638: asm(" XORW2 %r1, 4(%r7)"); ! 639: asm(" ADDW2 %r6, %r8"); ! 640: asm(" ADDW2 %r5, %r7"); ! 641: } while (--i > 0); ! 642: asm(" POPW %fp"); /* restore fp from stack */ ! 643: asm(" POPW %ap"); /* restore ap from stack */ ! 644: break; ! 645: case F_OR: ! 646: mask1 = topbits[a+1] >> px31; ! 647: asm(" MOVW 0x20(%fp),%r1"); /* mask1 */ ! 648: do { ! 649: asm(" ROTW %r4,0(%r8),%r2"); ! 650: asm(" ANDW2 %r1,%r2"); ! 651: asm(" ORW2 %r2,0(%r7)"); ! 652: asm(" ADDW2 %r6, %r8"); ! 653: asm(" ADDW2 %r5, %r7"); ! 654: } while (--i > 0); ! 655: break; ! 656: case F_OR | S_STRADDLE: ! 657: asm(" MOVW 0x20(%fp),%r0"); /* store mask1 in a reg */ ! 658: asm(" PUSHW %ap"); /* store ap on stack */ ! 659: asm(" MOVW 0x24(%fp),%ap"); /* store mask1 in a reg */ ! 660: ! 661: do { ! 662: asm(" ANDW3 %r0,0(%r8),%r2"); /* x20(fp)=mask1 */ ! 663: asm(" ANDW3 %ap,4(%r8),%r1"); /* x24(fp)=mask2 */ ! 664: asm(" ORW2 %r2,%r1"); ! 665: asm(" ROTW %r4,%r1,%r1"); ! 666: asm(" ORW2 %r1,0(%r7)"); ! 667: asm(" ADDW2 %r6, %r8"); ! 668: asm(" ADDW2 %r5, %r7"); ! 669: } while (--i > 0); ! 670: asm(" POPW %ap"); /* restore ap from stack */ ! 671: break; ! 672: case F_OR | D_STRADDLE: ! 673: if (a <= 16) /* very narrow, 17 bits max */ ! 674: { ! 675: asm(" MOVW &0xffff0000,%r2"); ! 676: asm(" ORW3 0x28(%fp),0x2c(%fp),%r0"); /* compute mask */ ! 677: do { ! 678: asm(" ROTW %r4,0(%r8),%r1"); ! 679: asm(" ANDW2 %r0,%r1"); /* mask */ ! 680: asm(" ORH2 %r1,2(%r7)"); ! 681: asm(" ANDW2 %r2, %r1"); ! 682: asm(" ORW2 %r1, 4(%r7)"); ! 683: asm(" ADDW2 %r6, %r8"); ! 684: asm(" ADDW2 %r5, %r7"); ! 685: } while (--i > 0); ! 686: } ! 687: else ! 688: { ! 689: asm(" MOVW 0x28(%fp),%r0"); /* store mask3 in a reg */ ! 690: asm(" PUSHW %ap"); /* store ap on stack */ ! 691: asm(" MOVW 0x2c(%fp),%ap"); /* store mask4 in a reg */ ! 692: do { ! 693: asm(" ROTW %r4,0(%r8),%r1"); ! 694: asm(" ANDW3 %r0,%r1,%r2"); ! 695: asm(" ORW2 %r2,0(%r7)"); ! 696: asm(" ANDW2 %ap,%r1"); ! 697: asm(" ORW2 %r1,4(%r7)"); ! 698: asm(" ADDW2 %r6, %r8"); ! 699: asm(" ADDW2 %r5, %r7"); ! 700: } while (--i > 0); ! 701: asm(" POPW %ap"); /* restore ap from stack */ ! 702: } ! 703: break; ! 704: case F_OR | S_STRADDLE | D_STRADDLE: ! 705: asm(" MOVW 0x20(%fp),%r0"); /* store mask1 in a reg */ ! 706: asm(" PUSHW %ap"); /* store ap on stack */ ! 707: asm(" MOVW 0x24(%fp),%ap"); /* store mask2 in a reg */ ! 708: if (a > 16){ /* not super narrow */ ! 709: do { ! 710: asm(" ANDW3 %r0,0(%r8),%r1"); ! 711: asm(" ANDW3 %ap,4(%r8),%r2"); ! 712: asm(" ORW2 %r2,%r1"); ! 713: asm(" ROTW %r4,%r1,%r1"); ! 714: asm(" ANDW3 0x28(%fp),%r1,%r2"); ! 715: asm(" ORW2 %r2,0(%r7)"); ! 716: asm(" ANDW2 0x2c(%fp),%r1"); ! 717: asm(" ORW2 %r1,4(%r7)"); ! 718: asm(" ADDW2 %r6, %r8"); ! 719: asm(" ADDW2 %r5, %r7"); ! 720: } while (--i > 0); ! 721: } ! 722: else ! 723: { ! 724: do { ! 725: asm(" ANDW3 %r0,0(%r8),%r1"); ! 726: asm(" ANDW3 %ap,4(%r8),%r2"); ! 727: asm(" ORW2 %r2,%r1"); ! 728: asm(" ROTW %r4,%r1,%r1"); ! 729: asm(" ORH2 %r1,2(%r7)"); ! 730: asm(" ANDW2 &0xffff0000,%r1"); ! 731: asm(" ORW2 %r1,4(%r7)"); ! 732: asm(" ADDW2 %r6, %r8"); ! 733: asm(" ADDW2 %r5, %r7"); ! 734: } while (--i > 0); ! 735: } ! 736: asm(" POPW %ap"); /* restore ap from stack */ ! 737: break; ! 738: case F_CLR: ! 739: mask1 = topbits[a+1] >> px31; ! 740: asm(" MOVW 0x20(%fp),%r1"); /* mask1 */ ! 741: do { ! 742: asm(" ROTW %r4,0(%r8),%r2"); ! 743: asm(" ANDW2 %r1,%r2"); ! 744: asm(" MCOMW %r2,%r2"); ! 745: asm(" ANDW2 %r2,0(%r7)"); ! 746: asm(" ADDW2 %r6, %r8"); ! 747: asm(" ADDW2 %r5, %r7"); ! 748: } while (--i > 0); ! 749: break; ! 750: case F_CLR | S_STRADDLE: ! 751: asm(" MOVW 0x20(%fp),%r0"); /* store mask1 in a reg */ ! 752: asm(" PUSHW %ap"); /* store ap on stack */ ! 753: asm(" MOVW 0x24(%fp),%ap"); /* store mask1 in a reg */ ! 754: ! 755: do { ! 756: asm(" ANDW3 %r0,0(%r8),%r2"); /* x20(fp)=mask1 */ ! 757: asm(" ANDW3 %ap,4(%r8),%r1"); /* x24(fp)=mask2 */ ! 758: asm(" ORW2 %r2,%r1"); ! 759: asm(" ROTW %r4,%r1,%r1"); ! 760: asm(" MCOMW %r1,%r1"); ! 761: asm(" ANDW2 %r1,0(%r7)"); ! 762: asm(" ADDW2 %r6, %r8"); ! 763: asm(" ADDW2 %r5, %r7"); ! 764: } while (--i > 0); ! 765: asm(" POPW %ap"); /* restore ap from stack */ ! 766: break; ! 767: case F_CLR | D_STRADDLE: ! 768: if (a <= 16) /* very narrow, 17 bits max */ ! 769: { ! 770: asm(" MOVW &0xffff,%r2"); ! 771: asm(" ORW3 0x28(%fp),0x2c(%fp),%r0"); /* compute mask */ ! 772: do { ! 773: asm(" ROTW %r4,0(%r8),%r1"); ! 774: asm(" ANDW2 %r0,%r1"); /* mask */ ! 775: asm(" MCOMW %r1,%r1"); ! 776: asm(" ANDH2 %r1,2(%r7)"); ! 777: asm(" ORW2 %r2,%r1"); ! 778: asm(" ANDW2 %r1,4(%r7)"); ! 779: asm(" ADDW2 %r6, %r8"); ! 780: asm(" ADDW2 %r5, %r7"); ! 781: } while (--i > 0); ! 782: } ! 783: else ! 784: { ! 785: asm(" MOVW 0x28(%fp),%r0"); /* store mask3 in a reg */ ! 786: asm(" PUSHW %ap"); /* store ap on stack */ ! 787: asm(" MOVW 0x2c(%fp),%ap"); /* store mask4 in a reg */ ! 788: do { ! 789: asm(" ROTW %r4,0(%r8),%r1"); ! 790: asm(" ANDW3 %r0,%r1,%r2"); ! 791: asm(" MCOMW %r2,%r2"); ! 792: asm(" ANDW2 %r2,0(%r7)"); ! 793: asm(" ANDW2 %ap,%r1"); ! 794: asm(" MCOMW %r1,%r1"); ! 795: asm(" ANDW2 %r1,4(%r7)"); ! 796: asm(" ADDW2 %r6, %r8"); ! 797: asm(" ADDW2 %r5, %r7"); ! 798: } while (--i > 0); ! 799: asm(" POPW %ap"); /* restore ap from stack */ ! 800: } ! 801: break; ! 802: case F_CLR | S_STRADDLE | D_STRADDLE: ! 803: asm(" MOVW 0x20(%fp),%r0"); /* store mask1 in a reg */ ! 804: asm(" PUSHW %ap"); /* store ap on stack */ ! 805: asm(" MOVW 0x24(%fp),%ap"); /* store mask2 in a reg */ ! 806: if (a > 16){ /* not super narrow */ ! 807: do { ! 808: asm(" ANDW3 %r0,0(%r8),%r1"); ! 809: asm(" ANDW3 %ap,4(%r8),%r2"); ! 810: asm(" ORW2 %r2,%r1"); ! 811: asm(" ROTW %r4,%r1,%r1"); ! 812: asm(" ANDW3 0x28(%fp),%r1,%r2"); ! 813: asm(" MCOMW %r2,%r2"); ! 814: asm(" ANDW2 %r2,0(%r7)"); ! 815: asm(" ANDW2 0x2c(%fp),%r1"); ! 816: asm(" MCOMW %r1,%r1"); ! 817: asm(" ANDW2 %r1,4(%r7)"); ! 818: asm(" ADDW2 %r6, %r8"); ! 819: asm(" ADDW2 %r5, %r7"); ! 820: } while (--i > 0); ! 821: } ! 822: else ! 823: { ! 824: do { ! 825: asm(" ANDW3 %r0,0(%r8),%r1"); ! 826: asm(" ANDW3 %ap,4(%r8),%r2"); ! 827: asm(" ORW2 %r2,%r1"); ! 828: asm(" ROTW %r4,%r1,%r1"); ! 829: asm(" MCOMW %r1,%r1"); ! 830: asm(" ANDH2 %r1,2(%r7)"); ! 831: asm(" ORW2 &0xffff,%r1"); ! 832: asm(" ANDW2 %r1,4(%r7)"); ! 833: asm(" ADDW2 %r6, %r8"); ! 834: asm(" ADDW2 %r5, %r7"); ! 835: } while (--i > 0); ! 836: } ! 837: asm(" POPW %ap"); /* restore ap from stack */ ! 838: break; ! 839: case F_XOR: ! 840: mask1 = topbits[a+1] >> px31; ! 841: asm(" MOVW 0x20(%fp),%r1"); /* mask1 */ ! 842: do { ! 843: asm(" ROTW %r4,0(%r8),%r2"); ! 844: asm(" ANDW2 %r1,%r2"); ! 845: asm(" XORW2 %r2,0(%r7)"); ! 846: asm(" ADDW2 %r6, %r8"); ! 847: asm(" ADDW2 %r5, %r7"); ! 848: } while (--i > 0); ! 849: break; ! 850: case F_XOR | S_STRADDLE: ! 851: asm(" MOVW 0x20(%fp),%r0"); /* store mask1 in a reg */ ! 852: asm(" PUSHW %ap"); /* store ap on stack */ ! 853: asm(" MOVW 0x24(%fp),%ap"); /* store mask1 in a reg */ ! 854: ! 855: do { ! 856: asm(" ANDW3 %r0,0(%r8),%r2"); /* x20(fp)=mask1 */ ! 857: asm(" ANDW3 %ap,4(%r8),%r1"); /* x24(fp)=mask2 */ ! 858: asm(" ORW2 %r2,%r1"); ! 859: asm(" ROTW %r4,%r1,%r1"); ! 860: asm(" XORW2 %r1,0(%r7)"); ! 861: asm(" ADDW2 %r6, %r8"); ! 862: asm(" ADDW2 %r5, %r7"); ! 863: } while (--i > 0); ! 864: asm(" POPW %ap"); /* restore ap from stack */ ! 865: break; ! 866: case F_XOR | D_STRADDLE: ! 867: if (a <= 16) /* very narrow, 17 bits max */ ! 868: { ! 869: asm(" MOVW &0xffff0000,%r2"); ! 870: asm(" ORW3 0x28(%fp),0x2c(%fp),%r0"); /* compute mask */ ! 871: do { ! 872: asm(" ROTW %r4,0(%r8),%r1"); ! 873: asm(" ANDW2 %r0,%r1"); /* mask */ ! 874: asm(" XORH2 %r1,2(%r7)"); ! 875: asm(" ANDW2 %r2,%r1"); ! 876: asm(" XORW2 %r1,4(%r7)"); ! 877: asm(" ADDW2 %r6, %r8"); ! 878: asm(" ADDW2 %r5, %r7"); ! 879: } while (--i > 0); ! 880: } ! 881: else ! 882: { ! 883: asm(" MOVW 0x28(%fp),%r0"); /* store mask3 in a reg */ ! 884: asm(" PUSHW %ap"); /* store ap on stack */ ! 885: asm(" MOVW 0x2c(%fp),%ap"); /* store mask4 in a reg */ ! 886: do { ! 887: asm(" ROTW %r4,0(%r8),%r1"); ! 888: asm(" ANDW3 %r0,%r1,%r2"); ! 889: asm(" XORW2 %r2,0(%r7)"); ! 890: asm(" ANDW2 %ap,%r1"); ! 891: asm(" XORW2 %r1,4(%r7)"); ! 892: asm(" ADDW2 %r6, %r8"); ! 893: asm(" ADDW2 %r5, %r7"); ! 894: } while (--i > 0); ! 895: asm(" POPW %ap"); /* restore ap from stack */ ! 896: } ! 897: break; ! 898: case F_XOR | S_STRADDLE | D_STRADDLE: ! 899: asm(" MOVW 0x20(%fp),%r0"); /* store mask1 in a reg */ ! 900: asm(" PUSHW %ap"); /* store ap on stack */ ! 901: asm(" MOVW 0x24(%fp),%ap"); /* store mask2 in a reg */ ! 902: if (a > 16){ /* not super narrow */ ! 903: do { ! 904: asm(" ANDW3 %r0,0(%r8),%r1"); ! 905: asm(" ANDW3 %ap,4(%r8),%r2"); ! 906: asm(" ORW2 %r2,%r1"); ! 907: asm(" ROTW %r4,%r1,%r1"); ! 908: asm(" ANDW3 0x28(%fp),%r1,%r2"); ! 909: asm(" XORW2 %r2,0(%r7)"); ! 910: asm(" ANDW2 0x2c(%fp),%r1"); ! 911: asm(" XORW2 %r1,4(%r7)"); ! 912: asm(" ADDW2 %r6, %r8"); ! 913: asm(" ADDW2 %r5, %r7"); ! 914: } while (--i > 0); ! 915: } ! 916: else ! 917: { ! 918: do { ! 919: asm(" ANDW3 %r0,0(%r8),%r1"); ! 920: asm(" ANDW3 %ap,4(%r8),%r2"); ! 921: asm(" ORW2 %r2,%r1"); ! 922: asm(" ROTW %r4,%r1,%r1"); ! 923: asm(" XORH2 %r1,2(%r7)"); ! 924: asm(" ANDW2 &0xffff0000,%r1"); ! 925: asm(" XORW2 %r1,4(%r7)"); ! 926: asm(" ADDW2 %r6, %r8"); ! 927: asm(" ADDW2 %r5, %r7"); ! 928: } while (--i > 0); ! 929: } ! 930: asm(" POPW %ap"); /* restore ap from stack */ ! 931: break; ! 932: } ! 933: return; ! 934: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.