1 /* 2 Copyright (C) 1996-1997 Id Software, Inc. 3 4 This program is free software; you can redistribute it and/or 5 modify it under the terms of the GNU General Public License 6 as published by the Free Software Foundation; either version 2 7 of the License, or (at your option) any later version. 8 9 This program is distributed in the hope that it will be useful, 10 but WITHOUT ANY WARRANTY; without even the implied warranty of 11 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. 12 13 See the GNU General Public License for more details. 14 15 You should have received a copy of the GNU General Public License 16 along with this program; if not, write to the Free Software 17 Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. 18 19 */ 20 // 21 // d_draw16.s 22 // x86 assembly-language horizontal 8-bpp span-drawing code, with 16-pixel 23 // subdivision. 24 // 25 26 #include "asm_i386.h" 27 #include "quakeasm.h" 28 #include "asm_draw.h" 29 #include "d_ifacea.h" 30 31 #if id386 32 33 //---------------------------------------------------------------------- 34 // 8-bpp horizontal span drawing code for polygons, with no transparency and 35 // 16-pixel subdivision. 36 // 37 // Assumes there is at least one span in pspans, and that every span 38 // contains at least one pixel 39 //---------------------------------------------------------------------- 40 41 .data 42 43 .text 44 45 // out-of-line, rarely-needed clamping code 46 47 LClampHigh0: 48 movl C(bbextents),%esi 49 jmp LClampReentry0 50 LClampHighOrLow0: 51 jg LClampHigh0 52 xorl %esi,%esi 53 jmp LClampReentry0 54 55 LClampHigh1: 56 movl C(bbextentt),%edx 57 jmp LClampReentry1 58 LClampHighOrLow1: 59 jg LClampHigh1 60 xorl %edx,%edx 61 jmp LClampReentry1 62 63 LClampLow2: 64 movl $4096,%ebp 65 jmp LClampReentry2 66 LClampHigh2: 67 movl C(bbextents),%ebp 68 jmp LClampReentry2 69 70 LClampLow3: 71 movl $4096,%ecx 72 jmp LClampReentry3 73 LClampHigh3: 74 movl C(bbextentt),%ecx 75 jmp LClampReentry3 76 77 LClampLow4: 78 movl $4096,%eax 79 jmp LClampReentry4 80 LClampHigh4: 81 movl C(bbextents),%eax 82 jmp LClampReentry4 83 84 LClampLow5: 85 movl $4096,%ebx 86 jmp LClampReentry5 87 LClampHigh5: 88 movl C(bbextentt),%ebx 89 jmp LClampReentry5 90 91 92 #define pspans 4+16 93 94 .align 4 95 .globl C(D_DrawSpans16) 96 C(D_DrawSpans16): 97 pushl %ebp // preserve caller's stack frame 98 pushl %edi 99 pushl %esi // preserve register variables 100 pushl %ebx 101 102 // 103 // set up scaled-by-16 steps, for 16-long segments; also set up cacheblock 104 // and span list pointers 105 // 106 // TODO: any overlap from rearranging? 107 flds C(d_sdivzstepu) 108 fmuls fp_16 109 movl C(cacheblock),%edx 110 flds C(d_tdivzstepu) 111 fmuls fp_16 112 movl pspans(%esp),%ebx // point to the first span descriptor 113 flds C(d_zistepu) 114 fmuls fp_16 115 movl %edx,pbase // pbase = cacheblock 116 fstps zi16stepu 117 fstps tdivz16stepu 118 fstps sdivz16stepu 119 120 LSpanLoop: 121 // 122 // set up the initial s/z, t/z, and 1/z on the FP stack, and generate the 123 // initial s and t values 124 // 125 // FIXME: pipeline FILD? 126 fildl espan_t_v(%ebx) 127 fildl espan_t_u(%ebx) 128 129 fld %st(1) // dv | du | dv 130 fmuls C(d_sdivzstepv) // dv*d_sdivzstepv | du | dv 131 fld %st(1) // du | dv*d_sdivzstepv | du | dv 132 fmuls C(d_sdivzstepu) // du*d_sdivzstepu | dv*d_sdivzstepv | du | dv 133 fld %st(2) // du | du*d_sdivzstepu | dv*d_sdivzstepv | du | dv 134 fmuls C(d_tdivzstepu) // du*d_tdivzstepu | du*d_sdivzstepu | 135 // dv*d_sdivzstepv | du | dv 136 fxch %st(1) // du*d_sdivzstepu | du*d_tdivzstepu | 137 // dv*d_sdivzstepv | du | dv 138 faddp %st(0),%st(2) // du*d_tdivzstepu | 139 // du*d_sdivzstepu + dv*d_sdivzstepv | du | dv 140 fxch %st(1) // du*d_sdivzstepu + dv*d_sdivzstepv | 141 // du*d_tdivzstepu | du | dv 142 fld %st(3) // dv | du*d_sdivzstepu + dv*d_sdivzstepv | 143 // du*d_tdivzstepu | du | dv 144 fmuls C(d_tdivzstepv) // dv*d_tdivzstepv | 145 // du*d_sdivzstepu + dv*d_sdivzstepv | 146 // du*d_tdivzstepu | du | dv 147 fxch %st(1) // du*d_sdivzstepu + dv*d_sdivzstepv | 148 // dv*d_tdivzstepv | du*d_tdivzstepu | du | dv 149 fadds C(d_sdivzorigin) // sdivz = d_sdivzorigin + dv*d_sdivzstepv + 150 // du*d_sdivzstepu; stays in %st(2) at end 151 fxch %st(4) // dv | dv*d_tdivzstepv | du*d_tdivzstepu | du | 152 // s/z 153 fmuls C(d_zistepv) // dv*d_zistepv | dv*d_tdivzstepv | 154 // du*d_tdivzstepu | du | s/z 155 fxch %st(1) // dv*d_tdivzstepv | dv*d_zistepv | 156 // du*d_tdivzstepu | du | s/z 157 faddp %st(0),%st(2) // dv*d_zistepv | 158 // dv*d_tdivzstepv + du*d_tdivzstepu | du | s/z 159 fxch %st(2) // du | dv*d_tdivzstepv + du*d_tdivzstepu | 160 // dv*d_zistepv | s/z 161 fmuls C(d_zistepu) // du*d_zistepu | 162 // dv*d_tdivzstepv + du*d_tdivzstepu | 163 // dv*d_zistepv | s/z 164 fxch %st(1) // dv*d_tdivzstepv + du*d_tdivzstepu | 165 // du*d_zistepu | dv*d_zistepv | s/z 166 fadds C(d_tdivzorigin) // tdivz = d_tdivzorigin + dv*d_tdivzstepv + 167 // du*d_tdivzstepu; stays in %st(1) at end 168 fxch %st(2) // dv*d_zistepv | du*d_zistepu | t/z | s/z 169 faddp %st(0),%st(1) // dv*d_zistepv + du*d_zistepu | t/z | s/z 170 171 flds fp_64k // fp_64k | dv*d_zistepv + du*d_zistepu | t/z | s/z 172 fxch %st(1) // dv*d_zistepv + du*d_zistepu | fp_64k | t/z | s/z 173 fadds C(d_ziorigin) // zi = d_ziorigin + dv*d_zistepv + 174 // du*d_zistepu; stays in %st(0) at end 175 // 1/z | fp_64k | t/z | s/z 176 // 177 // calculate and clamp s & t 178 // 179 fdivr %st(0),%st(1) // 1/z | z*64k | t/z | s/z 180 181 // 182 // point %edi to the first pixel in the span 183 // 184 movl C(d_viewbuffer),%ecx 185 movl espan_t_v(%ebx),%eax 186 movl %ebx,pspantemp // preserve spans pointer 187 188 movl C(tadjust),%edx 189 movl C(sadjust),%esi 190 movl C(d_scantable)(,%eax,4),%edi // v * screenwidth 191 addl %ecx,%edi 192 movl espan_t_u(%ebx),%ecx 193 addl %ecx,%edi // pdest = &pdestspan[scans->u]; 194 movl espan_t_count(%ebx),%ecx 195 196 // 197 // now start the FDIV for the end of the span 198 // 199 cmpl $16,%ecx 200 ja LSetupNotLast1 201 202 decl %ecx 203 jz LCleanup1 // if only one pixel, no need to start an FDIV 204 movl %ecx,spancountminus1 205 206 // finish up the s and t calcs 207 fxch %st(1) // z*64k | 1/z | t/z | s/z 208 209 fld %st(0) // z*64k | z*64k | 1/z | t/z | s/z 210 fmul %st(4),%st(0) // s | z*64k | 1/z | t/z | s/z 211 fxch %st(1) // z*64k | s | 1/z | t/z | s/z 212 fmul %st(3),%st(0) // t | s | 1/z | t/z | s/z 213 fxch %st(1) // s | t | 1/z | t/z | s/z 214 fistpl s // 1/z | t | t/z | s/z 215 fistpl t // 1/z | t/z | s/z 216 217 fildl spancountminus1 218 219 flds C(d_tdivzstepu) // C(d_tdivzstepu) | spancountminus1 220 flds C(d_zistepu) // C(d_zistepu) | C(d_tdivzstepu) | spancountminus1 221 fmul %st(2),%st(0) // C(d_zistepu)*scm1 | C(d_tdivzstepu) | scm1 222 fxch %st(1) // C(d_tdivzstepu) | C(d_zistepu)*scm1 | scm1 223 fmul %st(2),%st(0) // C(d_tdivzstepu)*scm1 | C(d_zistepu)*scm1 | scm1 224 fxch %st(2) // scm1 | C(d_zistepu)*scm1 | C(d_tdivzstepu)*scm1 225 fmuls C(d_sdivzstepu) // C(d_sdivzstepu)*scm1 | C(d_zistepu)*scm1 | 226 // C(d_tdivzstepu)*scm1 227 fxch %st(1) // C(d_zistepu)*scm1 | C(d_sdivzstepu)*scm1 | 228 // C(d_tdivzstepu)*scm1 229 faddp %st(0),%st(3) // C(d_sdivzstepu)*scm1 | C(d_tdivzstepu)*scm1 230 fxch %st(1) // C(d_tdivzstepu)*scm1 | C(d_sdivzstepu)*scm1 231 faddp %st(0),%st(3) // C(d_sdivzstepu)*scm1 232 faddp %st(0),%st(3) 233 234 flds fp_64k 235 fdiv %st(1),%st(0) // this is what we've gone to all this trouble to 236 // overlap 237 jmp LFDIVInFlight1 238 239 LCleanup1: 240 // finish up the s and t calcs 241 fxch %st(1) // z*64k | 1/z | t/z | s/z 242 243 fld %st(0) // z*64k | z*64k | 1/z | t/z | s/z 244 fmul %st(4),%st(0) // s | z*64k | 1/z | t/z | s/z 245 fxch %st(1) // z*64k | s | 1/z | t/z | s/z 246 fmul %st(3),%st(0) // t | s | 1/z | t/z | s/z 247 fxch %st(1) // s | t | 1/z | t/z | s/z 248 fistpl s // 1/z | t | t/z | s/z 249 fistpl t // 1/z | t/z | s/z 250 jmp LFDIVInFlight1 251 252 .align 4 253 LSetupNotLast1: 254 // finish up the s and t calcs 255 fxch %st(1) // z*64k | 1/z | t/z | s/z 256 257 fld %st(0) // z*64k | z*64k | 1/z | t/z | s/z 258 fmul %st(4),%st(0) // s | z*64k | 1/z | t/z | s/z 259 fxch %st(1) // z*64k | s | 1/z | t/z | s/z 260 fmul %st(3),%st(0) // t | s | 1/z | t/z | s/z 261 fxch %st(1) // s | t | 1/z | t/z | s/z 262 fistpl s // 1/z | t | t/z | s/z 263 fistpl t // 1/z | t/z | s/z 264 265 fadds zi16stepu 266 fxch %st(2) 267 fadds sdivz16stepu 268 fxch %st(2) 269 flds tdivz16stepu 270 faddp %st(0),%st(2) 271 flds fp_64k 272 fdiv %st(1),%st(0) // z = 1/1/z 273 // this is what we've gone to all this trouble to 274 // overlap 275 LFDIVInFlight1: 276 277 addl s,%esi 278 addl t,%edx 279 movl C(bbextents),%ebx 280 movl C(bbextentt),%ebp 281 cmpl %ebx,%esi 282 ja LClampHighOrLow0 283 LClampReentry0: 284 movl %esi,s 285 movl pbase,%ebx 286 shll $16,%esi 287 cmpl %ebp,%edx 288 movl %esi,sfracf 289 ja LClampHighOrLow1 290 LClampReentry1: 291 movl %edx,t 292 movl s,%esi // sfrac = scans->sfrac; 293 shll $16,%edx 294 movl t,%eax // tfrac = scans->tfrac; 295 sarl $16,%esi 296 movl %edx,tfracf 297 298 // 299 // calculate the texture starting address 300 // 301 sarl $16,%eax 302 movl C(cachewidth),%edx 303 imull %edx,%eax // (tfrac >> 16) * cachewidth 304 addl %ebx,%esi 305 addl %eax,%esi // psource = pbase + (sfrac >> 16) + 306 // ((tfrac >> 16) * cachewidth); 307 // 308 // determine whether last span or not 309 // 310 cmpl $16,%ecx 311 jna LLastSegment 312 313 // 314 // not the last segment; do full 16-wide segment 315 // 316 LNotLastSegment: 317 318 // 319 // advance s/z, t/z, and 1/z, and calculate s & t at end of span and steps to 320 // get there 321 // 322 323 // pick up after the FDIV that was left in flight previously 324 325 fld %st(0) // duplicate it 326 fmul %st(4),%st(0) // s = s/z * z 327 fxch %st(1) 328 fmul %st(3),%st(0) // t = t/z * z 329 fxch %st(1) 330 fistpl snext 331 fistpl tnext 332 movl snext,%eax 333 movl tnext,%edx 334 335 movb (%esi),%bl // get first source texel 336 subl $16,%ecx // count off this segments' pixels 337 movl C(sadjust),%ebp 338 movl %ecx,counttemp // remember count of remaining pixels 339 340 movl C(tadjust),%ecx 341 movb %bl,(%edi) // store first dest pixel 342 343 addl %eax,%ebp 344 addl %edx,%ecx 345 346 movl C(bbextents),%eax 347 movl C(bbextentt),%edx 348 349 cmpl $4096,%ebp 350 jl LClampLow2 351 cmpl %eax,%ebp 352 ja LClampHigh2 353 LClampReentry2: 354 355 cmpl $4096,%ecx 356 jl LClampLow3 357 cmpl %edx,%ecx 358 ja LClampHigh3 359 LClampReentry3: 360 361 movl %ebp,snext 362 movl %ecx,tnext 363 364 subl s,%ebp 365 subl t,%ecx 366 367 // 368 // set up advancetable 369 // 370 movl %ecx,%eax 371 movl %ebp,%edx 372 sarl $20,%eax // tstep >>= 16; 373 jz LZero 374 sarl $20,%edx // sstep >>= 16; 375 movl C(cachewidth),%ebx 376 imull %ebx,%eax 377 jmp LSetUp1 378 379 LZero: 380 sarl $20,%edx // sstep >>= 16; 381 movl C(cachewidth),%ebx 382 383 LSetUp1: 384 385 addl %edx,%eax // add in sstep 386 // (tstep >> 16) * cachewidth + (sstep >> 16); 387 movl tfracf,%edx 388 movl %eax,advancetable+4 // advance base in t 389 addl %ebx,%eax // ((tstep >> 16) + 1) * cachewidth + 390 // (sstep >> 16); 391 shll $12,%ebp // left-justify sstep fractional part 392 movl sfracf,%ebx 393 shll $12,%ecx // left-justify tstep fractional part 394 movl %eax,advancetable // advance extra in t 395 396 movl %ecx,tstep 397 addl %ecx,%edx // advance tfrac fractional part by tstep frac 398 399 sbbl %ecx,%ecx // turn tstep carry into -1 (0 if none) 400 addl %ebp,%ebx // advance sfrac fractional part by sstep frac 401 adcl advancetable+4(,%ecx,4),%esi // point to next source texel 402 403 addl tstep,%edx 404 sbbl %ecx,%ecx 405 movb (%esi),%al 406 addl %ebp,%ebx 407 movb %al,1(%edi) 408 adcl advancetable+4(,%ecx,4),%esi 409 410 addl tstep,%edx 411 sbbl %ecx,%ecx 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,2(%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,3(%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,4(%edi) 433 addl %ebp,%ebx 434 movb (%esi),%al 435 adcl advancetable+4(,%ecx,4),%esi 436 437 addl tstep,%edx 438 sbbl %ecx,%ecx 439 movb %al,5(%edi) 440 addl %ebp,%ebx 441 movb (%esi),%al 442 adcl advancetable+4(,%ecx,4),%esi 443 444 addl tstep,%edx 445 sbbl %ecx,%ecx 446 movb %al,6(%edi) 447 addl %ebp,%ebx 448 movb (%esi),%al 449 adcl advancetable+4(,%ecx,4),%esi 450 451 addl tstep,%edx 452 sbbl %ecx,%ecx 453 movb %al,7(%edi) 454 addl %ebp,%ebx 455 movb (%esi),%al 456 adcl advancetable+4(,%ecx,4),%esi 457 458 459 // 460 // start FDIV for end of next segment in flight, so it can overlap 461 // 462 movl counttemp,%ecx 463 cmpl $16,%ecx // more than one segment after this? 464 ja LSetupNotLast2 // yes 465 466 decl %ecx 467 jz LFDIVInFlight2 // if only one pixel, no need to start an FDIV 468 movl %ecx,spancountminus1 469 fildl spancountminus1 470 471 flds C(d_zistepu) // C(d_zistepu) | spancountminus1 472 fmul %st(1),%st(0) // C(d_zistepu)*scm1 | scm1 473 flds C(d_tdivzstepu) // C(d_tdivzstepu) | C(d_zistepu)*scm1 | scm1 474 fmul %st(2),%st(0) // C(d_tdivzstepu)*scm1 | C(d_zistepu)*scm1 | scm1 475 fxch %st(1) // C(d_zistepu)*scm1 | C(d_tdivzstepu)*scm1 | scm1 476 faddp %st(0),%st(3) // C(d_tdivzstepu)*scm1 | scm1 477 fxch %st(1) // scm1 | C(d_tdivzstepu)*scm1 478 fmuls C(d_sdivzstepu) // C(d_sdivzstepu)*scm1 | C(d_tdivzstepu)*scm1 479 fxch %st(1) // C(d_tdivzstepu)*scm1 | C(d_sdivzstepu)*scm1 480 faddp %st(0),%st(3) // C(d_sdivzstepu)*scm1 481 flds fp_64k // 64k | C(d_sdivzstepu)*scm1 482 fxch %st(1) // C(d_sdivzstepu)*scm1 | 64k 483 faddp %st(0),%st(4) // 64k 484 485 fdiv %st(1),%st(0) // this is what we've gone to all this trouble to 486 // overlap 487 jmp LFDIVInFlight2 488 489 .align 4 490 LSetupNotLast2: 491 fadds zi16stepu 492 fxch %st(2) 493 fadds sdivz16stepu 494 fxch %st(2) 495 flds tdivz16stepu 496 faddp %st(0),%st(2) 497 flds fp_64k 498 fdiv %st(1),%st(0) // z = 1/1/z 499 // this is what we've gone to all this trouble to 500 // overlap 501 LFDIVInFlight2: 502 movl %ecx,counttemp 503 504 addl tstep,%edx 505 sbbl %ecx,%ecx 506 movb %al,8(%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,9(%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,10(%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,11(%edi) 528 addl %ebp,%ebx 529 movb (%esi),%al 530 adcl advancetable+4(,%ecx,4),%esi 531 532 addl tstep,%edx 533 sbbl %ecx,%ecx 534 movb %al,12(%edi) 535 addl %ebp,%ebx 536 movb (%esi),%al 537 adcl advancetable+4(,%ecx,4),%esi 538 539 addl tstep,%edx 540 sbbl %ecx,%ecx 541 movb %al,13(%edi) 542 addl %ebp,%ebx 543 movb (%esi),%al 544 adcl advancetable+4(,%ecx,4),%esi 545 546 addl tstep,%edx 547 sbbl %ecx,%ecx 548 movb %al,14(%edi) 549 addl %ebp,%ebx 550 movb (%esi),%al 551 adcl advancetable+4(,%ecx,4),%esi 552 553 addl $16,%edi 554 movl %edx,tfracf 555 movl snext,%edx 556 movl %ebx,sfracf 557 movl tnext,%ebx 558 movl %edx,s 559 movl %ebx,t 560 561 movl counttemp,%ecx // retrieve count 562 563 // 564 // determine whether last span or not 565 // 566 cmpl $16,%ecx // are there multiple segments remaining? 567 movb %al,-1(%edi) 568 ja LNotLastSegment // yes 569 570 // 571 // last segment of scan 572 // 573 LLastSegment: 574 575 // 576 // advance s/z, t/z, and 1/z, and calculate s & t at end of span and steps to 577 // get there. The number of pixels left is variable, and we want to land on the 578 // last pixel, not step one past it, so we can't run into arithmetic problems 579 // 580 testl %ecx,%ecx 581 jz LNoSteps // just draw the last pixel and we're done 582 583 // pick up after the FDIV that was left in flight previously 584 585 586 fld %st(0) // duplicate it 587 fmul %st(4),%st(0) // s = s/z * z 588 fxch %st(1) 589 fmul %st(3),%st(0) // t = t/z * z 590 fxch %st(1) 591 fistpl snext 592 fistpl tnext 593 594 movb (%esi),%al // load first texel in segment 595 movl C(tadjust),%ebx 596 movb %al,(%edi) // store first pixel in segment 597 movl C(sadjust),%eax 598 599 addl snext,%eax 600 addl tnext,%ebx 601 602 movl C(bbextents),%ebp 603 movl C(bbextentt),%edx 604 605 cmpl $4096,%eax 606 jl LClampLow4 607 cmpl %ebp,%eax 608 ja LClampHigh4 609 LClampReentry4: 610 movl %eax,snext 611 612 cmpl $4096,%ebx 613 jl LClampLow5 614 cmpl %edx,%ebx 615 ja LClampHigh5 616 LClampReentry5: 617 618 cmpl $1,%ecx // don't bother 619 je LOnlyOneStep // if two pixels in segment, there's only one step, 620 // of the segment length 621 subl s,%eax 622 subl t,%ebx 623 624 addl %eax,%eax // convert to 15.17 format so multiply by 1.31 625 addl %ebx,%ebx // reciprocal yields 16.48 626 627 imull reciprocal_table_16-8(,%ecx,4) // sstep = (snext - s) / 628 // (spancount-1) 629 movl %edx,%ebp 630 631 movl %ebx,%eax 632 imull reciprocal_table_16-8(,%ecx,4) // tstep = (tnext - t) / 633 // (spancount-1) 634 LSetEntryvec: 635 // 636 // set up advancetable 637 // 638 movl entryvec_table_16(,%ecx,4),%ebx 639 movl %edx,%eax 640 movl %ebx,jumptemp // entry point into code for RET later 641 movl %ebp,%ecx 642 sarl $16,%edx // tstep >>= 16; 643 movl C(cachewidth),%ebx 644 sarl $16,%ecx // sstep >>= 16; 645 imull %ebx,%edx 646 647 addl %ecx,%edx // add in sstep 648 // (tstep >> 16) * cachewidth + (sstep >> 16); 649 movl tfracf,%ecx 650 movl %edx,advancetable+4 // advance base in t 651 addl %ebx,%edx // ((tstep >> 16) + 1) * cachewidth + 652 // (sstep >> 16); 653 shll $16,%ebp // left-justify sstep fractional part 654 movl sfracf,%ebx 655 shll $16,%eax // left-justify tstep fractional part 656 movl %edx,advancetable // advance extra in t 657 658 movl %eax,tstep 659 movl %ecx,%edx 660 addl %eax,%edx 661 sbbl %ecx,%ecx 662 addl %ebp,%ebx 663 adcl advancetable+4(,%ecx,4),%esi 664 665 jmp *jumptemp // jump to the number-of-pixels handler 666 667 //---------------------------------------- 668 669 LNoSteps: 670 movb (%esi),%al // load first texel in segment 671 subl $15,%edi // adjust for hardwired offset 672 jmp LEndSpan 673 674 675 LOnlyOneStep: 676 subl s,%eax 677 subl t,%ebx 678 movl %eax,%ebp 679 movl %ebx,%edx 680 jmp LSetEntryvec 681 682 //---------------------------------------- 683 684 .globl Entry2_16, Entry3_16, Entry4_16, Entry5_16 685 .globl Entry6_16, Entry7_16, Entry8_16, Entry9_16 686 .globl Entry10_16, Entry11_16, Entry12_16, Entry13_16 687 .globl Entry14_16, Entry15_16, Entry16_16 688 689 Entry2_16: 690 subl $14,%edi // adjust for hardwired offsets 691 movb (%esi),%al 692 jmp LEntry2_16 693 694 //---------------------------------------- 695 696 Entry3_16: 697 subl $13,%edi // adjust for hardwired offsets 698 addl %eax,%edx 699 movb (%esi),%al 700 sbbl %ecx,%ecx 701 addl %ebp,%ebx 702 adcl advancetable+4(,%ecx,4),%esi 703 jmp LEntry3_16 704 705 //---------------------------------------- 706 707 Entry4_16: 708 subl $12,%edi // adjust for hardwired offsets 709 addl %eax,%edx 710 movb (%esi),%al 711 sbbl %ecx,%ecx 712 addl %ebp,%ebx 713 adcl advancetable+4(,%ecx,4),%esi 714 addl tstep,%edx 715 jmp LEntry4_16 716 717 //---------------------------------------- 718 719 Entry5_16: 720 subl $11,%edi // adjust for hardwired offsets 721 addl %eax,%edx 722 movb (%esi),%al 723 sbbl %ecx,%ecx 724 addl %ebp,%ebx 725 adcl advancetable+4(,%ecx,4),%esi 726 addl tstep,%edx 727 jmp LEntry5_16 728 729 //---------------------------------------- 730 731 Entry6_16: 732 subl $10,%edi // adjust for hardwired offsets 733 addl %eax,%edx 734 movb (%esi),%al 735 sbbl %ecx,%ecx 736 addl %ebp,%ebx 737 adcl advancetable+4(,%ecx,4),%esi 738 addl tstep,%edx 739 jmp LEntry6_16 740 741 //---------------------------------------- 742 743 Entry7_16: 744 subl $9,%edi // adjust for hardwired offsets 745 addl %eax,%edx 746 movb (%esi),%al 747 sbbl %ecx,%ecx 748 addl %ebp,%ebx 749 adcl advancetable+4(,%ecx,4),%esi 750 addl tstep,%edx 751 jmp LEntry7_16 752 753 //---------------------------------------- 754 755 Entry8_16: 756 subl $8,%edi // adjust for hardwired offsets 757 addl %eax,%edx 758 movb (%esi),%al 759 sbbl %ecx,%ecx 760 addl %ebp,%ebx 761 adcl advancetable+4(,%ecx,4),%esi 762 addl tstep,%edx 763 jmp LEntry8_16 764 765 //---------------------------------------- 766 767 Entry9_16: 768 subl $7,%edi // adjust for hardwired offsets 769 addl %eax,%edx 770 movb (%esi),%al 771 sbbl %ecx,%ecx 772 addl %ebp,%ebx 773 adcl advancetable+4(,%ecx,4),%esi 774 addl tstep,%edx 775 jmp LEntry9_16 776 777 //---------------------------------------- 778 779 Entry10_16: 780 subl $6,%edi // adjust for hardwired offsets 781 addl %eax,%edx 782 movb (%esi),%al 783 sbbl %ecx,%ecx 784 addl %ebp,%ebx 785 adcl advancetable+4(,%ecx,4),%esi 786 addl tstep,%edx 787 jmp LEntry10_16 788 789 //---------------------------------------- 790 791 Entry11_16: 792 subl $5,%edi // adjust for hardwired offsets 793 addl %eax,%edx 794 movb (%esi),%al 795 sbbl %ecx,%ecx 796 addl %ebp,%ebx 797 adcl advancetable+4(,%ecx,4),%esi 798 addl tstep,%edx 799 jmp LEntry11_16 800 801 //---------------------------------------- 802 803 Entry12_16: 804 subl $4,%edi // adjust for hardwired offsets 805 addl %eax,%edx 806 movb (%esi),%al 807 sbbl %ecx,%ecx 808 addl %ebp,%ebx 809 adcl advancetable+4(,%ecx,4),%esi 810 addl tstep,%edx 811 jmp LEntry12_16 812 813 //---------------------------------------- 814 815 Entry13_16: 816 subl $3,%edi // adjust for hardwired offsets 817 addl %eax,%edx 818 movb (%esi),%al 819 sbbl %ecx,%ecx 820 addl %ebp,%ebx 821 adcl advancetable+4(,%ecx,4),%esi 822 addl tstep,%edx 823 jmp LEntry13_16 824 825 //---------------------------------------- 826 827 Entry14_16: 828 subl $2,%edi // adjust for hardwired offsets 829 addl %eax,%edx 830 movb (%esi),%al 831 sbbl %ecx,%ecx 832 addl %ebp,%ebx 833 adcl advancetable+4(,%ecx,4),%esi 834 addl tstep,%edx 835 jmp LEntry14_16 836 837 //---------------------------------------- 838 839 Entry15_16: 840 decl %edi // adjust for hardwired offsets 841 addl %eax,%edx 842 movb (%esi),%al 843 sbbl %ecx,%ecx 844 addl %ebp,%ebx 845 adcl advancetable+4(,%ecx,4),%esi 846 addl tstep,%edx 847 jmp LEntry15_16 848 849 //---------------------------------------- 850 851 Entry16_16: 852 addl %eax,%edx 853 movb (%esi),%al 854 sbbl %ecx,%ecx 855 addl %ebp,%ebx 856 adcl advancetable+4(,%ecx,4),%esi 857 858 addl tstep,%edx 859 sbbl %ecx,%ecx 860 movb %al,1(%edi) 861 addl %ebp,%ebx 862 movb (%esi),%al 863 adcl advancetable+4(,%ecx,4),%esi 864 addl tstep,%edx 865 LEntry15_16: 866 sbbl %ecx,%ecx 867 movb %al,2(%edi) 868 addl %ebp,%ebx 869 movb (%esi),%al 870 adcl advancetable+4(,%ecx,4),%esi 871 addl tstep,%edx 872 LEntry14_16: 873 sbbl %ecx,%ecx 874 movb %al,3(%edi) 875 addl %ebp,%ebx 876 movb (%esi),%al 877 adcl advancetable+4(,%ecx,4),%esi 878 addl tstep,%edx 879 LEntry13_16: 880 sbbl %ecx,%ecx 881 movb %al,4(%edi) 882 addl %ebp,%ebx 883 movb (%esi),%al 884 adcl advancetable+4(,%ecx,4),%esi 885 addl tstep,%edx 886 LEntry12_16: 887 sbbl %ecx,%ecx 888 movb %al,5(%edi) 889 addl %ebp,%ebx 890 movb (%esi),%al 891 adcl advancetable+4(,%ecx,4),%esi 892 addl tstep,%edx 893 LEntry11_16: 894 sbbl %ecx,%ecx 895 movb %al,6(%edi) 896 addl %ebp,%ebx 897 movb (%esi),%al 898 adcl advancetable+4(,%ecx,4),%esi 899 addl tstep,%edx 900 LEntry10_16: 901 sbbl %ecx,%ecx 902 movb %al,7(%edi) 903 addl %ebp,%ebx 904 movb (%esi),%al 905 adcl advancetable+4(,%ecx,4),%esi 906 addl tstep,%edx 907 LEntry9_16: 908 sbbl %ecx,%ecx 909 movb %al,8(%edi) 910 addl %ebp,%ebx 911 movb (%esi),%al 912 adcl advancetable+4(,%ecx,4),%esi 913 addl tstep,%edx 914 LEntry8_16: 915 sbbl %ecx,%ecx 916 movb %al,9(%edi) 917 addl %ebp,%ebx 918 movb (%esi),%al 919 adcl advancetable+4(,%ecx,4),%esi 920 addl tstep,%edx 921 LEntry7_16: 922 sbbl %ecx,%ecx 923 movb %al,10(%edi) 924 addl %ebp,%ebx 925 movb (%esi),%al 926 adcl advancetable+4(,%ecx,4),%esi 927 addl tstep,%edx 928 LEntry6_16: 929 sbbl %ecx,%ecx 930 movb %al,11(%edi) 931 addl %ebp,%ebx 932 movb (%esi),%al 933 adcl advancetable+4(,%ecx,4),%esi 934 addl tstep,%edx 935 LEntry5_16: 936 sbbl %ecx,%ecx 937 movb %al,12(%edi) 938 addl %ebp,%ebx 939 movb (%esi),%al 940 adcl advancetable+4(,%ecx,4),%esi 941 addl tstep,%edx 942 LEntry4_16: 943 sbbl %ecx,%ecx 944 movb %al,13(%edi) 945 addl %ebp,%ebx 946 movb (%esi),%al 947 adcl advancetable+4(,%ecx,4),%esi 948 LEntry3_16: 949 movb %al,14(%edi) 950 movb (%esi),%al 951 LEntry2_16: 952 953 LEndSpan: 954 955 // 956 // clear s/z, t/z, 1/z from FP stack 957 // 958 fstp %st(0) 959 fstp %st(0) 960 fstp %st(0) 961 962 movl pspantemp,%ebx // restore spans pointer 963 movl espan_t_pnext(%ebx),%ebx // point to next span 964 testl %ebx,%ebx // any more spans? 965 movb %al,15(%edi) 966 jnz LSpanLoop // more spans 967 968 popl %ebx // restore register variables 969 popl %esi 970 popl %edi 971 popl %ebp // restore the caller's stack frame 972 ret 973 974 #endif // id386 975
