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