vwemirror/TeslaRel410
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity
Files
32ac5ca9b8a0c4e8bf0fab5ea23fe331c6cb33bc
TeslaRel410/sda4/DPL3/VRENDER/AS860/OPTFLOAT.S
T
CydandClaude Fable 5 db7745fcd0 sda4: commit the Glaze developer hard-drive dump 
Un-ignored: the dev drive is the ground truth the restoration and
emulator work constantly reference (DPL3/LIBDPL + VRENDER i860 renderer
source, BT/RP live+dev game trees, VGL_LABS pod boot, scene/audio
content). Kept in-repo for the pod-owner community.

Co-Authored-By: Claude Fable 5 <noreply@anthropic.com>
2026-07-04 19:41:15 -05:00

2371 lines
35 KiB
ArmAsm
Raw Blame History

//{{{ stuff
//
// The plan is to build up a library of often-used and highly
// optimised i860 assembler functions in here.
//
// So typically,
// homogeneous transformers,
// matrix concatenators,
// matrix inverters,
// equation solvers (e.g point/plane intersectors)
//
// will eventually be put in here and tweaked to hell.
//
//}}}
.align 8
.text
//{{{ fn_bbox_plane
// This is just a very good piece of compiler
// output which I have hand-tweaked and saved for posterity
// I cannot believe the compiler did this ...
.globl _fn_bbox_plane
.align 8
_fn_bbox_plane:
// lineno: 0
adds -1, r0, r18
// lineno: 190
fld.l r0(r17), f11
fld.l 4(r17), f12
fld.l 8(r17), f13
fld.l 12(r17), f14
mov r16, r21
adds 1, r0, r19
addu -12, r16, r26
addu -8, r16, r27
mov r0, r16
bla r18, r19,.B1088
pfmul.dd f0, f0, f0
// lineno: 201
.B1088: //.M0000
.align 8
d.pfadd.dd f0, f0, f0
nop
.align 8
.PD0.B1088105:
d.fnop
mov r26, r29
.DB.B10881088:
d.fnop
fld.l 16(r29)++, f17
d.fnop
fld.l 16(r29)++, f18
d.fnop
fld.l 16(r29)++, f19
d.fnop
addu 16, r29, r26
d.fnop
fld.l r0(r26), f9
d.pfmul.ss f19, f12, f0
mov r21, r30
d.pfmul.ss f0, f0, f0
mov r30, r22
d.pfmul.ss f9, f12, f0
fld.l 16(r30)++, f23
d.pfmul.ss f0, f0, f21
fld.l 16(r30)++, f24
d.pfmul.ss f0, f0, f0
fld.l r0(r22), f25
d.pfmul.ss f0, f0, f20
fld.l 16(r30)++, f10
d.pfmul.ss f24, f11, f0
mov r27, r23
d.pfmul.ss f0, f0, f0
fld.l 16(r23)++, f29
d.pfmul.ss f10, f11, f0
fld.l 16(r23)++, f30
d.mi2p1.ss f21, f0, f16
fld.l 16(r23)++, f31
d.mm12msm.ss f18, f12, f0
addu 16, r23, r27
d.mi2p1.ss f20, f0, f26
fld.l r0(r27), f8
d.m12tpa.ss f31, f13, f19
addu 16, r30, r21
d.mm12msm.ss f23, f11, f26
nop
d.m12tpa.ss f8, f13, f27
nop
d.mi2p1.ss f19, f0, f24
nop
d.mi2p1.ss f26, f0, f18
nop
d.mi2p1.ss f27, f0, f15
nop
d.pfadd.ss f14, f16, f16
nop
d.m12tpa.ss f30, f13, f20
nop
d.ia1p2.ss f14, f28, f28
nop
d.ia1p2.ss f0, f0, f21
nop
d.mm12msm.ss f0, f0, f31
nop
d.pfadd.ss f0, f0, f22
nop
d.pfgt.ss f22, f0, f0
nop
d.fnop
bnc ..L3
d.fnop
adds 1, r16, r16
..L3:
d.pfgt.ss f21, f0, f0
nop
d.fnop
bnc ..L2
d.fnop
adds 1, r16, r16
..L2:
d.pfadd.ss f20, f31, f0
nop
d.mm12msm.ss f25, f11, f0
nop
d.mm12msm.ss f17, f12, f0
nop
d.ia1p2.ss f14, f23, f23
nop
d.mm12msm.ss f0, f0, f19
nop
d.mm12msm.ss f0, f0, f18
nop
d.pfadd.ss f0, f0, f24
nop
d.pfgt.ss f24, f0, f0
nop
d.fnop
bnc ..L1
d.fnop
adds 1, r16, r16
..L1:
d.pfadd.ss f19, f18, f0
nop
d.mm12msm.ss f29, f13, f0
nop
d.mm12msm.ss f0, f0, f0
nop
d.ia1p2.ss f0, f0, f26
nop
d.mi2p1.ss f26, f0, f15
nop
d.pfadd.ss f0, f0, f0
nop
d.pfadd.ss f0, f0, f0
nop
d.pfadd.ss f14, f27, f27
nop
d.pfadd.ss f0, f0, f0
nop
d.pfadd.ss f0, f0, f0
nop
d.pfadd.ss f0, f0, f16
nop
d.pfgt.ss f16, f0, f0
nop
d.fnop
bnc ..L0
d.fnop
adds 1, r16, r16
..L0:
d.fnop
bla r18, r19, .DB.B10881088
d.fnop
mov r26, r29
fnop
bri r1
fnop
nop
// lineno: 0
//}}}
//{{{ p_memcpy
//
// p_memcpy
//
// uses pflds to load - use for copying tristrips from database to
// scratchpad - N.B does NOT cache the source
//
// must be given at least 32 bytes to copy or will fall over
//
// assumes .double aligned data
//
.globl _p_memcpy
.align 8
_p_memcpy::
or -1,r0, r19 // decrement by 1
addu 7, r18 , r18 // copy up to and including a double
shr 3, r18 , r18 // correct for sizeof double
adds -1, r18 , r18 // correct for bla
adds -8, r17 , r17 // correct for autoincrement
bla r19 , r18 ,.L666666
adds -8, r16 , r16 // and again
.L666666:
fld.d 8( r17 )++,f16
bla r19 , r18 ,.L666666
fst.d f16,8( r16 )++
bri r1
nop
//}}}
//{{{ matrix_copy
//
// matrix_copy
//
// assumes .double aligned data
//
.globl _matrix_copy
.align 8
_matrix_copy::
fld.l 0(r17), f8
fld.l 4(r17), f9
fld.l 8(r17), f10
fld.l 12(r17), f11
fld.l 16(r17), f12
fld.l 20(r17), f13
fld.l 24(r17), f14
fld.l 28(r17), f15
fld.l 32(r17), f16
fld.l 36(r17), f17
fld.l 40(r17), f18
fld.l 44(r17), f19
fld.l 48(r17), f20
fld.l 52(r17), f21
fld.l 56(r17), f22
fld.l 60(r17), f23
fst.d f8, 0(r16)
fst.d f10, 8(r16)
fst.d f12, 16(r16)
fst.d f14, 24(r16)
fst.d f16, 32(r16)
fst.d f18, 40(r16)
fst.d f20, 48(r16)
bri r1
fst.d f22, 56(r16)
//}}}
//{{{ matrix registers
//}}}
//{{{ fn_cache_mtx
.align 8
_fn_cache_mtx::
adds -4,r16,r31
fld.l 4(r31)++, f8
fld.l 4(r31)++, f9
fld.l 4(r31)++, f10
fld.l 4(r31)++, f11
fld.l 4(r31)++, f12
fld.l 4(r31)++, f13
fld.l 4(r31)++, f14
fld.l 4(r31)++, f15
fld.l 4(r31)++, f16
fld.l 4(r31)++, f17
fld.l 4(r31)++, f18
fld.l 4(r31)++, f19
fld.l 4(r31)++, f20
fld.l 4(r31)++, f21
fld.l 4(r31)++, f22
bri r1
fld.l 4(r31)++, f23
//}}}
//{{{ fn_cache_opt_mtx
.align 8
_fn_cache_opt_mtx::
adds -4,r16,r31
fld.l 4(r31)++, f8
fld.l 4(r31)++, f9
fld.l 4(r31)++, f10
fld.l 8(r31)++, f12
fld.l 4(r31)++, f13
fld.l 4(r31)++, f14
fld.l 8(r31)++, f16
fld.l 4(r31)++, f17
fld.l 4(r31)++, f18
fld.l 8(r31)++, f20
fld.l 4(r31)++, f21
bri r1
fld.l 4(r31)++, f22
//}}}
//{{{ fn_cache_mtx
.align 8
_fn_cache_mtxd::
adds -8,r16,r31
fld.d 8(r31)++, f8
fld.d 8(r31)++, f10
fld.d 8(r31)++, f12
fld.d 8(r31)++, f14
fld.d 8(r31)++, f16
fld.d 8(r31)++, f18
fld.d 8(r31)++, f20
bri r1
fld.d 8(r31)++, f22
//}}}
//{{{ fn_cache_opt_mtx
.align 8
_fn_cache_opt_mtxd::
adds -8,r16,r31
fld.d 8(r31)++, f8
fld.d 8(r31)++, f10
fld.d 8(r31)++, f12
fld.d 8(r31)++, f14
fld.d 8(r31)++, f16
fld.d 8(r31)++, f18
fld.d 8(r31)++, f20
bri r1
fld.d 8(r31)++, f22
//}}}
//{{{ fn_xform in 43 ticks
//
// #define fullxform(d,s) // sx =*s++; sy =*s++; sz =*s++; sw=*s++; // *d++ = (sx* f8 ) + (sy* f12 ) + (sz* f16 ) + (sw* f20 ); // *d++ = (sx* f9 ) + (sy* f13 ) + (sz* f17 ) + (sw* f21 ); // *d++ = (sx* f10 ) + (sy* f14 ) + (sz* f18 ) + (sw* f22 ); // *d++ = (sx* f11 ) + (sy* f15 ) + (sz* f19 ) + (sw* f23 )
//
// matrix held in f13 .. m44
// r16 points to destn
// r17 points at the point to transform,
//
.align 8
_fn_xform::
fld.l 0(r17), f24
fld.l 4(r17), f25
fld.l 8(r17), f26
pfmul.ss f24 , f8 ,f0
fld.l 12(r17), f27
pfmul.ss f25 , f12 ,f0
pfmul.ss f26 , f16 ,f0
pfmul.ss f27 , f20 , f28
pfmul.ss f24 , f9 , f29
pfadd.ss f28 , f29 ,f0 // adder 1 = x00+y10
pfmul.ss f25 , f13 , f28
pfmul.ss f26 , f17 , f29
pfadd.ss f28 , f29 ,f0 // adder 1 = z20 + w30
pfmul.ss f27 , f21 , f28
pfmul.ss f24 , f10 , f29
pfadd.ss f28 , f29 ,f0 // adder 1 = x01+y11
pfmul.ss f25 , f14 , f28
pfmul.ss f26 , f18 , f29
pfadd.ss f28 , f29 , f30 // adder1 = z21+w31 f30 =x00+y10
pfmul.ss f27 , f22 , f28
pfmul.ss f24 , f11 , f29
pfadd.ss f28 , f29 , f31 // adder1 = x02+y12 f31 =z20+w30
pfmul.ss f25 , f15 , f28
pfmul.ss f26 , f19 , f29
pfadd.ss f28 , f29 , f7 // adder1 = z22+w32 f7 =x01+y11
pfmul.ss f27 , f23 , f28
pfmul.ss f0,f0, f29
pfadd.ss f28 , f29 , f24 // adder1 = x03+y13 f24 =z21+w31
pfmul.ss f0,f0, f28
pfmul.ss f0,f0, f29
pfadd.ss f28 , f29 , f25 // adder1=z23+w33 f25 =x02+y12
pfadd.ss f30 , f31 , f28 // adder1=rx f28 =z22+w32
pfadd.ss f7 , f24 , f29 // adder1=ry f29 =x03+y13
pfadd.ss f28 , f25 , f30 // adder1=rz f30 =z23+w33
pfadd.ss f29 , f30 , f24
fst.l f24 , 0(r16)
pfadd.ss f0,f0, f25
fst.l f25 , 4(r16)
pfadd.ss f0,f0, f26
fst.l f26 , 8(r16)
pfadd.ss f0,f0, f27
bri r1
fst.l f27 , 12(r16) // total 43 ticks
//}}}
//{{{ fn_optxform in 28 ticks
//
// only called on vertices, which are quad-aligned
//
// #define optxform(s,d) // sx =*s++; sy =*s++; sz =*s++; sw=*s++; // *d++ = (sx* f8 ) + (sy* f12 ) + (sz* f16 ) + f20 ; // *d++ = (sx* f9 ) + (sy* f13 ) + (sz* f17 ) + f21 ; // *d++ = (sx* f10 ) + (sy* f14 ) + (sz* f18 ) + f22 ; // *d++ = 1
//
// matrix held in f13 .. m44
// r16 points to destn
// r17 points at the point to transform,
//
.align 8
_fn_optxform::
fld.l 0(r17), f24
fld.l 4(r17), f25
pfmul.ss f24 , f8 ,f0
fld.l 8(r17), f26
pfmul.ss f25 , f12 ,f0
pfmul.ss f24 , f9 ,f0
pfmul.ss f25 , f13 , f28
pfmul.ss f24 , f10 , f29
pfadd.ss f28 , f29 ,f0 // adder 1 = x00+y10
pfmul.ss f25 , f14 , f28
pfmul.ss f26 , f16 , f29
pfadd.ss f28 , f29 ,f0 // adder 1 = x01+y11
pfmul.ss f26 , f17 , f28
pfmul.ss f26 , f18 , f29
pfadd.ss f28 , f29 ,f0 // adder 1 = x02+y12
//
//
// here we have a full adder and a full multiplier
// we just drop the numbers out of each and add them
// leaving 3 results in the adder pipe to store
//
//
m12apm.ss f0,f0,f0 // fill adder unit with adder+mul units
m12apm.ss f0,f0,f0 //
m12apm.ss f0,f0,f0 //
r2ap1.ss f20 ,f0,f0
r2ap1.ss f21 ,f0,f0
r2ap1.ss f22 ,f0,f0
pfadd.ss f0,f0, f24
fst.l f24 , 0(r16)
pfadd.ss f0,f0, f25
fst.l f25 , 4(r16)
pfadd.ss f0,f0, f26
bri r1
fst.l f26 , 8(r16)
//}}}
//{{{ _fn_xform_bound in 256 ticks == 10 uS on i860-25
.globl _fn_xform_bound
// void xform_bound ( POINT *dest, POINT *src, MATRIX b )
// a bounding box is 8 points, so we just call xform 8 times
.align 8
_fn_xform_bound::
mov r1,r19
mov r16, r20
call _fn_cache_opt_mtx
mov r18,r16
// call 1
call _fn_optxform
mov r20,r16
// call 2
addu 16,r16,r16
call _fn_optxform
addu 16,r17,r17
// call 3
addu 16,r16,r16
call _fn_optxform
addu 16,r17,r17
// call 4
addu 16,r16,r16
call _fn_optxform
addu 16,r17,r17
// call 5
addu 16,r16,r16
call _fn_optxform
addu 16,r17,r17
// call 6
addu 16,r16,r16
call _fn_optxform
addu 16,r17,r17
// call 7
addu 16,r16,r16
call _fn_optxform
addu 16,r17,r17
// call 8
addu 16,r16,r16
call _fn_optxform
addu 16,r17,r17
bri r19
nop
//}}}
//{{{ _fn_xform_boundtroid in 288 ticks == 10 uS on i860-25
.globl _fn_xform_boundtroid
// void xform_boundtroid ( POINT *dest, POINT *src, MATRIX b )
// a bounding box plus centroid is 9 points, so we just call xform 9 times
.align 8
_fn_xform_boundtroid::
mov r1,r19
mov r16, r20
call _fn_cache_opt_mtx
mov r18,r16
// call 1
call _fn_optxform
mov r20,r16
// call 2
addu 16,r16,r16
call _fn_optxform
addu 16,r17,r17
// call 3
addu 16,r16,r16
call _fn_optxform
addu 16,r17,r17
// call 4
addu 16,r16,r16
call _fn_optxform
addu 16,r17,r17
// call 5
addu 16,r16,r16
call _fn_optxform
addu 16,r17,r17
// call 6
addu 16,r16,r16
call _fn_optxform
addu 16,r17,r17
// call 7
addu 16,r16,r16
call _fn_optxform
addu 16,r17,r17
// call 8
addu 16,r16,r16
call _fn_optxform
addu 16,r17,r17
// call 9
addu 16,r16,r16
call _fn_optxform
addu 16,r17,r17
bri r19
nop
//}}}
//{{{ _fn_concatenate in 190 ticks == 7.6 uS on i860-25
.globl _fn_concatenate
// extern void _concatenate ( MATRIX res, MATRIX a, MATRIX b );
// a matrix is 4 points, so we just call xform 8 times
.align 8
_fn_concatenate::
mov r1,r19
mov r16, r20
mov .C00038, r22
fxfr f7 , r21
call _fn_cache_mtx
mov r18,r16 // caches matrix B
// call 1
call _fn_xform
mov r22,r16
// call 2
addu 16,r16,r16
call _fn_xform
addu 16,r17,r17
// call 3
addu 16,r16,r16
call _fn_xform
addu 16,r17,r17
// call 4
addu 16,r16,r16
call _fn_xform
addu 16,r17,r17
// copy matrix from temporary (r22) to param 1 (r20)
fld.q 0(r22),f16
fld.q 16(r22),f20
fld.q 32(r22),f24
fld.q 48(r22),f28
//{{{ double precision stores
//fst.d f16, 0(r20) // store 0
//fst.d f18, 8(r20)
//fst.d f20, 16(r20)
//fst.d f22, 24(r20)
//fst.d f24, 32(r20)
//fst.d f26, 40(r20)
//fst.d f28, 48(r20)
//fst.d f30, 56(r20)
//}}}
//{{{ single
fst.l f16, 0(r20) // store 0
fst.l f17, 4(r20) // store 0
fst.l f18, 8(r20)
fst.l f19, 12(r20)
fst.l f20, 16(r20)
fst.l f21, 20(r20)
fst.l f22, 24(r20)
fst.l f23, 28(r20)
fst.l f24, 32(r20)
fst.l f25, 36(r20)
fst.l f26, 40(r20)
fst.l f27, 44(r20)
fst.l f28, 48(r20)
fst.l f29, 52(r20)
fst.l f30, 56(r20)
fst.l f31, 60(r20)
//}}}
bri r19
ixfr r21, f7
//}}}
// some rapid hack functions exploiting the 1/sqr(x) opcode
//{{{ quick_renorm
.globl _quick_renorm
.align 8
// f8, f9, f10 are normalized, multiplied by f11 and stored to *r16
_quick_renorm::
fmul.ss f8, f8, f19
fmul.ss f9, f9, f20
fmul.ss f10, f10, f21
fadd.ss f20, f21, f22
fadd.ss f19, f22, f23
frsqr.ss f23, f20
fmul.ss f20, f11, f20
fmul.ss f20, f8, f8
fmul.ss f20, f9, f9
fmul.ss f20, f10, f10
fst.l f8, 0(r16)
fst.l f9, 4(r16)
bri r1
fst.l f10, 8(r16)
//}}}
//{{{ quick_radius
.globl _quick_radius
.align 8
// f8, f9, f10 are squared and roughly rooted -- 18 ticks
_quick_radius::
fmul.ss f8, f8, f19
fmul.ss f9, f9, f20
fmul.ss f10, f10, f21
fadd.ss f20, f21, f22
fadd.ss f19, f22, f23
frsqr.ss f23, f20
bri r1
frcp.ss f20, f8
//}}}
//{{{ quick_root
.globl _quick_root
.align 8
// f8 is roughly square rooted
_quick_root::
frsqr.ss f8, f20
bri r1
frcp.ss f20, f8
//}}}
//{{{ quick_recip
.globl _quick_recip
.align 8
// f8 is roughly 1/f8
_quick_recip::
bri r1
frcp.ss f8, f8
//}}}
//{{{ copy_spoint
.globl _copy_spoint
.align 8
//
// hand-coded this as i was disgusted with the compilers output
//
_copy_spoint:
adds -1, r0, r18
adds 6, r0, r19
adds 4, r0, r20
adds -4, r16, r16
bla r18, r19,.B1264
adds -4, r17, r17
.B1264:
fld.l r20(r16)++, f16
bla r18, r19, .B1264
fst.l f16, r20(r17)++
bri r1
nop
//}}}
//{{{ smintersect
.globl _smintersect
.align 8
//
// this is slightly hand-tweaked compiler output
// it looks like some 89 cycles, and should be tweakable down to about 45
//
_smintersect:
// lineno: 234
shl 2, r19, r29
fld.l r17(r29), f16
fld.l r18(r29), f17
orh ha%.C00037, r0, r31
fld.l l%.C00037(r31), f21
fsub.ss f17, f16, f18
frcp.ss f18, f19
fmul.ss f18, f19, f20
fld.l r0(r17), f29
fld.l r0(r18), f30
fsub.ss f21, f20, f22
fmul.ss f19, f22, f23
fmul.ss f18, f23, f24
fsub.ss f21, f24, f25
fmul.ss f25, f23, f26
fsub.ss f8, f16, f27
fmul.ss f27, f26, f28
fsub.ss f30, f29, f31
fmul.ss f31, f28, f9
fld.l 4(r17), f11
fld.l 4(r18), f12
fadd.ss f29, f9, f10
fsub.ss f12, f11, f13
fst.l f10, r0(r16)
fmul.ss f28, f13, f14
fld.l 8(r17), f17
fld.l 8(r18), f20
fadd.ss f11, f14, f15
fsub.ss f20, f17, f22
fst.l f15, 4(r16)
fmul.ss f28, f22, f19
fld.l 16(r17), f21
fld.l 16(r18), f23
fadd.ss f17, f19, f24
fsub.ss f23, f21, f25
fst.l f24, 8(r16)
fmul.ss f28, f25, f18
fld.l 20(r17), f26
fld.l 20(r18), f27
fadd.ss f21, f18, f16
fsub.ss f27, f26, f30
fst.l f16, 16(r16)
fmul.ss f28, f30, f31
fld.l 24(r18), f10
fld.l 24(r17), f29
fadd.ss f26, f31, f9
fsub.ss f10, f29, f12
fst.l f9, 20(r16)
fmul.ss f28, f12, f13
fst.l f8, r29(r16)
fadd.ss f29, f13, f14
bri r1
fst.l f14, 24(r16)
//}}}
//{{{ _dnc_wait_count
.globl _dnc_Wait_count
.align 8
// while (*r16 == 0) spin(r17);
_dnc_Wait_count::
or r0, r0, r20
dnc_Wait_count1::
adds 1, r20, r20
st.l r20, 4(r16)
ld.l r0(r16), r18
btne r0,r18,.wait_loop
adds 1,r0,r18
bri r1
st.l r18,0(r16)
.wait_loop::
or r17,r0,r19
adds -1,r0,r18
bla r18,r19,.wait_spin
nop
.wait_spin::
bla r18,r19,.wait_spin
nop
br dnc_Wait_count1
nop
//}}}
//{{{ _bla
.globl _bla
.align 8
// simply loops r16 times, taking 2 x r16 cycles
_bla::
adds -1,r0,r17
bla r17,r16,bla_bla
nop
bla_bla::
bla r17,r16,bla_bla
nop
bri r1
nop
//}}}
//{{{ _xform_and_project_fn:
.globl _xform_and_project_fn
.align 8
_xform_and_project_fn:
.a18 = 0
.f18 = 96
orh h%.STACK+.f18-16, r0, r28
or l%.STACK+.f18-16, r28, r28
fst.d f2, -72(r28)
fst.d f4, -64(r28)
fst.d f6, -56(r28)
st.l r4, -48(r28)
// lineno: 0
orh ha%.C00037, r0, r31
fld.l l%.C00037(r31), f15
adds -1, r0, r19
// lineno: 1281
orh ha%.C00036, r0, r31
fld.l l%.C00036(r31), f16
fld.l 172(r16), f17
fld.l 144(r16), f19
fld.l 176(r16), f22
fadd.ss f17, f16, f18
orh ha%_sub_pixel_correct, r0, r31
fld.l l%_sub_pixel_correct(r31), f2
fmul.ss f19, f18, f20
fld.l 152(r16), f24
fld.l 164(r16), f26
fadd.ss f2, f20, f21
fld.l 128(r16), f27
fld.l 8(r17), f31
fst.l f21, -40(r28)
fadd.ss f22, f16, f23
orh ha%_Czscale, r0, r31
fld.l l%_Czscale(r31), f29
fmul.ss f24, f23, f25
fld.l 12(r17), f17
fld.l 24(r17), f18
fadd.ss f2, f25, f7
fld.l 28(r17), f20
fld.l 40(r17), f21
fmul.ss f27, f26, f28
fld.l 44(r17), f16
fld.l 56(r17), f22
fmul.ss f29, f28, f5
fld.l 60(r17), f23
fld.l 16(r17), f11
fmul.ss f27, f19, f30
fld.l 32(r17), f12
fld.l 48(r17), f13
fst.l f30, -36(r28)
fmul.ss f27, f24, f6
fld.l 64(r17), f14
ld.l 4(r18), r4
fst.l f31, -4(r28)
fst.l f17, -8(r28)
fst.l f18, -12(r28)
fst.l f20, -16(r28)
fst.l f21, -20(r28)
fst.l f16, -24(r28)
fst.l f22, -28(r28)
fst.l f23, -32(r28)
addu 8, r18, r21
subs 0, r4, r0
bnc .B1209
adds -1, r4, r20
bla r19, r20,.B1878
pfmul.dd f0, f0, f0
// lineno: 1307
.B1878: //.M0014
.align 8
d.pfadd.dd f0, f0, f0
nop
.align 8
.PD0.B1878105:
d.fnop
ld.l 76(r21), r18
d.fnop
fld.l r0(r21), f16
.DB.B18781878:
d.fnop
fld.l 4(r21), f9
d.fnop
fld.l 8(r21), f20
d.pfmul.ss f16, f11, f0
and r18, r18, r0
d.pfmul.ss f9, f12, f0
fld.l -4(r28), f31
d.pfmul.ss f20, f13, f0
bc .not_touched
d.pfmul.ss f31, f16, f17
nop
d.mi2p1.ss f17, f0, f18
fld.l -12(r28), f31
d.mm12msm.ss f0, f0, f21
nop
d.mm12msm.ss f0, f0, f18
nop
d.pfadd.ss f21, f19, f19
nop
d.mm12msm.ss f31, f9, f0
fld.l -20(r28), f21
d.mm12msm.ss f0, f0, f0
nop
d.ia1p2.ss f14, f22, f22
nop
d.mm12msm.ss f0, f0, f17
nop
d.pfadd.ss f0, f0, f0
nop
d.pfadd.ss f0, f0, f23
nop
d.frcp.ss f23, f24
nop
d.pfmul.ss f23, f24, f0
nop
d.ia1p2.ss f18, f17, f0
nop
d.mm12msm.ss f21, f20, f0
fld.l -28(r28), f17
d.mi2s1.ss f15, f0, f25
fld.l -36(r28), f18
d.ia1p2.ss f0, f0, f19
nop
d.mi2p1.ss f19, f0, f31
nop
d.m12tpa.ss f24, f26, f26
fld.l -40(r28), f31
d.mm12msm.ss f0, f0, f0
fld.l -8(r28), f24
d.ia1p2.ss f17, f22, f22
nop
d.mm12msm.ss f23, f27, f27
fld.l -16(r28), f17
d.mm12msm.ss f16, f24, f0
nop
d.m12tpa.ss f18, f4, f4
nop
d.mi2s1.ss f15, f0, f28
fld.l -24(r28), f18
d.mm12msm.ss f0, f0, f22
nop
d.mm12msm.ss f9, f17, f21
nop
d.m12tpa.ss f20, f18, f29
nop
d.pfmul.ss f27, f29, f0
fld.l -32(r28), f18
d.mi2p1.ss f22, f0, f24
nop
d.mm12msm.ss f0, f0, f28
nop
d.mm12msm.ss f21, f30, f30
nop
d.ia1p2.ss f28, f16, f16
nop
d.mm12msm.ss f5, f30, f0
nop
d.mi2p1.ss f31, f0, f25
nop
d.ia1p2.ss f18, f17, f17
nop
d.mm12msm.ss f0, f0, f24
fst.l f24, 56(r21)
d.pfsub.ss f19, f2, f19
nop
d.m12tpa.ss f6, f3, f3
nop
d.mm12msm.ss f0, f0, f0
nop
d.ia1p2.ss f0, f0, f26
fst.l f26, 48(r21)
d.pfmul.ss f30, f20, f20
nop
d.pfmul.ss f0, f0, f0
nop
d.pfmul.ss f0, f0, f0
nop
d.mi2p1.ss f7, f0, f29
nop
d.pfadd.ss f0, f0, f0
nop
d.pfadd.ss f0, f0, f0
nop
d.pfsub.ss f27, f2, f27
nop
d.pfadd.ss f0, f0, f0
nop
d.pfadd.ss f0, f0, f0
nop
d.pfadd.ss f0, f0, f23
fst.l f23, 52(r21)
d.fiadd.ss f30, f0, f8
nop
.not_touched:
d.fnop
ld.l 44(r21), r21
d.fnop
bla r19, r20, .PD0.B1878105
d.fnop
nop
.align 8
fnop
nop
fnop
nop
// lineno: 0
// lineno: 0
.B1209: //.B0085
// lineno: 1321
fld.d -72(r28), f2
fld.d -64(r28), f4
fld.d -56(r28), f6
ld.l -48(r28), r4
bri r1
nop
.align 8
//}}}
//{{{ _solve_fn:
.globl _solve_fn
.align 8
_solve_fn:
.a16 = 0
.f16 = 32
orh h%.STACK+.f16-16, r0, r28
or l%.STACK+.f16-16, r28, r28
st.l r4, -8(r28)
// lineno: 0
adds 1, r0, r19
// lineno: 1403
fld.d r0(r17), f8
fld.d 8(r17), f10
addu 8, r16, r4
bte 0x0000, r4, .sB1176
// lineno: 1410
.sB1819: //.M0012
fld.d 32(r4), f16
.sDB.B18191819:
fld.d 40(r4), f18
// plane eqn now in f16 f17 f18 f19,
// view in f8 f9 f10 f11
pfmul.ss f8, f16, f0
pfmul.ss f9, f17, f0
pfmul.ss f10, f18, f0
pfmul.ss f11, f19, f16 // f16=nx*vx
i2p1.ss f16, f0, f0 // adder 1=nx.vx+ny.vy
i2ap1.ss f0, f0, f0 // t=nz.vz
i2pt.ss f0, f0, f0 // adder 1=nz.vz+nw.vw
pfadd.ss f0, f0, f16 // f16 = first 2
pfadd.ss f0, f0, f0 // click adder
i2ap1.ss f16, f0, f0 // adder1=total
pfadd.ss f0, f0, f0 // click adder
pfadd.ss f0, f0, f0 // click adder
pfadd.ss f0, f0, f26 // got it
pfle.ss f26, f0, f0
ld.l 8(r4), r29
bnc .sB1178
st.l r19, 60(r4)
adds 3, r0, r18
addu 16, r4, r24
st.l r19, 76(r29)
addu 4, r4, r25
ld.l 12(r4), r30
st.l r19, 76(r30)
ld.l 16(r4), r22
st.l r19, 76(r22)
ld.l 4(r4), r23
subs r18, r23, r0
bnc .sB1181
mov r24, r20
mov r25, r21
// lineno: 1420
.sB1818: //.M0011
ld.l 4(r20), r29
.sDB.B18181818:
addu 4, r20, r20
st.l r19, 76(r29)
adds r19, r18, r18
ld.l r0(r21), r30
subs r18, r30, r0
bc.t .sDB.B18181818
ld.l 4(r20), r29
// lineno: 0
// lineno: 1421
.sB1181: //.B0100
br .sDB.B11831183
ld.l r0(r4), r4
// lineno: 1425
.sB1178: //.B0098
st.l r0, 60(r4)
.sDB.B11781178:
// lineno: 1427
.sB1183: //.B0101
ld.l r0(r4), r4
.sDB.B11831183:
xor 0x0000, r4, r0
bnc.t .sDB.B18191819
fld.d 32(r4), f16
// lineno: 0
// lineno: 0
.sB1176: //.B0097
// lineno: 1428
bri r1
ld.l -8(r28), r4
//}}}
//{{{ _wait_locked_nonzero
.globl _wait_locked_nonzero
.align 8
// while (*r16 != 0) spin(r17);
_wait_locked_nonzero::
or r0, r0, r20
wait_locked_nonzero1::
adds 1, r20, r20
st.l r20, 4(r16)
bte 0x0, r16, .wait_locked_exit
ld.l r0(r16), r18
bte 0x0, r18, .wait_locked_loop
.wait_locked_exit::
bri r1
nop
.wait_locked_loop::
or r17,r0,r19
adds -1,r0,r18
bla r18,r19,.wait_locked_spin
nop
.wait_locked_spin::
bla r18,r19,.wait_locked_spin
nop
br wait_locked_nonzero1
nop
//}}}
//{{{ _i860_locked_read
.globl _i860_locked_read
.align 8
_i860_locked_read::
lock
ld.l r0(r16), r17
unlock
st.l r0, 4(r16)
bri r1
mov r17, r16
//}}}
//{{{ _manual_flush
.globl _manual_flush
.align 8
_manual_flush::
mov r1, r17
ld.c dirbase, r21
andnot 0x0f00, r21 , r20
adds -1, r0, r23
adds -32, r16, r19
// flush pass 1
or 0x800, r20 , r18
call D_FLUSH
st.c r18 , dirbase
// flush pass 2
or 0x900, r20 , r18
call D_FLUSH
st.c r18 , dirbase
// am i an XP?
ld.c epsr, r18
shr 19, r18 , r18
and 0x07, r18 , r18
bc RESTORE_DIRBASE
// flush pass 3
or 0xa00, r20 , r18
call D_FLUSH
st.c r18 , dirbase
// flush pass 4
or 0xb00, r20 , r18
call D_FLUSH
st.c r18 , dirbase
RESTORE_DIRBASE::
st.c r21 , dirbase
nop
nop
nop
nop
nop
nop
bri r17
nop
D_FLUSH::
mov 127, r24
bla r23 , r24 ,D_FLUSH_LOOP
mov r19 , r22
D_FLUSH_LOOP::
bla r23 , r24 ,D_FLUSH_LOOP
flush 32( r22 )++
bri r1
nop
//}}}
//{{{ some data
.data
.align 8
.C00036: // (16)
.long 0x3f800000 // 1.00000000E+00
.C00037: // (64)
.long 0x40000000 // 2.00000000E+00
.align 16
.C00038:
.long 0x0
.long 0x0
.long 0x0
.long 0x0
.long 0x0
.long 0x0
.long 0x0
.long 0x0
.long 0x0
.long 0x0
.long 0x0
.long 0x0
.long 0x0
.long 0x0
.long 0x0
.long 0x0
.C00066: // (64)
.long 0x3f800000 // 1.00000000E+00
.C00067: // (64)
.long 0xbf800000 // -1.00000000E+00
.lcomm .STACK,96
.lcomm .BSS,32
//}}}
Reference in New Issue View Git Blame Copy Permalink