![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to r_edgea.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_edgea.s CVS log | Up to [Quake II] / quake2 / linux |
1.1 root 1: //
2: // r_edgea.s
3: // x86 assembly-language edge-processing code.
4: //
5:
6: #include "qasm.h"
7:
8: #if id386
9:
10: .data
11: Ltemp: .long 0
12: float_1_div_0100000h: .long 0x35800000 // 1.0/(float)0x100000
13: float_point_999: .single 0.999
14: float_1_point_001: .single 1.001
15:
16: .text
17:
18: //--------------------------------------------------------------------
19:
20: #define edgestoadd 4+8 // note odd stack offsets because of interleaving
21: #define edgelist 8+12 // with pushes
22:
23: .globl C(R_EdgeCodeStart)
24: C(R_EdgeCodeStart):
25:
26: .globl C(R_InsertNewEdges)
27: C(R_InsertNewEdges):
28: pushl %edi
29: pushl %esi // preserve register variables
30: movl edgestoadd(%esp),%edx
31: pushl %ebx
32: movl edgelist(%esp),%ecx
33:
34: LDoNextEdge:
35: movl et_u(%edx),%eax
36: movl %edx,%edi
37:
38: LContinueSearch:
39: movl et_u(%ecx),%ebx
40: movl et_next(%ecx),%esi
41: cmpl %ebx,%eax
42: jle LAddedge
43: movl et_u(%esi),%ebx
44: movl et_next(%esi),%ecx
45: cmpl %ebx,%eax
46: jle LAddedge2
47: movl et_u(%ecx),%ebx
48: movl et_next(%ecx),%esi
49: cmpl %ebx,%eax
50: jle LAddedge
51: movl et_u(%esi),%ebx
52: movl et_next(%esi),%ecx
53: cmpl %ebx,%eax
54: jg LContinueSearch
55:
56: LAddedge2:
57: movl et_next(%edx),%edx
58: movl et_prev(%esi),%ebx
59: movl %esi,et_next(%edi)
60: movl %ebx,et_prev(%edi)
61: movl %edi,et_next(%ebx)
62: movl %edi,et_prev(%esi)
63: movl %esi,%ecx
64:
65: cmpl $0,%edx
66: jnz LDoNextEdge
67: jmp LDone
68:
69: .align 4
70: LAddedge:
71: movl et_next(%edx),%edx
72: movl et_prev(%ecx),%ebx
73: movl %ecx,et_next(%edi)
74: movl %ebx,et_prev(%edi)
75: movl %edi,et_next(%ebx)
76: movl %edi,et_prev(%ecx)
77:
78: cmpl $0,%edx
79: jnz LDoNextEdge
80:
81: LDone:
82: popl %ebx // restore register variables
83: popl %esi
84: popl %edi
85:
86: ret
87:
88: //--------------------------------------------------------------------
89:
90: #define predge 4+4
91:
92: .globl C(R_RemoveEdges)
93: C(R_RemoveEdges):
94: pushl %ebx
95: movl predge(%esp),%eax
96:
97: Lre_loop:
98: movl et_next(%eax),%ecx
99: movl et_nextremove(%eax),%ebx
100: movl et_prev(%eax),%edx
101: testl %ebx,%ebx
102: movl %edx,et_prev(%ecx)
103: jz Lre_done
104: movl %ecx,et_next(%edx)
105:
106: movl et_next(%ebx),%ecx
107: movl et_prev(%ebx),%edx
108: movl et_nextremove(%ebx),%eax
109: movl %edx,et_prev(%ecx)
110: testl %eax,%eax
111: movl %ecx,et_next(%edx)
112: jnz Lre_loop
113:
114: popl %ebx
115: ret
116:
117: Lre_done:
118: movl %ecx,et_next(%edx)
119: popl %ebx
120:
121: ret
122:
123: //--------------------------------------------------------------------
124:
125: #define pedgelist 4+4 // note odd stack offset because of interleaving
126: // with pushes
127:
128: .globl C(R_StepActiveU)
129: C(R_StepActiveU):
130: pushl %edi
131: movl pedgelist(%esp),%edx
132: pushl %esi // preserve register variables
133: pushl %ebx
134:
135: movl et_prev(%edx),%esi
136:
137: LNewEdge:
138: movl et_u(%esi),%edi
139:
140: LNextEdge:
141: movl et_u(%edx),%eax
142: movl et_u_step(%edx),%ebx
143: addl %ebx,%eax
144: movl et_next(%edx),%esi
145: movl %eax,et_u(%edx)
146: cmpl %edi,%eax
147: jl LPushBack
148:
149: movl et_u(%esi),%edi
150: movl et_u_step(%esi),%ebx
151: addl %ebx,%edi
152: movl et_next(%esi),%edx
153: movl %edi,et_u(%esi)
154: cmpl %eax,%edi
155: jl LPushBack2
156:
157: movl et_u(%edx),%eax
158: movl et_u_step(%edx),%ebx
159: addl %ebx,%eax
160: movl et_next(%edx),%esi
161: movl %eax,et_u(%edx)
162: cmpl %edi,%eax
163: jl LPushBack
164:
165: movl et_u(%esi),%edi
166: movl et_u_step(%esi),%ebx
167: addl %ebx,%edi
168: movl et_next(%esi),%edx
169: movl %edi,et_u(%esi)
170: cmpl %eax,%edi
171: jnl LNextEdge
172:
173: LPushBack2:
174: movl %edx,%ebx
175: movl %edi,%eax
176: movl %esi,%edx
177: movl %ebx,%esi
178:
179: LPushBack:
180: // push it back to keep it sorted
181: movl et_prev(%edx),%ecx
182: movl et_next(%edx),%ebx
183:
184: // done if the -1 in edge_aftertail triggered this
185: cmpl $(C(edge_aftertail)),%edx
186: jz LUDone
187:
188: // pull the edge out of the edge list
189: movl et_prev(%ecx),%edi
190: movl %ecx,et_prev(%esi)
191: movl %ebx,et_next(%ecx)
192:
193: // find out where the edge goes in the edge list
194: LPushBackLoop:
195: movl et_prev(%edi),%ecx
196: movl et_u(%edi),%ebx
197: cmpl %ebx,%eax
198: jnl LPushBackFound
199:
200: movl et_prev(%ecx),%edi
201: movl et_u(%ecx),%ebx
202: cmpl %ebx,%eax
203: jl LPushBackLoop
204:
205: movl %ecx,%edi
206:
207: // put the edge back into the edge list
208: LPushBackFound:
209: movl et_next(%edi),%ebx
210: movl %edi,et_prev(%edx)
211: movl %ebx,et_next(%edx)
212: movl %edx,et_next(%edi)
213: movl %edx,et_prev(%ebx)
214:
215: movl %esi,%edx
216: movl et_prev(%esi),%esi
217:
218: cmpl $(C(edge_tail)),%edx
219: jnz LNewEdge
220:
221: LUDone:
222: popl %ebx // restore register variables
223: popl %esi
224: popl %edi
225:
226: ret
227:
228: //--------------------------------------------------------------------
229:
230: #define surf 4 // note this is loaded before any pushes
231:
232: .align 4
233: TrailingEdge:
234: movl st_spanstate(%esi),%eax // check for edge inversion
235: decl %eax
236: jnz LInverted
237:
238: movl %eax,st_spanstate(%esi)
239: movl st_insubmodel(%esi),%ecx
240: movl 0x12345678,%edx // surfaces[1].st_next
241: LPatch0:
242: movl C(r_bmodelactive),%eax
243: subl %ecx,%eax
244: cmpl %esi,%edx
245: movl %eax,C(r_bmodelactive)
246: jnz LNoEmit // surface isn't on top, just remove
247:
248: // emit a span (current top going away)
249: movl et_u(%ebx),%eax
250: shrl $20,%eax // iu = integral pixel u
251: movl st_last_u(%esi),%edx
252: movl st_next(%esi),%ecx
253: cmpl %edx,%eax
254: jle LNoEmit2 // iu <= surf->last_u, so nothing to emit
255:
256: movl %eax,st_last_u(%ecx) // surf->next->last_u = iu;
257: subl %edx,%eax
258: movl %edx,espan_t_u(%ebp) // span->u = surf->last_u;
259:
260: movl %eax,espan_t_count(%ebp) // span->count = iu - span->u;
261: movl C(current_iv),%eax
262: movl %eax,espan_t_v(%ebp) // span->v = current_iv;
263: movl st_spans(%esi),%eax
264: movl %eax,espan_t_pnext(%ebp) // span->pnext = surf->spans;
265: movl %ebp,st_spans(%esi) // surf->spans = span;
266: addl $(espan_t_size),%ebp
267:
268: movl st_next(%esi),%edx // remove the surface from the surface
269: movl st_prev(%esi),%esi // stack
270:
271: movl %edx,st_next(%esi)
272: movl %esi,st_prev(%edx)
273: ret
274:
275: LNoEmit2:
276: movl %eax,st_last_u(%ecx) // surf->next->last_u = iu;
277: movl st_next(%esi),%edx // remove the surface from the surface
278: movl st_prev(%esi),%esi // stack
279:
280: movl %edx,st_next(%esi)
281: movl %esi,st_prev(%edx)
282: ret
283:
284: LNoEmit:
285: movl st_next(%esi),%edx // remove the surface from the surface
286: movl st_prev(%esi),%esi // stack
287:
288: movl %edx,st_next(%esi)
289: movl %esi,st_prev(%edx)
290: ret
291:
292: LInverted:
293: movl %eax,st_spanstate(%esi)
294: ret
295:
296: //--------------------------------------------------------------------
297:
298: // trailing edge only
299: Lgs_trailing:
300: pushl $Lgs_nextedge
301: jmp TrailingEdge
302:
303:
304: .globl C(R_GenerateSpans)
305: C(R_GenerateSpans):
306: pushl %ebp // preserve caller's stack frame
307: pushl %edi
308: pushl %esi // preserve register variables
309: pushl %ebx
310:
311: // clear active surfaces to just the background surface
312: movl C(surfaces),%eax
313: movl C(edge_head_u_shift20),%edx
314: addl $(st_size),%eax
315: // %ebp = span_p throughout
316: movl C(span_p),%ebp
317:
318: movl $0,C(r_bmodelactive)
319:
320: movl %eax,st_next(%eax)
321: movl %eax,st_prev(%eax)
322: movl %edx,st_last_u(%eax)
323: movl C(edge_head)+et_next,%ebx // edge=edge_head.next
324:
325: // generate spans
326: cmpl $(C(edge_tail)),%ebx // done if empty list
327: jz Lgs_lastspan
328:
329: Lgs_edgeloop:
330:
331: movl et_surfs(%ebx),%edi
332: movl C(surfaces),%eax
333: movl %edi,%esi
334: andl $0xFFFF0000,%edi
335: andl $0xFFFF,%esi
336: jz Lgs_leading // not a trailing edge
337:
338: // it has a left surface, so a surface is going away for this span
339: shll $(SURF_T_SHIFT),%esi
340: addl %eax,%esi
341: testl %edi,%edi
342: jz Lgs_trailing
343:
344: // both leading and trailing
345: call TrailingEdge
346: movl C(surfaces),%eax
347:
348: // ---------------------------------------------------------------
349: // handle a leading edge
350: // ---------------------------------------------------------------
351:
352: Lgs_leading:
353: shrl $16-SURF_T_SHIFT,%edi
354: movl C(surfaces),%eax
355: addl %eax,%edi
356: movl 0x12345678,%esi // surf2 = surfaces[1].next;
357: LPatch2:
358: movl st_spanstate(%edi),%edx
359: movl st_insubmodel(%edi),%eax
360: testl %eax,%eax
361: jnz Lbmodel_leading
362:
363: // handle a leading non-bmodel edge
364:
365: // don't start a span if this is an inverted span, with the end edge preceding
366: // the start edge (that is, we've already seen the end edge)
367: testl %edx,%edx
368: jnz Lxl_done
369:
370:
371: // if (surf->key < surf2->key)
372: // goto newtop;
373: incl %edx
374: movl st_key(%edi),%eax
375: movl %edx,st_spanstate(%edi)
376: movl st_key(%esi),%ecx
377: cmpl %ecx,%eax
378: jl Lnewtop
379:
380: // main sorting loop to search through surface stack until insertion point
381: // found. Always terminates because background surface is sentinel
382: // do
383: // {
384: // surf2 = surf2->next;
385: // } while (surf->key >= surf2->key);
386: Lsortloopnb:
387: movl st_next(%esi),%esi
388: movl st_key(%esi),%ecx
389: cmpl %ecx,%eax
390: jge Lsortloopnb
391:
392: jmp LInsertAndExit
393:
394:
395: // handle a leading bmodel edge
396: .align 4
397: Lbmodel_leading:
398:
399: // don't start a span if this is an inverted span, with the end edge preceding
400: // the start edge (that is, we've already seen the end edge)
401: testl %edx,%edx
402: jnz Lxl_done
403:
404: movl C(r_bmodelactive),%ecx
405: incl %edx
406: incl %ecx
407: movl %edx,st_spanstate(%edi)
408: movl %ecx,C(r_bmodelactive)
409:
410: // if (surf->key < surf2->key)
411: // goto newtop;
412: movl st_key(%edi),%eax
413: movl st_key(%esi),%ecx
414: cmpl %ecx,%eax
415: jl Lnewtop
416:
417: // if ((surf->key == surf2->key) && surf->insubmodel)
418: // {
419: jz Lzcheck_for_newtop
420:
421: // main sorting loop to search through surface stack until insertion point
422: // found. Always terminates because background surface is sentinel
423: // do
424: // {
425: // surf2 = surf2->next;
426: // } while (surf->key > surf2->key);
427: Lsortloop:
428: movl st_next(%esi),%esi
429: movl st_key(%esi),%ecx
430: cmpl %ecx,%eax
431: jg Lsortloop
432:
433: jne LInsertAndExit
434:
435: // Do 1/z sorting to see if we've arrived in the right position
436: movl et_u(%ebx),%eax
437: subl $0xFFFFF,%eax
438: movl %eax,Ltemp
439: fildl Ltemp
440:
441: fmuls float_1_div_0100000h // fu = (float)(edge->u - 0xFFFFF) *
442: // (1.0 / 0x100000);
443:
444: fld %st(0) // fu | fu
445: fmuls st_d_zistepu(%edi) // fu*surf->d_zistepu | fu
446: flds C(fv) // fv | fu*surf->d_zistepu | fu
447: fmuls st_d_zistepv(%edi) // fv*surf->d_zistepv | fu*surf->d_zistepu | fu
448: fxch %st(1) // fu*surf->d_zistepu | fv*surf->d_zistepv | fu
449: fadds st_d_ziorigin(%edi) // fu*surf->d_zistepu + surf->d_ziorigin |
450: // fv*surf->d_zistepv | fu
451:
452: flds st_d_zistepu(%esi) // surf2->d_zistepu |
453: // fu*surf->d_zistepu + surf->d_ziorigin |
454: // fv*surf->d_zistepv | fu
455: fmul %st(3),%st(0) // fu*surf2->d_zistepu |
456: // fu*surf->d_zistepu + surf->d_ziorigin |
457: // fv*surf->d_zistepv | fu
458: fxch %st(1) // fu*surf->d_zistepu + surf->d_ziorigin |
459: // fu*surf2->d_zistepu |
460: // fv*surf->d_zistepv | fu
461: faddp %st(0),%st(2) // fu*surf2->d_zistepu | newzi | fu
462:
463: flds C(fv) // fv | fu*surf2->d_zistepu | newzi | fu
464: fmuls st_d_zistepv(%esi) // fv*surf2->d_zistepv |
465: // fu*surf2->d_zistepu | newzi | fu
466: fld %st(2) // newzi | fv*surf2->d_zistepv |
467: // fu*surf2->d_zistepu | newzi | fu
468: fmuls float_point_999 // newzibottom | fv*surf2->d_zistepv |
469: // fu*surf2->d_zistepu | newzi | fu
470:
471: fxch %st(2) // fu*surf2->d_zistepu | fv*surf2->d_zistepv |
472: // newzibottom | newzi | fu
473: fadds st_d_ziorigin(%esi) // fu*surf2->d_zistepu + surf2->d_ziorigin |
474: // fv*surf2->d_zistepv | newzibottom | newzi |
475: // fu
476: faddp %st(0),%st(1) // testzi | newzibottom | newzi | fu
477: fxch %st(1) // newzibottom | testzi | newzi | fu
478:
479: // if (newzibottom >= testzi)
480: // goto Lgotposition;
481:
482: fcomp %st(1) // testzi | newzi | fu
483:
484: fxch %st(1) // newzi | testzi | fu
485: fmuls float_1_point_001 // newzitop | testzi | fu
486: fxch %st(1) // testzi | newzitop | fu
487:
488: fnstsw %ax
489: testb $0x01,%ah
490: jz Lgotposition_fpop3
491:
492: // if (newzitop >= testzi)
493: // {
494:
495: fcomp %st(1) // newzitop | fu
496: fnstsw %ax
497: testb $0x45,%ah
498: jz Lsortloop_fpop2
499:
500: // if (surf->d_zistepu >= surf2->d_zistepu)
501: // goto newtop;
502:
503: flds st_d_zistepu(%edi) // surf->d_zistepu | newzitop| fu
504: fcomps st_d_zistepu(%esi) // newzitop | fu
505: fnstsw %ax
506: testb $0x01,%ah
507: jz Lgotposition_fpop2
508:
509: fstp %st(0) // clear the FPstack
510: fstp %st(0)
511: movl st_key(%edi),%eax
512: jmp Lsortloop
513:
514:
515: Lgotposition_fpop3:
516: fstp %st(0)
517: Lgotposition_fpop2:
518: fstp %st(0)
519: fstp %st(0)
520: jmp LInsertAndExit
521:
522:
523: // emit a span (obscures current top)
524:
525: Lnewtop_fpop3:
526: fstp %st(0)
527: Lnewtop_fpop2:
528: fstp %st(0)
529: fstp %st(0)
530: movl st_key(%edi),%eax // reload the sorting key
531:
532: Lnewtop:
533: movl et_u(%ebx),%eax
534: movl st_last_u(%esi),%edx
535: shrl $20,%eax // iu = integral pixel u
536: movl %eax,st_last_u(%edi) // surf->last_u = iu;
537: cmpl %edx,%eax
538: jle LInsertAndExit // iu <= surf->last_u, so nothing to emit
539:
540: subl %edx,%eax
541: movl %edx,espan_t_u(%ebp) // span->u = surf->last_u;
542:
543: movl %eax,espan_t_count(%ebp) // span->count = iu - span->u;
544: movl C(current_iv),%eax
545: movl %eax,espan_t_v(%ebp) // span->v = current_iv;
546: movl st_spans(%esi),%eax
547: movl %eax,espan_t_pnext(%ebp) // span->pnext = surf->spans;
548: movl %ebp,st_spans(%esi) // surf->spans = span;
549: addl $(espan_t_size),%ebp
550:
551: LInsertAndExit:
552: // insert before surf2
553: movl %esi,st_next(%edi) // surf->next = surf2;
554: movl st_prev(%esi),%eax
555: movl %eax,st_prev(%edi) // surf->prev = surf2->prev;
556: movl %edi,st_prev(%esi) // surf2->prev = surf;
557: movl %edi,st_next(%eax) // surf2->prev->next = surf;
558:
559: // ---------------------------------------------------------------
560: // leading edge done
561: // ---------------------------------------------------------------
562:
563: // ---------------------------------------------------------------
564: // see if there are any more edges
565: // ---------------------------------------------------------------
566:
567: Lgs_nextedge:
568: movl et_next(%ebx),%ebx
569: cmpl $(C(edge_tail)),%ebx
570: jnz Lgs_edgeloop
571:
572: // clean up at the right edge
573: Lgs_lastspan:
574:
575: // now that we've reached the right edge of the screen, we're done with any
576: // unfinished surfaces, so emit a span for whatever's on top
577: movl 0x12345678,%esi // surfaces[1].st_next
578: LPatch3:
579: movl C(edge_tail_u_shift20),%eax
580: xorl %ecx,%ecx
581: movl st_last_u(%esi),%edx
582: subl %edx,%eax
583: jle Lgs_resetspanstate
584:
585: movl %edx,espan_t_u(%ebp)
586: movl %eax,espan_t_count(%ebp)
587: movl C(current_iv),%eax
588: movl %eax,espan_t_v(%ebp)
589: movl st_spans(%esi),%eax
590: movl %eax,espan_t_pnext(%ebp)
591: movl %ebp,st_spans(%esi)
592: addl $(espan_t_size),%ebp
593:
594: // reset spanstate for all surfaces in the surface stack
595: Lgs_resetspanstate:
596: movl %ecx,st_spanstate(%esi)
597: movl st_next(%esi),%esi
598: cmpl $0x12345678,%esi // &surfaces[1]
599: LPatch4:
600: jnz Lgs_resetspanstate
601:
602: // store the final span_p
603: movl %ebp,C(span_p)
604:
605: popl %ebx // restore register variables
606: popl %esi
607: popl %edi
608: popl %ebp // restore the caller's stack frame
609: ret
610:
611:
612: // ---------------------------------------------------------------
613: // 1/z sorting for bmodels in the same leaf
614: // ---------------------------------------------------------------
615: .align 4
616: Lxl_done:
617: incl %edx
618: movl %edx,st_spanstate(%edi)
619:
620: jmp Lgs_nextedge
621:
622:
623: .align 4
624: Lzcheck_for_newtop:
625: movl et_u(%ebx),%eax
626: subl $0xFFFFF,%eax
627: movl %eax,Ltemp
628: fildl Ltemp
629:
630: fmuls float_1_div_0100000h // fu = (float)(edge->u - 0xFFFFF) *
631: // (1.0 / 0x100000);
632:
633: fld %st(0) // fu | fu
634: fmuls st_d_zistepu(%edi) // fu*surf->d_zistepu | fu
635: flds C(fv) // fv | fu*surf->d_zistepu | fu
636: fmuls st_d_zistepv(%edi) // fv*surf->d_zistepv | fu*surf->d_zistepu | fu
637: fxch %st(1) // fu*surf->d_zistepu | fv*surf->d_zistepv | fu
638: fadds st_d_ziorigin(%edi) // fu*surf->d_zistepu + surf->d_ziorigin |
639: // fv*surf->d_zistepv | fu
640:
641: flds st_d_zistepu(%esi) // surf2->d_zistepu |
642: // fu*surf->d_zistepu + surf->d_ziorigin |
643: // fv*surf->d_zistepv | fu
644: fmul %st(3),%st(0) // fu*surf2->d_zistepu |
645: // fu*surf->d_zistepu + surf->d_ziorigin |
646: // fv*surf->d_zistepv | fu
647: fxch %st(1) // fu*surf->d_zistepu + surf->d_ziorigin |
648: // fu*surf2->d_zistepu |
649: // fv*surf->d_zistepv | fu
650: faddp %st(0),%st(2) // fu*surf2->d_zistepu | newzi | fu
651:
652: flds C(fv) // fv | fu*surf2->d_zistepu | newzi | fu
653: fmuls st_d_zistepv(%esi) // fv*surf2->d_zistepv |
654: // fu*surf2->d_zistepu | newzi | fu
655: fld %st(2) // newzi | fv*surf2->d_zistepv |
656: // fu*surf2->d_zistepu | newzi | fu
657: fmuls float_point_999 // newzibottom | fv*surf2->d_zistepv |
658: // fu*surf2->d_zistepu | newzi | fu
659:
660: fxch %st(2) // fu*surf2->d_zistepu | fv*surf2->d_zistepv |
661: // newzibottom | newzi | fu
662: fadds st_d_ziorigin(%esi) // fu*surf2->d_zistepu + surf2->d_ziorigin |
663: // fv*surf2->d_zistepv | newzibottom | newzi |
664: // fu
665: faddp %st(0),%st(1) // testzi | newzibottom | newzi | fu
666: fxch %st(1) // newzibottom | testzi | newzi | fu
667:
668: // if (newzibottom >= testzi)
669: // goto newtop;
670:
671: fcomp %st(1) // testzi | newzi | fu
672:
673: fxch %st(1) // newzi | testzi | fu
674: fmuls float_1_point_001 // newzitop | testzi | fu
675: fxch %st(1) // testzi | newzitop | fu
676:
677: fnstsw %ax
678: testb $0x01,%ah
679: jz Lnewtop_fpop3
680:
681: // if (newzitop >= testzi)
682: // {
683:
684: fcomp %st(1) // newzitop | fu
685: fnstsw %ax
686: testb $0x45,%ah
687: jz Lsortloop_fpop2
688:
689: // if (surf->d_zistepu >= surf2->d_zistepu)
690: // goto newtop;
691:
692: flds st_d_zistepu(%edi) // surf->d_zistepu | newzitop | fu
693: fcomps st_d_zistepu(%esi) // newzitop | fu
694: fnstsw %ax
695: testb $0x01,%ah
696: jz Lnewtop_fpop2
697:
698: Lsortloop_fpop2:
699: fstp %st(0) // clear the FP stack
700: fstp %st(0)
701: movl st_key(%edi),%eax
702: jmp Lsortloop
703:
704:
705: .globl C(R_EdgeCodeEnd)
706: C(R_EdgeCodeEnd):
707:
708:
709: //----------------------------------------------------------------------
710: // Surface array address code patching routine
711: //----------------------------------------------------------------------
712:
713: .align 4
714: .globl C(R_SurfacePatch)
715: C(R_SurfacePatch):
716:
717: movl C(surfaces),%eax
718: addl $(st_size),%eax
719: movl %eax,LPatch4-4
720:
721: addl $(st_next),%eax
722: movl %eax,LPatch0-4
723: movl %eax,LPatch2-4
724: movl %eax,LPatch3-4
725:
726: ret
727:
728: #endif // id386
729:
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.