CydandClaude Fable 5
db7745fcd0
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>
2381 lines
56 KiB
Scheme
2381 lines
56 KiB
Scheme
//{{{ 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
|
|
|
|
|
|
|
|
#if 0
|
|
//{{{ hm - not much used in here
|
|
//{{{ fn_plane_term
|
|
.globl _fn_plane_term
|
|
.align 8
|
|
|
|
#define ay f8
|
|
#define by f9
|
|
#define cy f10
|
|
#define az f11
|
|
#define bz f12
|
|
#define cz f13
|
|
|
|
#define tmp1 f11
|
|
#define tmp2 f12
|
|
#define tmp3 f13
|
|
|
|
_fn_plane_term::
|
|
pfsub.ss az, bz, f0 // az-bz ? ?
|
|
pfsub.ss bz, cz, f0 // bz-cz az-bz ?
|
|
pfsub.ss cz, az, f0 // cz-az bz-cz az-bz
|
|
|
|
pfsub.ss f0, f0, tmp1 // trash cz-az bz-cz tmp1=az-bz
|
|
|
|
m12apm.ss tmp1, cy, tmp2 // cy*... trash cz-az tmp2=bz-cz
|
|
m12apm.ss tmp2, ay, tmp1 // ay*... cy*... trash tmp1=cz-az
|
|
m12apm.ss tmp1, by, f0 // by*... ay*... cy*...
|
|
mm12tpm.ss f0, f0, tmp1 // tmp1=cy* ...
|
|
mm12tpm.ss f0, f0, tmp2 // tmp2=ay* ...
|
|
mim1p2.ss tmp2, tmp1, tmp3 // tmp1+tmp2 tmp3=by*...
|
|
pfadd.ss f0,f0,f0 // ?? tmp1+tmp2 ??
|
|
pfadd.ss f0,f0,f0 // ?? ?? tmp1+tmp2
|
|
pfadd.ss f0,f0,tmp2 // ?? ?? ?? tmp2=tmp1+tmp2
|
|
bri r1
|
|
fadd.ss tmp3,tmp2,f8
|
|
|
|
|
|
#undef ay
|
|
#undef by
|
|
#undef cy
|
|
#undef az
|
|
#undef bz
|
|
#undef cz
|
|
|
|
#undef tmp1
|
|
#undef tmp2
|
|
#undef tmp3
|
|
|
|
//}}}
|
|
|
|
|
|
//{{{ fn_invert ?
|
|
.globl _fn_invert
|
|
.align 8
|
|
|
|
_fn_invert::
|
|
|
|
|
|
|
|
//}}}
|
|
|
|
//{{{ fn_renorm
|
|
.globl _fn_renorm
|
|
.align 8
|
|
|
|
|
|
// r16 holds matrix to renormalise
|
|
// r17 holds -1
|
|
// r18 holds loop count
|
|
// r19 r20 r21 r22 hold 4 temps (for page-mode access)
|
|
// r23 holds IEEE exponent mask
|
|
|
|
_fn_renorm::
|
|
|
|
adds -1, r0, r17
|
|
adds 3, r0, r18
|
|
bla r17,r18,.renorm_loop
|
|
orh 0x7f80, r0, r23
|
|
|
|
.renorm_loop::
|
|
ld.l 0(r16), r19
|
|
ld.l 4(r16), r20
|
|
ld.l 8(r16), r21
|
|
ld.l 12(r16), r22
|
|
|
|
and r19,r23,r0
|
|
bnc .renorm0
|
|
st.l r0, 0(r16)
|
|
.renorm0::
|
|
|
|
and r20,r23,r0
|
|
bnc .renorm1
|
|
st.l r0, 4(r16)
|
|
.renorm1::
|
|
|
|
and r21,r23,r0
|
|
bnc .renorm2
|
|
st.l r0, 8(r16)
|
|
.renorm2::
|
|
|
|
and r22,r23,r0
|
|
bnc .renorm3
|
|
st.l r0, 12(r16)
|
|
.renorm3::
|
|
|
|
bla r17,r18,.renorm_loop
|
|
addu 16,r16,r16
|
|
|
|
bri r1
|
|
nop
|
|
|
|
|
|
|
|
|
|
|
|
//}}}
|
|
//}}}
|
|
#endif
|
|
//{{{ 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
|
|
|
|
#define dst r16
|
|
#define src r17
|
|
#define bytes r18
|
|
#define itemp r19
|
|
|
|
_p_memcpy::
|
|
or -1,r0,itemp // decrement by 1
|
|
addu 7,bytes,bytes // copy up to and including a double
|
|
shr 3,bytes,bytes // correct for sizeof double
|
|
adds -1,bytes,bytes // correct for bla
|
|
adds -8,src,src // correct for autoincrement
|
|
|
|
bla itemp,bytes,.L666666
|
|
adds -8,dst,dst // and again
|
|
.L666666:
|
|
fld.d 8(src)++,f16
|
|
bla itemp,bytes,.L666666
|
|
fst.d f16,8(dst)++
|
|
|
|
bri r1
|
|
nop
|
|
|
|
#undef dst
|
|
#undef src
|
|
#undef bytes
|
|
|
|
//}}}
|
|
|
|
|
|
|
|
//{{{ 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
|
|
|
|
#define m00 f8
|
|
#define m01 f9
|
|
#define m02 f10
|
|
#define m03 f11
|
|
#define m10 f12
|
|
#define m11 f13
|
|
#define m12 f14
|
|
#define m13 f15
|
|
#define m20 f16
|
|
#define m21 f17
|
|
#define m22 f18
|
|
#define m23 f19
|
|
#define m30 f20
|
|
#define m31 f21
|
|
#define m32 f22
|
|
#define m33 f23
|
|
|
|
#define px f24
|
|
#define py f25
|
|
#define pz f26
|
|
#define pw f27
|
|
|
|
#define tmp1 f28
|
|
#define tmp2 f29
|
|
#define tmp3 f30
|
|
#define tmp4 f31
|
|
#define tmp5 f7
|
|
|
|
//}}}
|
|
|
|
//{{{ fn_cache_mtx
|
|
.align 8
|
|
|
|
_fn_cache_mtx::
|
|
adds -4,r16,r31
|
|
fld.l 4(r31)++, m00
|
|
fld.l 4(r31)++, m01
|
|
fld.l 4(r31)++, m02
|
|
fld.l 4(r31)++, m03
|
|
fld.l 4(r31)++, m10
|
|
fld.l 4(r31)++, m11
|
|
fld.l 4(r31)++, m12
|
|
fld.l 4(r31)++, m13
|
|
fld.l 4(r31)++, m20
|
|
fld.l 4(r31)++, m21
|
|
fld.l 4(r31)++, m22
|
|
fld.l 4(r31)++, m23
|
|
fld.l 4(r31)++, m30
|
|
fld.l 4(r31)++, m31
|
|
fld.l 4(r31)++, m32
|
|
bri r1
|
|
fld.l 4(r31)++, m33
|
|
//}}}
|
|
|
|
//{{{ fn_cache_opt_mtx
|
|
.align 8
|
|
|
|
_fn_cache_opt_mtx::
|
|
adds -4,r16,r31
|
|
fld.l 4(r31)++, m00
|
|
fld.l 4(r31)++, m01
|
|
fld.l 4(r31)++, m02
|
|
fld.l 8(r31)++, m10
|
|
fld.l 4(r31)++, m11
|
|
fld.l 4(r31)++, m12
|
|
fld.l 8(r31)++, m20
|
|
fld.l 4(r31)++, m21
|
|
fld.l 4(r31)++, m22
|
|
fld.l 8(r31)++, m30
|
|
fld.l 4(r31)++, m31
|
|
bri r1
|
|
fld.l 4(r31)++, m32
|
|
//}}}
|
|
|
|
//{{{ fn_cache_mtx
|
|
.align 8
|
|
|
|
_fn_cache_mtxd::
|
|
adds -8,r16,r31
|
|
fld.d 8(r31)++, m00
|
|
fld.d 8(r31)++, m02
|
|
fld.d 8(r31)++, m10
|
|
fld.d 8(r31)++, m12
|
|
fld.d 8(r31)++, m20
|
|
fld.d 8(r31)++, m22
|
|
fld.d 8(r31)++, m30
|
|
bri r1
|
|
fld.d 8(r31)++, m32
|
|
//}}}
|
|
|
|
//{{{ fn_cache_opt_mtx
|
|
.align 8
|
|
|
|
_fn_cache_opt_mtxd::
|
|
adds -8,r16,r31
|
|
fld.d 8(r31)++, m00
|
|
fld.d 8(r31)++, m02
|
|
fld.d 8(r31)++, m10
|
|
fld.d 8(r31)++, m12
|
|
fld.d 8(r31)++, m20
|
|
fld.d 8(r31)++, m22
|
|
fld.d 8(r31)++, m30
|
|
bri r1
|
|
fld.d 8(r31)++, m32
|
|
//}}}
|
|
|
|
//{{{ fn_xform in 43 ticks
|
|
//
|
|
// #define fullxform(d,s) \
|
|
// sx =*s++; sy =*s++; sz =*s++; sw=*s++; \
|
|
// *d++ = (sx*m00) + (sy*m10) + (sz*m20) + (sw*m30); \
|
|
// *d++ = (sx*m01) + (sy*m11) + (sz*m21) + (sw*m31); \
|
|
// *d++ = (sx*m02) + (sy*m12) + (sz*m22) + (sw*m32); \
|
|
// *d++ = (sx*m03) + (sy*m13) + (sz*m23) + (sw*m33)
|
|
//
|
|
// matrix held in m11 .. m44
|
|
// r16 points to destn
|
|
// r17 points at the point to transform,
|
|
//
|
|
|
|
.align 8
|
|
|
|
_fn_xform::
|
|
|
|
fld.l 0(r17),px
|
|
fld.l 4(r17),py
|
|
fld.l 8(r17),pz
|
|
|
|
pfmul.ss px,m00,f0
|
|
fld.l 12(r17),pw
|
|
pfmul.ss py,m10,f0
|
|
pfmul.ss pz,m20,f0
|
|
pfmul.ss pw,m30,tmp1
|
|
pfmul.ss px,m01,tmp2
|
|
pfadd.ss tmp1,tmp2,f0 // adder 1 = x00+y10
|
|
pfmul.ss py,m11,tmp1
|
|
pfmul.ss pz,m21,tmp2
|
|
pfadd.ss tmp1,tmp2,f0 // adder 1 = z20 + w30
|
|
pfmul.ss pw,m31,tmp1
|
|
pfmul.ss px,m02,tmp2
|
|
pfadd.ss tmp1,tmp2,f0 // adder 1 = x01+y11
|
|
pfmul.ss py,m12,tmp1
|
|
pfmul.ss pz,m22,tmp2
|
|
pfadd.ss tmp1,tmp2,tmp3 // adder1 = z21+w31 tmp3=x00+y10
|
|
pfmul.ss pw,m32,tmp1
|
|
pfmul.ss px,m03,tmp2
|
|
pfadd.ss tmp1,tmp2,tmp4 // adder1 = x02+y12 tmp4=z20+w30
|
|
pfmul.ss py,m13,tmp1
|
|
pfmul.ss pz,m23,tmp2
|
|
pfadd.ss tmp1,tmp2,tmp5 // adder1 = z22+w32 tmp5=x01+y11
|
|
pfmul.ss pw,m33,tmp1
|
|
pfmul.ss f0,f0,tmp2
|
|
pfadd.ss tmp1,tmp2,px // adder1 = x03+y13 px=z21+w31
|
|
pfmul.ss f0,f0,tmp1
|
|
pfmul.ss f0,f0,tmp2
|
|
pfadd.ss tmp1,tmp2,py // adder1=z23+w33 py=x02+y12
|
|
pfadd.ss tmp3,tmp4,tmp1 // adder1=rx tmp1=z22+w32
|
|
pfadd.ss tmp5,px,tmp2 // adder1=ry tmp2=x03+y13
|
|
pfadd.ss tmp1,py,tmp3 // adder1=rz tmp3=z23+w33
|
|
pfadd.ss tmp2,tmp3,px
|
|
fst.l px, 0(r16)
|
|
pfadd.ss f0,f0,py
|
|
fst.l py, 4(r16)
|
|
pfadd.ss f0,f0,pz
|
|
fst.l pz, 8(r16)
|
|
pfadd.ss f0,f0,pw
|
|
bri r1
|
|
fst.l pw, 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*m00) + (sy*m10) + (sz*m20) + m30; \
|
|
// *d++ = (sx*m01) + (sy*m11) + (sz*m21) + m31; \
|
|
// *d++ = (sx*m02) + (sy*m12) + (sz*m22) + m32; \
|
|
// *d++ = 1
|
|
//
|
|
// matrix held in m11 .. m44
|
|
// r16 points to destn
|
|
// r17 points at the point to transform,
|
|
//
|
|
|
|
.align 8
|
|
|
|
_fn_optxform::
|
|
|
|
fld.l 0(r17),px
|
|
fld.l 4(r17),py
|
|
|
|
pfmul.ss px,m00,f0
|
|
fld.l 8(r17),pz
|
|
pfmul.ss py,m10,f0
|
|
pfmul.ss px,m01,f0
|
|
pfmul.ss py,m11,tmp1
|
|
pfmul.ss px,m02,tmp2
|
|
pfadd.ss tmp1,tmp2,f0 // adder 1 = x00+y10
|
|
pfmul.ss py,m12,tmp1
|
|
pfmul.ss pz,m20,tmp2
|
|
pfadd.ss tmp1,tmp2,f0 // adder 1 = x01+y11
|
|
pfmul.ss pz,m21,tmp1
|
|
pfmul.ss pz,m22,tmp2
|
|
pfadd.ss tmp1,tmp2,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 m30,f0,f0
|
|
r2ap1.ss m31,f0,f0
|
|
r2ap1.ss m32,f0,f0
|
|
|
|
pfadd.ss f0,f0,px
|
|
fst.l px, 0(r16)
|
|
pfadd.ss f0,f0,py
|
|
fst.l py, 4(r16)
|
|
pfadd.ss f0,f0,pz
|
|
bri r1
|
|
fst.l pz, 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 tmp5, 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, tmp5
|
|
|
|
//}}}
|
|
|
|
// 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
|
|
//}}}
|
|
|
|
#if 0
|
|
//{{{ fn_solve ()
|
|
.globl _fn_solve_l
|
|
.align 8
|
|
_fn_solve_l::
|
|
fld.l 0(r16), f16
|
|
fld.l 0(r17), f19
|
|
|
|
fmul.ss f16, f19, f23
|
|
fld.l 4(r16), f17
|
|
fld.l 4(r17), f20
|
|
fmul.ss f17, f20, f16
|
|
fld.l 8(r16), f18
|
|
fld.l 8(r17), f21
|
|
fmul.ss f18, f21, f17
|
|
fld.l 12(r17), f22
|
|
adds 0, r0, r16
|
|
fadd.ss f23, f16, f19
|
|
fadd.ss f17, f19, f18
|
|
fadd.ss f18, f22, f16
|
|
|
|
pfgt.ss f16,f0,f0
|
|
bnc .L55
|
|
adds 1,r0,r16
|
|
.L55::
|
|
bri r1
|
|
nop
|
|
//}}}
|
|
|
|
// old paz structures
|
|
//{{{ vertex_copy
|
|
//
|
|
// vertex_copy
|
|
//
|
|
// assumes .double aligned data
|
|
//
|
|
.globl _vertex_copy
|
|
.align 8
|
|
|
|
#define dst r16
|
|
#define src r17
|
|
#define verts r18
|
|
#define itemp r19
|
|
|
|
// typedef struct s_vert {
|
|
// POINT position;
|
|
// POINT planeEqn;
|
|
// float normcol [3];
|
|
// struct s_vert *next;
|
|
// float texcoords [2];
|
|
// } VERTEX;
|
|
//
|
|
// 14 words, 7 double register loads
|
|
//
|
|
_vertex_copy::
|
|
adds r0, r1, r20
|
|
or -1,r0,itemp // decrement by 1
|
|
adds -1,verts,verts // correct for bla
|
|
adds -8,src,src // correct for autoincrement
|
|
|
|
bla itemp,verts,.vcopy_bla
|
|
adds -8,dst,dst // and again
|
|
.vcopy_bla:
|
|
fld.d 8(src)++,f16
|
|
fld.d 8(src)++,f18
|
|
fld.d 8(src)++,f20
|
|
fld.d 8(src)++,f22
|
|
fld.d 8(src)++,f24
|
|
fld.d 8(src)++,f26
|
|
fld.d 8(src)++,f28
|
|
|
|
// this should remain cached, its the render_strip, hit
|
|
// hard every strip
|
|
fst.d f16,8(dst)++
|
|
fst.d f18,8(dst)++
|
|
fst.d f20,8(dst)++
|
|
fst.d f22,8(dst)++
|
|
fst.d f24,8(dst)++
|
|
fst.l f26,8(dst)++ // dont copy next field !
|
|
bla itemp,verts,.vcopy_bla
|
|
fst.d f28,8(dst)++
|
|
|
|
bri r1
|
|
nop
|
|
|
|
#undef dst
|
|
#undef src
|
|
#undef verts
|
|
#undef itemp
|
|
|
|
//}}}
|
|
//{{{ pmesh_tri_copy
|
|
//
|
|
// pmesh_tri_copy
|
|
//
|
|
//
|
|
//
|
|
.globl _pmesh_tri_copy
|
|
.align 8
|
|
|
|
#define dst r16
|
|
#define src r17
|
|
#define verts r18
|
|
#define delta r19
|
|
#define itemp r20
|
|
|
|
// typedef struct s_vert {
|
|
// POINT position;
|
|
// POINT planeEqn;
|
|
// float normcol [3];
|
|
// struct s_vert *next;
|
|
// float texcoords [2];
|
|
// } VERTEX;
|
|
//
|
|
// do 3 triangle pointers, zero W, do plane equation
|
|
//
|
|
_pmesh_tri_copy::
|
|
or -1,r0,itemp // decrement by 1
|
|
adds -1,verts,verts // correct for bla
|
|
|
|
bla itemp,verts,.tcopy_bla
|
|
nop
|
|
.tcopy_bla:
|
|
ld.l 0(src), r29
|
|
ld.l 4(src), r30
|
|
adds r29, delta, r29
|
|
ld.l 8(src), r31
|
|
adds r30, delta, r30
|
|
fld.d 16(src), f16
|
|
adds r31, delta, r31
|
|
fld.d 24(src), f18
|
|
|
|
st.l r29, 0(dst)
|
|
st.l r30, 4(dst)
|
|
st.l r31, 8(dst)
|
|
st.l r0, 12(dst)
|
|
|
|
fst.d f16, 16(dst)
|
|
fst.d f18, 24(dst)
|
|
|
|
adds 56, src, src
|
|
bla itemp,verts,.tcopy_bla
|
|
adds 56, dst, dst
|
|
|
|
bri r1
|
|
nop
|
|
|
|
|
|
|
|
#undef dst
|
|
#undef src
|
|
#undef verts
|
|
#undef delta
|
|
#undef itemp
|
|
|
|
//}}}
|
|
//{{{ pmesh_vertex_copy
|
|
//
|
|
// pmesh_vertex_copy
|
|
//
|
|
// assumes .double aligned data
|
|
//
|
|
.globl _pmesh_vertex_copy
|
|
.align 8
|
|
|
|
#define dst r16
|
|
#define src r17
|
|
#define verts r18
|
|
#define itemp r19
|
|
|
|
// typedef struct s_vert {
|
|
// POINT position;
|
|
// POINT planeEqn;
|
|
// float normcol [3];
|
|
// struct s_vert *next;
|
|
// float texcoords [2];
|
|
// } VERTEX;
|
|
//
|
|
// we only need to copy position, normcol and texcoords
|
|
//
|
|
_pmesh_vertex_copy::
|
|
or -1,r0,itemp // decrement by 1
|
|
adds -1,verts,verts // correct for bla
|
|
adds -8, src, src
|
|
bla itemp,verts,.pvcopy_bla
|
|
adds -8, dst, dst
|
|
.pvcopy_bla:
|
|
fld.d 8(src),f16
|
|
fld.d 16(src),f18 // position
|
|
fld.d 40(src),f20
|
|
fld.d 48(src),f22 // normcol/next
|
|
fld.d 56(src)++,f24
|
|
|
|
// this should remain cached, its the render_strip, hit
|
|
// hard every strip
|
|
fst.d f16, 8(dst)
|
|
fst.d f18,16(dst)
|
|
fst.d f20,40(dst)
|
|
fst.d f22,48(dst) // dont bash the next ptr
|
|
bla itemp,verts,.pvcopy_bla
|
|
fst.d f24,56(dst)++
|
|
|
|
bri r1
|
|
nop
|
|
|
|
#undef dst
|
|
#undef src
|
|
#undef bytes
|
|
|
|
//}}}
|
|
|
|
//{{{ _fn_solve
|
|
.globl _fn_solve
|
|
.align 8
|
|
_fn_solve::
|
|
fld.l 0(r16), f16
|
|
fld.l 4(r16), f17
|
|
fld.l 0(r17), f20
|
|
fld.l 4(r17), f21
|
|
// we are computing
|
|
//
|
|
// r16( 0)*r17( 0) +
|
|
// r16( 4)*r17( 4) +
|
|
// r16( 8)*r17( 8) +
|
|
// r16(12) > 0
|
|
//
|
|
// 18 ticks raw, now done in 11
|
|
//
|
|
// in fact we can compute
|
|
// ax + bx + cz > d, if we store -d rather than d into
|
|
// plane equation
|
|
//
|
|
d.pfmul.ss f16, f20, f0
|
|
fld.l 8(r16), f18
|
|
d.pfmul.ss f17, f21, f0
|
|
fld.l 8(r17), f22
|
|
pfmul.ss f18, f22, f0
|
|
fld.l 12(r16), f19
|
|
iat1p2.ss f0, f0, f0
|
|
adds 0, r0, r16
|
|
m12tpm.ss f0, f0, f0 // push px*ptx + py*pty into adder
|
|
iat1p2.ss f0, f0, f0 // push pz*ptz into t
|
|
pfadd.ss f0, f0, f0 // push partial into last-stage adder
|
|
m12tpa.ss f0, f0, f0 // and push dot-product into adder
|
|
pfadd.ss f0, f0, f0 // stage 2
|
|
pfadd.ss f0, f0, f0 // stage 3
|
|
pfadd.ss f0, f0, f16 // stage 3
|
|
|
|
pfgt.ss f16,f19,f0 // will run some 50% faster
|
|
bnc .Ld55
|
|
adds 1,r0,r16
|
|
.Ld55::
|
|
bri r1
|
|
nop
|
|
//}}}
|
|
//{{{ _fn_solve
|
|
.globl _fn_solve
|
|
.align 8
|
|
_fn_solve::
|
|
fld.d 0(r16), f16
|
|
fld.d 0(r17), f18
|
|
|
|
fmul.ss f16, f18, f23
|
|
fld.d 8(r17), f20
|
|
fld.l 8(r16), f22
|
|
fmul.ss f17, f19, f16
|
|
fmul.ss f22, f20, f17
|
|
adds 0, r0, r16
|
|
fadd.ss f23, f16, f19
|
|
fadd.ss f17, f19, f18
|
|
fadd.ss f22, f18, f16
|
|
|
|
pfgt.ss f16,f0,f0
|
|
bnc .Ld55
|
|
adds 1,r0,r16
|
|
.Ld55::
|
|
bri r1
|
|
nop
|
|
//}}}
|
|
//{{{ _fn_distance_strip
|
|
.globl _fn_distance_strip
|
|
.align 8
|
|
|
|
//
|
|
// fn_distance_strip ( POINT inveye, VERTEX *v1, int n_tris, float scaleFac )
|
|
//
|
|
// this puts the point into the plane equation and saves the answer into
|
|
// vert->position[3]
|
|
//
|
|
|
|
#define inveye r16
|
|
#define vertex r17
|
|
#define n_tris r18
|
|
#define minus_1 r20
|
|
#define scaleFac f8
|
|
|
|
_fn_distance_strip::
|
|
// exit if loop count == 0
|
|
bte r0, n_tris, .exit_distance_strip
|
|
|
|
// load up inverse eye position (constant for strip)
|
|
fld.l 0(inveye), f16
|
|
fld.l 4(inveye), f17
|
|
fld.l 8(inveye), f18
|
|
|
|
//
|
|
// we are computing
|
|
//
|
|
// r16( 0)*r17( 0) +
|
|
// r16( 4)*r17( 4) +
|
|
// r16( 8)*r17( 8) - r16(12)
|
|
//
|
|
// ax + bx + cz > d, but we MUST store -d rather than d into
|
|
// plane equation
|
|
//
|
|
adds -1, n_tris, n_tris
|
|
adds -1, r0, minus_1
|
|
|
|
bla minus_1, n_tris, .distance_point_db
|
|
fld.l 16(vertex), f20
|
|
|
|
.distance_point::
|
|
fld.l 16(vertex), f20
|
|
.distance_point_db::
|
|
fld.l 20(vertex), f21
|
|
fld.l 24(vertex), f22
|
|
fld.l 28(vertex), f19
|
|
|
|
pfmul.ss f16, f20, f0
|
|
pfmul.ss f17, f21, f0
|
|
pfmul.ss f18, f22, f0
|
|
iat1p2.ss f0, f0, f0
|
|
m12tpm.ss f0, f0, f0 // push px*ptx + py*pty into adder
|
|
iat1p2.ss f0, f0, f0 // push pz*ptz into t
|
|
pfadd.ss f0, f0, f0 // push partial into last-stage adder
|
|
m12tpa.ss f0, f0, f0 // and push dot-product into adder
|
|
pfadd.ss f0, f0, f0 // stage 2
|
|
pfadd.ss f0, f0, f0 // stage 3
|
|
pfadd.ss f0, f0, f20 // stage 3
|
|
|
|
fsub.ss f20, f19, f21
|
|
fmul.ss f21, f21, f20
|
|
frcp.ss f20, f21
|
|
frsqr.ss f21, f20
|
|
fmul.ss f20, scaleFac, f21
|
|
st.l f21, 12(vertex)
|
|
bla minus_1, n_tris, .distance_point
|
|
adds 56, vertex, vertex
|
|
|
|
.exit_distance_strip::
|
|
bri r1
|
|
nop
|
|
//}}}
|
|
//{{{ _fn_view_distance
|
|
.globl _fn_view_distance
|
|
.align 8
|
|
|
|
#define inveye r16
|
|
#define vertex r17
|
|
|
|
_fn_view_distance::
|
|
// load up inverse eye position (constant for strip)
|
|
fld.l 0(inveye), f16
|
|
fld.l 4(inveye), f17
|
|
fld.l 8(inveye), f18
|
|
|
|
fld.l 16(vertex), f20
|
|
fld.l 20(vertex), f21
|
|
fld.l 24(vertex), f22
|
|
fld.l 28(vertex), f19
|
|
|
|
pfmul.ss f16, f20, f0
|
|
pfmul.ss f17, f21, f0
|
|
pfmul.ss f18, f22, f0
|
|
iat1p2.ss f0, f0, f0
|
|
m12tpm.ss f0, f0, f0 // push px*ptx + py*pty into adder
|
|
iat1p2.ss f0, f0, f0 // push pz*ptz into t
|
|
pfadd.ss f0, f0, f0 // push partial into last-stage adder
|
|
m12tpa.ss f0, f0, f0 // and push dot-product into adder
|
|
pfadd.ss f0, f0, f0 // stage 2
|
|
pfadd.ss f0, f0, f0 // stage 3
|
|
pfadd.ss f0, f0, f20 // stage 3
|
|
|
|
fsub.ss f20, f19, f20
|
|
fmul.ss f20, f20, f19
|
|
frcp.ss f20, f19
|
|
bri r1
|
|
frsqr.ss f20, f8
|
|
//}}}
|
|
//{{{ _fn_xform_strip in 32 ticks per point == 790 k xforms/sec on i860-25
|
|
.globl _fn_xform_strip
|
|
// extern float fn_xform_strip ( VERTEX *head, MATRIX m, int n );
|
|
|
|
.align 8
|
|
_fn_xform_strip::
|
|
subs r0, r18, r0
|
|
bnc .getout
|
|
|
|
mov r1,r19
|
|
|
|
mov r16, r20
|
|
call _fn_cache_opt_mtx
|
|
mov r17,r16
|
|
|
|
adds -1,r18,r18 // prepare n for auto decrement
|
|
adds -1,r0,r21 // using -1 as decrement
|
|
bla r21,r18,.dloop
|
|
.dloop:
|
|
fld.d 0(r20),px
|
|
|
|
pfmul.ss px,m00,f0
|
|
pfmul.ss py,m10,f0
|
|
fld.l 8(r20),pz
|
|
pfmul.ss px,m01,f0
|
|
pfmul.ss py,m11,tmp1
|
|
pfmul.ss px,m02,tmp2
|
|
pfadd.ss tmp1,tmp2,f0 // adder 1 = x00+y10
|
|
pfmul.ss py,m12,tmp1
|
|
pfmul.ss pz,m20,tmp2
|
|
pfadd.ss tmp1,tmp2,f0 // adder 1 = x01+y11
|
|
pfmul.ss pz,m21,tmp1
|
|
pfmul.ss pz,m22,tmp2
|
|
pfadd.ss tmp1,tmp2,f0 // adder 1 = x02+y12
|
|
m12apm.ss f0,f0,f0 // fill adder unit with adder+mul units
|
|
m12apm.ss f0,f0,f0 //
|
|
m12apm.ss f0,f0,f0 //
|
|
|
|
r2ap1.ss m30,f0,f0
|
|
r2ap1.ss m31,f0,f0
|
|
r2ap1.ss m32,f0,f0
|
|
|
|
pfadd.ss f0,f0,px
|
|
pfadd.ss f0,f0,py
|
|
pfadd.ss f0,f0,pz
|
|
fst.d px, 0(r20)
|
|
adds 56, r20, r20
|
|
|
|
bla r21,r18,.dloop
|
|
fst.l pz, -48(r20)
|
|
|
|
bri r19
|
|
nop
|
|
.getout:
|
|
bri r1
|
|
nop
|
|
//}}}
|
|
//{{{ _fn_solve_strip
|
|
.globl _fn_solve_strip
|
|
.align 8
|
|
|
|
#define texScaleFac f8
|
|
|
|
//
|
|
// fn_solve_strip ( POINT inveye, VERTEX *v1, int n_tris )
|
|
//
|
|
// this puts the point into the plane equation and saves the answer into
|
|
// vert->position[3]
|
|
//
|
|
|
|
#define inveye r16
|
|
#define vertex r17
|
|
#define n_tris r18
|
|
#define twosided r19
|
|
#define one r20
|
|
#define minus_1 r21
|
|
|
|
|
|
_fn_solve_strip::
|
|
// exit if loop count == 0
|
|
bte r0, n_tris, .exit_solve_strip
|
|
|
|
// load up inverse eye position (constant for strip)
|
|
fld.l 0(inveye), f16
|
|
fld.l 4(inveye), f17
|
|
fld.l 8(inveye), f18
|
|
|
|
//
|
|
// we are computing
|
|
//
|
|
// r16( 0)*r17( 0) +
|
|
// r16( 4)*r17( 4) +
|
|
// r16( 8)*r17( 8) > r16(12)
|
|
//
|
|
// ax + bx + cz > d, but we MUST store -d rather than d into
|
|
// plane equation
|
|
//
|
|
adds -1, n_tris, n_tris
|
|
adds -1, r0, minus_1
|
|
|
|
bla minus_1, n_tris, .solve_point
|
|
or 1, r0, one
|
|
|
|
.solve_point::
|
|
fld.l 16(vertex), f20
|
|
fld.l 20(vertex), f21
|
|
fld.l 24(vertex), f22
|
|
fld.l 28(vertex), f19
|
|
|
|
pfmul.ss f16, f20, f0
|
|
pfmul.ss f17, f21, f0
|
|
pfmul.ss f18, f22, f0
|
|
iat1p2.ss f0, f0, f0
|
|
m12tpm.ss f0, f0, f0 // push px*ptx + py*pty into adder
|
|
iat1p2.ss f0, f0, f0 // push pz*ptz into t
|
|
pfadd.ss f0, f0, f0 // push partial into last-stage adder
|
|
m12tpa.ss f0, f0, f0 // and push dot-product into adder
|
|
pfadd.ss f0, f0, f0 // stage 2
|
|
pfadd.ss f0, f0, f0 // stage 3
|
|
pfadd.ss f0, f0, f20 // stage 3
|
|
|
|
pfgt.ss f20,f19,f0
|
|
|
|
bnc .solution_zero
|
|
|
|
.solution_one::
|
|
fsub.ss f20, f19, f31
|
|
fmul.ss f31, f31, f20
|
|
frsqr.ss f20, f21
|
|
fmul.ss f21, texScaleFac, f20
|
|
fxfr f20, r31
|
|
or 1, r31, r31
|
|
st.l r31, 12(vertex)
|
|
bla minus_1, n_tris, .solve_point
|
|
adds 56, vertex, vertex
|
|
|
|
.exit_solve_strip::
|
|
bri r1
|
|
nop
|
|
|
|
.solution_zero::
|
|
or r0, twosided, r0
|
|
bnc .solution_zeroish
|
|
|
|
.solution_straight_zero::
|
|
st.l r0, 12(vertex)
|
|
bla minus_1, n_tris, .solve_point
|
|
adds 56, vertex, vertex
|
|
|
|
bri r1
|
|
nop
|
|
|
|
.solution_zeroish::
|
|
fsub.ss f20, f19, f31
|
|
fmul.ss f31, f31, f20
|
|
frsqr.ss f20, f21
|
|
fmul.ss f21, texScaleFac, f20
|
|
fxfr f20, r31
|
|
andh 0xffff, r31, r31
|
|
st.l r31, 12(vertex)
|
|
// st.l r0, 12(vertex)
|
|
bla minus_1, n_tris, .solve_point
|
|
adds 56, vertex, vertex
|
|
|
|
bri r1
|
|
nop
|
|
|
|
//}}}
|
|
//{{{ _fn_solve_pmesh
|
|
.globl _fn_solve_pmesh
|
|
.align 8
|
|
|
|
//
|
|
// fn_solve_pmesh ( POINT inveye, VERTEX *v1, int n_tris )
|
|
//
|
|
// this puts the point into the plane equation and saves the answer into
|
|
// vert->position[3], and also flags each vertex (in position[0],[1],[2])
|
|
// as requiring transformation
|
|
//
|
|
// note that we cant just blindly drop the result into the vertex, as
|
|
// a shared vertex is likely to have bothe +ve and -ve solutions, so
|
|
// we need 2 copies of the loop, one which saves the result and one
|
|
// which doest, and we have to bla to the correct one dependent on the
|
|
// result
|
|
//
|
|
// by coding this up in dual-instruction mode, the stores to the triangles
|
|
// come (virtually) for free - now we just need an xflghtpr with
|
|
// conditional behaviour
|
|
//
|
|
//
|
|
|
|
#define inveye r16
|
|
#define vertex r17
|
|
#define n_tris r18
|
|
#define twosided r19
|
|
|
|
#define one r20
|
|
#define minus_1 r21
|
|
#define prev_vertex r22
|
|
#define v0 r23
|
|
#define v1 r24
|
|
#define v2 r25
|
|
|
|
_fn_solve_pmesh::
|
|
// exit if loop count == 0
|
|
bte r0, n_tris, .exit_solve_strip
|
|
|
|
// load up inverse eye position (constant for strip)
|
|
fld.l 0(inveye), f16
|
|
fld.l 4(inveye), f17
|
|
fld.l 8(inveye), f18
|
|
|
|
adds r0, vertex, prev_vertex
|
|
|
|
//
|
|
// we are computing
|
|
//
|
|
// r16( 0)*r17( 0) +
|
|
// r16( 4)*r17( 4) +
|
|
// r16( 8)*r17( 8) > r16(12)
|
|
//
|
|
// ax + bx + cz > d, but we MUST store -d rather than d into
|
|
// plane equation
|
|
//
|
|
adds -1, n_tris, n_tris
|
|
adds -1, r0, minus_1
|
|
|
|
bla minus_1, n_tris, .pmesh_solve_point_dont_write
|
|
or 1, r0, one
|
|
|
|
.align 8
|
|
.pmesh_solve_point_do_write::
|
|
d.pfmul.ss f0, f0, f0
|
|
fld.l 16(vertex), f20
|
|
d.pfmul.ss f0, f0, f0
|
|
fld.l 20(vertex), f21
|
|
d.pfmul.ss f0, f0, f0
|
|
fld.l 28(vertex), f19
|
|
d.pfmul.ss f16, f20, f0
|
|
fld.l 24(vertex), f22
|
|
d.pfmul.ss f17, f21, f0
|
|
ld.l 0(prev_vertex), v0
|
|
d.pfmul.ss f18, f22, f0
|
|
nop
|
|
d.iat1p2.ss f0, f0, f0
|
|
nop
|
|
d.m12tpm.ss f0, f0, f0 // push px*ptx + py*pty into adder
|
|
ld.l 4(prev_vertex), v1
|
|
d.iat1p2.ss f0, f0, f0 // push pz*ptz into t
|
|
nop
|
|
d.pfadd.ss f0, f0, f0 // push partial into last-stage adder
|
|
nop
|
|
d.m12tpa.ss f0, f0, f0 // and push dot-product into adder
|
|
ld.l 8(prev_vertex), v2
|
|
d.pfadd.ss f0, f0, f0 // stage 2
|
|
st.l one, 12(v0)
|
|
d.pfadd.ss f0, f0, f0 // stage 3
|
|
st.l one, 12(v1)
|
|
pfadd.ss f0, f0, f20 // stage 3
|
|
st.l one, 12(v2)
|
|
pfgt.ss f20,f19,f0
|
|
adds r0, vertex, prev_vertex
|
|
bnc .pmesh_solution_zero
|
|
br .pmesh_solution_one
|
|
nop // st.l one, 12(vertex)
|
|
|
|
.align 8
|
|
.pmesh_solve_point_dont_write::
|
|
d.pfmul.ss f0, f0, f0
|
|
fld.l 16(vertex), f20
|
|
d.pfmul.ss f0, f0, f0
|
|
fld.l 20(vertex), f21
|
|
d.pfmul.ss f0, f0, f0
|
|
fld.l 28(vertex), f19
|
|
d.pfmul.ss f16, f20, f0
|
|
fld.l 24(vertex), f22
|
|
d.pfmul.ss f17, f21, f0
|
|
nop
|
|
d.pfmul.ss f18, f22, f0
|
|
nop
|
|
d.iat1p2.ss f0, f0, f0
|
|
nop
|
|
d.m12tpm.ss f0, f0, f0 // push px*ptx + py*pty into adder
|
|
nop
|
|
d.iat1p2.ss f0, f0, f0 // push pz*ptz into t
|
|
nop
|
|
d.pfadd.ss f0, f0, f0 // push partial into last-stage adder
|
|
nop
|
|
d.m12tpa.ss f0, f0, f0 // and push dot-product into adder
|
|
nop
|
|
d.pfadd.ss f0, f0, f0 // stage 2
|
|
nop
|
|
d.pfadd.ss f0, f0, f0 // stage 3
|
|
nop
|
|
pfadd.ss f0, f0, f20 // stage 3
|
|
adds r0, vertex, prev_vertex
|
|
pfgt.ss f20,f19,f0
|
|
nop
|
|
bnc .pmesh_solution_zero
|
|
|
|
.pmesh_solution_one::
|
|
// do full distance solution
|
|
// which involves computing square of distance
|
|
// to plane, rooting it, then clearing bottom bit
|
|
//fsub.ss f20, f19, f31
|
|
//fmul.ss f31, f31, f21
|
|
//frsqr.ss f21, f20
|
|
//fmul.ss f20, texScaleFac, f20
|
|
//fxfr f20, r31
|
|
//or 1, r31, r31
|
|
or 1, r0, r31
|
|
st.l r31, 12(vertex)
|
|
bla minus_1, n_tris, .pmesh_solve_point_do_write
|
|
adds 56, vertex, vertex
|
|
|
|
.exit_solve_pmesh::
|
|
|
|
// wind down result of last triangle
|
|
|
|
ld.l 0(prev_vertex), v0
|
|
ld.l 4(prev_vertex), v1
|
|
ld.l 8(prev_vertex), v2
|
|
st.l one, 12(v0)
|
|
st.l one, 12(v1)
|
|
bri r1
|
|
st.l one, 12(v2)
|
|
|
|
.pmesh_solution_zero::
|
|
// if twosided, do solution
|
|
or r0, twosided, r0
|
|
bc .pmesh_straight_zero
|
|
// so, twosided, do full distance solution
|
|
// which involves computing square of distance
|
|
// to plane, rooting it, then clearing bottom bit
|
|
//fsub.ss f20, f19, f31
|
|
//fmul.ss f31, f31, f21
|
|
//frsqr.ss f21, f20
|
|
//fmul.ss f20, texScaleFac, f20
|
|
//fxfr f20, r31
|
|
//andh 0xffff, r31, r31
|
|
//st.l r31, 12(vertex)
|
|
st.l r0, 12(vertex)
|
|
bla minus_1, n_tris, .pmesh_solve_point_dont_write
|
|
adds 56, vertex, vertex
|
|
|
|
bri r1
|
|
nop
|
|
|
|
|
|
|
|
.pmesh_straight_zero::
|
|
st.l r0, 12(vertex)
|
|
bla minus_1, n_tris, .pmesh_solve_point_dont_write
|
|
adds 56, vertex, vertex
|
|
|
|
bri r1
|
|
nop
|
|
//}}}
|
|
#endif
|
|
|
|
|
|
|
|
|
|
//{{{ 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
|
|
//}}}
|
|
|
|
#if 0
|
|
//{{{ _dnc_wait_count
|
|
.globl _dnc_Wait_count
|
|
.align 32
|
|
|
|
// while (*r16 == 0) spin(r17);
|
|
|
|
_dnc_Wait_count::
|
|
lock
|
|
ld.l r0(r16), r18
|
|
btne r0,r18,.wait_loop
|
|
adds 1,r0,r18
|
|
unlock
|
|
st.l r18,0(r16)
|
|
bri r1
|
|
st.l r0,4(r16)
|
|
|
|
.wait_loop::
|
|
unlock
|
|
st.l r0,4(r16)
|
|
st.l r0,4(r16)
|
|
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_count
|
|
nop
|
|
|
|
//}}}
|
|
//{{{ _wait_locked_nonzero
|
|
.globl _wait_locked_nonzero
|
|
.align 32
|
|
|
|
// while (*r16 != 0) spin(r17);
|
|
|
|
_wait_locked_nonzero::
|
|
bte 0x0, r16, .wait_locked_exit
|
|
lock
|
|
ld.l r0(r16), r18
|
|
bte 0x0, r18, .wait_locked_loop
|
|
|
|
unlock
|
|
st.l r0, 4(r16)
|
|
st.l r0, 4(r16)
|
|
.wait_locked_exit::
|
|
bri r1
|
|
nop
|
|
|
|
.wait_locked_loop::
|
|
unlock
|
|
st.l r0, 4(r16)
|
|
st.l r0, 4(r16)
|
|
|
|
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_nonzero
|
|
nop
|
|
|
|
//}}}
|
|
#endif
|
|
|
|
//{{{ _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
|
|
|
|
#define Rr r17
|
|
#define Rs r18
|
|
#define Rt r19
|
|
#define Ru r20
|
|
#define Rv r21
|
|
#define Rw r22
|
|
#define Rx r23
|
|
#define Ry r24
|
|
#define DIRB_rb 0xc00
|
|
#define DIRB_rc 0x300
|
|
|
|
_manual_flush::
|
|
mov r1, Rr
|
|
ld.c dirbase, Rv
|
|
andnot 0x0f00, Rv, Ru
|
|
adds -1, r0, Rx
|
|
adds -32, r16, Rt
|
|
|
|
// flush pass 1
|
|
or 0x800, Ru, Rs
|
|
call D_FLUSH
|
|
st.c Rs, dirbase
|
|
// flush pass 2
|
|
or 0x900, Ru, Rs
|
|
call D_FLUSH
|
|
st.c Rs, dirbase
|
|
// am i an XP?
|
|
ld.c epsr, Rs
|
|
shr 19, Rs, Rs
|
|
and 0x07, Rs, Rs
|
|
bc RESTORE_DIRBASE
|
|
// flush pass 3
|
|
or 0xa00, Ru, Rs
|
|
call D_FLUSH
|
|
st.c Rs, dirbase
|
|
// flush pass 4
|
|
or 0xb00, Ru, Rs
|
|
call D_FLUSH
|
|
st.c Rs, dirbase
|
|
RESTORE_DIRBASE::
|
|
st.c Rv, dirbase
|
|
nop
|
|
nop
|
|
nop
|
|
nop
|
|
nop
|
|
nop
|
|
bri Rr
|
|
nop
|
|
|
|
D_FLUSH::
|
|
mov 127, Ry
|
|
bla Rx,Ry,D_FLUSH_LOOP
|
|
mov Rt, Rw
|
|
D_FLUSH_LOOP::
|
|
bla Rx,Ry,D_FLUSH_LOOP
|
|
flush 32(Rw)++
|
|
|
|
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
|
|
|
|
//}}}
|