![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to r_draw16.s CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [Quake II] / quake2 / linux|
Return to r_draw16.s CVS log | Up to [Quake II] / quake2 / linux |
1.1 ! root 1: // ! 2: // d_draw16.s ! 3: // x86 assembly-language horizontal 8-bpp span-drawing code, with 16-pixel ! 4: // subdivision. ! 5: // ! 6: ! 7: #include "qasm.h" ! 8: #include "d_ifacea.h" ! 9: ! 10: #if id386 ! 11: ! 12: //---------------------------------------------------------------------- ! 13: // 8-bpp horizontal span drawing code for polygons, with no transparency and ! 14: // 16-pixel subdivision. ! 15: // ! 16: // Assumes there is at least one span in pspans, and that every span ! 17: // contains at least one pixel ! 18: //---------------------------------------------------------------------- ! 19: ! 20: .data ! 21: ! 22: .text ! 23: ! 24: // out-of-line, rarely-needed clamping code ! 25: ! 26: LClampHigh0: ! 27: movl C(bbextents),%esi ! 28: jmp LClampReentry0 ! 29: LClampHighOrLow0: ! 30: jg LClampHigh0 ! 31: xorl %esi,%esi ! 32: jmp LClampReentry0 ! 33: ! 34: LClampHigh1: ! 35: movl C(bbextentt),%edx ! 36: jmp LClampReentry1 ! 37: LClampHighOrLow1: ! 38: jg LClampHigh1 ! 39: xorl %edx,%edx ! 40: jmp LClampReentry1 ! 41: ! 42: LClampLow2: ! 43: movl $4096,%ebp ! 44: jmp LClampReentry2 ! 45: LClampHigh2: ! 46: movl C(bbextents),%ebp ! 47: jmp LClampReentry2 ! 48: ! 49: LClampLow3: ! 50: movl $4096,%ecx ! 51: jmp LClampReentry3 ! 52: LClampHigh3: ! 53: movl C(bbextentt),%ecx ! 54: jmp LClampReentry3 ! 55: ! 56: LClampLow4: ! 57: movl $4096,%eax ! 58: jmp LClampReentry4 ! 59: LClampHigh4: ! 60: movl C(bbextents),%eax ! 61: jmp LClampReentry4 ! 62: ! 63: LClampLow5: ! 64: movl $4096,%ebx ! 65: jmp LClampReentry5 ! 66: LClampHigh5: ! 67: movl C(bbextentt),%ebx ! 68: jmp LClampReentry5 ! 69: ! 70: ! 71: #define pspans 4+16 ! 72: ! 73: .align 4 ! 74: .globl C(D_DrawSpans16) ! 75: C(D_DrawSpans16): ! 76: pushl %ebp // preserve caller's stack frame ! 77: pushl %edi ! 78: pushl %esi // preserve register variables ! 79: pushl %ebx ! 80: ! 81: // ! 82: // set up scaled-by-16 steps, for 16-long segments; also set up cacheblock ! 83: // and span list pointers ! 84: // ! 85: // TODO: any overlap from rearranging? ! 86: flds C(d_sdivzstepu) ! 87: fmuls fp_16 ! 88: movl C(cacheblock),%edx ! 89: flds C(d_tdivzstepu) ! 90: fmuls fp_16 ! 91: movl pspans(%esp),%ebx // point to the first span descriptor ! 92: flds C(d_zistepu) ! 93: fmuls fp_16 ! 94: movl %edx,pbase // pbase = cacheblock ! 95: fstps zi16stepu ! 96: fstps tdivz16stepu ! 97: fstps sdivz16stepu ! 98: ! 99: LSpanLoop: ! 100: // ! 101: // set up the initial s/z, t/z, and 1/z on the FP stack, and generate the ! 102: // initial s and t values ! 103: // ! 104: // FIXME: pipeline FILD? ! 105: fildl espan_t_v(%ebx) ! 106: fildl espan_t_u(%ebx) ! 107: ! 108: fld %st(1) // dv | du | dv ! 109: fmuls C(d_sdivzstepv) // dv*d_sdivzstepv | du | dv ! 110: fld %st(1) // du | dv*d_sdivzstepv | du | dv ! 111: fmuls C(d_sdivzstepu) // du*d_sdivzstepu | dv*d_sdivzstepv | du | dv ! 112: fld %st(2) // du | du*d_sdivzstepu | dv*d_sdivzstepv | du | dv ! 113: fmuls C(d_tdivzstepu) // du*d_tdivzstepu | du*d_sdivzstepu | ! 114: // dv*d_sdivzstepv | du | dv ! 115: fxch %st(1) // du*d_sdivzstepu | du*d_tdivzstepu | ! 116: // dv*d_sdivzstepv | du | dv ! 117: faddp %st(0),%st(2) // du*d_tdivzstepu | ! 118: // du*d_sdivzstepu + dv*d_sdivzstepv | du | dv ! 119: fxch %st(1) // du*d_sdivzstepu + dv*d_sdivzstepv | ! 120: // du*d_tdivzstepu | du | dv ! 121: fld %st(3) // dv | du*d_sdivzstepu + dv*d_sdivzstepv | ! 122: // du*d_tdivzstepu | du | dv ! 123: fmuls C(d_tdivzstepv) // dv*d_tdivzstepv | ! 124: // du*d_sdivzstepu + dv*d_sdivzstepv | ! 125: // du*d_tdivzstepu | du | dv ! 126: fxch %st(1) // du*d_sdivzstepu + dv*d_sdivzstepv | ! 127: // dv*d_tdivzstepv | du*d_tdivzstepu | du | dv ! 128: fadds C(d_sdivzorigin) // sdivz = d_sdivzorigin + dv*d_sdivzstepv + ! 129: // du*d_sdivzstepu; stays in %st(2) at end ! 130: fxch %st(4) // dv | dv*d_tdivzstepv | du*d_tdivzstepu | du | ! 131: // s/z ! 132: fmuls C(d_zistepv) // dv*d_zistepv | dv*d_tdivzstepv | ! 133: // du*d_tdivzstepu | du | s/z ! 134: fxch %st(1) // dv*d_tdivzstepv | dv*d_zistepv | ! 135: // du*d_tdivzstepu | du | s/z ! 136: faddp %st(0),%st(2) // dv*d_zistepv | ! 137: // dv*d_tdivzstepv + du*d_tdivzstepu | du | s/z ! 138: fxch %st(2) // du | dv*d_tdivzstepv + du*d_tdivzstepu | ! 139: // dv*d_zistepv | s/z ! 140: fmuls C(d_zistepu) // du*d_zistepu | ! 141: // dv*d_tdivzstepv + du*d_tdivzstepu | ! 142: // dv*d_zistepv | s/z ! 143: fxch %st(1) // dv*d_tdivzstepv + du*d_tdivzstepu | ! 144: // du*d_zistepu | dv*d_zistepv | s/z ! 145: fadds C(d_tdivzorigin) // tdivz = d_tdivzorigin + dv*d_tdivzstepv + ! 146: // du*d_tdivzstepu; stays in %st(1) at end ! 147: fxch %st(2) // dv*d_zistepv | du*d_zistepu | t/z | s/z ! 148: faddp %st(0),%st(1) // dv*d_zistepv + du*d_zistepu | t/z | s/z ! 149: ! 150: flds fp_64k // fp_64k | dv*d_zistepv + du*d_zistepu | t/z | s/z ! 151: fxch %st(1) // dv*d_zistepv + du*d_zistepu | fp_64k | t/z | s/z ! 152: fadds C(d_ziorigin) // zi = d_ziorigin + dv*d_zistepv + ! 153: // du*d_zistepu; stays in %st(0) at end ! 154: // 1/z | fp_64k | t/z | s/z ! 155: // ! 156: // calculate and clamp s & t ! 157: // ! 158: fdivr %st(0),%st(1) // 1/z | z*64k | t/z | s/z ! 159: ! 160: // ! 161: // point %edi to the first pixel in the span ! 162: // ! 163: movl C(d_viewbuffer),%ecx ! 164: movl espan_t_v(%ebx),%eax ! 165: movl %ebx,pspantemp // preserve spans pointer ! 166: ! 167: movl C(tadjust),%edx ! 168: movl C(sadjust),%esi ! 169: movl C(d_scantable)(,%eax,4),%edi // v * screenwidth ! 170: addl %ecx,%edi ! 171: movl espan_t_u(%ebx),%ecx ! 172: addl %ecx,%edi // pdest = &pdestspan[scans->u]; ! 173: movl espan_t_count(%ebx),%ecx ! 174: ! 175: // ! 176: // now start the FDIV for the end of the span ! 177: // ! 178: cmpl $16,%ecx ! 179: ja LSetupNotLast1 ! 180: ! 181: decl %ecx ! 182: jz LCleanup1 // if only one pixel, no need to start an FDIV ! 183: movl %ecx,spancountminus1 ! 184: ! 185: // finish up the s and t calcs ! 186: fxch %st(1) // z*64k | 1/z | t/z | s/z ! 187: ! 188: fld %st(0) // z*64k | z*64k | 1/z | t/z | s/z ! 189: fmul %st(4),%st(0) // s | z*64k | 1/z | t/z | s/z ! 190: fxch %st(1) // z*64k | s | 1/z | t/z | s/z ! 191: fmul %st(3),%st(0) // t | s | 1/z | t/z | s/z ! 192: fxch %st(1) // s | t | 1/z | t/z | s/z ! 193: fistpl s // 1/z | t | t/z | s/z ! 194: fistpl t // 1/z | t/z | s/z ! 195: ! 196: fildl spancountminus1 ! 197: ! 198: flds C(d_tdivzstepu) // C(d_tdivzstepu) | spancountminus1 ! 199: flds C(d_zistepu) // C(d_zistepu) | C(d_tdivzstepu) | spancountminus1 ! 200: fmul %st(2),%st(0) // C(d_zistepu)*scm1 | C(d_tdivzstepu) | scm1 ! 201: fxch %st(1) // C(d_tdivzstepu) | C(d_zistepu)*scm1 | scm1 ! 202: fmul %st(2),%st(0) // C(d_tdivzstepu)*scm1 | C(d_zistepu)*scm1 | scm1 ! 203: fxch %st(2) // scm1 | C(d_zistepu)*scm1 | C(d_tdivzstepu)*scm1 ! 204: fmuls C(d_sdivzstepu) // C(d_sdivzstepu)*scm1 | C(d_zistepu)*scm1 | ! 205: // C(d_tdivzstepu)*scm1 ! 206: fxch %st(1) // C(d_zistepu)*scm1 | C(d_sdivzstepu)*scm1 | ! 207: // C(d_tdivzstepu)*scm1 ! 208: faddp %st(0),%st(3) // C(d_sdivzstepu)*scm1 | C(d_tdivzstepu)*scm1 ! 209: fxch %st(1) // C(d_tdivzstepu)*scm1 | C(d_sdivzstepu)*scm1 ! 210: faddp %st(0),%st(3) // C(d_sdivzstepu)*scm1 ! 211: faddp %st(0),%st(3) ! 212: ! 213: flds fp_64k ! 214: fdiv %st(1),%st(0) // this is what we've gone to all this trouble to ! 215: // overlap ! 216: jmp LFDIVInFlight1 ! 217: ! 218: LCleanup1: ! 219: // finish up the s and t calcs ! 220: fxch %st(1) // z*64k | 1/z | t/z | s/z ! 221: ! 222: fld %st(0) // z*64k | z*64k | 1/z | t/z | s/z ! 223: fmul %st(4),%st(0) // s | z*64k | 1/z | t/z | s/z ! 224: fxch %st(1) // z*64k | s | 1/z | t/z | s/z ! 225: fmul %st(3),%st(0) // t | s | 1/z | t/z | s/z ! 226: fxch %st(1) // s | t | 1/z | t/z | s/z ! 227: fistpl s // 1/z | t | t/z | s/z ! 228: fistpl t // 1/z | t/z | s/z ! 229: jmp LFDIVInFlight1 ! 230: ! 231: .align 4 ! 232: LSetupNotLast1: ! 233: // finish up the s and t calcs ! 234: fxch %st(1) // z*64k | 1/z | t/z | s/z ! 235: ! 236: fld %st(0) // z*64k | z*64k | 1/z | t/z | s/z ! 237: fmul %st(4),%st(0) // s | z*64k | 1/z | t/z | s/z ! 238: fxch %st(1) // z*64k | s | 1/z | t/z | s/z ! 239: fmul %st(3),%st(0) // t | s | 1/z | t/z | s/z ! 240: fxch %st(1) // s | t | 1/z | t/z | s/z ! 241: fistpl s // 1/z | t | t/z | s/z ! 242: fistpl t // 1/z | t/z | s/z ! 243: ! 244: fadds zi16stepu ! 245: fxch %st(2) ! 246: fadds sdivz16stepu ! 247: fxch %st(2) ! 248: flds tdivz16stepu ! 249: faddp %st(0),%st(2) ! 250: flds fp_64k ! 251: fdiv %st(1),%st(0) // z = 1/1/z ! 252: // this is what we've gone to all this trouble to ! 253: // overlap ! 254: LFDIVInFlight1: ! 255: ! 256: addl s,%esi ! 257: addl t,%edx ! 258: movl C(bbextents),%ebx ! 259: movl C(bbextentt),%ebp ! 260: cmpl %ebx,%esi ! 261: ja LClampHighOrLow0 ! 262: LClampReentry0: ! 263: movl %esi,s ! 264: movl pbase,%ebx ! 265: shll $16,%esi ! 266: cmpl %ebp,%edx ! 267: movl %esi,sfracf ! 268: ja LClampHighOrLow1 ! 269: LClampReentry1: ! 270: movl %edx,t ! 271: movl s,%esi // sfrac = scans->sfrac; ! 272: shll $16,%edx ! 273: movl t,%eax // tfrac = scans->tfrac; ! 274: sarl $16,%esi ! 275: movl %edx,tfracf ! 276: ! 277: // ! 278: // calculate the texture starting address ! 279: // ! 280: sarl $16,%eax ! 281: movl C(cachewidth),%edx ! 282: imull %edx,%eax // (tfrac >> 16) * cachewidth ! 283: addl %ebx,%esi ! 284: addl %eax,%esi // psource = pbase + (sfrac >> 16) + ! 285: // ((tfrac >> 16) * cachewidth); ! 286: // ! 287: // determine whether last span or not ! 288: // ! 289: cmpl $16,%ecx ! 290: jna LLastSegment ! 291: ! 292: // ! 293: // not the last segment; do full 16-wide segment ! 294: // ! 295: LNotLastSegment: ! 296: ! 297: // ! 298: // advance s/z, t/z, and 1/z, and calculate s & t at end of span and steps to ! 299: // get there ! 300: // ! 301: ! 302: // pick up after the FDIV that was left in flight previously ! 303: ! 304: fld %st(0) // duplicate it ! 305: fmul %st(4),%st(0) // s = s/z * z ! 306: fxch %st(1) ! 307: fmul %st(3),%st(0) // t = t/z * z ! 308: fxch %st(1) ! 309: fistpl snext ! 310: fistpl tnext ! 311: movl snext,%eax ! 312: movl tnext,%edx ! 313: ! 314: movb (%esi),%bl // get first source texel ! 315: subl $16,%ecx // count off this segments' pixels ! 316: movl C(sadjust),%ebp ! 317: movl %ecx,counttemp // remember count of remaining pixels ! 318: ! 319: movl C(tadjust),%ecx ! 320: movb %bl,(%edi) // store first dest pixel ! 321: ! 322: addl %eax,%ebp ! 323: addl %edx,%ecx ! 324: ! 325: movl C(bbextents),%eax ! 326: movl C(bbextentt),%edx ! 327: ! 328: cmpl $4096,%ebp ! 329: jl LClampLow2 ! 330: cmpl %eax,%ebp ! 331: ja LClampHigh2 ! 332: LClampReentry2: ! 333: ! 334: cmpl $4096,%ecx ! 335: jl LClampLow3 ! 336: cmpl %edx,%ecx ! 337: ja LClampHigh3 ! 338: LClampReentry3: ! 339: ! 340: movl %ebp,snext ! 341: movl %ecx,tnext ! 342: ! 343: subl s,%ebp ! 344: subl t,%ecx ! 345: ! 346: // ! 347: // set up advancetable ! 348: // ! 349: movl %ecx,%eax ! 350: movl %ebp,%edx ! 351: sarl $20,%eax // tstep >>= 16; ! 352: jz LZero ! 353: sarl $20,%edx // sstep >>= 16; ! 354: movl C(cachewidth),%ebx ! 355: imull %ebx,%eax ! 356: jmp LSetUp1 ! 357: ! 358: LZero: ! 359: sarl $20,%edx // sstep >>= 16; ! 360: movl C(cachewidth),%ebx ! 361: ! 362: LSetUp1: ! 363: ! 364: addl %edx,%eax // add in sstep ! 365: // (tstep >> 16) * cachewidth + (sstep >> 16); ! 366: movl tfracf,%edx ! 367: movl %eax,advancetable+4 // advance base in t ! 368: addl %ebx,%eax // ((tstep >> 16) + 1) * cachewidth + ! 369: // (sstep >> 16); ! 370: shll $12,%ebp // left-justify sstep fractional part ! 371: movl sfracf,%ebx ! 372: shll $12,%ecx // left-justify tstep fractional part ! 373: movl %eax,advancetable // advance extra in t ! 374: ! 375: movl %ecx,tstep ! 376: addl %ecx,%edx // advance tfrac fractional part by tstep frac ! 377: ! 378: sbbl %ecx,%ecx // turn tstep carry into -1 (0 if none) ! 379: addl %ebp,%ebx // advance sfrac fractional part by sstep frac ! 380: adcl advancetable+4(,%ecx,4),%esi // point to next source texel ! 381: ! 382: addl tstep,%edx ! 383: sbbl %ecx,%ecx ! 384: movb (%esi),%al ! 385: addl %ebp,%ebx ! 386: movb %al,1(%edi) ! 387: adcl advancetable+4(,%ecx,4),%esi ! 388: ! 389: addl tstep,%edx ! 390: sbbl %ecx,%ecx ! 391: addl %ebp,%ebx ! 392: movb (%esi),%al ! 393: adcl advancetable+4(,%ecx,4),%esi ! 394: ! 395: addl tstep,%edx ! 396: sbbl %ecx,%ecx ! 397: movb %al,2(%edi) ! 398: addl %ebp,%ebx ! 399: movb (%esi),%al ! 400: adcl advancetable+4(,%ecx,4),%esi ! 401: ! 402: addl tstep,%edx ! 403: sbbl %ecx,%ecx ! 404: movb %al,3(%edi) ! 405: addl %ebp,%ebx ! 406: movb (%esi),%al ! 407: adcl advancetable+4(,%ecx,4),%esi ! 408: ! 409: addl tstep,%edx ! 410: sbbl %ecx,%ecx ! 411: movb %al,4(%edi) ! 412: addl %ebp,%ebx ! 413: movb (%esi),%al ! 414: adcl advancetable+4(,%ecx,4),%esi ! 415: ! 416: addl tstep,%edx ! 417: sbbl %ecx,%ecx ! 418: movb %al,5(%edi) ! 419: addl %ebp,%ebx ! 420: movb (%esi),%al ! 421: adcl advancetable+4(,%ecx,4),%esi ! 422: ! 423: addl tstep,%edx ! 424: sbbl %ecx,%ecx ! 425: movb %al,6(%edi) ! 426: addl %ebp,%ebx ! 427: movb (%esi),%al ! 428: adcl advancetable+4(,%ecx,4),%esi ! 429: ! 430: addl tstep,%edx ! 431: sbbl %ecx,%ecx ! 432: movb %al,7(%edi) ! 433: addl %ebp,%ebx ! 434: movb (%esi),%al ! 435: adcl advancetable+4(,%ecx,4),%esi ! 436: ! 437: ! 438: // ! 439: // start FDIV for end of next segment in flight, so it can overlap ! 440: // ! 441: movl counttemp,%ecx ! 442: cmpl $16,%ecx // more than one segment after this? ! 443: ja LSetupNotLast2 // yes ! 444: ! 445: decl %ecx ! 446: jz LFDIVInFlight2 // if only one pixel, no need to start an FDIV ! 447: movl %ecx,spancountminus1 ! 448: fildl spancountminus1 ! 449: ! 450: flds C(d_zistepu) // C(d_zistepu) | spancountminus1 ! 451: fmul %st(1),%st(0) // C(d_zistepu)*scm1 | scm1 ! 452: flds C(d_tdivzstepu) // C(d_tdivzstepu) | C(d_zistepu)*scm1 | scm1 ! 453: fmul %st(2),%st(0) // C(d_tdivzstepu)*scm1 | C(d_zistepu)*scm1 | scm1 ! 454: fxch %st(1) // C(d_zistepu)*scm1 | C(d_tdivzstepu)*scm1 | scm1 ! 455: faddp %st(0),%st(3) // C(d_tdivzstepu)*scm1 | scm1 ! 456: fxch %st(1) // scm1 | C(d_tdivzstepu)*scm1 ! 457: fmuls C(d_sdivzstepu) // C(d_sdivzstepu)*scm1 | C(d_tdivzstepu)*scm1 ! 458: fxch %st(1) // C(d_tdivzstepu)*scm1 | C(d_sdivzstepu)*scm1 ! 459: faddp %st(0),%st(3) // C(d_sdivzstepu)*scm1 ! 460: flds fp_64k // 64k | C(d_sdivzstepu)*scm1 ! 461: fxch %st(1) // C(d_sdivzstepu)*scm1 | 64k ! 462: faddp %st(0),%st(4) // 64k ! 463: ! 464: fdiv %st(1),%st(0) // this is what we've gone to all this trouble to ! 465: // overlap ! 466: jmp LFDIVInFlight2 ! 467: ! 468: .align 4 ! 469: LSetupNotLast2: ! 470: fadds zi16stepu ! 471: fxch %st(2) ! 472: fadds sdivz16stepu ! 473: fxch %st(2) ! 474: flds tdivz16stepu ! 475: faddp %st(0),%st(2) ! 476: flds fp_64k ! 477: fdiv %st(1),%st(0) // z = 1/1/z ! 478: // this is what we've gone to all this trouble to ! 479: // overlap ! 480: LFDIVInFlight2: ! 481: movl %ecx,counttemp ! 482: ! 483: addl tstep,%edx ! 484: sbbl %ecx,%ecx ! 485: movb %al,8(%edi) ! 486: addl %ebp,%ebx ! 487: movb (%esi),%al ! 488: adcl advancetable+4(,%ecx,4),%esi ! 489: ! 490: addl tstep,%edx ! 491: sbbl %ecx,%ecx ! 492: movb %al,9(%edi) ! 493: addl %ebp,%ebx ! 494: movb (%esi),%al ! 495: adcl advancetable+4(,%ecx,4),%esi ! 496: ! 497: addl tstep,%edx ! 498: sbbl %ecx,%ecx ! 499: movb %al,10(%edi) ! 500: addl %ebp,%ebx ! 501: movb (%esi),%al ! 502: adcl advancetable+4(,%ecx,4),%esi ! 503: ! 504: addl tstep,%edx ! 505: sbbl %ecx,%ecx ! 506: movb %al,11(%edi) ! 507: addl %ebp,%ebx ! 508: movb (%esi),%al ! 509: adcl advancetable+4(,%ecx,4),%esi ! 510: ! 511: addl tstep,%edx ! 512: sbbl %ecx,%ecx ! 513: movb %al,12(%edi) ! 514: addl %ebp,%ebx ! 515: movb (%esi),%al ! 516: adcl advancetable+4(,%ecx,4),%esi ! 517: ! 518: addl tstep,%edx ! 519: sbbl %ecx,%ecx ! 520: movb %al,13(%edi) ! 521: addl %ebp,%ebx ! 522: movb (%esi),%al ! 523: adcl advancetable+4(,%ecx,4),%esi ! 524: ! 525: addl tstep,%edx ! 526: sbbl %ecx,%ecx ! 527: movb %al,14(%edi) ! 528: addl %ebp,%ebx ! 529: movb (%esi),%al ! 530: adcl advancetable+4(,%ecx,4),%esi ! 531: ! 532: addl $16,%edi ! 533: movl %edx,tfracf ! 534: movl snext,%edx ! 535: movl %ebx,sfracf ! 536: movl tnext,%ebx ! 537: movl %edx,s ! 538: movl %ebx,t ! 539: ! 540: movl counttemp,%ecx // retrieve count ! 541: ! 542: // ! 543: // determine whether last span or not ! 544: // ! 545: cmpl $16,%ecx // are there multiple segments remaining? ! 546: movb %al,-1(%edi) ! 547: ja LNotLastSegment // yes ! 548: ! 549: // ! 550: // last segment of scan ! 551: // ! 552: LLastSegment: ! 553: ! 554: // ! 555: // advance s/z, t/z, and 1/z, and calculate s & t at end of span and steps to ! 556: // get there. The number of pixels left is variable, and we want to land on the ! 557: // last pixel, not step one past it, so we can't run into arithmetic problems ! 558: // ! 559: testl %ecx,%ecx ! 560: jz LNoSteps // just draw the last pixel and we're done ! 561: ! 562: // pick up after the FDIV that was left in flight previously ! 563: ! 564: ! 565: fld %st(0) // duplicate it ! 566: fmul %st(4),%st(0) // s = s/z * z ! 567: fxch %st(1) ! 568: fmul %st(3),%st(0) // t = t/z * z ! 569: fxch %st(1) ! 570: fistpl snext ! 571: fistpl tnext ! 572: ! 573: movb (%esi),%al // load first texel in segment ! 574: movl C(tadjust),%ebx ! 575: movb %al,(%edi) // store first pixel in segment ! 576: movl C(sadjust),%eax ! 577: ! 578: addl snext,%eax ! 579: addl tnext,%ebx ! 580: ! 581: movl C(bbextents),%ebp ! 582: movl C(bbextentt),%edx ! 583: ! 584: cmpl $4096,%eax ! 585: jl LClampLow4 ! 586: cmpl %ebp,%eax ! 587: ja LClampHigh4 ! 588: LClampReentry4: ! 589: movl %eax,snext ! 590: ! 591: cmpl $4096,%ebx ! 592: jl LClampLow5 ! 593: cmpl %edx,%ebx ! 594: ja LClampHigh5 ! 595: LClampReentry5: ! 596: ! 597: cmpl $1,%ecx // don't bother ! 598: je LOnlyOneStep // if two pixels in segment, there's only one step, ! 599: // of the segment length ! 600: subl s,%eax ! 601: subl t,%ebx ! 602: ! 603: addl %eax,%eax // convert to 15.17 format so multiply by 1.31 ! 604: addl %ebx,%ebx // reciprocal yields 16.48 ! 605: ! 606: imull reciprocal_table_16-8(,%ecx,4) // sstep = (snext - s) / ! 607: // (spancount-1) ! 608: movl %edx,%ebp ! 609: ! 610: movl %ebx,%eax ! 611: imull reciprocal_table_16-8(,%ecx,4) // tstep = (tnext - t) / ! 612: // (spancount-1) ! 613: LSetEntryvec: ! 614: // ! 615: // set up advancetable ! 616: // ! 617: movl entryvec_table_16(,%ecx,4),%ebx ! 618: movl %edx,%eax ! 619: movl %ebx,jumptemp // entry point into code for RET later ! 620: movl %ebp,%ecx ! 621: sarl $16,%edx // tstep >>= 16; ! 622: movl C(cachewidth),%ebx ! 623: sarl $16,%ecx // sstep >>= 16; ! 624: imull %ebx,%edx ! 625: ! 626: addl %ecx,%edx // add in sstep ! 627: // (tstep >> 16) * cachewidth + (sstep >> 16); ! 628: movl tfracf,%ecx ! 629: movl %edx,advancetable+4 // advance base in t ! 630: addl %ebx,%edx // ((tstep >> 16) + 1) * cachewidth + ! 631: // (sstep >> 16); ! 632: shll $16,%ebp // left-justify sstep fractional part ! 633: movl sfracf,%ebx ! 634: shll $16,%eax // left-justify tstep fractional part ! 635: movl %edx,advancetable // advance extra in t ! 636: ! 637: movl %eax,tstep ! 638: movl %ecx,%edx ! 639: addl %eax,%edx ! 640: sbbl %ecx,%ecx ! 641: addl %ebp,%ebx ! 642: adcl advancetable+4(,%ecx,4),%esi ! 643: ! 644: jmp *jumptemp // jump to the number-of-pixels handler ! 645: ! 646: //---------------------------------------- ! 647: ! 648: LNoSteps: ! 649: movb (%esi),%al // load first texel in segment ! 650: subl $15,%edi // adjust for hardwired offset ! 651: jmp LEndSpan ! 652: ! 653: ! 654: LOnlyOneStep: ! 655: subl s,%eax ! 656: subl t,%ebx ! 657: movl %eax,%ebp ! 658: movl %ebx,%edx ! 659: jmp LSetEntryvec ! 660: ! 661: //---------------------------------------- ! 662: ! 663: .globl Entry2_16, Entry3_16, Entry4_16, Entry5_16 ! 664: .globl Entry6_16, Entry7_16, Entry8_16, Entry9_16 ! 665: .globl Entry10_16, Entry11_16, Entry12_16, Entry13_16 ! 666: .globl Entry14_16, Entry15_16, Entry16_16 ! 667: ! 668: Entry2_16: ! 669: subl $14,%edi // adjust for hardwired offsets ! 670: movb (%esi),%al ! 671: jmp LEntry2_16 ! 672: ! 673: //---------------------------------------- ! 674: ! 675: Entry3_16: ! 676: subl $13,%edi // adjust for hardwired offsets ! 677: addl %eax,%edx ! 678: movb (%esi),%al ! 679: sbbl %ecx,%ecx ! 680: addl %ebp,%ebx ! 681: adcl advancetable+4(,%ecx,4),%esi ! 682: jmp LEntry3_16 ! 683: ! 684: //---------------------------------------- ! 685: ! 686: Entry4_16: ! 687: subl $12,%edi // adjust for hardwired offsets ! 688: addl %eax,%edx ! 689: movb (%esi),%al ! 690: sbbl %ecx,%ecx ! 691: addl %ebp,%ebx ! 692: adcl advancetable+4(,%ecx,4),%esi ! 693: addl tstep,%edx ! 694: jmp LEntry4_16 ! 695: ! 696: //---------------------------------------- ! 697: ! 698: Entry5_16: ! 699: subl $11,%edi // adjust for hardwired offsets ! 700: addl %eax,%edx ! 701: movb (%esi),%al ! 702: sbbl %ecx,%ecx ! 703: addl %ebp,%ebx ! 704: adcl advancetable+4(,%ecx,4),%esi ! 705: addl tstep,%edx ! 706: jmp LEntry5_16 ! 707: ! 708: //---------------------------------------- ! 709: ! 710: Entry6_16: ! 711: subl $10,%edi // adjust for hardwired offsets ! 712: addl %eax,%edx ! 713: movb (%esi),%al ! 714: sbbl %ecx,%ecx ! 715: addl %ebp,%ebx ! 716: adcl advancetable+4(,%ecx,4),%esi ! 717: addl tstep,%edx ! 718: jmp LEntry6_16 ! 719: ! 720: //---------------------------------------- ! 721: ! 722: Entry7_16: ! 723: subl $9,%edi // adjust for hardwired offsets ! 724: addl %eax,%edx ! 725: movb (%esi),%al ! 726: sbbl %ecx,%ecx ! 727: addl %ebp,%ebx ! 728: adcl advancetable+4(,%ecx,4),%esi ! 729: addl tstep,%edx ! 730: jmp LEntry7_16 ! 731: ! 732: //---------------------------------------- ! 733: ! 734: Entry8_16: ! 735: subl $8,%edi // adjust for hardwired offsets ! 736: addl %eax,%edx ! 737: movb (%esi),%al ! 738: sbbl %ecx,%ecx ! 739: addl %ebp,%ebx ! 740: adcl advancetable+4(,%ecx,4),%esi ! 741: addl tstep,%edx ! 742: jmp LEntry8_16 ! 743: ! 744: //---------------------------------------- ! 745: ! 746: Entry9_16: ! 747: subl $7,%edi // adjust for hardwired offsets ! 748: addl %eax,%edx ! 749: movb (%esi),%al ! 750: sbbl %ecx,%ecx ! 751: addl %ebp,%ebx ! 752: adcl advancetable+4(,%ecx,4),%esi ! 753: addl tstep,%edx ! 754: jmp LEntry9_16 ! 755: ! 756: //---------------------------------------- ! 757: ! 758: Entry10_16: ! 759: subl $6,%edi // adjust for hardwired offsets ! 760: addl %eax,%edx ! 761: movb (%esi),%al ! 762: sbbl %ecx,%ecx ! 763: addl %ebp,%ebx ! 764: adcl advancetable+4(,%ecx,4),%esi ! 765: addl tstep,%edx ! 766: jmp LEntry10_16 ! 767: ! 768: //---------------------------------------- ! 769: ! 770: Entry11_16: ! 771: subl $5,%edi // adjust for hardwired offsets ! 772: addl %eax,%edx ! 773: movb (%esi),%al ! 774: sbbl %ecx,%ecx ! 775: addl %ebp,%ebx ! 776: adcl advancetable+4(,%ecx,4),%esi ! 777: addl tstep,%edx ! 778: jmp LEntry11_16 ! 779: ! 780: //---------------------------------------- ! 781: ! 782: Entry12_16: ! 783: subl $4,%edi // adjust for hardwired offsets ! 784: addl %eax,%edx ! 785: movb (%esi),%al ! 786: sbbl %ecx,%ecx ! 787: addl %ebp,%ebx ! 788: adcl advancetable+4(,%ecx,4),%esi ! 789: addl tstep,%edx ! 790: jmp LEntry12_16 ! 791: ! 792: //---------------------------------------- ! 793: ! 794: Entry13_16: ! 795: subl $3,%edi // adjust for hardwired offsets ! 796: addl %eax,%edx ! 797: movb (%esi),%al ! 798: sbbl %ecx,%ecx ! 799: addl %ebp,%ebx ! 800: adcl advancetable+4(,%ecx,4),%esi ! 801: addl tstep,%edx ! 802: jmp LEntry13_16 ! 803: ! 804: //---------------------------------------- ! 805: ! 806: Entry14_16: ! 807: subl $2,%edi // adjust for hardwired offsets ! 808: addl %eax,%edx ! 809: movb (%esi),%al ! 810: sbbl %ecx,%ecx ! 811: addl %ebp,%ebx ! 812: adcl advancetable+4(,%ecx,4),%esi ! 813: addl tstep,%edx ! 814: jmp LEntry14_16 ! 815: ! 816: //---------------------------------------- ! 817: ! 818: Entry15_16: ! 819: decl %edi // adjust for hardwired offsets ! 820: addl %eax,%edx ! 821: movb (%esi),%al ! 822: sbbl %ecx,%ecx ! 823: addl %ebp,%ebx ! 824: adcl advancetable+4(,%ecx,4),%esi ! 825: addl tstep,%edx ! 826: jmp LEntry15_16 ! 827: ! 828: //---------------------------------------- ! 829: ! 830: Entry16_16: ! 831: addl %eax,%edx ! 832: movb (%esi),%al ! 833: sbbl %ecx,%ecx ! 834: addl %ebp,%ebx ! 835: adcl advancetable+4(,%ecx,4),%esi ! 836: ! 837: addl tstep,%edx ! 838: sbbl %ecx,%ecx ! 839: movb %al,1(%edi) ! 840: addl %ebp,%ebx ! 841: movb (%esi),%al ! 842: adcl advancetable+4(,%ecx,4),%esi ! 843: addl tstep,%edx ! 844: LEntry15_16: ! 845: sbbl %ecx,%ecx ! 846: movb %al,2(%edi) ! 847: addl %ebp,%ebx ! 848: movb (%esi),%al ! 849: adcl advancetable+4(,%ecx,4),%esi ! 850: addl tstep,%edx ! 851: LEntry14_16: ! 852: sbbl %ecx,%ecx ! 853: movb %al,3(%edi) ! 854: addl %ebp,%ebx ! 855: movb (%esi),%al ! 856: adcl advancetable+4(,%ecx,4),%esi ! 857: addl tstep,%edx ! 858: LEntry13_16: ! 859: sbbl %ecx,%ecx ! 860: movb %al,4(%edi) ! 861: addl %ebp,%ebx ! 862: movb (%esi),%al ! 863: adcl advancetable+4(,%ecx,4),%esi ! 864: addl tstep,%edx ! 865: LEntry12_16: ! 866: sbbl %ecx,%ecx ! 867: movb %al,5(%edi) ! 868: addl %ebp,%ebx ! 869: movb (%esi),%al ! 870: adcl advancetable+4(,%ecx,4),%esi ! 871: addl tstep,%edx ! 872: LEntry11_16: ! 873: sbbl %ecx,%ecx ! 874: movb %al,6(%edi) ! 875: addl %ebp,%ebx ! 876: movb (%esi),%al ! 877: adcl advancetable+4(,%ecx,4),%esi ! 878: addl tstep,%edx ! 879: LEntry10_16: ! 880: sbbl %ecx,%ecx ! 881: movb %al,7(%edi) ! 882: addl %ebp,%ebx ! 883: movb (%esi),%al ! 884: adcl advancetable+4(,%ecx,4),%esi ! 885: addl tstep,%edx ! 886: LEntry9_16: ! 887: sbbl %ecx,%ecx ! 888: movb %al,8(%edi) ! 889: addl %ebp,%ebx ! 890: movb (%esi),%al ! 891: adcl advancetable+4(,%ecx,4),%esi ! 892: addl tstep,%edx ! 893: LEntry8_16: ! 894: sbbl %ecx,%ecx ! 895: movb %al,9(%edi) ! 896: addl %ebp,%ebx ! 897: movb (%esi),%al ! 898: adcl advancetable+4(,%ecx,4),%esi ! 899: addl tstep,%edx ! 900: LEntry7_16: ! 901: sbbl %ecx,%ecx ! 902: movb %al,10(%edi) ! 903: addl %ebp,%ebx ! 904: movb (%esi),%al ! 905: adcl advancetable+4(,%ecx,4),%esi ! 906: addl tstep,%edx ! 907: LEntry6_16: ! 908: sbbl %ecx,%ecx ! 909: movb %al,11(%edi) ! 910: addl %ebp,%ebx ! 911: movb (%esi),%al ! 912: adcl advancetable+4(,%ecx,4),%esi ! 913: addl tstep,%edx ! 914: LEntry5_16: ! 915: sbbl %ecx,%ecx ! 916: movb %al,12(%edi) ! 917: addl %ebp,%ebx ! 918: movb (%esi),%al ! 919: adcl advancetable+4(,%ecx,4),%esi ! 920: addl tstep,%edx ! 921: LEntry4_16: ! 922: sbbl %ecx,%ecx ! 923: movb %al,13(%edi) ! 924: addl %ebp,%ebx ! 925: movb (%esi),%al ! 926: adcl advancetable+4(,%ecx,4),%esi ! 927: LEntry3_16: ! 928: movb %al,14(%edi) ! 929: movb (%esi),%al ! 930: LEntry2_16: ! 931: ! 932: LEndSpan: ! 933: ! 934: // ! 935: // clear s/z, t/z, 1/z from FP stack ! 936: // ! 937: fstp %st(0) ! 938: fstp %st(0) ! 939: fstp %st(0) ! 940: ! 941: movl pspantemp,%ebx // restore spans pointer ! 942: movl espan_t_pnext(%ebx),%ebx // point to next span ! 943: testl %ebx,%ebx // any more spans? ! 944: movb %al,15(%edi) ! 945: jnz LSpanLoop // more spans ! 946: ! 947: popl %ebx // restore register variables ! 948: popl %esi ! 949: popl %edi ! 950: popl %ebp // restore the caller's stack frame ! 951: ret ! 952: ! 953: //---------------------------------------------------------------------- ! 954: // 8-bpp horizontal span z drawing codefor polygons, with no transparency. ! 955: // ! 956: // Assumes there is at least one span in pzspans, and that every span ! 957: // contains at least one pixel ! 958: //---------------------------------------------------------------------- ! 959: ! 960: .text ! 961: ! 962: // z-clamp on a non-negative gradient span ! 963: LClamp: ! 964: movl $0x40000000,%edx ! 965: xorl %ebx,%ebx ! 966: fstp %st(0) ! 967: jmp LZDraw ! 968: ! 969: // z-clamp on a negative gradient span ! 970: LClampNeg: ! 971: movl $0x40000000,%edx ! 972: xorl %ebx,%ebx ! 973: fstp %st(0) ! 974: jmp LZDrawNeg ! 975: ! 976: ! 977: #define pzspans 4+16 ! 978: ! 979: .globl C(D_DrawZSpans) ! 980: C(D_DrawZSpans): ! 981: pushl %ebp // preserve caller's stack frame ! 982: pushl %edi ! 983: pushl %esi // preserve register variables ! 984: pushl %ebx ! 985: ! 986: flds C(d_zistepu) ! 987: movl C(d_zistepu),%eax ! 988: movl pzspans(%esp),%esi ! 989: testl %eax,%eax ! 990: jz LFNegSpan ! 991: ! 992: fmuls Float2ToThe31nd ! 993: fistpl izistep // note: we are relying on FP exceptions being turned ! 994: // off here to avoid range problems ! 995: movl izistep,%ebx // remains loaded for all spans ! 996: ! 997: LFSpanLoop: ! 998: // set up the initial 1/z value ! 999: fildl espan_t_v(%esi) ! 1000: fildl espan_t_u(%esi) ! 1001: movl espan_t_v(%esi),%ecx ! 1002: movl C(d_pzbuffer),%edi ! 1003: fmuls C(d_zistepu) ! 1004: fxch %st(1) ! 1005: fmuls C(d_zistepv) ! 1006: fxch %st(1) ! 1007: fadds C(d_ziorigin) ! 1008: imull C(d_zrowbytes),%ecx ! 1009: faddp %st(0),%st(1) ! 1010: ! 1011: // clamp if z is nearer than 2 (1/z > 0.5) ! 1012: fcoms float_point5 ! 1013: addl %ecx,%edi ! 1014: movl espan_t_u(%esi),%edx ! 1015: addl %edx,%edx // word count ! 1016: movl espan_t_count(%esi),%ecx ! 1017: addl %edx,%edi // pdest = &pdestspan[scans->u]; ! 1018: pushl %esi // preserve spans pointer ! 1019: fnstsw %ax ! 1020: testb $0x45,%ah ! 1021: jz LClamp ! 1022: ! 1023: fmuls Float2ToThe31nd ! 1024: fistpl izi // note: we are relying on FP exceptions being turned ! 1025: // off here to avoid problems when the span is closer ! 1026: // than 1/(2**31) ! 1027: movl izi,%edx ! 1028: ! 1029: // at this point: ! 1030: // %ebx = izistep ! 1031: // %ecx = count ! 1032: // %edx = izi ! 1033: // %edi = pdest ! 1034: ! 1035: LZDraw: ! 1036: ! 1037: // do a single pixel up front, if necessary to dword align the destination ! 1038: testl $2,%edi ! 1039: jz LFMiddle ! 1040: movl %edx,%eax ! 1041: addl %ebx,%edx ! 1042: shrl $16,%eax ! 1043: decl %ecx ! 1044: movw %ax,(%edi) ! 1045: addl $2,%edi ! 1046: ! 1047: // do middle a pair of aligned dwords at a time ! 1048: LFMiddle: ! 1049: pushl %ecx ! 1050: shrl $1,%ecx // count / 2 ! 1051: jz LFLast // no aligned dwords to do ! 1052: shrl $1,%ecx // (count / 2) / 2 ! 1053: jnc LFMiddleLoop // even number of aligned dwords to do ! 1054: ! 1055: movl %edx,%eax ! 1056: addl %ebx,%edx ! 1057: shrl $16,%eax ! 1058: movl %edx,%esi ! 1059: addl %ebx,%edx ! 1060: andl $0xFFFF0000,%esi ! 1061: orl %esi,%eax ! 1062: movl %eax,(%edi) ! 1063: addl $4,%edi ! 1064: andl %ecx,%ecx ! 1065: jz LFLast ! 1066: ! 1067: LFMiddleLoop: ! 1068: movl %edx,%eax ! 1069: addl %ebx,%edx ! 1070: shrl $16,%eax ! 1071: movl %edx,%esi ! 1072: addl %ebx,%edx ! 1073: andl $0xFFFF0000,%esi ! 1074: orl %esi,%eax ! 1075: movl %edx,%ebp ! 1076: movl %eax,(%edi) ! 1077: addl %ebx,%edx ! 1078: shrl $16,%ebp ! 1079: movl %edx,%esi ! 1080: addl %ebx,%edx ! 1081: andl $0xFFFF0000,%esi ! 1082: orl %esi,%ebp ! 1083: movl %ebp,4(%edi) // FIXME: eliminate register contention ! 1084: addl $8,%edi ! 1085: ! 1086: decl %ecx ! 1087: jnz LFMiddleLoop ! 1088: ! 1089: LFLast: ! 1090: popl %ecx // retrieve count ! 1091: popl %esi // retrieve span pointer ! 1092: ! 1093: // do the last, unaligned pixel, if there is one ! 1094: andl $1,%ecx // is there an odd pixel left to do? ! 1095: jz LFSpanDone // no ! 1096: shrl $16,%edx ! 1097: movw %dx,(%edi) // do the final pixel's z ! 1098: ! 1099: LFSpanDone: ! 1100: movl espan_t_pnext(%esi),%esi ! 1101: testl %esi,%esi ! 1102: jnz LFSpanLoop ! 1103: ! 1104: jmp LFDone ! 1105: ! 1106: LFNegSpan: ! 1107: fmuls FloatMinus2ToThe31nd ! 1108: fistpl izistep // note: we are relying on FP exceptions being turned ! 1109: // off here to avoid range problems ! 1110: movl izistep,%ebx // remains loaded for all spans ! 1111: ! 1112: LFNegSpanLoop: ! 1113: // set up the initial 1/z value ! 1114: fildl espan_t_v(%esi) ! 1115: fildl espan_t_u(%esi) ! 1116: movl espan_t_v(%esi),%ecx ! 1117: movl C(d_pzbuffer),%edi ! 1118: fmuls C(d_zistepu) ! 1119: fxch %st(1) ! 1120: fmuls C(d_zistepv) ! 1121: fxch %st(1) ! 1122: fadds C(d_ziorigin) ! 1123: imull C(d_zrowbytes),%ecx ! 1124: faddp %st(0),%st(1) ! 1125: ! 1126: // clamp if z is nearer than 2 (1/z > 0.5) ! 1127: fcoms float_point5 ! 1128: addl %ecx,%edi ! 1129: movl espan_t_u(%esi),%edx ! 1130: addl %edx,%edx // word count ! 1131: movl espan_t_count(%esi),%ecx ! 1132: addl %edx,%edi // pdest = &pdestspan[scans->u]; ! 1133: pushl %esi // preserve spans pointer ! 1134: fnstsw %ax ! 1135: testb $0x45,%ah ! 1136: jz LClampNeg ! 1137: ! 1138: fmuls Float2ToThe31nd ! 1139: fistpl izi // note: we are relying on FP exceptions being turned ! 1140: // off here to avoid problems when the span is closer ! 1141: // than 1/(2**31) ! 1142: movl izi,%edx ! 1143: ! 1144: // at this point: ! 1145: // %ebx = izistep ! 1146: // %ecx = count ! 1147: // %edx = izi ! 1148: // %edi = pdest ! 1149: ! 1150: LZDrawNeg: ! 1151: ! 1152: // do a single pixel up front, if necessary to dword align the destination ! 1153: testl $2,%edi ! 1154: jz LFNegMiddle ! 1155: movl %edx,%eax ! 1156: subl %ebx,%edx ! 1157: shrl $16,%eax ! 1158: decl %ecx ! 1159: movw %ax,(%edi) ! 1160: addl $2,%edi ! 1161: ! 1162: // do middle a pair of aligned dwords at a time ! 1163: LFNegMiddle: ! 1164: pushl %ecx ! 1165: shrl $1,%ecx // count / 2 ! 1166: jz LFNegLast // no aligned dwords to do ! 1167: shrl $1,%ecx // (count / 2) / 2 ! 1168: jnc LFNegMiddleLoop // even number of aligned dwords to do ! 1169: ! 1170: movl %edx,%eax ! 1171: subl %ebx,%edx ! 1172: shrl $16,%eax ! 1173: movl %edx,%esi ! 1174: subl %ebx,%edx ! 1175: andl $0xFFFF0000,%esi ! 1176: orl %esi,%eax ! 1177: movl %eax,(%edi) ! 1178: addl $4,%edi ! 1179: andl %ecx,%ecx ! 1180: jz LFNegLast ! 1181: ! 1182: LFNegMiddleLoop: ! 1183: movl %edx,%eax ! 1184: subl %ebx,%edx ! 1185: shrl $16,%eax ! 1186: movl %edx,%esi ! 1187: subl %ebx,%edx ! 1188: andl $0xFFFF0000,%esi ! 1189: orl %esi,%eax ! 1190: movl %edx,%ebp ! 1191: movl %eax,(%edi) ! 1192: subl %ebx,%edx ! 1193: shrl $16,%ebp ! 1194: movl %edx,%esi ! 1195: subl %ebx,%edx ! 1196: andl $0xFFFF0000,%esi ! 1197: orl %esi,%ebp ! 1198: movl %ebp,4(%edi) // FIXME: eliminate register contention ! 1199: addl $8,%edi ! 1200: ! 1201: decl %ecx ! 1202: jnz LFNegMiddleLoop ! 1203: ! 1204: LFNegLast: ! 1205: popl %ecx // retrieve count ! 1206: popl %esi // retrieve span pointer ! 1207: ! 1208: // do the last, unaligned pixel, if there is one ! 1209: andl $1,%ecx // is there an odd pixel left to do? ! 1210: jz LFNegSpanDone // no ! 1211: shrl $16,%edx ! 1212: movw %dx,(%edi) // do the final pixel's z ! 1213: ! 1214: LFNegSpanDone: ! 1215: movl espan_t_pnext(%esi),%esi ! 1216: testl %esi,%esi ! 1217: jnz LFNegSpanLoop ! 1218: ! 1219: LFDone: ! 1220: popl %ebx // restore register variables ! 1221: popl %esi ! 1222: popl %edi ! 1223: popl %ebp // restore the caller's stack frame ! 1224: ret ! 1225: ! 1226: #endif // id386 ! 1227:
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.