/[pcsx2_0.9.7]/trunk/pcsx2/VUops.cpp
ViewVC logotype

Annotation of /trunk/pcsx2/VUops.cpp

Parent Directory Parent Directory | Revision Log Revision Log


Revision 273 - (hide annotations) (download)
Fri Nov 12 01:10:22 2010 UTC (9 years, 6 months ago) by william
File size: 180168 byte(s)
Auto Commited Import of: pcsx2-0.9.7-DEBUG (upstream: v0.9.7.4013 local: v0.9.7.197-latest) in ./trunk
1 william 31 /* PCSX2 - PS2 Emulator for PCs
2     * Copyright (C) 2002-2010 PCSX2 Dev Team
3     *
4     * PCSX2 is free software: you can redistribute it and/or modify it under the terms
5     * of the GNU Lesser General Public License as published by the Free Software Found-
6     * ation, either version 3 of the License, or (at your option) any later version.
7     *
8     * PCSX2 is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY;
9     * without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR
10     * PURPOSE. See the GNU General Public License for more details.
11     *
12     * You should have received a copy of the GNU General Public License along with PCSX2.
13     * If not, see <http://www.gnu.org/licenses/>.
14     */
15    
16     #include "PrecompiledHeader.h"
17     #include "Common.h"
18 william 62 #include "VUops.h"
19     #include "GS.h"
20 william 31
21     #include <cmath>
22    
23     //Lower/Upper instructions can use that..
24     #define _Ft_ ((VU->code >> 16) & 0x1F) // The rt part of the instruction register
25     #define _Fs_ ((VU->code >> 11) & 0x1F) // The rd part of the instruction register
26     #define _Fd_ ((VU->code >> 6) & 0x1F) // The sa part of the instruction register
27     #define _It_ (_Ft_ & 0xF)
28     #define _Is_ (_Fs_ & 0xF)
29     #define _Id_ (_Fd_ & 0xF)
30    
31     #define _X ((VU->code>>24) & 0x1)
32     #define _Y ((VU->code>>23) & 0x1)
33     #define _Z ((VU->code>>22) & 0x1)
34     #define _W ((VU->code>>21) & 0x1)
35    
36     #define _XYZW ((VU->code>>21) & 0xF)
37    
38     #define _Fsf_ ((VU->code >> 21) & 0x03)
39     #define _Ftf_ ((VU->code >> 23) & 0x03)
40    
41     #define _Imm11_ (s32)(VU->code & 0x400 ? 0xfffffc00 | (VU->code & 0x3ff) : VU->code & 0x3ff)
42     #define _UImm11_ (s32)(VU->code & 0x7ff)
43    
44    
45     static __aligned16 VECTOR RDzero;
46    
47 william 62 static __ri void _vuFMACflush(VURegs * VU) {
48 william 31 int i;
49    
50     for (i=0; i<8; i++) {
51     if (VU->fmac[i].enable == 0) continue;
52    
53     if ((VU->cycle - VU->fmac[i].sCycle) >= VU->fmac[i].Cycle) {
54     VUM_LOG("flushing FMAC pipe[%d] (macflag=%x)", i, VU->fmac[i].macflag);
55    
56     VU->fmac[i].enable = 0;
57     VU->VI[REG_MAC_FLAG].UL = VU->fmac[i].macflag;
58     VU->VI[REG_STATUS_FLAG].UL = VU->fmac[i].statusflag;
59     VU->VI[REG_CLIP_FLAG].UL = VU->fmac[i].clipflag;
60     }
61     }
62     }
63    
64 william 62 static __ri void _vuFDIVflush(VURegs * VU) {
65 william 31 if (VU->fdiv.enable == 0) return;
66    
67     if ((VU->cycle - VU->fdiv.sCycle) >= VU->fdiv.Cycle) {
68     VUM_LOG("flushing FDIV pipe");
69    
70     VU->fdiv.enable = 0;
71     VU->VI[REG_Q].UL = VU->fdiv.reg.UL;
72     VU->VI[REG_STATUS_FLAG].UL = VU->fdiv.statusflag;
73     }
74     }
75    
76 william 62 static __ri void _vuEFUflush(VURegs * VU) {
77 william 31 if (VU->efu.enable == 0) return;
78    
79     if ((VU->cycle - VU->efu.sCycle) >= VU->efu.Cycle) {
80     // VUM_LOG("flushing EFU pipe");
81    
82     VU->efu.enable = 0;
83     VU->VI[REG_P].UL = VU->efu.reg.UL;
84     }
85     }
86    
87     // called at end of program
88     void _vuFlushAll(VURegs* VU)
89     {
90     int nRepeat = 1, i;
91    
92     do {
93     nRepeat = 0;
94    
95     for (i=0; i<8; i++) {
96     if (VU->fmac[i].enable == 0) continue;
97    
98     nRepeat = 1;
99    
100     if ((VU->cycle - VU->fmac[i].sCycle) >= VU->fmac[i].Cycle) {
101     VUM_LOG("flushing FMAC pipe[%d] (macflag=%x)", i, VU->fmac[i].macflag);
102    
103     VU->fmac[i].enable = 0;
104     VU->VI[REG_MAC_FLAG].UL = VU->fmac[i].macflag;
105     VU->VI[REG_STATUS_FLAG].UL = VU->fmac[i].statusflag;
106     VU->VI[REG_CLIP_FLAG].UL = VU->fmac[i].clipflag;
107     }
108     }
109    
110     if (VU->fdiv.enable ) {
111    
112     nRepeat = 1;
113    
114     if ((VU->cycle - VU->fdiv.sCycle) >= VU->fdiv.Cycle) {
115     VUM_LOG("flushing FDIV pipe");
116    
117     nRepeat = 1;
118     VU->fdiv.enable = 0;
119     VU->VI[REG_Q].UL = VU->fdiv.reg.UL;
120     VU->VI[REG_STATUS_FLAG].UL = VU->fdiv.statusflag;
121     }
122     }
123    
124     if (VU->efu.enable) {
125    
126     nRepeat = 1;
127    
128     if ((VU->cycle - VU->efu.sCycle) >= VU->efu.Cycle) {
129     // VUM_LOG("flushing EFU pipe");
130    
131     nRepeat = 1;
132     VU->efu.enable = 0;
133     VU->VI[REG_P].UL = VU->efu.reg.UL;
134     }
135     }
136    
137     VU->cycle++;
138    
139     } while(nRepeat);
140     }
141    
142 william 62 __fi void _vuTestPipes(VURegs * VU) {
143 william 31 _vuFMACflush(VU);
144     _vuFDIVflush(VU);
145     _vuEFUflush(VU);
146     }
147    
148     static void __fastcall _vuFMACTestStall(VURegs * VU, int reg, int xyzw) {
149     int cycle;
150     int i;
151    
152     for (i=0; i<8; i++) {
153     if (VU->fmac[i].enable == 0) continue;
154     if (VU->fmac[i].reg == reg &&
155     VU->fmac[i].xyzw & xyzw) break;
156     }
157    
158     if (i == 8) return;
159    
160     cycle = VU->fmac[i].Cycle - (VU->cycle - VU->fmac[i].sCycle) + 1; // add 1 delay! (fixes segaclassics bad geom)
161     VU->fmac[i].enable = 0;
162     VU->VI[REG_MAC_FLAG].UL = VU->fmac[i].macflag;
163     VU->VI[REG_STATUS_FLAG].UL = VU->fmac[i].statusflag;
164     VU->VI[REG_CLIP_FLAG].UL = VU->fmac[i].clipflag;
165     VUM_LOG("FMAC[%d] stall %d", i, cycle);
166    
167     VU->cycle+= cycle;
168     _vuTestPipes(VU);
169     }
170    
171 william 62 static __ri void __fastcall _vuFMACAdd(VURegs * VU, int reg, int xyzw) {
172 william 31 int i;
173    
174     /* find a free fmac pipe */
175     for (i=0; i<8; i++) {
176     if (VU->fmac[i].enable == 1) continue;
177     break;
178     }
179     //if (i==8) Console.Error("*PCSX2*: error , out of fmacs %d", VU->cycle);
180    
181    
182     VUM_LOG("adding FMAC pipe[%d]; xyzw=%x", i, xyzw);
183    
184     VU->fmac[i].enable = 1;
185     VU->fmac[i].sCycle = VU->cycle;
186     VU->fmac[i].Cycle = 3;
187     VU->fmac[i].reg = reg;
188     VU->fmac[i].xyzw = xyzw;
189     VU->fmac[i].macflag = VU->macflag;
190     VU->fmac[i].statusflag = VU->statusflag;
191     VU->fmac[i].clipflag = VU->clipflag;
192     }
193    
194 william 62 static __ri void __fastcall _vuFDIVAdd(VURegs * VU, int cycles) {
195 william 31 VUM_LOG("adding FDIV pipe");
196    
197     VU->fdiv.enable = 1;
198     VU->fdiv.sCycle = VU->cycle;
199     VU->fdiv.Cycle = cycles;
200     VU->fdiv.reg.F = VU->q.F;
201     VU->fdiv.statusflag = VU->statusflag;
202     }
203    
204 william 62 static __ri void __fastcall _vuEFUAdd(VURegs * VU, int cycles) {
205 william 31 // VUM_LOG("adding EFU pipe\n");
206    
207     VU->efu.enable = 1;
208     VU->efu.sCycle = VU->cycle;
209     VU->efu.Cycle = cycles;
210     VU->efu.reg.F = VU->p.F;
211     }
212    
213 william 62 static __ri void __fastcall _vuFlushFDIV(VURegs * VU) {
214 william 31 int cycle;
215    
216     if (VU->fdiv.enable == 0) return;
217    
218     cycle = VU->fdiv.Cycle - (VU->cycle - VU->fdiv.sCycle);
219     VUM_LOG("waiting FDIV pipe %d", cycle);
220    
221     VU->fdiv.enable = 0;
222     VU->cycle+= cycle;
223     VU->VI[REG_Q].UL = VU->fdiv.reg.UL;
224     VU->VI[REG_STATUS_FLAG].UL = VU->fdiv.statusflag;
225     }
226    
227 william 62 static __ri void __fastcall _vuFlushEFU(VURegs * VU) {
228 william 31 int cycle;
229    
230     if (VU->efu.enable == 0) return;
231    
232     cycle = VU->efu.Cycle - (VU->cycle - VU->efu.sCycle);
233     // VUM_LOG("waiting EFU pipe %d", cycle);
234    
235     VU->efu.enable = 0;
236     VU->cycle+= cycle;
237     VU->VI[REG_P].UL = VU->efu.reg.UL;
238     }
239    
240 william 62 static __fi void _vuTestFMACStalls(VURegs * VU, _VURegsNum *VUregsn) {
241 william 31 if (VUregsn->VFread0) {
242     _vuFMACTestStall(VU, VUregsn->VFread0, VUregsn->VFr0xyzw);
243     }
244     if (VUregsn->VFread1) {
245     _vuFMACTestStall(VU, VUregsn->VFread1, VUregsn->VFr1xyzw);
246     }
247     }
248    
249 william 62 static __fi void _vuAddFMACStalls(VURegs * VU, _VURegsNum *VUregsn) {
250 william 31 if (VUregsn->VFwrite) {
251     _vuFMACAdd(VU, VUregsn->VFwrite, VUregsn->VFwxyzw);
252     } else
253     if (VUregsn->VIwrite & (1 << REG_CLIP_FLAG)) {
254     _vuFMACAdd(VU, -REG_CLIP_FLAG, 0);
255     } else {
256     _vuFMACAdd(VU, 0, 0);
257     }
258     }
259    
260 william 62 static __fi void _vuTestFDIVStalls(VURegs * VU, _VURegsNum *VUregsn) {
261 william 31 // _vuTestFMACStalls(VURegs * VU, _VURegsNum *VUregsn);
262     _vuFlushFDIV(VU);
263     }
264    
265 william 62 static __fi void _vuAddFDIVStalls(VURegs * VU, _VURegsNum *VUregsn) {
266 william 31 if (VUregsn->VIwrite & (1 << REG_Q)) {
267     _vuFDIVAdd(VU, VUregsn->cycles);
268     }
269     }
270    
271    
272 william 62 static __fi void _vuTestEFUStalls(VURegs * VU, _VURegsNum *VUregsn) {
273 william 31 // _vuTestFMACStalls(VURegs * VU, _VURegsNum *VUregsn);
274     _vuFlushEFU(VU);
275     }
276    
277 william 62 static __fi void _vuAddEFUStalls(VURegs * VU, _VURegsNum *VUregsn) {
278 william 31 if (VUregsn->VIwrite & (1 << REG_P)) {
279     _vuEFUAdd(VU, VUregsn->cycles);
280     }
281     }
282    
283 william 62 __fi void _vuTestUpperStalls(VURegs * VU, _VURegsNum *VUregsn) {
284 william 31 switch (VUregsn->pipe) {
285     case VUPIPE_FMAC: _vuTestFMACStalls(VU, VUregsn); break;
286     }
287     }
288    
289 william 62 __fi void _vuTestLowerStalls(VURegs * VU, _VURegsNum *VUregsn) {
290 william 31 switch (VUregsn->pipe) {
291     case VUPIPE_FMAC: _vuTestFMACStalls(VU, VUregsn); break;
292     case VUPIPE_FDIV: _vuTestFDIVStalls(VU, VUregsn); break;
293     case VUPIPE_EFU: _vuTestEFUStalls(VU, VUregsn); break;
294     }
295     }
296    
297 william 62 __fi void _vuAddUpperStalls(VURegs * VU, _VURegsNum *VUregsn) {
298 william 31 switch (VUregsn->pipe) {
299     case VUPIPE_FMAC: _vuAddFMACStalls(VU, VUregsn); break;
300     }
301     }
302    
303 william 62 __fi void _vuAddLowerStalls(VURegs * VU, _VURegsNum *VUregsn) {
304 william 31 switch (VUregsn->pipe) {
305     case VUPIPE_FMAC: _vuAddFMACStalls(VU, VUregsn); break;
306     case VUPIPE_FDIV: _vuAddFDIVStalls(VU, VUregsn); break;
307     case VUPIPE_EFU: _vuAddEFUStalls(VU, VUregsn); break;
308     }
309     }
310    
311    
312     /******************************/
313     /* VU Upper instructions */
314     /******************************/
315     #ifndef INT_VUDOUBLEHACK
316     static float __fastcall vuDouble(u32 f)
317     {
318     switch(f & 0x7f800000)
319     {
320     case 0x0:
321     f &= 0x80000000;
322     return *(float*)&f;
323     break;
324     case 0x7f800000:
325     {
326     u32 d = (f & 0x80000000)|0x7f7fffff;
327     return *(float*)&d;
328     break;
329     }
330     }
331     return *(float*)&f;
332     }
333     #else
334 william 62 static __fi float vuDouble(u32 f)
335 william 31 {
336     return *(float*)&f;
337     }
338     #endif
339    
340     void _vuABS(VURegs * VU) {
341     if (_Ft_ == 0) return;
342    
343     if (_X){ VU->VF[_Ft_].f.x = fabs(vuDouble(VU->VF[_Fs_].i.x)); }
344     if (_Y){ VU->VF[_Ft_].f.y = fabs(vuDouble(VU->VF[_Fs_].i.y)); }
345     if (_Z){ VU->VF[_Ft_].f.z = fabs(vuDouble(VU->VF[_Fs_].i.z)); }
346     if (_W){ VU->VF[_Ft_].f.w = fabs(vuDouble(VU->VF[_Fs_].i.w)); }
347     }/*Reworked from define to function. asadr*/
348    
349    
350 william 62 static __fi void _vuADD(VURegs * VU) {
351 william 31 VECTOR * dst;
352     if (_Fd_ == 0) dst = &RDzero;
353     else dst = &VU->VF[_Fd_];
354    
355     if (_X){ dst->i.x = VU_MACx_UPDATE(VU, vuDouble(VU->VF[_Fs_].i.x) + vuDouble(VU->VF[_Ft_].i.x)); } else VU_MACx_CLEAR(VU);
356     if (_Y){ dst->i.y = VU_MACy_UPDATE(VU, vuDouble(VU->VF[_Fs_].i.y) + vuDouble(VU->VF[_Ft_].i.y)); } else VU_MACy_CLEAR(VU);
357     if (_Z){ dst->i.z = VU_MACz_UPDATE(VU, vuDouble(VU->VF[_Fs_].i.z) + vuDouble(VU->VF[_Ft_].i.z)); } else VU_MACz_CLEAR(VU);
358     if (_W){ dst->i.w = VU_MACw_UPDATE(VU, vuDouble(VU->VF[_Fs_].i.w) + vuDouble(VU->VF[_Ft_].i.w)); } else VU_MACw_CLEAR(VU);
359     VU_STAT_UPDATE(VU);
360     }/*Reworked from define to function. asadr*/
361    
362    
363 william 62 static __fi void _vuADDi(VURegs * VU) {
364 william 31 VECTOR * dst;
365     if (_Fd_ == 0) dst = &RDzero;
366     else dst = &VU->VF[_Fd_];
367    
368     if (_X){ dst->i.x = VU_MACx_UPDATE(VU, vuDouble(VU->VF[_Fs_].i.x) + vuDouble(VU->VI[REG_I].UL));} else VU_MACx_CLEAR(VU);
369     if (_Y){ dst->i.y = VU_MACy_UPDATE(VU, vuDouble(VU->VF[_Fs_].i.y) + vuDouble(VU->VI[REG_I].UL));} else VU_MACy_CLEAR(VU);
370     if (_Z){ dst->i.z = VU_MACz_UPDATE(VU, vuDouble(VU->VF[_Fs_].i.z) + vuDouble(VU->VI[REG_I].UL));} else VU_MACz_CLEAR(VU);
371     if (_W){ dst->i.w = VU_MACw_UPDATE(VU, vuDouble(VU->VF[_Fs_].i.w) + vuDouble(VU->VI[REG_I].UL));} else VU_MACw_CLEAR(VU);
372     VU_STAT_UPDATE(VU);
373     }/*Reworked from define to function. asadr*/
374    
375 william 62 static __fi void _vuADDq(VURegs * VU) {
376 william 31 VECTOR * dst;
377     if (_Fd_ == 0) dst = &RDzero;
378     else dst = &VU->VF[_Fd_];
379    
380     if (_X){ dst->i.x = VU_MACx_UPDATE(VU, vuDouble(VU->VF[_Fs_].i.x) + vuDouble(VU->VI[REG_Q].UL)); } else VU_MACx_CLEAR(VU);
381     if (_Y){ dst->i.y = VU_MACy_UPDATE(VU, vuDouble(VU->VF[_Fs_].i.y) + vuDouble(VU->VI[REG_Q].UL)); } else VU_MACy_CLEAR(VU);
382     if (_Z){ dst->i.z = VU_MACz_UPDATE(VU, vuDouble(VU->VF[_Fs_].i.z) + vuDouble(VU->VI[REG_Q].UL)); } else VU_MACz_CLEAR(VU);
383     if (_W){ dst->i.w = VU_MACw_UPDATE(VU, vuDouble(VU->VF[_Fs_].i.w) + vuDouble(VU->VI[REG_Q].UL)); } else VU_MACw_CLEAR(VU);
384     VU_STAT_UPDATE(VU);
385     }/*Reworked from define to function. asadr*/
386    
387    
388 william 62 static __fi void _vuADDx(VURegs * VU) {
389 william 31 float ftx;
390     VECTOR * dst;
391     if (_Fd_ == 0) dst = &RDzero;
392     else dst = &VU->VF[_Fd_];
393    
394     ftx=vuDouble(VU->VF[_Ft_].i.x);
395     if (_X){ dst->i.x = VU_MACx_UPDATE(VU, vuDouble(VU->VF[_Fs_].i.x) + ftx); } else VU_MACx_CLEAR(VU);
396     if (_Y){ dst->i.y = VU_MACy_UPDATE(VU, vuDouble(VU->VF[_Fs_].i.y) + ftx); } else VU_MACy_CLEAR(VU);
397     if (_Z){ dst->i.z = VU_MACz_UPDATE(VU, vuDouble(VU->VF[_Fs_].i.z) + ftx); } else VU_MACz_CLEAR(VU);
398     if (_W){ dst->i.w = VU_MACw_UPDATE(VU, vuDouble(VU->VF[_Fs_].i.w) + ftx); } else VU_MACw_CLEAR(VU);
399     VU_STAT_UPDATE(VU);
400     }/*Reworked from define to function. asadr*/
401    
402 william 62 static __fi void _vuADDy(VURegs * VU) {
403 william 31 float fty;
404     VECTOR * dst;
405     if (_Fd_ == 0) dst = &RDzero;
406     else dst = &VU->VF[_Fd_];
407    
408     fty=vuDouble(VU->VF[_Ft_].i.y);
409     if (_X){ dst->i.x = VU_MACx_UPDATE(VU, vuDouble(VU->VF[_Fs_].i.x) + fty);} else VU_MACx_CLEAR(VU);
410     if (_Y){ dst->i.y = VU_MACy_UPDATE(VU, vuDouble(VU->VF[_Fs_].i.y) + fty);} else VU_MACy_CLEAR(VU);
411     if (_Z){ dst->i.z = VU_MACz_UPDATE(VU, vuDouble(VU->VF[_Fs_].i.z) + fty);} else VU_MACz_CLEAR(VU);
412     if (_W){ dst->i.w = VU_MACw_UPDATE(VU, vuDouble(VU->VF[_Fs_].i.w) + fty);} else VU_MACw_CLEAR(VU);
413     VU_STAT_UPDATE(VU);
414     }/*Reworked from define to function. asadr*/
415    
416 william 62 static __fi void _vuADDz(VURegs * VU) {
417 william 31 float ftz;
418     VECTOR * dst;
419     if (_Fd_ == 0) dst = &RDzero;
420     else dst = &VU->VF[_Fd_];
421    
422     ftz=vuDouble(VU->VF[_Ft_].i.z);
423     if (_X){ dst->i.x = VU_MACx_UPDATE(VU, vuDouble(VU->VF[_Fs_].i.x) + ftz); } else VU_MACx_CLEAR(VU);
424     if (_Y){ dst->i.y = VU_MACy_UPDATE(VU, vuDouble(VU->VF[_Fs_].i.y) + ftz); } else VU_MACy_CLEAR(VU);
425     if (_Z){ dst->i.z = VU_MACz_UPDATE(VU, vuDouble(VU->VF[_Fs_].i.z) + ftz); } else VU_MACz_CLEAR(VU);
426     if (_W){ dst->i.w = VU_MACw_UPDATE(VU, vuDouble(VU->VF[_Fs_].i.w) + ftz); } else VU_MACw_CLEAR(VU);
427     VU_STAT_UPDATE(VU);
428     }/*Reworked from define to function. asadr*/
429    
430 william 62 static __fi void _vuADDw(VURegs * VU) {
431 william 31 float ftw;
432     VECTOR * dst;
433     if (_Fd_ == 0) dst = &RDzero;
434     else dst = &VU->VF[_Fd_];
435    
436     ftw=vuDouble(VU->VF[_Ft_].i.w);
437     if (_X){ dst->i.x = VU_MACx_UPDATE(VU, vuDouble(VU->VF[_Fs_].i.x) + ftw); } else VU_MACx_CLEAR(VU);
438     if (_Y){ dst->i.y = VU_MACy_UPDATE(VU, vuDouble(VU->VF[_Fs_].i.y) + ftw); } else VU_MACy_CLEAR(VU);
439     if (_Z){ dst->i.z = VU_MACz_UPDATE(VU, vuDouble(VU->VF[_Fs_].i.z) + ftw); } else VU_MACz_CLEAR(VU);
440     if (_W){ dst->i.w = VU_MACw_UPDATE(VU, vuDouble(VU->VF[_Fs_].i.w) + ftw); } else VU_MACw_CLEAR(VU);
441     VU_STAT_UPDATE(VU);
442     }/*Reworked from define to function. asadr*/
443    
444 william 62 static __fi void _vuADDA(VURegs * VU) {
445 william 31 if (_X){ VU->ACC.i.x = VU_MACx_UPDATE(VU, vuDouble(VU->VF[_Fs_].i.x) + vuDouble(VU->VF[_Ft_].i.x)); } else VU_MACx_CLEAR(VU);
446     if (_Y){ VU->ACC.i.y = VU_MACy_UPDATE(VU, vuDouble(VU->VF[_Fs_].i.y) + vuDouble(VU->VF[_Ft_].i.y)); } else VU_MACy_CLEAR(VU);
447     if (_Z){ VU->ACC.i.z = VU_MACz_UPDATE(VU, vuDouble(VU->VF[_Fs_].i.z) + vuDouble(VU->VF[_Ft_].i.z)); } else VU_MACz_CLEAR(VU);
448     if (_W){ VU->ACC.i.w = VU_MACw_UPDATE(VU, vuDouble(VU->VF[_Fs_].i.w) + vuDouble(VU->VF[_Ft_].i.w)); } else VU_MACw_CLEAR(VU);
449     VU_STAT_UPDATE(VU);
450     }/*Reworked from define to function. asadr*/
451    
452 william 62 static __fi void _vuADDAi(VURegs * VU) {
453 william 31 float ti = vuDouble(VU->VI[REG_I].UL);
454    
455     if (_X){ VU->ACC.i.x = VU_MACx_UPDATE(VU, vuDouble(VU->VF[_Fs_].i.x) + ti); } else VU_MACx_CLEAR(VU);
456     if (_Y){ VU->ACC.i.y = VU_MACy_UPDATE(VU, vuDouble(VU->VF[_Fs_].i.y) + ti); } else VU_MACy_CLEAR(VU);
457     if (_Z){ VU->ACC.i.z = VU_MACz_UPDATE(VU, vuDouble(VU->VF[_Fs_].i.z) + ti); } else VU_MACz_CLEAR(VU);
458     if (_W){ VU->ACC.i.w = VU_MACw_UPDATE(VU, vuDouble(VU->VF[_Fs_].i.w) + ti); } else VU_MACw_CLEAR(VU);
459     VU_STAT_UPDATE(VU);
460     }/*Reworked from define to function. asadr*/
461    
462 william 62 static __fi void _vuADDAq(VURegs * VU) {
463 william 31 float tf = vuDouble(VU->VI[REG_Q].UL);
464    
465     if (_X){ VU->ACC.i.x = VU_MACx_UPDATE(VU, vuDouble(VU->VF[_Fs_].i.x) + tf); } else VU_MACx_CLEAR(VU);
466     if (_Y){ VU->ACC.i.y = VU_MACy_UPDATE(VU, vuDouble(VU->VF[_Fs_].i.y) + tf); } else VU_MACy_CLEAR(VU);
467     if (_Z){ VU->ACC.i.z = VU_MACz_UPDATE(VU, vuDouble(VU->VF[_Fs_].i.z) + tf); } else VU_MACz_CLEAR(VU);
468     if (_W){ VU->ACC.i.w = VU_MACw_UPDATE(VU, vuDouble(VU->VF[_Fs_].i.w) + tf); } else VU_MACw_CLEAR(VU);
469     VU_STAT_UPDATE(VU);
470     }/*Reworked from define to function. asadr*/
471    
472 william 62 static __fi void _vuADDAx(VURegs * VU) {
473 william 31 float tx = vuDouble(VU->VF[_Ft_].i.x);
474    
475     if (_X){ VU->ACC.i.x = VU_MACx_UPDATE(VU, vuDouble(VU->VF[_Fs_].i.x) + tx); } else VU_MACx_CLEAR(VU);
476     if (_Y){ VU->ACC.i.y = VU_MACy_UPDATE(VU, vuDouble(VU->VF[_Fs_].i.y) + tx); } else VU_MACy_CLEAR(VU);
477     if (_Z){ VU->ACC.i.z = VU_MACz_UPDATE(VU, vuDouble(VU->VF[_Fs_].i.z) + tx); } else VU_MACz_CLEAR(VU);
478     if (_W){ VU->ACC.i.w = VU_MACw_UPDATE(VU, vuDouble(VU->VF[_Fs_].i.w) + tx); } else VU_MACw_CLEAR(VU);
479     VU_STAT_UPDATE(VU);
480     }/*Reworked from define to function. asadr*/
481    
482 william 62 static __fi void _vuADDAy(VURegs * VU) {
483 william 31 float ty = vuDouble(VU->VF[_Ft_].i.y);
484    
485     if (_X){ VU->ACC.i.x = VU_MACx_UPDATE(VU, vuDouble(VU->VF[_Fs_].i.x) + ty); } else VU_MACx_CLEAR(VU);
486     if (_Y){ VU->ACC.i.y = VU_MACy_UPDATE(VU, vuDouble(VU->VF[_Fs_].i.y) + ty); } else VU_MACy_CLEAR(VU);
487     if (_Z){ VU->ACC.i.z = VU_MACz_UPDATE(VU, vuDouble(VU->VF[_Fs_].i.z) + ty); } else VU_MACz_CLEAR(VU);
488     if (_W){ VU->ACC.i.w = VU_MACw_UPDATE(VU, vuDouble(VU->VF[_Fs_].i.w) + ty); } else VU_MACw_CLEAR(VU);
489     VU_STAT_UPDATE(VU);
490     }/*Reworked from define to function. asadr*/
491    
492 william 62 static __fi void _vuADDAz(VURegs * VU) {
493 william 31 float tz = vuDouble(VU->VF[_Ft_].i.z);
494    
495     if (_X){ VU->ACC.i.x = VU_MACx_UPDATE(VU, vuDouble(VU->VF[_Fs_].i.x) + tz); } else VU_MACx_CLEAR(VU);
496     if (_Y){ VU->ACC.i.y = VU_MACy_UPDATE(VU, vuDouble(VU->VF[_Fs_].i.y) + tz); } else VU_MACy_CLEAR(VU);
497     if (_Z){ VU->ACC.i.z = VU_MACz_UPDATE(VU, vuDouble(VU->VF[_Fs_].i.z) + tz); } else VU_MACz_CLEAR(VU);
498     if (_W){ VU->ACC.i.w = VU_MACw_UPDATE(VU, vuDouble(VU->VF[_Fs_].i.w) + tz); } else VU_MACw_CLEAR(VU);
499     VU_STAT_UPDATE(VU);
500     }/*Reworked from define to function. asadr*/
501    
502 william 62 static __fi void _vuADDAw(VURegs * VU) {
503 william 31 float tw = vuDouble(VU->VF[_Ft_].i.w);
504    
505     if (_X){ VU->ACC.i.x = VU_MACx_UPDATE(VU, vuDouble(VU->VF[_Fs_].i.x) + tw); } else VU_MACx_CLEAR(VU);
506     if (_Y){ VU->ACC.i.y = VU_MACy_UPDATE(VU, vuDouble(VU->VF[_Fs_].i.y) + tw); } else VU_MACy_CLEAR(VU);
507     if (_Z){ VU->ACC.i.z = VU_MACz_UPDATE(VU, vuDouble(VU->VF[_Fs_].i.z) + tw); } else VU_MACz_CLEAR(VU);
508     if (_W){ VU->ACC.i.w = VU_MACw_UPDATE(VU, vuDouble(VU->VF[_Fs_].i.w) + tw); } else VU_MACw_CLEAR(VU);
509     VU_STAT_UPDATE(VU);
510     }/*Reworked from define to function. asadr*/
511    
512    
513 william 62 static __fi void _vuSUB(VURegs * VU) {
514 william 31 VECTOR * dst;
515     if (_Fd_ == 0) dst = &RDzero;
516     else dst = &VU->VF[_Fd_];
517    
518     if (_X){ dst->i.x = VU_MACx_UPDATE(VU, vuDouble(VU->VF[_Fs_].i.x) - vuDouble(VU->VF[_Ft_].i.x)); } else VU_MACx_CLEAR(VU);
519     if (_Y){ dst->i.y = VU_MACy_UPDATE(VU, vuDouble(VU->VF[_Fs_].i.y) - vuDouble(VU->VF[_Ft_].i.y)); } else VU_MACy_CLEAR(VU);
520     if (_Z){ dst->i.z = VU_MACz_UPDATE(VU, vuDouble(VU->VF[_Fs_].i.z) - vuDouble(VU->VF[_Ft_].i.z)); } else VU_MACz_CLEAR(VU);
521     if (_W){ dst->i.w = VU_MACw_UPDATE(VU, vuDouble(VU->VF[_Fs_].i.w) - vuDouble(VU->VF[_Ft_].i.w)); } else VU_MACw_CLEAR(VU);
522     VU_STAT_UPDATE(VU);
523     }//updated 10/05/03 shadow
524    
525 william 62 static __fi void _vuSUBi(VURegs * VU) {
526 william 31 VECTOR * dst;
527     if (_Fd_ == 0) dst = &RDzero;
528     else dst = &VU->VF[_Fd_];
529    
530     if (_X){ dst->i.x = VU_MACx_UPDATE(VU, vuDouble(VU->VF[_Fs_].i.x) - vuDouble(VU->VI[REG_I].UL)); } else VU_MACx_CLEAR(VU);
531     if (_Y){ dst->i.y = VU_MACy_UPDATE(VU, vuDouble(VU->VF[_Fs_].i.y) - vuDouble(VU->VI[REG_I].UL)); } else VU_MACy_CLEAR(VU);
532     if (_Z){ dst->i.z = VU_MACz_UPDATE(VU, vuDouble(VU->VF[_Fs_].i.z) - vuDouble(VU->VI[REG_I].UL)); } else VU_MACz_CLEAR(VU);
533     if (_W){ dst->i.w = VU_MACw_UPDATE(VU, vuDouble(VU->VF[_Fs_].i.w) - vuDouble(VU->VI[REG_I].UL)); } else VU_MACw_CLEAR(VU);
534     VU_STAT_UPDATE(VU);
535     }//updated 10/05/03 shadow
536    
537 william 62 static __fi void _vuSUBq(VURegs * VU) {
538 william 31 VECTOR * dst;
539     if (_Fd_ == 0) dst = &RDzero;
540     else dst = &VU->VF[_Fd_];
541    
542     if (_X){ dst->i.x = VU_MACx_UPDATE(VU, vuDouble(VU->VF[_Fs_].i.x) - vuDouble(VU->VI[REG_Q].UL)); } else VU_MACx_CLEAR(VU);
543     if (_Y){ dst->i.y = VU_MACy_UPDATE(VU, vuDouble(VU->VF[_Fs_].i.y) - vuDouble(VU->VI[REG_Q].UL)); } else VU_MACy_CLEAR(VU);
544     if (_Z){ dst->i.z = VU_MACz_UPDATE(VU, vuDouble(VU->VF[_Fs_].i.z) - vuDouble(VU->VI[REG_Q].UL)); } else VU_MACz_CLEAR(VU);
545     if (_W){ dst->i.w = VU_MACw_UPDATE(VU, vuDouble(VU->VF[_Fs_].i.w) - vuDouble(VU->VI[REG_Q].UL)); } else VU_MACw_CLEAR(VU);
546     VU_STAT_UPDATE(VU);
547     }//updated 10/05/03 shadow
548    
549 william 62 static __fi void _vuSUBx(VURegs * VU) {
550 william 31 float ftx;
551     VECTOR * dst;
552     if (_Fd_ == 0) dst = &RDzero;
553     else dst = &VU->VF[_Fd_];
554    
555     ftx=vuDouble(VU->VF[_Ft_].i.x);
556     if (_X){ dst->i.x = VU_MACx_UPDATE(VU, vuDouble(VU->VF[_Fs_].i.x) - ftx); } else VU_MACx_CLEAR(VU);
557     if (_Y){ dst->i.y = VU_MACy_UPDATE(VU, vuDouble(VU->VF[_Fs_].i.y) - ftx); } else VU_MACy_CLEAR(VU);
558     if (_Z){ dst->i.z = VU_MACz_UPDATE(VU, vuDouble(VU->VF[_Fs_].i.z) - ftx); } else VU_MACz_CLEAR(VU);
559     if (_W){ dst->i.w = VU_MACw_UPDATE(VU, vuDouble(VU->VF[_Fs_].i.w) - ftx); } else VU_MACw_CLEAR(VU);
560     VU_STAT_UPDATE(VU);
561     }//updated 10/05/03 shadow
562    
563 william 62 static __fi void _vuSUBy(VURegs * VU) {
564 william 31 float fty;
565     VECTOR * dst;
566     if (_Fd_ == 0) dst = &RDzero;
567     else dst = &VU->VF[_Fd_];
568    
569     fty=vuDouble(VU->VF[_Ft_].i.y);
570     if (_X){ dst->i.x = VU_MACx_UPDATE(VU, vuDouble(VU->VF[_Fs_].i.x) - fty); } else VU_MACx_CLEAR(VU);
571     if (_Y){ dst->i.y = VU_MACy_UPDATE(VU, vuDouble(VU->VF[_Fs_].i.y) - fty); } else VU_MACy_CLEAR(VU);
572     if (_Z){ dst->i.z = VU_MACz_UPDATE(VU, vuDouble(VU->VF[_Fs_].i.z) - fty); } else VU_MACz_CLEAR(VU);
573     if (_W){ dst->i.w = VU_MACw_UPDATE(VU, vuDouble(VU->VF[_Fs_].i.w) - fty); } else VU_MACw_CLEAR(VU);
574     VU_STAT_UPDATE(VU);
575     }//updated 10/05/03 shadow
576    
577 william 62 static __fi void _vuSUBz(VURegs * VU) {
578 william 31 float ftz;
579     VECTOR * dst;
580     if (_Fd_ == 0) dst = &RDzero;
581     else dst = &VU->VF[_Fd_];
582    
583     ftz=vuDouble(VU->VF[_Ft_].i.z);
584     if (_X){ dst->i.x = VU_MACx_UPDATE(VU, vuDouble(VU->VF[_Fs_].i.x) - ftz); } else VU_MACx_CLEAR(VU);
585     if (_Y){ dst->i.y = VU_MACy_UPDATE(VU, vuDouble(VU->VF[_Fs_].i.y) - ftz); } else VU_MACy_CLEAR(VU);
586     if (_Z){ dst->i.z = VU_MACz_UPDATE(VU, vuDouble(VU->VF[_Fs_].i.z) - ftz); } else VU_MACz_CLEAR(VU);
587     if (_W){ dst->i.w = VU_MACw_UPDATE(VU, vuDouble(VU->VF[_Fs_].i.w) - ftz); } else VU_MACw_CLEAR(VU);
588     VU_STAT_UPDATE(VU);
589     }//updated 10/05/03 shadow
590    
591 william 62 static __fi void _vuSUBw(VURegs * VU) {
592 william 31 float ftw;
593     VECTOR * dst;
594     if (_Fd_ == 0) dst = &RDzero;
595     else dst = &VU->VF[_Fd_];
596    
597     ftw=vuDouble(VU->VF[_Ft_].i.w);
598     if (_X){ dst->i.x = VU_MACx_UPDATE(VU, vuDouble(VU->VF[_Fs_].i.x) - ftw); } else VU_MACx_CLEAR(VU);
599     if (_Y){ dst->i.y = VU_MACy_UPDATE(VU, vuDouble(VU->VF[_Fs_].i.y) - ftw); } else VU_MACy_CLEAR(VU);
600     if (_Z){ dst->i.z = VU_MACz_UPDATE(VU, vuDouble(VU->VF[_Fs_].i.z) - ftw); } else VU_MACz_CLEAR(VU);
601     if (_W){ dst->i.w = VU_MACw_UPDATE(VU, vuDouble(VU->VF[_Fs_].i.w) - ftw); } else VU_MACw_CLEAR(VU);
602     VU_STAT_UPDATE(VU);
603     }//updated 10/05/03 shadow
604    
605    
606 william 62 static __fi void _vuSUBA(VURegs * VU) {
607 william 31 if (_X){ VU->ACC.i.x = VU_MACx_UPDATE(VU, vuDouble(VU->VF[_Fs_].i.x) - vuDouble(VU->VF[_Ft_].i.x)); } else VU_MACx_CLEAR(VU);
608     if (_Y){ VU->ACC.i.y = VU_MACy_UPDATE(VU, vuDouble(VU->VF[_Fs_].i.y) - vuDouble(VU->VF[_Ft_].i.y)); } else VU_MACy_CLEAR(VU);
609     if (_Z){ VU->ACC.i.z = VU_MACz_UPDATE(VU, vuDouble(VU->VF[_Fs_].i.z) - vuDouble(VU->VF[_Ft_].i.z)); } else VU_MACz_CLEAR(VU);
610     if (_W){ VU->ACC.i.w = VU_MACw_UPDATE(VU, vuDouble(VU->VF[_Fs_].i.w) - vuDouble(VU->VF[_Ft_].i.w)); } else VU_MACw_CLEAR(VU);
611     VU_STAT_UPDATE(VU);
612     }//updated 10/05/03 shadow
613    
614 william 62 static __fi void _vuSUBAi(VURegs * VU) {
615 william 31 if (_X){ VU->ACC.i.x = VU_MACx_UPDATE(VU, vuDouble(VU->VF[_Fs_].i.x) - vuDouble(VU->VI[REG_I].UL)); } else VU_MACx_CLEAR(VU);
616     if (_Y){ VU->ACC.i.y = VU_MACy_UPDATE(VU, vuDouble(VU->VF[_Fs_].i.y) - vuDouble(VU->VI[REG_I].UL)); } else VU_MACy_CLEAR(VU);
617     if (_Z){ VU->ACC.i.z = VU_MACz_UPDATE(VU, vuDouble(VU->VF[_Fs_].i.z) - vuDouble(VU->VI[REG_I].UL)); } else VU_MACz_CLEAR(VU);
618     if (_W){ VU->ACC.i.w = VU_MACw_UPDATE(VU, vuDouble(VU->VF[_Fs_].i.w) - vuDouble(VU->VI[REG_I].UL)); } else VU_MACw_CLEAR(VU);
619     VU_STAT_UPDATE(VU);
620     }//updated 10/05/03 shadow
621    
622 william 62 static __fi void _vuSUBAq(VURegs * VU) {
623 william 31 if (_X){ VU->ACC.i.x = VU_MACx_UPDATE(VU, vuDouble(VU->VF[_Fs_].i.x) - vuDouble(VU->VI[REG_Q].UL)); } else VU_MACx_CLEAR(VU);
624     if (_Y){ VU->ACC.i.y = VU_MACy_UPDATE(VU, vuDouble(VU->VF[_Fs_].i.y) - vuDouble(VU->VI[REG_Q].UL)); } else VU_MACy_CLEAR(VU);
625     if (_Z){ VU->ACC.i.z = VU_MACz_UPDATE(VU, vuDouble(VU->VF[_Fs_].i.z) - vuDouble(VU->VI[REG_Q].UL)); } else VU_MACz_CLEAR(VU);
626     if (_W){ VU->ACC.i.w = VU_MACw_UPDATE(VU, vuDouble(VU->VF[_Fs_].i.w) - vuDouble(VU->VI[REG_Q].UL)); } else VU_MACw_CLEAR(VU);
627     VU_STAT_UPDATE(VU);
628     }//updated 10/05/03 shadow
629    
630 william 62 static __fi void _vuSUBAx(VURegs * VU) {
631 william 31 float tx = vuDouble(VU->VF[_Ft_].i.x);
632    
633     if (_X){ VU->ACC.i.x = VU_MACx_UPDATE(VU, vuDouble(VU->VF[_Fs_].i.x) - tx); } else VU_MACx_CLEAR(VU);
634     if (_Y){ VU->ACC.i.y = VU_MACy_UPDATE(VU, vuDouble(VU->VF[_Fs_].i.y) - tx); } else VU_MACy_CLEAR(VU);
635     if (_Z){ VU->ACC.i.z = VU_MACz_UPDATE(VU, vuDouble(VU->VF[_Fs_].i.z) - tx); } else VU_MACz_CLEAR(VU);
636     if (_W){ VU->ACC.i.w = VU_MACw_UPDATE(VU, vuDouble(VU->VF[_Fs_].i.w) - tx); } else VU_MACw_CLEAR(VU);
637     VU_STAT_UPDATE(VU);
638     }//updated 10/05/03 shadow
639    
640 william 62 static __fi void _vuSUBAy(VURegs * VU) {
641 william 31 float ty = vuDouble(VU->VF[_Ft_].i.y);
642    
643     if (_X){ VU->ACC.i.x = VU_MACx_UPDATE(VU, vuDouble(VU->VF[_Fs_].i.x) - ty); } else VU_MACx_CLEAR(VU);
644     if (_Y){ VU->ACC.i.y = VU_MACy_UPDATE(VU, vuDouble(VU->VF[_Fs_].i.y) - ty); } else VU_MACy_CLEAR(VU);
645     if (_Z){ VU->ACC.i.z = VU_MACz_UPDATE(VU, vuDouble(VU->VF[_Fs_].i.z) - ty); } else VU_MACz_CLEAR(VU);
646     if (_W){ VU->ACC.i.w = VU_MACw_UPDATE(VU, vuDouble(VU->VF[_Fs_].i.w) - ty); } else VU_MACw_CLEAR(VU);
647     VU_STAT_UPDATE(VU);
648     }//updated 10/05/03 shadow
649    
650 william 62 static __fi void _vuSUBAz(VURegs * VU) {
651 william 31 float tz = vuDouble(VU->VF[_Ft_].i.z);
652    
653     if (_X){ VU->ACC.i.x = VU_MACx_UPDATE(VU, vuDouble(VU->VF[_Fs_].i.x) - tz); } else VU_MACx_CLEAR(VU);
654     if (_Y){ VU->ACC.i.y = VU_MACy_UPDATE(VU, vuDouble(VU->VF[_Fs_].i.y) - tz); } else VU_MACy_CLEAR(VU);
655     if (_Z){ VU->ACC.i.z = VU_MACz_UPDATE(VU, vuDouble(VU->VF[_Fs_].i.z) - tz); } else VU_MACz_CLEAR(VU);
656     if (_W){ VU->ACC.i.w = VU_MACw_UPDATE(VU, vuDouble(VU->VF[_Fs_].i.w) - tz); } else VU_MACw_CLEAR(VU);
657     VU_STAT_UPDATE(VU);
658     }//updated 10/05/03 shadow
659    
660 william 62 static __fi void _vuSUBAw(VURegs * VU) {
661 william 31 float tw = vuDouble(VU->VF[_Ft_].i.w);
662    
663     if (_X){ VU->ACC.i.x = VU_MACx_UPDATE(VU, vuDouble(VU->VF[_Fs_].i.x) - tw); } else VU_MACx_CLEAR(VU);
664     if (_Y){ VU->ACC.i.y = VU_MACy_UPDATE(VU, vuDouble(VU->VF[_Fs_].i.y) - tw); } else VU_MACy_CLEAR(VU);
665     if (_Z){ VU->ACC.i.z = VU_MACz_UPDATE(VU, vuDouble(VU->VF[_Fs_].i.z) - tw); } else VU_MACz_CLEAR(VU);
666     if (_W){ VU->ACC.i.w = VU_MACw_UPDATE(VU, vuDouble(VU->VF[_Fs_].i.w) - tw); } else VU_MACw_CLEAR(VU);
667     VU_STAT_UPDATE(VU);
668     }//updated 10/05/03 shadow
669    
670 william 62 static __fi void _vuMUL(VURegs * VU) {
671 william 31 VECTOR * dst;
672     if (_Fd_ == 0) dst = &RDzero;
673     else dst = &VU->VF[_Fd_];
674    
675     if (_X){ dst->i.x = VU_MACx_UPDATE(VU, vuDouble(VU->VF[_Fs_].i.x) * vuDouble(VU->VF[_Ft_].i.x)); } else VU_MACx_CLEAR(VU);
676     if (_Y){ dst->i.y = VU_MACy_UPDATE(VU, vuDouble(VU->VF[_Fs_].i.y) * vuDouble(VU->VF[_Ft_].i.y)); } else VU_MACy_CLEAR(VU);
677     if (_Z){ dst->i.z = VU_MACz_UPDATE(VU, vuDouble(VU->VF[_Fs_].i.z) * vuDouble(VU->VF[_Ft_].i.z)); } else VU_MACz_CLEAR(VU);
678     if (_W){ dst->i.w = VU_MACw_UPDATE(VU, vuDouble(VU->VF[_Fs_].i.w) * vuDouble(VU->VF[_Ft_].i.w)); } else VU_MACw_CLEAR(VU);
679     VU_STAT_UPDATE(VU);
680     }/* last update 8/05/03 shadow */
681    
682     /* No need to presave I reg in ti. asadr */
683 william 62 static __fi void _vuMULi(VURegs * VU) {
684 william 31 VECTOR * dst;
685     if (_Fd_ == 0) dst = &RDzero;
686     else dst = &VU->VF[_Fd_];
687    
688     if (_X){ dst->i.x = VU_MACx_UPDATE(VU, vuDouble(VU->VF[_Fs_].i.x) * vuDouble(VU->VI[REG_I].UL)); } else VU_MACx_CLEAR(VU);
689     if (_Y){ dst->i.y = VU_MACy_UPDATE(VU, vuDouble(VU->VF[_Fs_].i.y) * vuDouble(VU->VI[REG_I].UL)); } else VU_MACy_CLEAR(VU);
690     if (_Z){ dst->i.z = VU_MACz_UPDATE(VU, vuDouble(VU->VF[_Fs_].i.z) * vuDouble(VU->VI[REG_I].UL)); } else VU_MACz_CLEAR(VU);
691     if (_W){ dst->i.w = VU_MACw_UPDATE(VU, vuDouble(VU->VF[_Fs_].i.w) * vuDouble(VU->VI[REG_I].UL)); } else VU_MACw_CLEAR(VU);
692     VU_STAT_UPDATE(VU);
693     }/* last update 8/05/03 shadow */
694    
695 william 62 static __fi void _vuMULq(VURegs * VU) {
696 william 31 VECTOR * dst;
697     if (_Fd_ == 0) dst = &RDzero;
698     else dst = &VU->VF[_Fd_];
699    
700     if (_X){ dst->i.x = VU_MACx_UPDATE(VU, vuDouble(VU->VF[_Fs_].i.x) * vuDouble(VU->VI[REG_Q].UL)); } else VU_MACx_CLEAR(VU);
701     if (_Y){ dst->i.y = VU_MACy_UPDATE(VU, vuDouble(VU->VF[_Fs_].i.y) * vuDouble(VU->VI[REG_Q].UL)); } else VU_MACy_CLEAR(VU);
702     if (_Z){ dst->i.z = VU_MACz_UPDATE(VU, vuDouble(VU->VF[_Fs_].i.z) * vuDouble(VU->VI[REG_Q].UL)); } else VU_MACz_CLEAR(VU);
703     if (_W){ dst->i.w = VU_MACw_UPDATE(VU, vuDouble(VU->VF[_Fs_].i.w) * vuDouble(VU->VI[REG_Q].UL)); } else VU_MACw_CLEAR(VU);
704     VU_STAT_UPDATE(VU);
705     }/* last update 8/05/03 shadow */
706    
707 william 62 static __fi void _vuMULx(VURegs * VU) {
708 william 31 float ftx;
709     VECTOR * dst;
710     if (_Fd_ == 0) dst = &RDzero;
711     else dst = &VU->VF[_Fd_];
712    
713     ftx=vuDouble(VU->VF[_Ft_].i.x);
714     if (_X){ dst->i.x = VU_MACx_UPDATE(VU, vuDouble(VU->VF[_Fs_].i.x) * ftx); } else VU_MACx_CLEAR(VU);
715     if (_Y){ dst->i.y = VU_MACy_UPDATE(VU, vuDouble(VU->VF[_Fs_].i.y) * ftx); } else VU_MACy_CLEAR(VU);
716     if (_Z){ dst->i.z = VU_MACz_UPDATE(VU, vuDouble(VU->VF[_Fs_].i.z) * ftx); } else VU_MACz_CLEAR(VU);
717     if (_W){ dst->i.w = VU_MACw_UPDATE(VU, vuDouble(VU->VF[_Fs_].i.w) * ftx); } else VU_MACw_CLEAR(VU);
718     VU_STAT_UPDATE(VU);
719     }/* last update 8/05/03 shadow */
720    
721    
722 william 62 static __fi void _vuMULy(VURegs * VU) {
723 william 31 float fty;
724     VECTOR * dst;
725     if (_Fd_ == 0) dst = &RDzero;
726     else dst = &VU->VF[_Fd_];
727    
728     fty=vuDouble(VU->VF[_Ft_].i.y);
729     if (_X){ dst->i.x = VU_MACx_UPDATE(VU, vuDouble(VU->VF[_Fs_].i.x) * fty); } else VU_MACx_CLEAR(VU);
730     if (_Y){ dst->i.y = VU_MACy_UPDATE(VU, vuDouble(VU->VF[_Fs_].i.y) * fty); } else VU_MACy_CLEAR(VU);
731     if (_Z){ dst->i.z = VU_MACz_UPDATE(VU, vuDouble(VU->VF[_Fs_].i.z) * fty); } else VU_MACz_CLEAR(VU);
732     if (_W){ dst->i.w = VU_MACw_UPDATE(VU, vuDouble(VU->VF[_Fs_].i.w) * fty); } else VU_MACw_CLEAR(VU);
733     VU_STAT_UPDATE(VU);
734     }/* last update 8/05/03 shadow */
735    
736 william 62 static __fi void _vuMULz(VURegs * VU) {
737 william 31 float ftz;
738     VECTOR * dst;
739     if (_Fd_ == 0) dst = &RDzero;
740     else dst = &VU->VF[_Fd_];
741    
742     ftz=vuDouble(VU->VF[_Ft_].i.z);
743     if (_X){ dst->i.x = VU_MACx_UPDATE(VU, vuDouble(VU->VF[_Fs_].i.x) * ftz); } else VU_MACx_CLEAR(VU);
744     if (_Y){ dst->i.y = VU_MACy_UPDATE(VU, vuDouble(VU->VF[_Fs_].i.y) * ftz); } else VU_MACy_CLEAR(VU);
745     if (_Z){ dst->i.z = VU_MACz_UPDATE(VU, vuDouble(VU->VF[_Fs_].i.z) * ftz); } else VU_MACz_CLEAR(VU);
746     if (_W){ dst->i.w = VU_MACw_UPDATE(VU, vuDouble(VU->VF[_Fs_].i.w) * ftz); } else VU_MACw_CLEAR(VU);
747     VU_STAT_UPDATE(VU);
748     }/* last update 8/05/03 shadow */
749    
750 william 62 static __fi void _vuMULw(VURegs * VU) {
751 william 31 float ftw;
752     VECTOR * dst;
753     if (_Fd_ == 0) dst = &RDzero;
754     else dst = &VU->VF[_Fd_];
755    
756     ftw=vuDouble(VU->VF[_Ft_].i.w);
757     if (_X){ dst->i.x = VU_MACx_UPDATE(VU, vuDouble(VU->VF[_Fs_].i.x) * ftw); } else VU_MACx_CLEAR(VU);
758     if (_Y){ dst->i.y = VU_MACy_UPDATE(VU, vuDouble(VU->VF[_Fs_].i.y) * ftw); } else VU_MACy_CLEAR(VU);
759     if (_Z){ dst->i.z = VU_MACz_UPDATE(VU, vuDouble(VU->VF[_Fs_].i.z) * ftw); } else VU_MACz_CLEAR(VU);
760     if (_W){ dst->i.w = VU_MACw_UPDATE(VU, vuDouble(VU->VF[_Fs_].i.w) * ftw); } else VU_MACw_CLEAR(VU);
761     VU_STAT_UPDATE(VU);
762     }/* last update 8/05/03 shadow */
763    
764    
765 william 62 static __fi void _vuMULA(VURegs * VU) {
766 william 31 if (_X){ VU->ACC.i.x = VU_MACx_UPDATE(VU, vuDouble(VU->VF[_Fs_].i.x) * vuDouble(VU->VF[_Ft_].i.x)); } else VU_MACx_CLEAR(VU);
767     if (_Y){ VU->ACC.i.y = VU_MACy_UPDATE(VU, vuDouble(VU->VF[_Fs_].i.y) * vuDouble(VU->VF[_Ft_].i.y)); } else VU_MACy_CLEAR(VU);
768     if (_Z){ VU->ACC.i.z = VU_MACz_UPDATE(VU, vuDouble(VU->VF[_Fs_].i.z) * vuDouble(VU->VF[_Ft_].i.z)); } else VU_MACz_CLEAR(VU);
769     if (_W){ VU->ACC.i.w = VU_MACw_UPDATE(VU, vuDouble(VU->VF[_Fs_].i.w) * vuDouble(VU->VF[_Ft_].i.w)); } else VU_MACw_CLEAR(VU);
770     VU_STAT_UPDATE(VU);
771     }/* last update 8/05/03 shadow */
772    
773     /* No need to presave I reg in ti. asadr */
774 william 62 static __fi void _vuMULAi(VURegs * VU) {
775 william 31 if (_X){ VU->ACC.i.x = VU_MACx_UPDATE(VU, vuDouble(VU->VF[_Fs_].i.x) * vuDouble(VU->VI[REG_I].UL)); } else VU_MACx_CLEAR(VU);
776     if (_Y){ VU->ACC.i.y = VU_MACy_UPDATE(VU, vuDouble(VU->VF[_Fs_].i.y) * vuDouble(VU->VI[REG_I].UL)); } else VU_MACy_CLEAR(VU);
777     if (_Z){ VU->ACC.i.z = VU_MACz_UPDATE(VU, vuDouble(VU->VF[_Fs_].i.z) * vuDouble(VU->VI[REG_I].UL)); } else VU_MACz_CLEAR(VU);
778     if (_W){ VU->ACC.i.w = VU_MACw_UPDATE(VU, vuDouble(VU->VF[_Fs_].i.w) * vuDouble(VU->VI[REG_I].UL)); } else VU_MACw_CLEAR(VU);
779     VU_STAT_UPDATE(VU);
780     }/* last update 8/05/03 shadow */
781    
782     /* No need to presave Q reg in ti. asadr */
783 william 62 static __fi void _vuMULAq(VURegs * VU) {
784 william 31 if (_X){ VU->ACC.i.x = VU_MACx_UPDATE(VU, vuDouble(VU->VF[_Fs_].i.x) * vuDouble(VU->VI[REG_Q].UL)); } else VU_MACx_CLEAR(VU);
785     if (_Y){ VU->ACC.i.y = VU_MACy_UPDATE(VU, vuDouble(VU->VF[_Fs_].i.y) * vuDouble(VU->VI[REG_Q].UL)); } else VU_MACy_CLEAR(VU);
786     if (_Z){ VU->ACC.i.z = VU_MACz_UPDATE(VU, vuDouble(VU->VF[_Fs_].i.z) * vuDouble(VU->VI[REG_Q].UL)); } else VU_MACz_CLEAR(VU);
787     if (_W){ VU->ACC.i.w = VU_MACw_UPDATE(VU, vuDouble(VU->VF[_Fs_].i.w) * vuDouble(VU->VI[REG_Q].UL)); } else VU_MACw_CLEAR(VU);
788     VU_STAT_UPDATE(VU);
789     }/* last update 8/05/03 shadow */
790    
791     /* No need to presave X reg in ti. asadr */
792 william 62 static __fi void _vuMULAx(VURegs * VU) {
793 william 31 if (_X){ VU->ACC.i.x = VU_MACx_UPDATE(VU, vuDouble(VU->VF[_Fs_].i.x) * vuDouble(VU->VF[_Ft_].i.x)); } else VU_MACx_CLEAR(VU);
794     if (_Y){ VU->ACC.i.y = VU_MACy_UPDATE(VU, vuDouble(VU->VF[_Fs_].i.y) * vuDouble(VU->VF[_Ft_].i.x)); } else VU_MACy_CLEAR(VU);
795     if (_Z){ VU->ACC.i.z = VU_MACz_UPDATE(VU, vuDouble(VU->VF[_Fs_].i.z) * vuDouble(VU->VF[_Ft_].i.x)); } else VU_MACz_CLEAR(VU);
796     if (_W){ VU->ACC.i.w = VU_MACw_UPDATE(VU, vuDouble(VU->VF[_Fs_].i.w) * vuDouble(VU->VF[_Ft_].i.x)); } else VU_MACw_CLEAR(VU);
797     VU_STAT_UPDATE(VU);
798     }/* last update 8/05/03 shadow */
799    
800 william 62 static __fi void _vuMULAy(VURegs * VU) {
801 william 31 if (_X){ VU->ACC.i.x = VU_MACx_UPDATE(VU, vuDouble(VU->VF[_Fs_].i.x) * vuDouble(VU->VF[_Ft_].i.y)); } else VU_MACx_CLEAR(VU);
802     if (_Y){ VU->ACC.i.y = VU_MACy_UPDATE(VU, vuDouble(VU->VF[_Fs_].i.y) * vuDouble(VU->VF[_Ft_].i.y)); } else VU_MACy_CLEAR(VU);
803     if (_Z){ VU->ACC.i.z = VU_MACz_UPDATE(VU, vuDouble(VU->VF[_Fs_].i.z) * vuDouble(VU->VF[_Ft_].i.y)); } else VU_MACz_CLEAR(VU);
804     if (_W){ VU->ACC.i.w = VU_MACw_UPDATE(VU, vuDouble(VU->VF[_Fs_].i.w) * vuDouble(VU->VF[_Ft_].i.y)); } else VU_MACw_CLEAR(VU);
805     VU_STAT_UPDATE(VU);
806     }/* last update 8/05/03 shadow */
807    
808 william 62 static __fi void _vuMULAz(VURegs * VU) {
809 william 31 if (_X){ VU->ACC.i.x = VU_MACx_UPDATE(VU, vuDouble(VU->VF[_Fs_].i.x) * vuDouble(VU->VF[_Ft_].i.z)); } else VU_MACx_CLEAR(VU);
810     if (_Y){ VU->ACC.i.y = VU_MACy_UPDATE(VU, vuDouble(VU->VF[_Fs_].i.y) * vuDouble(VU->VF[_Ft_].i.z)); } else VU_MACy_CLEAR(VU);
811     if (_Z){ VU->ACC.i.z = VU_MACz_UPDATE(VU, vuDouble(VU->VF[_Fs_].i.z) * vuDouble(VU->VF[_Ft_].i.z)); } else VU_MACz_CLEAR(VU);
812     if (_W){ VU->ACC.i.w = VU_MACw_UPDATE(VU, vuDouble(VU->VF[_Fs_].i.w) * vuDouble(VU->VF[_Ft_].i.z)); } else VU_MACw_CLEAR(VU);
813     VU_STAT_UPDATE(VU);
814     }/* last update 8/05/03 shadow */
815    
816 william 62 static __fi void _vuMULAw(VURegs * VU) {
817 william 31 if (_X){ VU->ACC.i.x = VU_MACx_UPDATE(VU, vuDouble(VU->VF[_Fs_].i.x) * vuDouble(VU->VF[_Ft_].i.w)); } else VU_MACx_CLEAR(VU);
818     if (_Y){ VU->ACC.i.y = VU_MACy_UPDATE(VU, vuDouble(VU->VF[_Fs_].i.y) * vuDouble(VU->VF[_Ft_].i.w)); } else VU_MACy_CLEAR(VU);
819     if (_Z){ VU->ACC.i.z = VU_MACz_UPDATE(VU, vuDouble(VU->VF[_Fs_].i.z) * vuDouble(VU->VF[_Ft_].i.w)); } else VU_MACz_CLEAR(VU);
820     if (_W){ VU->ACC.i.w = VU_MACw_UPDATE(VU, vuDouble(VU->VF[_Fs_].i.w) * vuDouble(VU->VF[_Ft_].i.w)); } else VU_MACw_CLEAR(VU);
821     VU_STAT_UPDATE(VU);
822     }/* last update 8/05/03 shadow */
823    
824 william 62 static __fi void _vuMADD(VURegs * VU) {
825 william 31 VECTOR * dst;
826     if (_Fd_ == 0) dst = &RDzero;
827     else dst = &VU->VF[_Fd_];
828    
829     if (_X) dst->i.x = VU_MACx_UPDATE(VU, vuDouble(VU->ACC.i.x) + ( vuDouble(VU->VF[_Fs_].i.x) * vuDouble(VU->VF[_Ft_].i.x))); else VU_MACx_CLEAR(VU);
830     if (_Y) dst->i.y = VU_MACy_UPDATE(VU, vuDouble(VU->ACC.i.y) + ( vuDouble(VU->VF[_Fs_].i.y) * vuDouble(VU->VF[_Ft_].i.y))); else VU_MACy_CLEAR(VU);
831     if (_Z) dst->i.z = VU_MACz_UPDATE(VU, vuDouble(VU->ACC.i.z) + ( vuDouble(VU->VF[_Fs_].i.z) * vuDouble(VU->VF[_Ft_].i.z))); else VU_MACz_CLEAR(VU);
832     if (_W) dst->i.w = VU_MACw_UPDATE(VU, vuDouble(VU->ACC.i.w) + ( vuDouble(VU->VF[_Fs_].i.w) * vuDouble(VU->VF[_Ft_].i.w))); else VU_MACw_CLEAR(VU);
833     VU_STAT_UPDATE(VU);
834     }/* last update 10/05/03 shadow */
835    
836    
837 william 62 static __fi void _vuMADDi(VURegs * VU) {
838 william 31 VECTOR * dst;
839     if (_Fd_ == 0) dst = &RDzero;
840     else dst = &VU->VF[_Fd_];
841    
842     if (_X) dst->i.x = VU_MACx_UPDATE(VU, vuDouble(VU->ACC.i.x) + (vuDouble(VU->VF[_Fs_].i.x) * vuDouble(VU->VI[REG_I].UL))); else VU_MACx_CLEAR(VU);
843     if (_Y) dst->i.y = VU_MACy_UPDATE(VU, vuDouble(VU->ACC.i.y) + (vuDouble(VU->VF[_Fs_].i.y) * vuDouble(VU->VI[REG_I].UL))); else VU_MACy_CLEAR(VU);
844     if (_Z) dst->i.z = VU_MACz_UPDATE(VU, vuDouble(VU->ACC.i.z) + (vuDouble(VU->VF[_Fs_].i.z) * vuDouble(VU->VI[REG_I].UL))); else VU_MACz_CLEAR(VU);
845     if (_W) dst->i.w = VU_MACw_UPDATE(VU, vuDouble(VU->ACC.i.w) + (vuDouble(VU->VF[_Fs_].i.w) * vuDouble(VU->VI[REG_I].UL))); else VU_MACw_CLEAR(VU);
846     VU_STAT_UPDATE(VU);
847     }/* last update 10/05/03 shadow */
848    
849     /* No need to presave . asadr */
850 william 62 static __fi void _vuMADDq(VURegs * VU) {
851 william 31 VECTOR * dst;
852     if (_Fd_ == 0) dst = &RDzero;
853     else dst = &VU->VF[_Fd_];
854    
855     if (_X) dst->i.x = VU_MACx_UPDATE(VU, vuDouble(VU->ACC.i.x) + (vuDouble(VU->VF[_Fs_].i.x) * vuDouble(VU->VI[REG_Q].UL))); else VU_MACx_CLEAR(VU);
856     if (_Y) dst->i.y = VU_MACy_UPDATE(VU, vuDouble(VU->ACC.i.y) + (vuDouble(VU->VF[_Fs_].i.y) * vuDouble(VU->VI[REG_Q].UL))); else VU_MACy_CLEAR(VU);
857     if (_Z) dst->i.z = VU_MACz_UPDATE(VU, vuDouble(VU->ACC.i.z) + (vuDouble(VU->VF[_Fs_].i.z) * vuDouble(VU->VI[REG_Q].UL))); else VU_MACz_CLEAR(VU);
858     if (_W) dst->i.w = VU_MACw_UPDATE(VU, vuDouble(VU->ACC.i.w) + (vuDouble(VU->VF[_Fs_].i.w) * vuDouble(VU->VI[REG_Q].UL))); else VU_MACw_CLEAR(VU);
859     VU_STAT_UPDATE(VU);
860     }/* last update 10/05/03 shadow */
861    
862 william 62 static __fi void _vuMADDx(VURegs * VU) {
863 william 31 float ftx;
864     VECTOR * dst;
865     if (_Fd_ == 0) dst = &RDzero;
866     else dst = &VU->VF[_Fd_];
867    
868     ftx=vuDouble(VU->VF[_Ft_].i.x);
869     if (_X) dst->i.x = VU_MACx_UPDATE(VU, vuDouble(VU->ACC.i.x) + (vuDouble(VU->VF[_Fs_].i.x) * ftx)); else VU_MACx_CLEAR(VU);
870     if (_Y) dst->i.y = VU_MACy_UPDATE(VU, vuDouble(VU->ACC.i.y) + (vuDouble(VU->VF[_Fs_].i.y) * ftx)); else VU_MACy_CLEAR(VU);
871     if (_Z) dst->i.z = VU_MACz_UPDATE(VU, vuDouble(VU->ACC.i.z) + (vuDouble(VU->VF[_Fs_].i.z) * ftx)); else VU_MACz_CLEAR(VU);
872     if (_W) dst->i.w = VU_MACw_UPDATE(VU, vuDouble(VU->ACC.i.w) + (vuDouble(VU->VF[_Fs_].i.w) * ftx)); else VU_MACw_CLEAR(VU);
873     VU_STAT_UPDATE(VU);
874     }/* last update 10/05/03 shadow */
875    
876 william 62 static __fi void _vuMADDy(VURegs * VU) {
877 william 31 float fty;
878     VECTOR * dst;
879     if (_Fd_ == 0) dst = &RDzero;
880     else dst = &VU->VF[_Fd_];
881    
882     fty=vuDouble(VU->VF[_Ft_].i.y);
883     if (_X) dst->i.x = VU_MACx_UPDATE(VU, vuDouble(VU->ACC.i.x) + (vuDouble(VU->VF[_Fs_].i.x) * fty)); else VU_MACx_CLEAR(VU);
884     if (_Y) dst->i.y = VU_MACy_UPDATE(VU, vuDouble(VU->ACC.i.y) + (vuDouble(VU->VF[_Fs_].i.y) * fty)); else VU_MACy_CLEAR(VU);
885     if (_Z) dst->i.z = VU_MACz_UPDATE(VU, vuDouble(VU->ACC.i.z) + (vuDouble(VU->VF[_Fs_].i.z) * fty)); else VU_MACz_CLEAR(VU);
886     if (_W) dst->i.w = VU_MACw_UPDATE(VU, vuDouble(VU->ACC.i.w) + (vuDouble(VU->VF[_Fs_].i.w) * fty)); else VU_MACw_CLEAR(VU);
887     VU_STAT_UPDATE(VU);
888     }/* last update 10/05/03 shadow */
889    
890 william 62 static __fi void _vuMADDz(VURegs * VU) {
891 william 31 float ftz;
892     VECTOR * dst;
893     if (_Fd_ == 0) dst = &RDzero;
894     else dst = &VU->VF[_Fd_];
895    
896     ftz=vuDouble(VU->VF[_Ft_].i.z);
897     if (_X) dst->i.x = VU_MACx_UPDATE(VU, vuDouble(VU->ACC.i.x) + (vuDouble(VU->VF[_Fs_].i.x) * ftz)); else VU_MACx_CLEAR(VU);
898     if (_Y) dst->i.y = VU_MACy_UPDATE(VU, vuDouble(VU->ACC.i.y) + (vuDouble(VU->VF[_Fs_].i.y) * ftz)); else VU_MACy_CLEAR(VU);
899     if (_Z) dst->i.z = VU_MACz_UPDATE(VU, vuDouble(VU->ACC.i.z) + (vuDouble(VU->VF[_Fs_].i.z) * ftz)); else VU_MACz_CLEAR(VU);
900     if (_W) dst->i.w = VU_MACw_UPDATE(VU, vuDouble(VU->ACC.i.w) + (vuDouble(VU->VF[_Fs_].i.w) * ftz)); else VU_MACw_CLEAR(VU);
901     VU_STAT_UPDATE(VU);
902     }/* last update 10/05/03 shadow */
903    
904 william 62 static __fi void _vuMADDw(VURegs * VU) {
905 william 31 float ftw;
906     VECTOR * dst;
907     if (_Fd_ == 0) dst = &RDzero;
908     else dst = &VU->VF[_Fd_];
909    
910     ftw=vuDouble(VU->VF[_Ft_].i.w);
911     if (_X) dst->i.x = VU_MACx_UPDATE(VU, vuDouble(VU->ACC.i.x) + (vuDouble(VU->VF[_Fs_].i.x) * ftw)); else VU_MACx_CLEAR(VU);
912     if (_Y) dst->i.y = VU_MACy_UPDATE(VU, vuDouble(VU->ACC.i.y) + (vuDouble(VU->VF[_Fs_].i.y) * ftw)); else VU_MACy_CLEAR(VU);
913     if (_Z) dst->i.z = VU_MACz_UPDATE(VU, vuDouble(VU->ACC.i.z) + (vuDouble(VU->VF[_Fs_].i.z) * ftw)); else VU_MACz_CLEAR(VU);
914     if (_W) dst->i.w = VU_MACw_UPDATE(VU, vuDouble(VU->ACC.i.w) + (vuDouble(VU->VF[_Fs_].i.w) * ftw)); else VU_MACw_CLEAR(VU);
915     VU_STAT_UPDATE(VU);
916     }/* last update 10/05/03 shadow */
917    
918 william 62 static __fi void _vuMADDA(VURegs * VU) {
919 william 31 if (_X) VU->ACC.i.x = VU_MACx_UPDATE(VU, vuDouble(VU->ACC.i.x) + (vuDouble(VU->VF[_Fs_].i.x) * vuDouble(VU->VF[_Ft_].i.x))); else VU_MACx_CLEAR(VU);
920     if (_Y) VU->ACC.i.y = VU_MACy_UPDATE(VU, vuDouble(VU->ACC.i.y) + (vuDouble(VU->VF[_Fs_].i.y) * vuDouble(VU->VF[_Ft_].i.y))); else VU_MACy_CLEAR(VU);
921     if (_Z) VU->ACC.i.z = VU_MACz_UPDATE(VU, vuDouble(VU->ACC.i.z) + (vuDouble(VU->VF[_Fs_].i.z) * vuDouble(VU->VF[_Ft_].i.z))); else VU_MACz_CLEAR(VU);
922     if (_W) VU->ACC.i.w = VU_MACw_UPDATE(VU, vuDouble(VU->ACC.i.w) + (vuDouble(VU->VF[_Fs_].i.w) * vuDouble(VU->VF[_Ft_].i.w))); else VU_MACw_CLEAR(VU);
923     VU_STAT_UPDATE(VU);
924     }/*last updated 10/05/03 shadow*/
925    
926 william 62 static __fi void _vuMADDAi(VURegs * VU) {
927 william 31 float ti = vuDouble(VU->VI[REG_I].UL);
928    
929     if (_X) VU->ACC.i.x = VU_MACx_UPDATE(VU, vuDouble(VU->ACC.i.x) + ( vuDouble(VU->VF[_Fs_].i.x) * ti)); else VU_MACx_CLEAR(VU);
930     if (_Y) VU->ACC.i.y = VU_MACy_UPDATE(VU, vuDouble(VU->ACC.i.y) + ( vuDouble(VU->VF[_Fs_].i.y) * ti)); else VU_MACy_CLEAR(VU);
931     if (_Z) VU->ACC.i.z = VU_MACz_UPDATE(VU, vuDouble(VU->ACC.i.z) + ( vuDouble(VU->VF[_Fs_].i.z) * ti)); else VU_MACz_CLEAR(VU);
932     if (_W) VU->ACC.i.w = VU_MACw_UPDATE(VU, vuDouble(VU->ACC.i.w) + ( vuDouble(VU->VF[_Fs_].i.w) * ti)); else VU_MACw_CLEAR(VU);
933     VU_STAT_UPDATE(VU);
934     }/*last updated 10/05/03 shadow*/
935    
936 william 62 static __fi void _vuMADDAq(VURegs * VU) {
937 william 31 float tq = vuDouble(VU->VI[REG_Q].UL);
938    
939     if (_X) VU->ACC.i.x = VU_MACx_UPDATE(VU, vuDouble(VU->ACC.i.x) + ( vuDouble(VU->VF[_Fs_].i.x) * tq)); else VU_MACx_CLEAR(VU);
940     if (_Y) VU->ACC.i.y = VU_MACy_UPDATE(VU, vuDouble(VU->ACC.i.y) + ( vuDouble(VU->VF[_Fs_].i.y) * tq)); else VU_MACy_CLEAR(VU);
941     if (_Z) VU->ACC.i.z = VU_MACz_UPDATE(VU, vuDouble(VU->ACC.i.z) + ( vuDouble(VU->VF[_Fs_].i.z) * tq)); else VU_MACz_CLEAR(VU);
942     if (_W) VU->ACC.i.w = VU_MACw_UPDATE(VU, vuDouble(VU->ACC.i.w) + ( vuDouble(VU->VF[_Fs_].i.w) * tq)); else VU_MACw_CLEAR(VU);
943     VU_STAT_UPDATE(VU);
944     }/*last update 10/05/03 shadow*/
945    
946 william 62 static __fi void _vuMADDAx(VURegs * VU) {
947 william 31 if (_X) VU->ACC.i.x = VU_MACx_UPDATE(VU, vuDouble(VU->ACC.i.x) + ( vuDouble(VU->VF[_Fs_].i.x) * vuDouble(VU->VF[_Ft_].i.x))); else VU_MACx_CLEAR(VU);
948     if (_Y) VU->ACC.i.y = VU_MACy_UPDATE(VU, vuDouble(VU->ACC.i.y) + ( vuDouble(VU->VF[_Fs_].i.y) * vuDouble(VU->VF[_Ft_].i.x))); else VU_MACy_CLEAR(VU);
949     if (_Z) VU->ACC.i.z = VU_MACz_UPDATE(VU, vuDouble(VU->ACC.i.z) + ( vuDouble(VU->VF[_Fs_].i.z) * vuDouble(VU->VF[_Ft_].i.x))); else VU_MACz_CLEAR(VU);
950     if (_W) VU->ACC.i.w = VU_MACw_UPDATE(VU, vuDouble(VU->ACC.i.w) + ( vuDouble(VU->VF[_Fs_].i.w) * vuDouble(VU->VF[_Ft_].i.x))); else VU_MACw_CLEAR(VU);
951     VU_STAT_UPDATE(VU);
952     }/*last update 11/05/03 shadow*/
953    
954 william 62 static __fi void _vuMADDAy(VURegs * VU) {
955 william 31 if (_X) VU->ACC.i.x = VU_MACx_UPDATE(VU, vuDouble(VU->ACC.i.x) + ( vuDouble(VU->VF[_Fs_].i.x) * vuDouble(VU->VF[_Ft_].i.y))); else VU_MACx_CLEAR(VU);
956     if (_Y) VU->ACC.i.y = VU_MACy_UPDATE(VU, vuDouble(VU->ACC.i.y) + ( vuDouble(VU->VF[_Fs_].i.y) * vuDouble(VU->VF[_Ft_].i.y))); else VU_MACy_CLEAR(VU);
957     if (_Z) VU->ACC.i.z = VU_MACz_UPDATE(VU, vuDouble(VU->ACC.i.z) + ( vuDouble(VU->VF[_Fs_].i.z) * vuDouble(VU->VF[_Ft_].i.y))); else VU_MACz_CLEAR(VU);
958     if (_W) VU->ACC.i.w = VU_MACw_UPDATE(VU, vuDouble(VU->ACC.i.w) + ( vuDouble(VU->VF[_Fs_].i.w) * vuDouble(VU->VF[_Ft_].i.y))); else VU_MACw_CLEAR(VU);
959     VU_STAT_UPDATE(VU);
960     }/*last update 11/05/03 shadow*/
961    
962 william 62 static __fi void _vuMADDAz(VURegs * VU) {
963 william 31 if (_X) VU->ACC.i.x = VU_MACx_UPDATE(VU, vuDouble(VU->ACC.i.x) + ( vuDouble(VU->VF[_Fs_].i.x) * vuDouble(VU->VF[_Ft_].i.z))); else VU_MACx_CLEAR(VU);
964     if (_Y) VU->ACC.i.y = VU_MACy_UPDATE(VU, vuDouble(VU->ACC.i.y) + ( vuDouble(VU->VF[_Fs_].i.y) * vuDouble(VU->VF[_Ft_].i.z))); else VU_MACy_CLEAR(VU);
965     if (_Z) VU->ACC.i.z = VU_MACz_UPDATE(VU, vuDouble(VU->ACC.i.z) + ( vuDouble(VU->VF[_Fs_].i.z) * vuDouble(VU->VF[_Ft_].i.z))); else VU_MACz_CLEAR(VU);
966     if (_W) VU->ACC.i.w = VU_MACw_UPDATE(VU, vuDouble(VU->ACC.i.w) + ( vuDouble(VU->VF[_Fs_].i.w) * vuDouble(VU->VF[_Ft_].i.z))); else VU_MACw_CLEAR(VU);
967     VU_STAT_UPDATE(VU);
968     }/*last update 11/05/03 shadow*/
969    
970 william 62 static __fi void _vuMADDAw(VURegs * VU) {
971 william 31 if (_X) VU->ACC.i.x = VU_MACx_UPDATE(VU, vuDouble(VU->ACC.i.x) + ( vuDouble(VU->VF[_Fs_].i.x) * vuDouble(VU->VF[_Ft_].i.w))); else VU_MACx_CLEAR(VU);
972     if (_Y) VU->ACC.i.y = VU_MACy_UPDATE(VU, vuDouble(VU->ACC.i.y) + ( vuDouble(VU->VF[_Fs_].i.y) * vuDouble(VU->VF[_Ft_].i.w))); else VU_MACy_CLEAR(VU);
973     if (_Z) VU->ACC.i.z = VU_MACz_UPDATE(VU, vuDouble(VU->ACC.i.z) + ( vuDouble(VU->VF[_Fs_].i.z) * vuDouble(VU->VF[_Ft_].i.w))); else VU_MACz_CLEAR(VU);
974     if (_W) VU->ACC.i.w = VU_MACw_UPDATE(VU, vuDouble(VU->ACC.i.w) + ( vuDouble(VU->VF[_Fs_].i.w) * vuDouble(VU->VF[_Ft_].i.w))); else VU_MACw_CLEAR(VU);
975     VU_STAT_UPDATE(VU);
976     }/*last update 11/05/03 shadow*/
977    
978 william 62 static __fi void _vuMSUB(VURegs * VU) {
979 william 31 VECTOR * dst;
980     if (_Fd_ == 0) dst = &RDzero;
981     else dst = &VU->VF[_Fd_];
982    
983     if (_X) dst->i.x = VU_MACx_UPDATE(VU, vuDouble(VU->ACC.i.x) - ( vuDouble(VU->VF[_Fs_].i.x) * vuDouble(VU->VF[_Ft_].i.x))); else VU_MACx_CLEAR(VU);
984     if (_Y) dst->i.y = VU_MACy_UPDATE(VU, vuDouble(VU->ACC.i.y) - ( vuDouble(VU->VF[_Fs_].i.y) * vuDouble(VU->VF[_Ft_].i.y))); else VU_MACy_CLEAR(VU);
985     if (_Z) dst->i.z = VU_MACz_UPDATE(VU, vuDouble(VU->ACC.i.z) - ( vuDouble(VU->VF[_Fs_].i.z) * vuDouble(VU->VF[_Ft_].i.z))); else VU_MACz_CLEAR(VU);
986     if (_W) dst->i.w = VU_MACw_UPDATE(VU, vuDouble(VU->ACC.i.w) - ( vuDouble(VU->VF[_Fs_].i.w) * vuDouble(VU->VF[_Ft_].i.w))); else VU_MACw_CLEAR(VU);
987     VU_STAT_UPDATE(VU);
988     }/* last update 11/05/03 shadow */
989    
990 william 62 static __fi void _vuMSUBi(VURegs * VU) {
991 william 31 float ti = vuDouble(VU->VI[REG_I].UL);
992     VECTOR * dst;
993     if (_Fd_ == 0) dst = &RDzero;
994     else dst = &VU->VF[_Fd_];
995    
996     if (_X) dst->i.x = VU_MACx_UPDATE(VU, vuDouble(VU->ACC.i.x) - ( vuDouble(VU->VF[_Fs_].i.x) * ti ) ); else VU_MACx_CLEAR(VU);
997     if (_Y) dst->i.y = VU_MACy_UPDATE(VU, vuDouble(VU->ACC.i.y) - ( vuDouble(VU->VF[_Fs_].i.y) * ti ) ); else VU_MACy_CLEAR(VU);
998     if (_Z) dst->i.z = VU_MACz_UPDATE(VU, vuDouble(VU->ACC.i.z) - ( vuDouble(VU->VF[_Fs_].i.z) * ti ) ); else VU_MACz_CLEAR(VU);
999     if (_W) dst->i.w = VU_MACw_UPDATE(VU, vuDouble(VU->ACC.i.w) - ( vuDouble(VU->VF[_Fs_].i.w) * ti ) ); else VU_MACw_CLEAR(VU);
1000     VU_STAT_UPDATE(VU);
1001     }/* last update 11/05/03 shadow */
1002    
1003 william 62 static __fi void _vuMSUBq(VURegs * VU) {
1004 william 31 float tq = vuDouble(VU->VI[REG_Q].UL);
1005     VECTOR * dst;
1006     if (_Fd_ == 0) dst = &RDzero;
1007     else dst = &VU->VF[_Fd_];
1008    
1009     if (_X) dst->i.x = VU_MACx_UPDATE(VU, vuDouble(VU->ACC.i.x) - ( vuDouble(VU->VF[_Fs_].i.x) * tq ) ); else VU_MACx_CLEAR(VU);
1010     if (_Y) dst->i.y = VU_MACy_UPDATE(VU, vuDouble(VU->ACC.i.y) - ( vuDouble(VU->VF[_Fs_].i.y) * tq ) ); else VU_MACy_CLEAR(VU);
1011     if (_Z) dst->i.z = VU_MACz_UPDATE(VU, vuDouble(VU->ACC.i.z) - ( vuDouble(VU->VF[_Fs_].i.z) * tq ) ); else VU_MACz_CLEAR(VU);
1012     if (_W) dst->i.w = VU_MACw_UPDATE(VU, vuDouble(VU->ACC.i.w) - ( vuDouble(VU->VF[_Fs_].i.w) * tq ) ); else VU_MACw_CLEAR(VU);
1013     VU_STAT_UPDATE(VU);
1014     }/* last update 11/05/03 shadow */
1015    
1016    
1017 william 62 static __fi void _vuMSUBx(VURegs * VU) {
1018 william 31 float ftx;
1019     VECTOR * dst;
1020     if (_Fd_ == 0) dst = &RDzero;
1021     else dst = &VU->VF[_Fd_];
1022    
1023     ftx=vuDouble(VU->VF[_Ft_].i.x);
1024     if (_X) dst->i.x = VU_MACx_UPDATE(VU, vuDouble(VU->ACC.i.x) - ( vuDouble(VU->VF[_Fs_].i.x) * ftx ) ); else VU_MACx_CLEAR(VU);
1025     if (_Y) dst->i.y = VU_MACy_UPDATE(VU, vuDouble(VU->ACC.i.y) - ( vuDouble(VU->VF[_Fs_].i.y) * ftx ) ); else VU_MACy_CLEAR(VU);
1026     if (_Z) dst->i.z = VU_MACz_UPDATE(VU, vuDouble(VU->ACC.i.z) - ( vuDouble(VU->VF[_Fs_].i.z) * ftx ) ); else VU_MACz_CLEAR(VU);
1027     if (_W) dst->i.w = VU_MACw_UPDATE(VU, vuDouble(VU->ACC.i.w) - ( vuDouble(VU->VF[_Fs_].i.w) * ftx ) ); else VU_MACw_CLEAR(VU);
1028     VU_STAT_UPDATE(VU);
1029     }/* last update 11/05/03 shadow */
1030    
1031    
1032 william 62 static __fi void _vuMSUBy(VURegs * VU) {
1033 william 31 float fty;
1034     VECTOR * dst;
1035     if (_Fd_ == 0) dst = &RDzero;
1036     else dst = &VU->VF[_Fd_];
1037    
1038     fty=vuDouble(VU->VF[_Ft_].i.y);
1039     if (_X) dst->i.x = VU_MACx_UPDATE(VU, vuDouble(VU->ACC.i.x) - ( vuDouble(VU->VF[_Fs_].i.x) * fty ) ); else VU_MACx_CLEAR(VU);
1040     if (_Y) dst->i.y = VU_MACy_UPDATE(VU, vuDouble(VU->ACC.i.y) - ( vuDouble(VU->VF[_Fs_].i.y) * fty ) ); else VU_MACy_CLEAR(VU);
1041     if (_Z) dst->i.z = VU_MACz_UPDATE(VU, vuDouble(VU->ACC.i.z) - ( vuDouble(VU->VF[_Fs_].i.z) * fty ) ); else VU_MACz_CLEAR(VU);
1042     if (_W) dst->i.w = VU_MACw_UPDATE(VU, vuDouble(VU->ACC.i.w) - ( vuDouble(VU->VF[_Fs_].i.w) * fty ) ); else VU_MACw_CLEAR(VU);
1043     VU_STAT_UPDATE(VU);
1044     }/* last update 11/05/03 shadow */
1045    
1046    
1047 william 62 static __fi void _vuMSUBz(VURegs * VU) {
1048 william 31 float ftz;
1049     VECTOR * dst;
1050     if (_Fd_ == 0) dst = &RDzero;
1051     else dst = &VU->VF[_Fd_];
1052    
1053     ftz=vuDouble(VU->VF[_Ft_].i.z);
1054     if (_X) dst->i.x = VU_MACx_UPDATE(VU, vuDouble(VU->ACC.i.x) - ( vuDouble(VU->VF[_Fs_].i.x) * ftz ) ); else VU_MACx_CLEAR(VU);
1055     if (_Y) dst->i.y = VU_MACy_UPDATE(VU, vuDouble(VU->ACC.i.y) - ( vuDouble(VU->VF[_Fs_].i.y) * ftz ) ); else VU_MACy_CLEAR(VU);
1056     if (_Z) dst->i.z = VU_MACz_UPDATE(VU, vuDouble(VU->ACC.i.z) - ( vuDouble(VU->VF[_Fs_].i.z) * ftz ) ); else VU_MACz_CLEAR(VU);
1057     if (_W) dst->i.w = VU_MACw_UPDATE(VU, vuDouble(VU->ACC.i.w) - ( vuDouble(VU->VF[_Fs_].i.w) * ftz ) ); else VU_MACw_CLEAR(VU);
1058     VU_STAT_UPDATE(VU);
1059     }/* last update 11/05/03 shadow */
1060    
1061 william 62 static __fi void _vuMSUBw(VURegs * VU) {
1062 william 31 float ftw;
1063     VECTOR * dst;
1064     if (_Fd_ == 0) dst = &RDzero;
1065     else dst = &VU->VF[_Fd_];
1066    
1067     ftw=vuDouble(VU->VF[_Ft_].i.w);
1068     if (_X) dst->i.x = VU_MACx_UPDATE(VU, vuDouble(VU->ACC.i.x) - ( vuDouble(VU->VF[_Fs_].i.x) * ftw ) ); else VU_MACx_CLEAR(VU);
1069     if (_Y) dst->i.y = VU_MACy_UPDATE(VU, vuDouble(VU->ACC.i.y) - ( vuDouble(VU->VF[_Fs_].i.y) * ftw ) ); else VU_MACy_CLEAR(VU);
1070     if (_Z) dst->i.z = VU_MACz_UPDATE(VU, vuDouble(VU->ACC.i.z) - ( vuDouble(VU->VF[_Fs_].i.z) * ftw ) ); else VU_MACz_CLEAR(VU);
1071     if (_W) dst->i.w = VU_MACw_UPDATE(VU, vuDouble(VU->ACC.i.w) - ( vuDouble(VU->VF[_Fs_].i.w) * ftw ) ); else VU_MACw_CLEAR(VU);
1072     VU_STAT_UPDATE(VU);
1073     }/* last update 11/05/03 shadow */
1074    
1075    
1076 william 62 static __fi void _vuMSUBA(VURegs * VU) {
1077 william 31 if (_X) VU->ACC.i.x = VU_MACx_UPDATE(VU, vuDouble(VU->ACC.i.x) - ( vuDouble(VU->VF[_Fs_].i.x) * vuDouble(VU->VF[_Ft_].i.x))); else VU_MACx_CLEAR(VU);
1078     if (_Y) VU->ACC.i.y = VU_MACy_UPDATE(VU, vuDouble(VU->ACC.i.y) - ( vuDouble(VU->VF[_Fs_].i.y) * vuDouble(VU->VF[_Ft_].i.y))); else VU_MACy_CLEAR(VU);
1079     if (_Z) VU->ACC.i.z = VU_MACz_UPDATE(VU, vuDouble(VU->ACC.i.z) - ( vuDouble(VU->VF[_Fs_].i.z) * vuDouble(VU->VF[_Ft_].i.z))); else VU_MACz_CLEAR(VU);
1080     if (_W) VU->ACC.i.w = VU_MACw_UPDATE(VU, vuDouble(VU->ACC.i.w) - ( vuDouble(VU->VF[_Fs_].i.w) * vuDouble(VU->VF[_Ft_].i.w))); else VU_MACw_CLEAR(VU);
1081     VU_STAT_UPDATE(VU);
1082     }/*last updated 11/05/03 shadow*/
1083    
1084 william 62 static __fi void _vuMSUBAi(VURegs * VU) {
1085 william 31 if (_X) VU->ACC.i.x = VU_MACx_UPDATE(VU, vuDouble(VU->ACC.i.x) - ( vuDouble(VU->VF[_Fs_].i.x) * vuDouble(VU->VI[REG_I].UL))); else VU_MACx_CLEAR(VU);
1086     if (_Y) VU->ACC.i.y = VU_MACy_UPDATE(VU, vuDouble(VU->ACC.i.y) - ( vuDouble(VU->VF[_Fs_].i.y) * vuDouble(VU->VI[REG_I].UL))); else VU_MACy_CLEAR(VU);
1087     if (_Z) VU->ACC.i.z = VU_MACz_UPDATE(VU, vuDouble(VU->ACC.i.z) - ( vuDouble(VU->VF[_Fs_].i.z) * vuDouble(VU->VI[REG_I].UL))); else VU_MACz_CLEAR(VU);
1088     if (_W) VU->ACC.i.w = VU_MACw_UPDATE(VU, vuDouble(VU->ACC.i.w) - ( vuDouble(VU->VF[_Fs_].i.w) * vuDouble(VU->VI[REG_I].UL))); else VU_MACw_CLEAR(VU);
1089     VU_STAT_UPDATE(VU);
1090     }/*last updated 11/05/03 shadow*/
1091    
1092 william 62 static __fi void _vuMSUBAq(VURegs * VU) {
1093 william 31 if (_X) VU->ACC.i.x = VU_MACx_UPDATE(VU, vuDouble(VU->ACC.i.x) - ( vuDouble(VU->VF[_Fs_].i.x) * vuDouble(VU->VI[REG_Q].UL))); else VU_MACx_CLEAR(VU);
1094     if (_Y) VU->ACC.i.y = VU_MACy_UPDATE(VU, vuDouble(VU->ACC.i.y) - ( vuDouble(VU->VF[_Fs_].i.y) * vuDouble(VU->VI[REG_Q].UL))); else VU_MACy_CLEAR(VU);
1095     if (_Z) VU->ACC.i.z = VU_MACz_UPDATE(VU, vuDouble(VU->ACC.i.z) - ( vuDouble(VU->VF[_Fs_].i.z) * vuDouble(VU->VI[REG_Q].UL))); else VU_MACz_CLEAR(VU);
1096     if (_W) VU->ACC.i.w = VU_MACw_UPDATE(VU, vuDouble(VU->ACC.i.w) - ( vuDouble(VU->VF[_Fs_].i.w) * vuDouble(VU->VI[REG_Q].UL))); else VU_MACw_CLEAR(VU);
1097     VU_STAT_UPDATE(VU);
1098     }/*last updated 11/05/03 shadow*/
1099    
1100 william 62 static __fi void _vuMSUBAx(VURegs * VU) {
1101 william 31 float tx = vuDouble(VU->VF[_Ft_].i.x);
1102    
1103     if (_X) VU->ACC.i.x = VU_MACx_UPDATE(VU, vuDouble(VU->ACC.i.x) - ( vuDouble(VU->VF[_Fs_].i.x) * tx)); else VU_MACx_CLEAR(VU);
1104     if (_Y) VU->ACC.i.y = VU_MACy_UPDATE(VU, vuDouble(VU->ACC.i.y) - ( vuDouble(VU->VF[_Fs_].i.y) * tx)); else VU_MACy_CLEAR(VU);
1105     if (_Z) VU->ACC.i.z = VU_MACz_UPDATE(VU, vuDouble(VU->ACC.i.z) - ( vuDouble(VU->VF[_Fs_].i.z) * tx)); else VU_MACz_CLEAR(VU);
1106     if (_W) VU->ACC.i.w = VU_MACw_UPDATE(VU, vuDouble(VU->ACC.i.w) - ( vuDouble(VU->VF[_Fs_].i.w) * tx)); else VU_MACw_CLEAR(VU);
1107     VU_STAT_UPDATE(VU);
1108     }/*last updated 11/05/03 shadow*/
1109    
1110 william 62 static __fi void _vuMSUBAy(VURegs * VU) {
1111 william 31 float ty = vuDouble(VU->VF[_Ft_].i.y);
1112    
1113     if (_X) VU->ACC.i.x = VU_MACx_UPDATE(VU, vuDouble(VU->ACC.i.x) - ( vuDouble(VU->VF[_Fs_].i.x) * ty)); else VU_MACx_CLEAR(VU);
1114     if (_Y) VU->ACC.i.y = VU_MACy_UPDATE(VU, vuDouble(VU->ACC.i.y) - ( vuDouble(VU->VF[_Fs_].i.y) * ty)); else VU_MACy_CLEAR(VU);
1115     if (_Z) VU->ACC.i.z = VU_MACz_UPDATE(VU, vuDouble(VU->ACC.i.z) - ( vuDouble(VU->VF[_Fs_].i.z) * ty)); else VU_MACz_CLEAR(VU);
1116     if (_W) VU->ACC.i.w = VU_MACw_UPDATE(VU, vuDouble(VU->ACC.i.w) - ( vuDouble(VU->VF[_Fs_].i.w) * ty)); else VU_MACw_CLEAR(VU);
1117     VU_STAT_UPDATE(VU);
1118     }/*last updated 11/05/03 shadow*/
1119    
1120 william 62 static __fi void _vuMSUBAz(VURegs * VU) {
1121 william 31 float tz = vuDouble(VU->VF[_Ft_].i.z);
1122    
1123     if (_X) VU->ACC.i.x = VU_MACx_UPDATE(VU, vuDouble(VU->ACC.i.x) - ( vuDouble(VU->VF[_Fs_].i.x) * tz)); else VU_MACx_CLEAR(VU);
1124     if (_Y) VU->ACC.i.y = VU_MACy_UPDATE(VU, vuDouble(VU->ACC.i.y) - ( vuDouble(VU->VF[_Fs_].i.y) * tz)); else VU_MACy_CLEAR(VU);
1125     if (_Z) VU->ACC.i.z = VU_MACz_UPDATE(VU, vuDouble(VU->ACC.i.z) - ( vuDouble(VU->VF[_Fs_].i.z) * tz)); else VU_MACz_CLEAR(VU);
1126     if (_W) VU->ACC.i.w = VU_MACw_UPDATE(VU, vuDouble(VU->ACC.i.w) - ( vuDouble(VU->VF[_Fs_].i.w) * tz)); else VU_MACw_CLEAR(VU);
1127     VU_STAT_UPDATE(VU);
1128     }/*last updated 11/05/03 shadow*/
1129    
1130 william 62 static __fi void _vuMSUBAw(VURegs * VU) {
1131 william 31 float tw = vuDouble(VU->VF[_Ft_].i.w);
1132    
1133     if (_X) VU->ACC.i.x = VU_MACx_UPDATE(VU, vuDouble(VU->ACC.i.x) - ( vuDouble(VU->VF[_Fs_].i.x) * tw)); else VU_MACx_CLEAR(VU);
1134     if (_Y) VU->ACC.i.y = VU_MACy_UPDATE(VU, vuDouble(VU->ACC.i.y) - ( vuDouble(VU->VF[_Fs_].i.y) * tw)); else VU_MACy_CLEAR(VU);
1135     if (_Z) VU->ACC.i.z = VU_MACz_UPDATE(VU, vuDouble(VU->ACC.i.z) - ( vuDouble(VU->VF[_Fs_].i.z) * tw)); else VU_MACz_CLEAR(VU);
1136     if (_W) VU->ACC.i.w = VU_MACw_UPDATE(VU, vuDouble(VU->ACC.i.w) - ( vuDouble(VU->VF[_Fs_].i.w) * tw)); else VU_MACw_CLEAR(VU);
1137     VU_STAT_UPDATE(VU);
1138     }/*last updated 11/05/03 shadow*/
1139    
1140     u32 _MAX(u32 a, u32 b) {
1141     if (a & 0x80000000) { // -a
1142     if (b & 0x80000000) { // -b
1143     return (a & 0x7fffffff) > (b & 0x7fffffff) ? b : a;
1144     } else { // +b
1145     return b;
1146     }
1147     } else { // +a
1148     if (b & 0x80000000) { // -b
1149     return a;
1150     } else { // +b
1151     return (a & 0x7fffffff) > (b & 0x7fffffff) ? a : b;
1152     }
1153     }
1154    
1155     return 0;
1156     }
1157    
1158 william 62 static __fi void _vuMAX(VURegs * VU) {
1159 william 31 if (_Fd_ == 0) return;
1160    
1161     /* ft is bc */
1162     if (_X) VU->VF[_Fd_].i.x = _MAX(VU->VF[_Fs_].i.x, (s32)VU->VF[_Ft_].i.x);
1163     if (_Y) VU->VF[_Fd_].i.y = _MAX(VU->VF[_Fs_].i.y, (s32)VU->VF[_Ft_].i.y);
1164     if (_Z) VU->VF[_Fd_].i.z = _MAX(VU->VF[_Fs_].i.z, (s32)VU->VF[_Ft_].i.z);
1165     if (_W) VU->VF[_Fd_].i.w = _MAX(VU->VF[_Fs_].i.w, (s32)VU->VF[_Ft_].i.w);
1166     }//checked 13/05/03 shadow
1167    
1168 william 62 static __fi void _vuMAXi(VURegs * VU) {
1169 william 31 if (_Fd_ == 0) return;
1170    
1171     /* ft is bc */
1172     if (_X) VU->VF[_Fd_].i.x = _MAX(VU->VF[_Fs_].i.x, VU->VI[REG_I].UL);
1173     if (_Y) VU->VF[_Fd_].i.y = _MAX(VU->VF[_Fs_].i.y, VU->VI[REG_I].UL);
1174     if (_Z) VU->VF[_Fd_].i.z = _MAX(VU->VF[_Fs_].i.z, VU->VI[REG_I].UL);
1175     if (_W) VU->VF[_Fd_].i.w = _MAX(VU->VF[_Fs_].i.w, VU->VI[REG_I].UL);
1176     }//checked 13/05/03 shadow
1177    
1178 william 62 static __fi void _vuMAXx(VURegs * VU) {
1179 william 31 s32 ftx;
1180     if (_Fd_ == 0) return;
1181    
1182     ftx=(s32)VU->VF[_Ft_].i.x;
1183     if (_X) VU->VF[_Fd_].i.x = _MAX(VU->VF[_Fs_].i.x, ftx);
1184     if (_Y) VU->VF[_Fd_].i.y = _MAX(VU->VF[_Fs_].i.y, ftx);
1185     if (_Z) VU->VF[_Fd_].i.z = _MAX(VU->VF[_Fs_].i.z, ftx);
1186     if (_W) VU->VF[_Fd_].i.w = _MAX(VU->VF[_Fs_].i.w, ftx);
1187     }
1188     //checked 13/05/03 shadow
1189    
1190 william 62 static __fi void _vuMAXy(VURegs * VU) {
1191 william 31 s32 fty;
1192     if (_Fd_ == 0) return;
1193    
1194     fty=(s32)VU->VF[_Ft_].i.y;
1195     if (_X) VU->VF[_Fd_].i.x = _MAX(VU->VF[_Fs_].i.x, fty);
1196     if (_Y) VU->VF[_Fd_].i.y = _MAX(VU->VF[_Fs_].i.y, fty);
1197     if (_Z) VU->VF[_Fd_].i.z = _MAX(VU->VF[_Fs_].i.z, fty);
1198     if (_W) VU->VF[_Fd_].i.w = _MAX(VU->VF[_Fs_].i.w, fty);
1199     }//checked 13/05/03 shadow
1200    
1201 william 62 static __fi void _vuMAXz(VURegs * VU) {
1202 william 31 s32 ftz;
1203     if (_Fd_ == 0) return;
1204    
1205     ftz=(s32)VU->VF[_Ft_].i.z;
1206     if (_X) VU->VF[_Fd_].i.x = _MAX(VU->VF[_Fs_].i.x, ftz);
1207     if (_Y) VU->VF[_Fd_].i.y = _MAX(VU->VF[_Fs_].i.y, ftz);
1208     if (_Z) VU->VF[_Fd_].i.z = _MAX(VU->VF[_Fs_].i.z, ftz);
1209     if (_W) VU->VF[_Fd_].i.w = _MAX(VU->VF[_Fs_].i.w, ftz);
1210     }
1211    
1212 william 62 static __fi void _vuMAXw(VURegs * VU) {
1213 william 31 s32 ftw;
1214     if (_Fd_ == 0) return;
1215    
1216     ftw=(s32)VU->VF[_Ft_].i.w;
1217     if (_X) VU->VF[_Fd_].i.x = _MAX(VU->VF[_Fs_].i.x, ftw);
1218     if (_Y) VU->VF[_Fd_].i.y = _MAX(VU->VF[_Fs_].i.y, ftw);
1219     if (_Z) VU->VF[_Fd_].i.z = _MAX(VU->VF[_Fs_].i.z, ftw);
1220     if (_W) VU->VF[_Fd_].i.w = _MAX(VU->VF[_Fs_].i.w, ftw);
1221     }
1222    
1223     u32 _MINI(u32 a, u32 b) {
1224     if (a & 0x80000000) { // -a
1225     if (b & 0x80000000) { // -b
1226     return (a & 0x7fffffff) < (b & 0x7fffffff) ? b : a;
1227     } else { // +b
1228     return a;
1229     }
1230     } else { // +a
1231     if (b & 0x80000000) { // -b
1232     return b;
1233     } else { // +b
1234     return (a & 0x7fffffff) < (b & 0x7fffffff) ? a : b;
1235     }
1236     }
1237    
1238     return 0;
1239     }
1240    
1241 william 62 static __fi void _vuMINI(VURegs * VU) {
1242 william 31 if (_Fd_ == 0) return;
1243    
1244     /* ft is bc */
1245     if (_X) VU->VF[_Fd_].i.x = _MINI(VU->VF[_Fs_].i.x, (s32)VU->VF[_Ft_].i.x);
1246     if (_Y) VU->VF[_Fd_].i.y = _MINI(VU->VF[_Fs_].i.y, (s32)VU->VF[_Ft_].i.y);
1247     if (_Z) VU->VF[_Fd_].i.z = _MINI(VU->VF[_Fs_].i.z, (s32)VU->VF[_Ft_].i.z);
1248     if (_W) VU->VF[_Fd_].i.w = _MINI(VU->VF[_Fs_].i.w, (s32)VU->VF[_Ft_].i.w);
1249     }//checked 13/05/03 shadow
1250    
1251 william 62 static __fi void _vuMINIi(VURegs * VU) {
1252 william 31 if (_Fd_ == 0) return;
1253    
1254     /* ft is bc */
1255     if (_X) VU->VF[_Fd_].i.x = _MINI(VU->VF[_Fs_].i.x, VU->VI[REG_I].UL);
1256     if (_Y) VU->VF[_Fd_].i.y = _MINI(VU->VF[_Fs_].i.y, VU->VI[REG_I].UL);
1257     if (_Z) VU->VF[_Fd_].i.z = _MINI(VU->VF[_Fs_].i.z, VU->VI[REG_I].UL);
1258     if (_W) VU->VF[_Fd_].i.w = _MINI(VU->VF[_Fs_].i.w, VU->VI[REG_I].UL);
1259     }//checked 13/05/03 shadow
1260    
1261 william 62 static __fi void _vuMINIx(VURegs * VU) {
1262 william 31 s32 ftx;
1263     if (_Fd_ == 0) return;
1264    
1265     ftx=(s32)VU->VF[_Ft_].i.x;
1266     if (_X) VU->VF[_Fd_].i.x = _MINI(VU->VF[_Fs_].i.x, ftx);
1267     if (_Y) VU->VF[_Fd_].i.y = _MINI(VU->VF[_Fs_].i.y, ftx);
1268     if (_Z) VU->VF[_Fd_].i.z = _MINI(VU->VF[_Fs_].i.z, ftx);
1269     if (_W) VU->VF[_Fd_].i.w = _MINI(VU->VF[_Fs_].i.w, ftx);
1270     }
1271     //checked 13/05/03 shadow
1272    
1273 william 62 static __fi void _vuMINIy(VURegs * VU) {
1274 william 31 s32 fty;
1275     if (_Fd_ == 0) return;
1276    
1277     fty=(s32)VU->VF[_Ft_].i.y;
1278     if (_X) VU->VF[_Fd_].i.x = _MINI(VU->VF[_Fs_].i.x, fty);
1279     if (_Y) VU->VF[_Fd_].i.y = _MINI(VU->VF[_Fs_].i.y, fty);
1280     if (_Z) VU->VF[_Fd_].i.z = _MINI(VU->VF[_Fs_].i.z, fty);
1281     if (_W) VU->VF[_Fd_].i.w = _MINI(VU->VF[_Fs_].i.w, fty);
1282     }//checked 13/05/03 shadow
1283    
1284 william 62 static __fi void _vuMINIz(VURegs * VU) {
1285 william 31 s32 ftz;
1286     if (_Fd_ == 0) return;
1287    
1288     ftz=(s32)VU->VF[_Ft_].i.z;
1289     if (_X) VU->VF[_Fd_].i.x = _MINI(VU->VF[_Fs_].i.x, ftz);
1290     if (_Y) VU->VF[_Fd_].i.y = _MINI(VU->VF[_Fs_].i.y, ftz);
1291     if (_Z) VU->VF[_Fd_].i.z = _MINI(VU->VF[_Fs_].i.z, ftz);
1292     if (_W) VU->VF[_Fd_].i.w = _MINI(VU->VF[_Fs_].i.w, ftz);
1293     }
1294    
1295 william 62 static __fi void _vuMINIw(VURegs * VU) {
1296 william 31 s32 ftw;
1297     if (_Fd_ == 0) return;
1298    
1299     ftw=(s32)VU->VF[_Ft_].i.w;
1300     if (_X) VU->VF[_Fd_].i.x = _MINI(VU->VF[_Fs_].i.x, ftw);
1301     if (_Y) VU->VF[_Fd_].i.y = _MINI(VU->VF[_Fs_].i.y, ftw);
1302     if (_Z) VU->VF[_Fd_].i.z = _MINI(VU->VF[_Fs_].i.z, ftw);
1303     if (_W) VU->VF[_Fd_].i.w = _MINI(VU->VF[_Fs_].i.w, ftw);
1304     }
1305    
1306 william 62 static __fi void _vuOPMULA(VURegs * VU) {
1307 william 31 VU->ACC.i.x = VU_MACx_UPDATE(VU, vuDouble(VU->VF[_Fs_].i.y) * vuDouble(VU->VF[_Ft_].i.z));
1308     VU->ACC.i.y = VU_MACy_UPDATE(VU, vuDouble(VU->VF[_Fs_].i.z) * vuDouble(VU->VF[_Ft_].i.x));
1309     VU->ACC.i.z = VU_MACz_UPDATE(VU, vuDouble(VU->VF[_Fs_].i.x) * vuDouble(VU->VF[_Ft_].i.y));
1310     VU_STAT_UPDATE(VU);
1311     }/*last updated 8/05/03 shadow*/
1312    
1313 william 62 static __fi void _vuOPMSUB(VURegs * VU) {
1314 william 31 VECTOR * dst;
1315     float ftx, fty, ftz;
1316     float fsx, fsy, fsz;
1317     if (_Fd_ == 0)
1318     dst = &RDzero;
1319     else
1320     dst = &VU->VF[_Fd_];
1321    
1322     ftx = vuDouble(VU->VF[_Ft_].i.x); fty = vuDouble(VU->VF[_Ft_].i.y); ftz = vuDouble(VU->VF[_Ft_].i.z);
1323     fsx = vuDouble(VU->VF[_Fs_].i.x); fsy = vuDouble(VU->VF[_Fs_].i.y); fsz = vuDouble(VU->VF[_Fs_].i.z);
1324     dst->i.x = VU_MACx_UPDATE(VU, vuDouble(VU->ACC.i.x) - fsy * ftz);
1325     dst->i.y = VU_MACy_UPDATE(VU, vuDouble(VU->ACC.i.y) - fsz * ftx);
1326     dst->i.z = VU_MACz_UPDATE(VU, vuDouble(VU->ACC.i.z) - fsx * fty);
1327     VU_STAT_UPDATE(VU);
1328     }/*last updated 8/05/03 shadow*/
1329    
1330 william 62 static __fi void _vuNOP(VURegs * VU) {
1331 william 31 }
1332    
1333 william 62 static __fi void _vuFTOI0(VURegs * VU) {
1334 william 31 if (_Ft_ == 0) return;
1335    
1336     if (_X) VU->VF[_Ft_].SL[0] = (s32)vuDouble(VU->VF[_Fs_].i.x);
1337     if (_Y) VU->VF[_Ft_].SL[1] = (s32)vuDouble(VU->VF[_Fs_].i.y);
1338     if (_Z) VU->VF[_Ft_].SL[2] = (s32)vuDouble(VU->VF[_Fs_].i.z);
1339     if (_W) VU->VF[_Ft_].SL[3] = (s32)vuDouble(VU->VF[_Fs_].i.w);
1340     }
1341    
1342 william 62 static __fi void _vuFTOI4(VURegs * VU) {
1343 william 31 if (_Ft_ == 0) return;
1344    
1345     if (_X) VU->VF[_Ft_].SL[0] = float_to_int4(vuDouble(VU->VF[_Fs_].i.x));
1346     if (_Y) VU->VF[_Ft_].SL[1] = float_to_int4(vuDouble(VU->VF[_Fs_].i.y));
1347     if (_Z) VU->VF[_Ft_].SL[2] = float_to_int4(vuDouble(VU->VF[_Fs_].i.z));
1348     if (_W) VU->VF[_Ft_].SL[3] = float_to_int4(vuDouble(VU->VF[_Fs_].i.w));
1349     }
1350    
1351 william 62 static __fi void _vuFTOI12(VURegs * VU) {
1352 william 31 if (_Ft_ == 0) return;
1353    
1354     if (_X) VU->VF[_Ft_].SL[0] = float_to_int12(vuDouble(VU->VF[_Fs_].i.x));
1355     if (_Y) VU->VF[_Ft_].SL[1] = float_to_int12(vuDouble(VU->VF[_Fs_].i.y));
1356     if (_Z) VU->VF[_Ft_].SL[2] = float_to_int12(vuDouble(VU->VF[_Fs_].i.z));
1357     if (_W) VU->VF[_Ft_].SL[3] = float_to_int12(vuDouble(VU->VF[_Fs_].i.w));
1358     }
1359    
1360 william 62 static __fi void _vuFTOI15(VURegs * VU) {
1361 william 31 if (_Ft_ == 0) return;
1362    
1363     if (_X) VU->VF[_Ft_].SL[0] = float_to_int15(vuDouble(VU->VF[_Fs_].i.x));
1364     if (_Y) VU->VF[_Ft_].SL[1] = float_to_int15(vuDouble(VU->VF[_Fs_].i.y));
1365     if (_Z) VU->VF[_Ft_].SL[2] = float_to_int15(vuDouble(VU->VF[_Fs_].i.z));
1366     if (_W) VU->VF[_Ft_].SL[3] = float_to_int15(vuDouble(VU->VF[_Fs_].i.w));
1367     }
1368    
1369 william 62 static __fi void _vuITOF0(VURegs * VU) {
1370 william 31 if (_Ft_ == 0) return;
1371    
1372     if (_X) VU->VF[_Ft_].f.x = (float)VU->VF[_Fs_].SL[0];
1373     if (_Y) VU->VF[_Ft_].f.y = (float)VU->VF[_Fs_].SL[1];
1374     if (_Z) VU->VF[_Ft_].f.z = (float)VU->VF[_Fs_].SL[2];
1375     if (_W) VU->VF[_Ft_].f.w = (float)VU->VF[_Fs_].SL[3];
1376     }
1377    
1378 william 62 static __fi void _vuITOF4(VURegs * VU) {
1379 william 31 if (_Ft_ == 0) return;
1380    
1381     if (_X) VU->VF[_Ft_].f.x = int4_to_float(VU->VF[_Fs_].SL<