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

Diff of /trunk/pcsx2/VUops.cpp

Parent Directory Parent Directory | Revision Log Revision Log | View Patch Patch

revision 31 by william, Tue Sep 7 03:24:11 2010 UTC revision 62 by william, Tue Sep 7 11:08:22 2010 UTC
# Line 15  Line 15 
15    
16  #include "PrecompiledHeader.h"  #include "PrecompiledHeader.h"
17  #include "Common.h"  #include "Common.h"
   
 #include <cmath>  
   
18  #include "VUops.h"  #include "VUops.h"
19  #include "GS.h"  #include "GS.h"
20    
21    #include <cmath>
22    
23  //Lower/Upper instructions can use that..  //Lower/Upper instructions can use that..
24  #define _Ft_ ((VU->code >> 16) & 0x1F)  // The rt part of the instruction register  #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  #define _Fs_ ((VU->code >> 11) & 0x1F)  // The rd part of the instruction register
# Line 45  Line 44 
44    
45  static __aligned16 VECTOR RDzero;  static __aligned16 VECTOR RDzero;
46    
47  static __releaseinline void __fastcall _vuFMACflush(VURegs * VU) {  static __ri void _vuFMACflush(VURegs * VU) {
48          int i;          int i;
49    
50          for (i=0; i<8; i++) {          for (i=0; i<8; i++) {
# Line 62  static __releaseinline void __fastcall _ Line 61  static __releaseinline void __fastcall _
61          }          }
62  }  }
63    
64  static __releaseinline void __fastcall _vuFDIVflush(VURegs * VU) {  static __ri void _vuFDIVflush(VURegs * VU) {
65          if (VU->fdiv.enable == 0) return;          if (VU->fdiv.enable == 0) return;
66    
67          if ((VU->cycle - VU->fdiv.sCycle) >= VU->fdiv.Cycle) {          if ((VU->cycle - VU->fdiv.sCycle) >= VU->fdiv.Cycle) {
# Line 74  static __releaseinline void __fastcall _ Line 73  static __releaseinline void __fastcall _
73          }          }
74  }  }
75    
76  static __releaseinline void __fastcall _vuEFUflush(VURegs * VU) {  static __ri void _vuEFUflush(VURegs * VU) {
77          if (VU->efu.enable == 0) return;          if (VU->efu.enable == 0) return;
78    
79          if ((VU->cycle - VU->efu.sCycle) >= VU->efu.Cycle) {          if ((VU->cycle - VU->efu.sCycle) >= VU->efu.Cycle) {
# Line 140  void _vuFlushAll(VURegs* VU) Line 139  void _vuFlushAll(VURegs* VU)
139          } while(nRepeat);          } while(nRepeat);
140  }  }
141    
142  __forceinline void _vuTestPipes(VURegs * VU) {  __fi void _vuTestPipes(VURegs * VU) {
143          _vuFMACflush(VU);          _vuFMACflush(VU);
144          _vuFDIVflush(VU);          _vuFDIVflush(VU);
145          _vuEFUflush(VU);          _vuEFUflush(VU);
# Line 169  static void __fastcall _vuFMACTestStall( Line 168  static void __fastcall _vuFMACTestStall(
168          _vuTestPipes(VU);          _vuTestPipes(VU);
169  }  }
170    
171  static __releaseinline void __fastcall _vuFMACAdd(VURegs * VU, int reg, int xyzw) {  static __ri void __fastcall _vuFMACAdd(VURegs * VU, int reg, int xyzw) {
172          int i;          int i;
173    
174          /* find a free fmac pipe */          /* find a free fmac pipe */
# Line 192  static __releaseinline void __fastcall _ Line 191  static __releaseinline void __fastcall _
191          VU->fmac[i].clipflag = VU->clipflag;          VU->fmac[i].clipflag = VU->clipflag;
192  }  }
193    
194  static __releaseinline void __fastcall _vuFDIVAdd(VURegs * VU, int cycles) {  static __ri void __fastcall _vuFDIVAdd(VURegs * VU, int cycles) {
195          VUM_LOG("adding FDIV pipe");          VUM_LOG("adding FDIV pipe");
196    
197          VU->fdiv.enable = 1;          VU->fdiv.enable = 1;
# Line 202  static __releaseinline void __fastcall _ Line 201  static __releaseinline void __fastcall _
201          VU->fdiv.statusflag = VU->statusflag;          VU->fdiv.statusflag = VU->statusflag;
202  }  }
203    
204  static __releaseinline void __fastcall _vuEFUAdd(VURegs * VU, int cycles) {  static __ri void __fastcall _vuEFUAdd(VURegs * VU, int cycles) {
205  //      VUM_LOG("adding EFU pipe\n");  //      VUM_LOG("adding EFU pipe\n");
206    
207          VU->efu.enable = 1;          VU->efu.enable = 1;
# Line 211  static __releaseinline void __fastcall _ Line 210  static __releaseinline void __fastcall _
210          VU->efu.reg.F  = VU->p.F;          VU->efu.reg.F  = VU->p.F;
211  }  }
212    
213  static __releaseinline void __fastcall _vuFlushFDIV(VURegs * VU) {  static __ri void __fastcall _vuFlushFDIV(VURegs * VU) {
214          int cycle;          int cycle;
215    
216          if (VU->fdiv.enable == 0) return;          if (VU->fdiv.enable == 0) return;
# Line 225  static __releaseinline void __fastcall _ Line 224  static __releaseinline void __fastcall _
224          VU->VI[REG_STATUS_FLAG].UL = VU->fdiv.statusflag;          VU->VI[REG_STATUS_FLAG].UL = VU->fdiv.statusflag;
225  }  }
226    
227  static __releaseinline void __fastcall _vuFlushEFU(VURegs * VU) {  static __ri void __fastcall _vuFlushEFU(VURegs * VU) {
228          int cycle;          int cycle;
229    
230          if (VU->efu.enable == 0) return;          if (VU->efu.enable == 0) return;
# Line 238  static __releaseinline void __fastcall _ Line 237  static __releaseinline void __fastcall _
237          VU->VI[REG_P].UL = VU->efu.reg.UL;          VU->VI[REG_P].UL = VU->efu.reg.UL;
238  }  }
239    
240  __forceinline void _vuTestFMACStalls(VURegs * VU, _VURegsNum *VUregsn) {  static __fi void _vuTestFMACStalls(VURegs * VU, _VURegsNum *VUregsn) {
241          if (VUregsn->VFread0) {          if (VUregsn->VFread0) {
242                  _vuFMACTestStall(VU, VUregsn->VFread0, VUregsn->VFr0xyzw);                  _vuFMACTestStall(VU, VUregsn->VFread0, VUregsn->VFr0xyzw);
243          }          }
# Line 247  __forceinline void _vuTestFMACStalls(VUR Line 246  __forceinline void _vuTestFMACStalls(VUR
246          }          }
247  }  }
248    
249  __forceinline void _vuAddFMACStalls(VURegs * VU, _VURegsNum *VUregsn) {  static __fi void _vuAddFMACStalls(VURegs * VU, _VURegsNum *VUregsn) {
250          if (VUregsn->VFwrite) {          if (VUregsn->VFwrite) {
251                  _vuFMACAdd(VU, VUregsn->VFwrite, VUregsn->VFwxyzw);                  _vuFMACAdd(VU, VUregsn->VFwrite, VUregsn->VFwxyzw);
252          } else          } else
# Line 258  __forceinline void _vuAddFMACStalls(VURe Line 257  __forceinline void _vuAddFMACStalls(VURe
257          }          }
258  }  }
259    
260  __forceinline void _vuTestFDIVStalls(VURegs * VU, _VURegsNum *VUregsn) {  static __fi void _vuTestFDIVStalls(VURegs * VU, _VURegsNum *VUregsn) {
261  //      _vuTestFMACStalls(VURegs * VU, _VURegsNum *VUregsn);  //      _vuTestFMACStalls(VURegs * VU, _VURegsNum *VUregsn);
262          _vuFlushFDIV(VU);          _vuFlushFDIV(VU);
263  }  }
264    
265  __forceinline void _vuAddFDIVStalls(VURegs * VU, _VURegsNum *VUregsn) {  static __fi void _vuAddFDIVStalls(VURegs * VU, _VURegsNum *VUregsn) {
266          if (VUregsn->VIwrite & (1 << REG_Q)) {          if (VUregsn->VIwrite & (1 << REG_Q)) {
267                  _vuFDIVAdd(VU, VUregsn->cycles);                  _vuFDIVAdd(VU, VUregsn->cycles);
268          }          }
269  }  }
270    
271    
272  __forceinline void _vuTestEFUStalls(VURegs * VU, _VURegsNum *VUregsn) {  static __fi void _vuTestEFUStalls(VURegs * VU, _VURegsNum *VUregsn) {
273  //      _vuTestFMACStalls(VURegs * VU, _VURegsNum *VUregsn);  //      _vuTestFMACStalls(VURegs * VU, _VURegsNum *VUregsn);
274          _vuFlushEFU(VU);          _vuFlushEFU(VU);
275  }  }
276    
277  __forceinline void _vuAddEFUStalls(VURegs * VU, _VURegsNum *VUregsn) {  static __fi void _vuAddEFUStalls(VURegs * VU, _VURegsNum *VUregsn) {
278          if (VUregsn->VIwrite & (1 << REG_P)) {          if (VUregsn->VIwrite & (1 << REG_P)) {
279                  _vuEFUAdd(VU, VUregsn->cycles);                  _vuEFUAdd(VU, VUregsn->cycles);
280          }          }
281  }  }
282    
283  __forceinline void _vuTestUpperStalls(VURegs * VU, _VURegsNum *VUregsn) {  __fi void _vuTestUpperStalls(VURegs * VU, _VURegsNum *VUregsn) {
284          switch (VUregsn->pipe) {          switch (VUregsn->pipe) {
285                  case VUPIPE_FMAC: _vuTestFMACStalls(VU, VUregsn); break;                  case VUPIPE_FMAC: _vuTestFMACStalls(VU, VUregsn); break;
286          }          }
287  }  }
288    
289  __forceinline void _vuTestLowerStalls(VURegs * VU, _VURegsNum *VUregsn) {  __fi void _vuTestLowerStalls(VURegs * VU, _VURegsNum *VUregsn) {
290          switch (VUregsn->pipe) {          switch (VUregsn->pipe) {
291                  case VUPIPE_FMAC: _vuTestFMACStalls(VU, VUregsn); break;                  case VUPIPE_FMAC: _vuTestFMACStalls(VU, VUregsn); break;
292                  case VUPIPE_FDIV: _vuTestFDIVStalls(VU, VUregsn); break;                  case VUPIPE_FDIV: _vuTestFDIVStalls(VU, VUregsn); break;
# Line 295  __forceinline void _vuTestLowerStalls(VU Line 294  __forceinline void _vuTestLowerStalls(VU
294          }          }
295  }  }
296    
297  __forceinline void _vuAddUpperStalls(VURegs * VU, _VURegsNum *VUregsn) {  __fi void _vuAddUpperStalls(VURegs * VU, _VURegsNum *VUregsn) {
298          switch (VUregsn->pipe) {          switch (VUregsn->pipe) {
299                  case VUPIPE_FMAC: _vuAddFMACStalls(VU, VUregsn); break;                  case VUPIPE_FMAC: _vuAddFMACStalls(VU, VUregsn); break;
300          }          }
301  }  }
302    
303  __forceinline void _vuAddLowerStalls(VURegs * VU, _VURegsNum *VUregsn) {  __fi void _vuAddLowerStalls(VURegs * VU, _VURegsNum *VUregsn) {
304          switch (VUregsn->pipe) {          switch (VUregsn->pipe) {
305                  case VUPIPE_FMAC: _vuAddFMACStalls(VU, VUregsn); break;                  case VUPIPE_FMAC: _vuAddFMACStalls(VU, VUregsn); break;
306                  case VUPIPE_FDIV: _vuAddFDIVStalls(VU, VUregsn); break;                  case VUPIPE_FDIV: _vuAddFDIVStalls(VU, VUregsn); break;
# Line 332  static float __fastcall vuDouble(u32 f) Line 331  static float __fastcall vuDouble(u32 f)
331          return *(float*)&f;          return *(float*)&f;
332  }  }
333  #else  #else
334  static __forceinline float vuDouble(u32 f)  static __fi float vuDouble(u32 f)
335  {  {
336          return *(float*)&f;          return *(float*)&f;
337  }  }
# Line 348  void _vuABS(VURegs * VU) { Line 347  void _vuABS(VURegs * VU) {
347  }/*Reworked from define to function. asadr*/  }/*Reworked from define to function. asadr*/
348    
349    
350  void _vuADD(VURegs * VU) {  static __fi void _vuADD(VURegs * VU) {
351          VECTOR * dst;          VECTOR * dst;
352          if (_Fd_ == 0) dst = &RDzero;          if (_Fd_ == 0) dst = &RDzero;
353          else dst = &VU->VF[_Fd_];          else dst = &VU->VF[_Fd_];
# Line 361  void _vuADD(VURegs * VU) { Line 360  void _vuADD(VURegs * VU) {
360  }/*Reworked from define to function. asadr*/  }/*Reworked from define to function. asadr*/
361    
362    
363  void _vuADDi(VURegs * VU) {  static __fi void _vuADDi(VURegs * VU) {
364          VECTOR * dst;          VECTOR * dst;
365          if (_Fd_ == 0) dst = &RDzero;          if (_Fd_ == 0) dst = &RDzero;
366          else dst = &VU->VF[_Fd_];          else dst = &VU->VF[_Fd_];
# Line 373  void _vuADDi(VURegs * VU) { Line 372  void _vuADDi(VURegs * VU) {
372          VU_STAT_UPDATE(VU);          VU_STAT_UPDATE(VU);
373  }/*Reworked from define to function. asadr*/  }/*Reworked from define to function. asadr*/
374    
375  void _vuADDq(VURegs * VU) {  static __fi void _vuADDq(VURegs * VU) {
376          VECTOR * dst;          VECTOR * dst;
377          if (_Fd_ == 0) dst = &RDzero;          if (_Fd_ == 0) dst = &RDzero;
378          else dst = &VU->VF[_Fd_];          else dst = &VU->VF[_Fd_];
# Line 386  void _vuADDq(VURegs * VU) { Line 385  void _vuADDq(VURegs * VU) {
385  }/*Reworked from define to function. asadr*/  }/*Reworked from define to function. asadr*/
386    
387    
388  void _vuADDx(VURegs * VU) {  static __fi void _vuADDx(VURegs * VU) {
389          float ftx;          float ftx;
390          VECTOR * dst;          VECTOR * dst;
391      if (_Fd_ == 0) dst = &RDzero;      if (_Fd_ == 0) dst = &RDzero;
# Line 400  void _vuADDx(VURegs * VU) { Line 399  void _vuADDx(VURegs * VU) {
399          VU_STAT_UPDATE(VU);          VU_STAT_UPDATE(VU);
400  }/*Reworked from define to function. asadr*/  }/*Reworked from define to function. asadr*/
401    
402  void _vuADDy(VURegs * VU) {  static __fi void _vuADDy(VURegs * VU) {
403          float fty;          float fty;
404          VECTOR * dst;          VECTOR * dst;
405      if (_Fd_ == 0) dst = &RDzero;      if (_Fd_ == 0) dst = &RDzero;
# Line 414  void _vuADDy(VURegs * VU) { Line 413  void _vuADDy(VURegs * VU) {
413          VU_STAT_UPDATE(VU);          VU_STAT_UPDATE(VU);
414  }/*Reworked from define to function. asadr*/  }/*Reworked from define to function. asadr*/
415    
416  void _vuADDz(VURegs * VU) {  static __fi void _vuADDz(VURegs * VU) {
417          float ftz;          float ftz;
418          VECTOR * dst;          VECTOR * dst;
419      if (_Fd_ == 0) dst = &RDzero;      if (_Fd_ == 0) dst = &RDzero;
# Line 428  void _vuADDz(VURegs * VU) { Line 427  void _vuADDz(VURegs * VU) {
427          VU_STAT_UPDATE(VU);          VU_STAT_UPDATE(VU);
428  }/*Reworked from define to function. asadr*/  }/*Reworked from define to function. asadr*/
429    
430  void _vuADDw(VURegs * VU) {  static __fi void _vuADDw(VURegs * VU) {
431          float ftw;          float ftw;
432          VECTOR * dst;          VECTOR * dst;
433      if (_Fd_ == 0) dst = &RDzero;      if (_Fd_ == 0) dst = &RDzero;
# Line 442  void _vuADDw(VURegs * VU) { Line 441  void _vuADDw(VURegs * VU) {
441          VU_STAT_UPDATE(VU);          VU_STAT_UPDATE(VU);
442  }/*Reworked from define to function. asadr*/  }/*Reworked from define to function. asadr*/
443    
444  void _vuADDA(VURegs * VU) {  static __fi void _vuADDA(VURegs * VU) {
445          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);          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);          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);          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);
# Line 450  void _vuADDA(VURegs * VU) { Line 449  void _vuADDA(VURegs * VU) {
449          VU_STAT_UPDATE(VU);          VU_STAT_UPDATE(VU);
450  }/*Reworked from define to function. asadr*/  }/*Reworked from define to function. asadr*/
451    
452  void _vuADDAi(VURegs * VU) {  static __fi void _vuADDAi(VURegs * VU) {
453          float ti = vuDouble(VU->VI[REG_I].UL);          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);          if (_X){ VU->ACC.i.x = VU_MACx_UPDATE(VU, vuDouble(VU->VF[_Fs_].i.x) + ti); } else VU_MACx_CLEAR(VU);
# Line 460  void _vuADDAi(VURegs * VU) { Line 459  void _vuADDAi(VURegs * VU) {
459          VU_STAT_UPDATE(VU);          VU_STAT_UPDATE(VU);
460  }/*Reworked from define to function. asadr*/  }/*Reworked from define to function. asadr*/
461    
462  void _vuADDAq(VURegs * VU) {  static __fi void _vuADDAq(VURegs * VU) {
463          float tf = vuDouble(VU->VI[REG_Q].UL);          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);          if (_X){ VU->ACC.i.x = VU_MACx_UPDATE(VU, vuDouble(VU->VF[_Fs_].i.x) + tf); } else VU_MACx_CLEAR(VU);
# Line 470  void _vuADDAq(VURegs * VU) { Line 469  void _vuADDAq(VURegs * VU) {
469          VU_STAT_UPDATE(VU);          VU_STAT_UPDATE(VU);
470  }/*Reworked from define to function. asadr*/  }/*Reworked from define to function. asadr*/
471    
472  void _vuADDAx(VURegs * VU) {  static __fi void _vuADDAx(VURegs * VU) {
473          float tx = vuDouble(VU->VF[_Ft_].i.x);          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);          if (_X){ VU->ACC.i.x = VU_MACx_UPDATE(VU, vuDouble(VU->VF[_Fs_].i.x) + tx); } else VU_MACx_CLEAR(VU);
# Line 480  void _vuADDAx(VURegs * VU) { Line 479  void _vuADDAx(VURegs * VU) {
479          VU_STAT_UPDATE(VU);          VU_STAT_UPDATE(VU);
480  }/*Reworked from define to function. asadr*/  }/*Reworked from define to function. asadr*/
481    
482  void _vuADDAy(VURegs * VU) {  static __fi void _vuADDAy(VURegs * VU) {
483          float ty = vuDouble(VU->VF[_Ft_].i.y);          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);          if (_X){ VU->ACC.i.x = VU_MACx_UPDATE(VU, vuDouble(VU->VF[_Fs_].i.x) + ty); } else VU_MACx_CLEAR(VU);
# Line 490  void _vuADDAy(VURegs * VU) { Line 489  void _vuADDAy(VURegs * VU) {
489          VU_STAT_UPDATE(VU);          VU_STAT_UPDATE(VU);
490  }/*Reworked from define to function. asadr*/  }/*Reworked from define to function. asadr*/
491    
492  void _vuADDAz(VURegs * VU) {  static __fi void _vuADDAz(VURegs * VU) {
493          float tz = vuDouble(VU->VF[_Ft_].i.z);          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);          if (_X){ VU->ACC.i.x = VU_MACx_UPDATE(VU, vuDouble(VU->VF[_Fs_].i.x) + tz); } else VU_MACx_CLEAR(VU);
# Line 500  void _vuADDAz(VURegs * VU) { Line 499  void _vuADDAz(VURegs * VU) {
499          VU_STAT_UPDATE(VU);          VU_STAT_UPDATE(VU);
500  }/*Reworked from define to function. asadr*/  }/*Reworked from define to function. asadr*/
501    
502  void _vuADDAw(VURegs * VU) {  static __fi void _vuADDAw(VURegs * VU) {
503          float tw = vuDouble(VU->VF[_Ft_].i.w);          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);          if (_X){ VU->ACC.i.x = VU_MACx_UPDATE(VU, vuDouble(VU->VF[_Fs_].i.x) + tw); } else VU_MACx_CLEAR(VU);
# Line 511  void _vuADDAw(VURegs * VU) { Line 510  void _vuADDAw(VURegs * VU) {
510  }/*Reworked from define to function. asadr*/  }/*Reworked from define to function. asadr*/
511    
512    
513  void _vuSUB(VURegs * VU) {  static __fi void _vuSUB(VURegs * VU) {
514          VECTOR * dst;          VECTOR * dst;
515      if (_Fd_ == 0) dst = &RDzero;      if (_Fd_ == 0) dst = &RDzero;
516          else dst = &VU->VF[_Fd_];          else dst = &VU->VF[_Fd_];
# Line 523  void _vuSUB(VURegs * VU) { Line 522  void _vuSUB(VURegs * VU) {
522          VU_STAT_UPDATE(VU);          VU_STAT_UPDATE(VU);
523  }//updated 10/05/03 shadow  }//updated 10/05/03 shadow
524    
525  void _vuSUBi(VURegs * VU) {  static __fi void _vuSUBi(VURegs * VU) {
526          VECTOR * dst;          VECTOR * dst;
527      if (_Fd_ == 0) dst = &RDzero;      if (_Fd_ == 0) dst = &RDzero;
528          else dst = &VU->VF[_Fd_];          else dst = &VU->VF[_Fd_];
# Line 535  void _vuSUBi(VURegs * VU) { Line 534  void _vuSUBi(VURegs * VU) {
534          VU_STAT_UPDATE(VU);          VU_STAT_UPDATE(VU);
535  }//updated 10/05/03 shadow  }//updated 10/05/03 shadow
536    
537  void _vuSUBq(VURegs * VU) {  static __fi void _vuSUBq(VURegs * VU) {
538          VECTOR * dst;          VECTOR * dst;
539      if (_Fd_ == 0) dst = &RDzero;      if (_Fd_ == 0) dst = &RDzero;
540          else dst = &VU->VF[_Fd_];          else dst = &VU->VF[_Fd_];
# Line 547  void _vuSUBq(VURegs * VU) { Line 546  void _vuSUBq(VURegs * VU) {
546          VU_STAT_UPDATE(VU);          VU_STAT_UPDATE(VU);
547  }//updated 10/05/03 shadow  }//updated 10/05/03 shadow
548    
549  void _vuSUBx(VURegs * VU) {  static __fi void _vuSUBx(VURegs * VU) {
550          float ftx;          float ftx;
551          VECTOR * dst;          VECTOR * dst;
552      if (_Fd_ == 0) dst = &RDzero;      if (_Fd_ == 0) dst = &RDzero;
# Line 561  void _vuSUBx(VURegs * VU) { Line 560  void _vuSUBx(VURegs * VU) {
560          VU_STAT_UPDATE(VU);          VU_STAT_UPDATE(VU);
561  }//updated 10/05/03 shadow  }//updated 10/05/03 shadow
562    
563  void _vuSUBy(VURegs * VU) {  static __fi void _vuSUBy(VURegs * VU) {
564          float fty;          float fty;
565          VECTOR * dst;          VECTOR * dst;
566      if (_Fd_ == 0) dst = &RDzero;      if (_Fd_ == 0) dst = &RDzero;
# Line 575  void _vuSUBy(VURegs * VU) { Line 574  void _vuSUBy(VURegs * VU) {
574          VU_STAT_UPDATE(VU);          VU_STAT_UPDATE(VU);
575  }//updated 10/05/03 shadow  }//updated 10/05/03 shadow
576    
577  void _vuSUBz(VURegs * VU) {  static __fi void _vuSUBz(VURegs * VU) {
578          float ftz;          float ftz;
579          VECTOR * dst;          VECTOR * dst;
580      if (_Fd_ == 0) dst = &RDzero;      if (_Fd_ == 0) dst = &RDzero;
# Line 589  void _vuSUBz(VURegs * VU) { Line 588  void _vuSUBz(VURegs * VU) {
588          VU_STAT_UPDATE(VU);          VU_STAT_UPDATE(VU);
589  }//updated 10/05/03 shadow  }//updated 10/05/03 shadow
590    
591  void _vuSUBw(VURegs * VU) {  static __fi void _vuSUBw(VURegs * VU) {
592          float ftw;          float ftw;
593          VECTOR * dst;          VECTOR * dst;
594      if (_Fd_ == 0) dst = &RDzero;      if (_Fd_ == 0) dst = &RDzero;
# Line 604  void _vuSUBw(VURegs * VU) { Line 603  void _vuSUBw(VURegs * VU) {
603  }//updated 10/05/03 shadow  }//updated 10/05/03 shadow
604    
605    
606  void _vuSUBA(VURegs * VU) {  static __fi void _vuSUBA(VURegs * VU) {
607          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);          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);          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);          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);
# Line 612  void _vuSUBA(VURegs * VU) { Line 611  void _vuSUBA(VURegs * VU) {
611          VU_STAT_UPDATE(VU);          VU_STAT_UPDATE(VU);
612  }//updated 10/05/03 shadow  }//updated 10/05/03 shadow
613    
614  void _vuSUBAi(VURegs * VU) {  static __fi void _vuSUBAi(VURegs * VU) {
615          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);          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);          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);          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);
# Line 620  void _vuSUBAi(VURegs * VU) { Line 619  void _vuSUBAi(VURegs * VU) {
619          VU_STAT_UPDATE(VU);          VU_STAT_UPDATE(VU);
620  }//updated 10/05/03 shadow  }//updated 10/05/03 shadow
621    
622  void _vuSUBAq(VURegs * VU) {  static __fi void _vuSUBAq(VURegs * VU) {
623          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);          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);          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);          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);
# Line 628  void _vuSUBAq(VURegs * VU) { Line 627  void _vuSUBAq(VURegs * VU) {
627          VU_STAT_UPDATE(VU);          VU_STAT_UPDATE(VU);
628  }//updated 10/05/03 shadow  }//updated 10/05/03 shadow
629    
630  void _vuSUBAx(VURegs * VU) {  static __fi void _vuSUBAx(VURegs * VU) {
631          float tx = vuDouble(VU->VF[_Ft_].i.x);          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);          if (_X){ VU->ACC.i.x = VU_MACx_UPDATE(VU, vuDouble(VU->VF[_Fs_].i.x) - tx); } else VU_MACx_CLEAR(VU);
# Line 638  void _vuSUBAx(VURegs * VU) { Line 637  void _vuSUBAx(VURegs * VU) {
637          VU_STAT_UPDATE(VU);          VU_STAT_UPDATE(VU);
638  }//updated 10/05/03 shadow  }//updated 10/05/03 shadow
639    
640  void _vuSUBAy(VURegs * VU) {  static __fi void _vuSUBAy(VURegs * VU) {
641          float ty = vuDouble(VU->VF[_Ft_].i.y);          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);          if (_X){ VU->ACC.i.x = VU_MACx_UPDATE(VU, vuDouble(VU->VF[_Fs_].i.x) - ty); } else VU_MACx_CLEAR(VU);
# Line 648  void _vuSUBAy(VURegs * VU) { Line 647  void _vuSUBAy(VURegs * VU) {
647          VU_STAT_UPDATE(VU);          VU_STAT_UPDATE(VU);
648  }//updated 10/05/03 shadow  }//updated 10/05/03 shadow
649    
650  void _vuSUBAz(VURegs * VU) {  static __fi void _vuSUBAz(VURegs * VU) {
651          float tz = vuDouble(VU->VF[_Ft_].i.z);          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);          if (_X){ VU->ACC.i.x = VU_MACx_UPDATE(VU, vuDouble(VU->VF[_Fs_].i.x) - tz); } else VU_MACx_CLEAR(VU);
# Line 658  void _vuSUBAz(VURegs * VU) { Line 657  void _vuSUBAz(VURegs * VU) {
657          VU_STAT_UPDATE(VU);          VU_STAT_UPDATE(VU);
658  }//updated 10/05/03 shadow  }//updated 10/05/03 shadow
659    
660  void _vuSUBAw(VURegs * VU) {  static __fi void _vuSUBAw(VURegs * VU) {
661          float tw = vuDouble(VU->VF[_Ft_].i.w);          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);          if (_X){ VU->ACC.i.x = VU_MACx_UPDATE(VU, vuDouble(VU->VF[_Fs_].i.x) - tw); } else VU_MACx_CLEAR(VU);
# Line 668  void _vuSUBAw(VURegs * VU) { Line 667  void _vuSUBAw(VURegs * VU) {
667          VU_STAT_UPDATE(VU);          VU_STAT_UPDATE(VU);
668  }//updated 10/05/03 shadow  }//updated 10/05/03 shadow
669    
670  void _vuMUL(VURegs * VU) {  static __fi void _vuMUL(VURegs * VU) {
671          VECTOR * dst;          VECTOR * dst;
672      if (_Fd_ == 0) dst = &RDzero;      if (_Fd_ == 0) dst = &RDzero;
673          else dst = &VU->VF[_Fd_];          else dst = &VU->VF[_Fd_];
# Line 681  void _vuMUL(VURegs * VU) { Line 680  void _vuMUL(VURegs * VU) {
680  }/* last update 8/05/03 shadow */  }/* last update 8/05/03 shadow */
681    
682  /* No need to presave I reg in ti. asadr */  /* No need to presave I reg in ti. asadr */
683  void _vuMULi(VURegs * VU) {  static __fi void _vuMULi(VURegs * VU) {
684          VECTOR * dst;          VECTOR * dst;
685      if (_Fd_ == 0) dst = &RDzero;      if (_Fd_ == 0) dst = &RDzero;
686          else dst = &VU->VF[_Fd_];          else dst = &VU->VF[_Fd_];
# Line 693  void _vuMULi(VURegs * VU) { Line 692  void _vuMULi(VURegs * VU) {
692      VU_STAT_UPDATE(VU);      VU_STAT_UPDATE(VU);
693  }/* last update 8/05/03 shadow */  }/* last update 8/05/03 shadow */
694    
695  void _vuMULq(VURegs * VU) {  static __fi void _vuMULq(VURegs * VU) {
696          VECTOR * dst;          VECTOR * dst;
697      if (_Fd_ == 0) dst = &RDzero;      if (_Fd_ == 0) dst = &RDzero;
698          else dst = &VU->VF[_Fd_];          else dst = &VU->VF[_Fd_];
# Line 705  void _vuMULq(VURegs * VU) { Line 704  void _vuMULq(VURegs * VU) {
704      VU_STAT_UPDATE(VU);      VU_STAT_UPDATE(VU);
705  }/* last update 8/05/03 shadow */  }/* last update 8/05/03 shadow */
706    
707  void _vuMULx(VURegs * VU) {  static __fi void _vuMULx(VURegs * VU) {
708          float ftx;          float ftx;
709          VECTOR * dst;          VECTOR * dst;
710      if (_Fd_ == 0) dst = &RDzero;      if (_Fd_ == 0) dst = &RDzero;
# Line 720  void _vuMULx(VURegs * VU) { Line 719  void _vuMULx(VURegs * VU) {
719  }/* last update 8/05/03 shadow */  }/* last update 8/05/03 shadow */
720    
721    
722  void _vuMULy(VURegs * VU) {  static __fi void _vuMULy(VURegs * VU) {
723          float fty;          float fty;
724          VECTOR * dst;          VECTOR * dst;
725      if (_Fd_ == 0) dst = &RDzero;      if (_Fd_ == 0) dst = &RDzero;
# Line 734  void _vuMULy(VURegs * VU) { Line 733  void _vuMULy(VURegs * VU) {
733      VU_STAT_UPDATE(VU);      VU_STAT_UPDATE(VU);
734  }/* last update 8/05/03 shadow */  }/* last update 8/05/03 shadow */
735    
736  void _vuMULz(VURegs * VU) {  static __fi void _vuMULz(VURegs * VU) {
737          float ftz;          float ftz;
738          VECTOR * dst;          VECTOR * dst;
739      if (_Fd_ == 0) dst = &RDzero;      if (_Fd_ == 0) dst = &RDzero;
# Line 748  void _vuMULz(VURegs * VU) { Line 747  void _vuMULz(VURegs * VU) {
747          VU_STAT_UPDATE(VU);          VU_STAT_UPDATE(VU);
748  }/* last update 8/05/03 shadow */  }/* last update 8/05/03 shadow */
749    
750  void _vuMULw(VURegs * VU) {  static __fi void _vuMULw(VURegs * VU) {
751          float ftw;          float ftw;
752          VECTOR * dst;          VECTOR * dst;
753      if (_Fd_ == 0) dst = &RDzero;      if (_Fd_ == 0) dst = &RDzero;
# Line 763  void _vuMULw(VURegs * VU) { Line 762  void _vuMULw(VURegs * VU) {
762  }/* last update 8/05/03 shadow */  }/* last update 8/05/03 shadow */
763    
764    
765  void _vuMULA(VURegs * VU) {  static __fi void _vuMULA(VURegs * VU) {
766          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);          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);          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);          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);
# Line 772  void _vuMULA(VURegs * VU) { Line 771  void _vuMULA(VURegs * VU) {
771  }/* last update 8/05/03 shadow */  }/* last update 8/05/03 shadow */
772    
773  /* No need to presave I reg in ti. asadr */  /* No need to presave I reg in ti. asadr */
774  void _vuMULAi(VURegs * VU) {  static __fi void _vuMULAi(VURegs * VU) {
775          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);          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);          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);          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);
# Line 781  void _vuMULAi(VURegs * VU) { Line 780  void _vuMULAi(VURegs * VU) {
780  }/* last update 8/05/03 shadow */  }/* last update 8/05/03 shadow */
781    
782  /* No need to presave Q reg in ti. asadr */  /* No need to presave Q reg in ti. asadr */
783  void _vuMULAq(VURegs * VU) {  static __fi void _vuMULAq(VURegs * VU) {
784          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);          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);          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);          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);
# Line 790  void _vuMULAq(VURegs * VU) { Line 789  void _vuMULAq(VURegs * VU) {
789  }/* last update 8/05/03 shadow */  }/* last update 8/05/03 shadow */
790    
791  /* No need to presave X reg in ti. asadr */  /* No need to presave X reg in ti. asadr */
792  void _vuMULAx(VURegs * VU) {  static __fi void _vuMULAx(VURegs * VU) {
793          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);          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);          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);          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);
# Line 798  void _vuMULAx(VURegs * VU) { Line 797  void _vuMULAx(VURegs * VU) {
797      VU_STAT_UPDATE(VU);      VU_STAT_UPDATE(VU);
798  }/* last update 8/05/03 shadow */  }/* last update 8/05/03 shadow */
799    
800  void _vuMULAy(VURegs * VU) {  static __fi void _vuMULAy(VURegs * VU) {
801          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);          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);          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);          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);
# Line 806  void _vuMULAy(VURegs * VU) { Line 805  void _vuMULAy(VURegs * VU) {
805      VU_STAT_UPDATE(VU);      VU_STAT_UPDATE(VU);
806  }/* last update 8/05/03 shadow */  }/* last update 8/05/03 shadow */
807    
808  void _vuMULAz(VURegs * VU) {  static __fi void _vuMULAz(VURegs * VU) {
809          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);          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);          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);          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);
# Line 814  void _vuMULAz(VURegs * VU) { Line 813  void _vuMULAz(VURegs * VU) {
813      VU_STAT_UPDATE(VU);      VU_STAT_UPDATE(VU);
814  }/* last update 8/05/03 shadow */  }/* last update 8/05/03 shadow */
815    
816  void _vuMULAw(VURegs * VU) {  static __fi void _vuMULAw(VURegs * VU) {
817          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);          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);          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);          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);
# Line 822  void _vuMULAw(VURegs * VU) { Line 821  void _vuMULAw(VURegs * VU) {
821      VU_STAT_UPDATE(VU);      VU_STAT_UPDATE(VU);
822  }/* last update 8/05/03 shadow */  }/* last update 8/05/03 shadow */
823    
824  void _vuMADD(VURegs * VU) {  static __fi void _vuMADD(VURegs * VU) {
825          VECTOR * dst;          VECTOR * dst;
826      if (_Fd_ == 0) dst = &RDzero;      if (_Fd_ == 0) dst = &RDzero;
827          else dst = &VU->VF[_Fd_];          else dst = &VU->VF[_Fd_];
# Line 835  void _vuMADD(VURegs * VU) { Line 834  void _vuMADD(VURegs * VU) {
834  }/* last update 10/05/03 shadow */  }/* last update 10/05/03 shadow */
835    
836    
837  void _vuMADDi(VURegs * VU) {  static __fi void _vuMADDi(VURegs * VU) {
838          VECTOR * dst;          VECTOR * dst;
839      if (_Fd_ == 0) dst = &RDzero;      if (_Fd_ == 0) dst = &RDzero;
840          else dst = &VU->VF[_Fd_];          else dst = &VU->VF[_Fd_];
# Line 848  void _vuMADDi(VURegs * VU) { Line 847  void _vuMADDi(VURegs * VU) {
847  }/* last update 10/05/03 shadow */  }/* last update 10/05/03 shadow */
848    
849  /* No need to presave . asadr */  /* No need to presave . asadr */
850  void _vuMADDq(VURegs * VU) {  static __fi void _vuMADDq(VURegs * VU) {
851          VECTOR * dst;          VECTOR * dst;
852      if (_Fd_ == 0) dst = &RDzero;      if (_Fd_ == 0) dst = &RDzero;
853          else dst = &VU->VF[_Fd_];          else dst = &VU->VF[_Fd_];
# Line 860  void _vuMADDq(VURegs * VU) { Line 859  void _vuMADDq(VURegs * VU) {
859      VU_STAT_UPDATE(VU);      VU_STAT_UPDATE(VU);
860  }/* last update 10/05/03 shadow */  }/* last update 10/05/03 shadow */
861    
862  void _vuMADDx(VURegs * VU) {  static __fi void _vuMADDx(VURegs * VU) {
863          float ftx;          float ftx;
864          VECTOR * dst;          VECTOR * dst;
865      if (_Fd_ == 0) dst = &RDzero;      if (_Fd_ == 0) dst = &RDzero;
# Line 874  void _vuMADDx(VURegs * VU) { Line 873  void _vuMADDx(VURegs * VU) {
873      VU_STAT_UPDATE(VU);      VU_STAT_UPDATE(VU);
874  }/* last update 10/05/03 shadow */  }/* last update 10/05/03 shadow */
875    
876  void _vuMADDy(VURegs * VU) {  static __fi void _vuMADDy(VURegs * VU) {
877          float fty;          float fty;
878          VECTOR * dst;          VECTOR * dst;
879      if (_Fd_ == 0) dst = &RDzero;      if (_Fd_ == 0) dst = &RDzero;
# Line 888  void _vuMADDy(VURegs * VU) { Line 887  void _vuMADDy(VURegs * VU) {
887      VU_STAT_UPDATE(VU);      VU_STAT_UPDATE(VU);
888  }/* last update 10/05/03 shadow */  }/* last update 10/05/03 shadow */
889    
890  void _vuMADDz(VURegs * VU) {  static __fi void _vuMADDz(VURegs * VU) {
891          float ftz;          float ftz;
892          VECTOR * dst;          VECTOR * dst;
893      if (_Fd_ == 0) dst = &RDzero;      if (_Fd_ == 0) dst = &RDzero;
# Line 902  void _vuMADDz(VURegs * VU) { Line 901  void _vuMADDz(VURegs * VU) {
901          VU_STAT_UPDATE(VU);          VU_STAT_UPDATE(VU);
902  }/* last update 10/05/03 shadow */  }/* last update 10/05/03 shadow */
903    
904  void _vuMADDw(VURegs * VU) {  static __fi void _vuMADDw(VURegs * VU) {
905          float ftw;          float ftw;
906          VECTOR * dst;          VECTOR * dst;
907      if (_Fd_ == 0) dst = &RDzero;      if (_Fd_ == 0) dst = &RDzero;
# Line 916  void _vuMADDw(VURegs * VU) { Line 915  void _vuMADDw(VURegs * VU) {
915      VU_STAT_UPDATE(VU);      VU_STAT_UPDATE(VU);
916  }/* last update 10/05/03 shadow */  }/* last update 10/05/03 shadow */
917    
918  void _vuMADDA(VURegs * VU) {  static __fi void _vuMADDA(VURegs * VU) {
919      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);      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);      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);      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);
# Line 924  void _vuMADDA(VURegs * VU) { Line 923  void _vuMADDA(VURegs * VU) {
923      VU_STAT_UPDATE(VU);      VU_STAT_UPDATE(VU);
924  }/*last updated  10/05/03 shadow*/  }/*last updated  10/05/03 shadow*/
925    
926  void _vuMADDAi(VURegs * VU) {  static __fi void _vuMADDAi(VURegs * VU) {
927          float ti = vuDouble(VU->VI[REG_I].UL);          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);      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);
# Line 934  void _vuMADDAi(VURegs * VU) { Line 933  void _vuMADDAi(VURegs * VU) {
933      VU_STAT_UPDATE(VU);      VU_STAT_UPDATE(VU);
934  }/*last updated  10/05/03 shadow*/  }/*last updated  10/05/03 shadow*/
935    
936  void _vuMADDAq(VURegs * VU) {  static __fi void _vuMADDAq(VURegs * VU) {
937          float tq = vuDouble(VU->VI[REG_Q].UL);          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);      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);
# Line 944  void _vuMADDAq(VURegs * VU) { Line 943  void _vuMADDAq(VURegs * VU) {
943      VU_STAT_UPDATE(VU);      VU_STAT_UPDATE(VU);
944  }/*last update  10/05/03 shadow*/  }/*last update  10/05/03 shadow*/
945    
946  void _vuMADDAx(VURegs * VU) {  static __fi void _vuMADDAx(VURegs * VU) {
947      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);      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);      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);      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);
# Line 952  void _vuMADDAx(VURegs * VU) { Line 951  void _vuMADDAx(VURegs * VU) {
951      VU_STAT_UPDATE(VU);      VU_STAT_UPDATE(VU);
952  }/*last update 11/05/03 shadow*/  }/*last update 11/05/03 shadow*/
953    
954  void _vuMADDAy(VURegs * VU) {  static __fi void _vuMADDAy(VURegs * VU) {
955          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);          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);      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);      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);
# Line 960  void _vuMADDAy(VURegs * VU) { Line 959  void _vuMADDAy(VURegs * VU) {
959      VU_STAT_UPDATE(VU);      VU_STAT_UPDATE(VU);
960  }/*last update  11/05/03 shadow*/  }/*last update  11/05/03 shadow*/
961    
962  void _vuMADDAz(VURegs * VU) {  static __fi void _vuMADDAz(VURegs * VU) {
963      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);      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);      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);      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);
# Line 968  void _vuMADDAz(VURegs * VU) { Line 967  void _vuMADDAz(VURegs * VU) {
967      VU_STAT_UPDATE(VU);      VU_STAT_UPDATE(VU);
968  }/*last update  11/05/03 shadow*/  }/*last update  11/05/03 shadow*/
969    
970  void _vuMADDAw(VURegs * VU) {  static __fi void _vuMADDAw(VURegs * VU) {
971      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);      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);      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);      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);
# Line 976  void _vuMADDAw(VURegs * VU) { Line 975  void _vuMADDAw(VURegs * VU) {
975      VU_STAT_UPDATE(VU);      VU_STAT_UPDATE(VU);
976  }/*last update  11/05/03 shadow*/  }/*last update  11/05/03 shadow*/
977    
978  void _vuMSUB(VURegs * VU) {  static __fi void _vuMSUB(VURegs * VU) {
979          VECTOR * dst;          VECTOR * dst;
980      if (_Fd_ == 0) dst = &RDzero;      if (_Fd_ == 0) dst = &RDzero;
981          else dst = &VU->VF[_Fd_];          else dst = &VU->VF[_Fd_];
# Line 988  void _vuMSUB(VURegs * VU) { Line 987  void _vuMSUB(VURegs * VU) {
987      VU_STAT_UPDATE(VU);      VU_STAT_UPDATE(VU);
988  }/* last update 11/05/03 shadow */  }/* last update 11/05/03 shadow */
989    
990  void _vuMSUBi(VURegs * VU) {  static __fi void _vuMSUBi(VURegs * VU) {
991          float ti = vuDouble(VU->VI[REG_I].UL);          float ti = vuDouble(VU->VI[REG_I].UL);
992          VECTOR * dst;          VECTOR * dst;
993      if (_Fd_ == 0) dst = &RDzero;      if (_Fd_ == 0) dst = &RDzero;
# Line 1001  void _vuMSUBi(VURegs * VU) { Line 1000  void _vuMSUBi(VURegs * VU) {
1000      VU_STAT_UPDATE(VU);      VU_STAT_UPDATE(VU);
1001  }/* last update 11/05/03 shadow */  }/* last update 11/05/03 shadow */
1002    
1003  void _vuMSUBq(VURegs * VU) {  static __fi void _vuMSUBq(VURegs * VU) {
1004          float tq = vuDouble(VU->VI[REG_Q].UL);          float tq = vuDouble(VU->VI[REG_Q].UL);
1005          VECTOR * dst;          VECTOR * dst;
1006      if (_Fd_ == 0) dst = &RDzero;      if (_Fd_ == 0) dst = &RDzero;
# Line 1015  void _vuMSUBq(VURegs * VU) { Line 1014  void _vuMSUBq(VURegs * VU) {
1014  }/* last update 11/05/03 shadow */  }/* last update 11/05/03 shadow */
1015    
1016    
1017  void _vuMSUBx(VURegs * VU) {  static __fi void _vuMSUBx(VURegs * VU) {
1018          float ftx;          float ftx;
1019          VECTOR * dst;          VECTOR * dst;
1020      if (_Fd_ == 0) dst = &RDzero;      if (_Fd_ == 0) dst = &RDzero;
# Line 1030  void _vuMSUBx(VURegs * VU) { Line 1029  void _vuMSUBx(VURegs * VU) {
1029  }/* last update 11/05/03 shadow */  }/* last update 11/05/03 shadow */
1030    
1031    
1032  void _vuMSUBy(VURegs * VU) {  static __fi void _vuMSUBy(VURegs * VU) {
1033          float fty;          float fty;
1034          VECTOR * dst;          VECTOR * dst;
1035      if (_Fd_ == 0) dst = &RDzero;      if (_Fd_ == 0) dst = &RDzero;
# Line 1045  void _vuMSUBy(VURegs * VU) { Line 1044  void _vuMSUBy(VURegs * VU) {
1044  }/* last update 11/05/03 shadow */  }/* last update 11/05/03 shadow */
1045    
1046    
1047  void _vuMSUBz(VURegs * VU) {  static __fi void _vuMSUBz(VURegs * VU) {
1048          float ftz;          float ftz;
1049          VECTOR * dst;          VECTOR * dst;
1050      if (_Fd_ == 0) dst = &RDzero;      if (_Fd_ == 0) dst = &RDzero;
# Line 1059  void _vuMSUBz(VURegs * VU) { Line 1058  void _vuMSUBz(VURegs * VU) {
1058      VU_STAT_UPDATE(VU);      VU_STAT_UPDATE(VU);
1059  }/* last update 11/05/03 shadow */  }/* last update 11/05/03 shadow */
1060    
1061  void _vuMSUBw(VURegs * VU) {  static __fi void _vuMSUBw(VURegs * VU) {
1062          float ftw;          float ftw;
1063          VECTOR * dst;          VECTOR * dst;
1064      if (_Fd_ == 0) dst = &RDzero;      if (_Fd_ == 0) dst = &RDzero;
# Line 1074  void _vuMSUBw(VURegs * VU) { Line 1073  void _vuMSUBw(VURegs * VU) {
1073  }/* last update 11/05/03 shadow */  }/* last update 11/05/03 shadow */
1074    
1075    
1076  void _vuMSUBA(VURegs * VU) {  static __fi void _vuMSUBA(VURegs * VU) {
1077      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);      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);      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);      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);
# Line 1082  void _vuMSUBA(VURegs * VU) { Line 1081  void _vuMSUBA(VURegs * VU) {
1081      VU_STAT_UPDATE(VU);      VU_STAT_UPDATE(VU);
1082  }/*last updated  11/05/03 shadow*/  }/*last updated  11/05/03 shadow*/
1083    
1084  void _vuMSUBAi(VURegs * VU) {  static __fi void _vuMSUBAi(VURegs * VU) {
1085      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);      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);      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);      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);
# Line 1090  void _vuMSUBAi(VURegs * VU) { Line 1089  void _vuMSUBAi(VURegs * VU) {
1089      VU_STAT_UPDATE(VU);      VU_STAT_UPDATE(VU);
1090  }/*last updated  11/05/03 shadow*/  }/*last updated  11/05/03 shadow*/
1091    
1092  void _vuMSUBAq(VURegs * VU) {  static __fi void _vuMSUBAq(VURegs * VU) {
1093      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);      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);      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);      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);
# Line 1098  void _vuMSUBAq(VURegs * VU) { Line 1097  void _vuMSUBAq(VURegs * VU) {
1097      VU_STAT_UPDATE(VU);      VU_STAT_UPDATE(VU);
1098  }/*last updated  11/05/03 shadow*/  }/*last updated  11/05/03 shadow*/
1099    
1100  void _vuMSUBAx(VURegs * VU) {  static __fi void _vuMSUBAx(VURegs * VU) {
1101          float tx = vuDouble(VU->VF[_Ft_].i.x);          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);      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);
# Line 1108  void _vuMSUBAx(VURegs * VU) { Line 1107  void _vuMSUBAx(VURegs * VU) {
1107      VU_STAT_UPDATE(VU);      VU_STAT_UPDATE(VU);
1108  }/*last updated  11/05/03 shadow*/  }/*last updated  11/05/03 shadow*/
1109    
1110  void _vuMSUBAy(VURegs * VU) {  static __fi void _vuMSUBAy(VURegs * VU) {
1111          float ty = vuDouble(VU->VF[_Ft_].i.y);          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);      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);
# Line 1118  void _vuMSUBAy(VURegs * VU) { Line 1117  void _vuMSUBAy(VURegs * VU) {
1117      VU_STAT_UPDATE(VU);      VU_STAT_UPDATE(VU);
1118  }/*last updated  11/05/03 shadow*/  }/*last updated  11/05/03 shadow*/
1119    
1120  void _vuMSUBAz(VURegs * VU) {  static __fi void _vuMSUBAz(VURegs * VU) {
1121          float tz = vuDouble(VU->VF[_Ft_].i.z);          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);      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);
# Line 1128  void _vuMSUBAz(VURegs * VU) { Line 1127  void _vuMSUBAz(VURegs * VU) {
1127      VU_STAT_UPDATE(VU);      VU_STAT_UPDATE(VU);
1128  }/*last updated  11/05/03 shadow*/  }/*last updated  11/05/03 shadow*/
1129    
1130  void _vuMSUBAw(VURegs * VU) {  static __fi void _vuMSUBAw(VURegs * VU) {
1131          float tw = vuDouble(VU->VF[_Ft_].i.w);          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);      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);
# Line 1156  u32 _MAX(u32 a, u32 b) { Line 1155  u32 _MAX(u32 a, u32 b) {
1155          return 0;          return 0;
1156  }  }
1157    
1158  void _vuMAX(VURegs * VU) {  static __fi void _vuMAX(VURegs * VU) {
1159          if (_Fd_ == 0) return;          if (_Fd_ == 0) return;
1160    
1161          /* ft is bc */          /* ft is bc */
# Line 1166  void _vuMAX(VURegs * VU) { Line 1165  void _vuMAX(VURegs * VU) {
1165          if (_W) VU->VF[_Fd_].i.w = _MAX(VU->VF[_Fs_].i.w, (s32)VU->VF[_Ft_].i.w);          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  }//checked 13/05/03 shadow
1167    
1168  void _vuMAXi(VURegs * VU) {  static __fi void _vuMAXi(VURegs * VU) {
1169          if (_Fd_ == 0) return;          if (_Fd_ == 0) return;
1170    
1171          /* ft is bc */          /* ft is bc */
# Line 1176  void _vuMAXi(VURegs * VU) { Line 1175  void _vuMAXi(VURegs * VU) {
1175          if (_W) VU->VF[_Fd_].i.w = _MAX(VU->VF[_Fs_].i.w, VU->VI[REG_I].UL);          if (_W) VU->VF[_Fd_].i.w = _MAX(VU->VF[_Fs_].i.w, VU->VI[REG_I].UL);
1176  }//checked 13/05/03 shadow  }//checked 13/05/03 shadow
1177    
1178  void _vuMAXx(VURegs * VU) {  static __fi void _vuMAXx(VURegs * VU) {
1179          s32 ftx;          s32 ftx;
1180          if (_Fd_ == 0) return;          if (_Fd_ == 0) return;
1181    
# Line 1188  void _vuMAXx(VURegs * VU) { Line 1187  void _vuMAXx(VURegs * VU) {
1187  }  }
1188  //checked 13/05/03 shadow  //checked 13/05/03 shadow
1189    
1190  void _vuMAXy(VURegs * VU) {  static __fi void _vuMAXy(VURegs * VU) {
1191          s32 fty;          s32 fty;
1192          if (_Fd_ == 0) return;          if (_Fd_ == 0) return;
1193    
# Line 1199  void _vuMAXy(VURegs * VU) { Line 1198  void _vuMAXy(VURegs * VU) {
1198          if (_W) VU->VF[_Fd_].i.w = _MAX(VU->VF[_Fs_].i.w, fty);          if (_W) VU->VF[_Fd_].i.w = _MAX(VU->VF[_Fs_].i.w, fty);
1199  }//checked 13/05/03 shadow  }//checked 13/05/03 shadow
1200    
1201  void _vuMAXz(VURegs * VU) {  static __fi void _vuMAXz(VURegs * VU) {
1202          s32 ftz;          s32 ftz;
1203          if (_Fd_ == 0) return;          if (_Fd_ == 0) return;
1204    
# Line 1210  void _vuMAXz(VURegs * VU) { Line 1209  void _vuMAXz(VURegs * VU) {
1209          if (_W) VU->VF[_Fd_].i.w = _MAX(VU->VF[_Fs_].i.w, ftz);          if (_W) VU->VF[_Fd_].i.w = _MAX(VU->VF[_Fs_].i.w, ftz);
1210  }  }
1211    
1212  void _vuMAXw(VURegs * VU) {  static __fi void _vuMAXw(VURegs * VU) {
1213          s32 ftw;          s32 ftw;
1214          if (_Fd_ == 0) return;          if (_Fd_ == 0) return;
1215    
# Line 1239  u32 _MINI(u32 a, u32 b) { Line 1238  u32 _MINI(u32 a, u32 b) {
1238          return 0;          return 0;
1239  }  }
1240    
1241  void _vuMINI(VURegs * VU) {  static __fi void _vuMINI(VURegs * VU) {
1242          if (_Fd_ == 0) return;          if (_Fd_ == 0) return;
1243    
1244          /* ft is bc */          /* ft is bc */
# Line 1249  void _vuMINI(VURegs * VU) { Line 1248  void _vuMINI(VURegs * VU) {
1248          if (_W) VU->VF[_Fd_].i.w = _MINI(VU->VF[_Fs_].i.w, (s32)VU->VF[_Ft_].i.w);          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  }//checked 13/05/03 shadow
1250    
1251  void _vuMINIi(VURegs * VU) {  static __fi void _vuMINIi(VURegs * VU) {
1252          if (_Fd_ == 0) return;          if (_Fd_ == 0) return;
1253    
1254          /* ft is bc */          /* ft is bc */
# Line 1259  void _vuMINIi(VURegs * VU) { Line 1258  void _vuMINIi(VURegs * VU) {
1258          if (_W) VU->VF[_Fd_].i.w = _MINI(VU->VF[_Fs_].i.w, VU->VI[REG_I].UL);          if (_W) VU->VF[_Fd_].i.w = _MINI(VU->VF[_Fs_].i.w, VU->VI[REG_I].UL);
1259  }//checked 13/05/03 shadow  }//checked 13/05/03 shadow
1260    
1261  void _vuMINIx(VURegs * VU) {  static __fi void _vuMINIx(VURegs * VU) {
1262          s32 ftx;          s32 ftx;
1263          if (_Fd_ == 0) return;          if (_Fd_ == 0) return;
1264    
# Line 1271  void _vuMINIx(VURegs * VU) { Line 1270  void _vuMINIx(VURegs * VU) {
1270  }  }
1271  //checked 13/05/03 shadow  //checked 13/05/03 shadow
1272    
1273  void _vuMINIy(VURegs * VU) {  static __fi void _vuMINIy(VURegs * VU) {
1274          s32 fty;          s32 fty;
1275          if (_Fd_ == 0) return;          if (_Fd_ == 0) return;
1276    
# Line 1282  void _vuMINIy(VURegs * VU) { Line 1281  void _vuMINIy(VURegs * VU) {
1281          if (_W) VU->VF[_Fd_].i.w = _MINI(VU->VF[_Fs_].i.w, fty);          if (_W) VU->VF[_Fd_].i.w = _MINI(VU->VF[_Fs_].i.w, fty);
1282  }//checked 13/05/03 shadow  }//checked 13/05/03 shadow
1283    
1284  void _vuMINIz(VURegs * VU) {  static __fi void _vuMINIz(VURegs * VU) {
1285          s32 ftz;          s32 ftz;
1286          if (_Fd_ == 0) return;          if (_Fd_ == 0) return;
1287    
# Line 1293  void _vuMINIz(VURegs * VU) { Line 1292  void _vuMINIz(VURegs * VU) {
1292          if (_W) VU->VF[_Fd_].i.w = _MINI(VU->VF[_Fs_].i.w, ftz);          if (_W) VU->VF[_Fd_].i.w = _MINI(VU->VF[_Fs_].i.w, ftz);
1293  }  }
1294    
1295  void _vuMINIw(VURegs * VU) {  static __fi void _vuMINIw(VURegs * VU) {
1296          s32 ftw;          s32 ftw;
1297          if (_Fd_ == 0) return;          if (_Fd_ == 0) return;
1298    
# Line 1304  void _vuMINIw(VURegs * VU) { Line 1303  void _vuMINIw(VURegs * VU) {
1303          if (_W) VU->VF[_Fd_].i.w = _MINI(VU->VF[_Fs_].i.w, ftw);          if (_W) VU->VF[_Fd_].i.w = _MINI(VU->VF[_Fs_].i.w, ftw);
1304  }  }
1305    
1306  void _vuOPMULA(VURegs * VU) {  static __fi void _vuOPMULA(VURegs * VU) {
1307          VU->ACC.i.x = VU_MACx_UPDATE(VU, vuDouble(VU->VF[_Fs_].i.y) * vuDouble(VU->VF[_Ft_].i.z));          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));          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));          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);          VU_STAT_UPDATE(VU);
1311  }/*last updated  8/05/03 shadow*/  }/*last updated  8/05/03 shadow*/
1312    
1313  void _vuOPMSUB(VURegs * VU) {  static __fi void _vuOPMSUB(VURegs * VU) {
1314          VECTOR * dst;          VECTOR * dst;
1315          float ftx, fty, ftz;          float ftx, fty, ftz;
1316          float fsx, fsy, fsz;          float fsx, fsy, fsz;
# Line 1328  void _vuOPMSUB(VURegs * VU) { Line 1327  void _vuOPMSUB(VURegs * VU) {
1327          VU_STAT_UPDATE(VU);          VU_STAT_UPDATE(VU);
1328  }/*last updated  8/05/03 shadow*/  }/*last updated  8/05/03 shadow*/
1329    
1330  void _vuNOP(VURegs * VU) {  static __fi void _vuNOP(VURegs * VU) {
1331  }  }
1332    
1333  void _vuFTOI0(VURegs * VU) {  static __fi void _vuFTOI0(VURegs * VU) {
1334          if (_Ft_ == 0) return;          if (_Ft_ == 0) return;
1335    
1336          if (_X) VU->VF[_Ft_].SL[0] = (s32)vuDouble(VU->VF[_Fs_].i.x);          if (_X) VU->VF[_Ft_].SL[0] = (s32)vuDouble(VU->VF[_Fs_].i.x);
# Line 1340  void _vuFTOI0(VURegs * VU) { Line 1339  void _vuFTOI0(VURegs * VU) {
1339          if (_W) VU->VF[_Ft_].SL[3] = (s32)vuDouble(VU->VF[_Fs_].i.w);          if (_W) VU->VF[_Ft_].SL[3] = (s32)vuDouble(VU->VF[_Fs_].i.w);
1340  }  }
1341    
1342  void _vuFTOI4(VURegs * VU) {  static __fi void _vuFTOI4(VURegs * VU) {
1343          if (_Ft_ == 0) return;          if (_Ft_ == 0) return;
1344    
1345          if (_X) VU->VF[_Ft_].SL[0] = float_to_int4(vuDouble(VU->VF[_Fs_].i.x));          if (_X) VU->VF[_Ft_].SL[0] = float_to_int4(vuDouble(VU->VF[_Fs_].i.x));
# Line 1349  void _vuFTOI4(VURegs * VU) { Line 1348  void _vuFTOI4(VURegs * VU) {
1348          if (_W) VU->VF[_Ft_].SL[3] = float_to_int4(vuDouble(VU->VF[_Fs_].i.w));          if (_W) VU->VF[_Ft_].SL[3] = float_to_int4(vuDouble(VU->VF[_Fs_].i.w));
1349  }  }
1350    
1351  void _vuFTOI12(VURegs * VU) {  static __fi void _vuFTOI12(VURegs * VU) {
1352          if (_Ft_ == 0) return;          if (_Ft_ == 0) return;
1353    
1354          if (_X) VU->VF[_Ft_].SL[0] = float_to_int12(vuDouble(VU->VF[_Fs_].i.x));          if (_X) VU->VF[_Ft_].SL[0] = float_to_int12(vuDouble(VU->VF[_Fs_].i.x));
# Line 1358  void _vuFTOI12(VURegs * VU) { Line 1357  void _vuFTOI12(VURegs * VU) {
1357          if (_W) VU->VF[_Ft_].SL[3] = float_to_int12(vuDouble(VU->VF[_Fs_].i.w));          if (_W) VU->VF[_Ft_].SL[3] = float_to_int12(vuDouble(VU->VF[_Fs_].i.w));
1358  }  }
1359    
1360  void _vuFTOI15(VURegs * VU) {  static __fi void _vuFTOI15(VURegs * VU) {
1361          if (_Ft_ == 0) return;          if (_Ft_ == 0) return;
1362    
1363          if (_X) VU->VF[_Ft_].SL[0] = float_to_int15(vuDouble(VU->VF[_Fs_].i.x));          if (_X) VU->VF[_Ft_].SL[0] = float_to_int15(vuDouble(VU->VF[_Fs_].i.x));
# Line 1367  void _vuFTOI15(VURegs * VU) { Line 1366  void _vuFTOI15(VURegs * VU) {
1366          if (_W) VU->VF[_Ft_].SL[3] = float_to_int15(vuDouble(VU->VF[_Fs_].i.w));          if (_W) VU->VF[_Ft_].SL[3] = float_to_int15(vuDouble(VU->VF[_Fs_].i.w));
1367  }  }
1368    
1369  void _vuITOF0(VURegs * VU) {  static __fi void _vuITOF0(VURegs * VU) {
1370          if (_Ft_ == 0) return;          if (_Ft_ == 0) return;
1371    
1372          if (_X) VU->VF[_Ft_].f.x = (float)VU->VF[_Fs_].SL[0];          if (_X) VU->VF[_Ft_].f.x = (float)VU->VF[_Fs_].SL[0];
# Line 1376  void _vuITOF0(VURegs * VU) { Line 1375  void _vuITOF0(VURegs * VU) {
1375          if (_W) VU->VF[_Ft_].f.w = (float)VU->VF[_Fs_].SL[3];          if (_W) VU->VF[_Ft_].f.w = (float)VU->VF[_Fs_].SL[3];
1376  }  }
1377    
1378  void _vuITOF4(VURegs * VU) {  static __fi void _vuITOF4(VURegs * VU) {
1379          if (_Ft_ == 0) return;          if (_Ft_ == 0) return;
1380    
1381          if (_X) VU->VF[_Ft_].f.x = int4_to_float(VU->VF[_Fs_].SL[0]);          if (_X) VU->VF[_Ft_].f.x = int4_to_float(VU->VF[_Fs_].SL[0]);
# Line 1385  void _vuITOF4(VURegs * VU) { Line 1384  void _vuITOF4(VURegs * VU) {
1384          if (_W) VU->VF[_Ft_].f.w = int4_to_float(VU->VF[_Fs_].SL[3]);          if (_W) VU->VF[_Ft_].f.w = int4_to_float(VU->VF[_Fs_].SL[3]);
1385  }  }
1386    
1387  void _vuITOF12(VURegs * VU) {  static __fi void _vuITOF12(VURegs * VU) {
1388          if (_Ft_ == 0) return;          if (_Ft_ == 0) return;
1389    
1390          if (_X) VU->VF[_Ft_].f.x = int12_to_float(VU->VF[_Fs_].SL[0]);          if (_X) VU->VF[_Ft_].f.x = int12_to_float(VU->VF[_Fs_].SL[0]);
# Line 1394  void _vuITOF12(VURegs * VU) { Line 1393  void _vuITOF12(VURegs * VU) {
1393          if (_W) VU->VF[_Ft_].f.w = int12_to_float(VU->VF[_Fs_].SL[3]);          if (_W) VU->VF[_Ft_].f.w = int12_to_float(VU->VF[_Fs_].SL[3]);
1394  }  }
1395    
1396  void _vuITOF15(VURegs * VU) {  static __fi void _vuITOF15(VURegs * VU) {
1397          if (_Ft_ == 0) return;          if (_Ft_ == 0) return;
1398    
1399          if (_X) VU->VF[_Ft_].f.x = int15_to_float(VU->VF[_Fs_].SL[0]);          if (_X) VU->VF[_Ft_].f.x = int15_to_float(VU->VF[_Fs_].SL[0]);
# Line 1404  void _vuITOF15(VURegs * VU) { Line 1403  void _vuITOF15(VURegs * VU) {
1403  }  }
1404    
1405  /* Different type of clipping by presaving w. asadr */  /* Different type of clipping by presaving w. asadr */
1406  void _vuCLIP(VURegs * VU) {  static __fi void _vuCLIP(VURegs * VU) {
1407          float value = fabs(vuDouble(VU->VF[_Ft_].i.w));          float value = fabs(vuDouble(VU->VF[_Ft_].i.w));
1408    
1409          VU->clipflag <<= 6;          VU->clipflag <<= 6;
# Line 1425  void _vuCLIP(VURegs * VU) { Line 1424  void _vuCLIP(VURegs * VU) {
1424  /*   VU Lower instructions    */  /*   VU Lower instructions    */
1425  /******************************/  /******************************/
1426    
1427  void _vuDIV(VURegs * VU) {  static __fi void _vuDIV(VURegs * VU) {
1428          float ft = vuDouble(VU->VF[_Ft_].UL[_Ftf_]);          float ft = vuDouble(VU->VF[_Ft_].UL[_Ftf_]);
1429          float fs = vuDouble(VU->VF[_Fs_].UL[_Fsf_]);          float fs = vuDouble(VU->VF[_Fs_].UL[_Fsf_]);
1430    
# Line 1449  void _vuDIV(VURegs * VU) { Line 1448  void _vuDIV(VURegs * VU) {
1448          }          }
1449  } //last update 15/01/06 zerofrog  } //last update 15/01/06 zerofrog
1450    
1451  void _vuSQRT(VURegs * VU) {  static __fi void _vuSQRT(VURegs * VU) {
1452          float ft = vuDouble(VU->VF[_Ft_].UL[_Ftf_]);          float ft = vuDouble(VU->VF[_Ft_].UL[_Ftf_]);
1453    
1454          VU->statusflag = (VU->statusflag&0xfcf)|((VU->statusflag&0x30)<<6);          VU->statusflag = (VU->statusflag&0xfcf)|((VU->statusflag&0x30)<<6);
# Line 1461  void _vuSQRT(VURegs * VU) { Line 1460  void _vuSQRT(VURegs * VU) {
1460    
1461  /* Eminent Bug - Dvisior == 0 Check Missing ( D Flag Not Set ) */  /* Eminent Bug - Dvisior == 0 Check Missing ( D Flag Not Set ) */
1462  /* REFIXED....ASADR; rerefixed....zerofrog */  /* REFIXED....ASADR; rerefixed....zerofrog */
1463  void _vuRSQRT(VURegs * VU) {  static __fi void _vuRSQRT(VURegs * VU) {
1464          float ft = vuDouble(VU->VF[_Ft_].UL[_Ftf_]);          float ft = vuDouble(VU->VF[_Ft_].UL[_Ftf_]);
1465          float fs = vuDouble(VU->VF[_Fs_].UL[_Fsf_]);          float fs = vuDouble(VU->VF[_Fs_].UL[_Fsf_]);
1466          float temp;          float temp;
# Line 1501  void _vuRSQRT(VURegs * VU) { Line 1500  void _vuRSQRT(VURegs * VU) {
1500          }          }
1501  } //last update 15/01/06 zerofrog  } //last update 15/01/06 zerofrog
1502    
1503  void _vuIADDI(VURegs * VU) {  static __fi void _vuIADDI(VURegs * VU) {
1504          s16 imm = ((VU->code >> 6) & 0x1f);          s16 imm = ((VU->code >> 6) & 0x1f);
1505          imm = ((imm & 0x10 ? 0xfff0 : 0) | (imm & 0xf));          imm = ((imm & 0x10 ? 0xfff0 : 0) | (imm & 0xf));
1506          if(_It_ == 0) return;          if(_It_ == 0) return;
1507          VU->VI[_It_].SS[0] = VU->VI[_Is_].SS[0] + imm;          VU->VI[_It_].SS[0] = VU->VI[_Is_].SS[0] + imm;
1508  }//last checked 17/05/03 shadow NOTE: not quite sure about that  }//last checked 17/05/03 shadow NOTE: not quite sure about that
1509    
1510  void _vuIADDIU(VURegs * VU) {  static __fi void _vuIADDIU(VURegs * VU) {
1511          if(_It_ == 0) return;          if(_It_ == 0) return;
1512          VU->VI[_It_].SS[0] = VU->VI[_Is_].SS[0] + (((VU->code >> 10) & 0x7800) | (VU->code & 0x7ff));          VU->VI[_It_].SS[0] = VU->VI[_Is_].SS[0] + (((VU->code >> 10) & 0x7800) | (VU->code & 0x7ff));
1513  }//last checked 17/05/03 shadow  }//last checked 17/05/03 shadow
1514    
1515  void _vuIADD(VURegs * VU) {  static __fi void _vuIADD(VURegs * VU) {
1516          if(_Id_ == 0) return;          if(_Id_ == 0) return;
1517          VU->VI[_Id_].SS[0] = VU->VI[_Is_].SS[0] + VU->VI[_It_].SS[0];          VU->VI[_Id_].SS[0] = VU->VI[_Is_].SS[0] + VU->VI[_It_].SS[0];
1518  }//last checked 17/05/03 shadow  }//last checked 17/05/03 shadow
1519    
1520  void _vuIAND(VURegs * VU) {  static __fi void _vuIAND(VURegs * VU) {
1521          if(_Id_ == 0) return;          if(_Id_ == 0) return;
1522          VU->VI[_Id_].US[0] = VU->VI[_Is_].US[0] & VU->VI[_It_].US[0];          VU->VI[_Id_].US[0] = VU->VI[_Is_].US[0] & VU->VI[_It_].US[0];
1523  }//last checked 17/05/03 shadow  }//last checked 17/05/03 shadow
1524    
1525  void _vuIOR(VURegs * VU) {  static __fi void _vuIOR(VURegs * VU) {
1526          if(_Id_ == 0) return;          if(_Id_ == 0) return;
1527          VU->VI[_Id_].US[0] = VU->VI[_Is_].US[0] | VU->VI[_It_].US[0];          VU->VI[_Id_].US[0] = VU->VI[_Is_].US[0] | VU->VI[_It_].US[0];
1528  }  }
1529    
1530  void _vuISUB(VURegs * VU) {  static __fi void _vuISUB(VURegs * VU) {
1531          if(_Id_ == 0) return;          if(_Id_ == 0) return;
1532          VU->VI[_Id_].SS[0] = VU->VI[_Is_].SS[0] - VU->VI[_It_].SS[0];          VU->VI[_Id_].SS[0] = VU->VI[_Is_].SS[0] - VU->VI[_It_].SS[0];
1533  }  }
1534    
1535  void _vuISUBIU(VURegs * VU) {  static __fi void _vuISUBIU(VURegs * VU) {
1536          if(_It_ == 0) return;          if(_It_ == 0) return;
1537          VU->VI[_It_].SS[0] = VU->VI[_Is_].SS[0] - (((VU->code >> 10) & 0x7800) | (VU->code & 0x7ff));          VU->VI[_It_].SS[0] = VU->VI[_Is_].SS[0] - (((VU->code >> 10) & 0x7800) | (VU->code & 0x7ff));
1538  }  }
1539    
1540  void _vuMOVE(VURegs * VU) {  static __fi void _vuMOVE(VURegs * VU) {
1541          if(_Ft_ == 0) return;          if(_Ft_ == 0) return;
1542    
1543          if (_X) VU->VF[_Ft_].UL[0] = VU->VF[_Fs_].UL[0];          if (_X) VU->VF[_Ft_].UL[0] = VU->VF[_Fs_].UL[0];
# Line 1547  void _vuMOVE(VURegs * VU) { Line 1546  void _vuMOVE(VURegs * VU) {
1546          if (_W) VU->VF[_Ft_].UL[3] = VU->VF[_Fs_].UL[3];          if (_W) VU->VF[_Ft_].UL[3] = VU->VF[_Fs_].UL[3];
1547  }//last checked 17/05/03 shadow  }//last checked 17/05/03 shadow
1548    
1549  void _vuMFIR(VURegs * VU) {  static __fi void _vuMFIR(VURegs * VU) {
1550          if (_Ft_ == 0) return;          if (_Ft_ == 0) return;
1551    
1552          if (_X) VU->VF[_Ft_].SL[0] = (s32)VU->VI[_Is_].SS[0];          if (_X) VU->VF[_Ft_].SL[0] = (s32)VU->VI[_Is_].SS[0];
# Line 1557  void _vuMFIR(VURegs * VU) { Line 1556  void _vuMFIR(VURegs * VU) {
1556  }  }
1557    
1558  // Big bug!!! mov from fs to ft not ft to fs. asadr  // Big bug!!! mov from fs to ft not ft to fs. asadr
1559  void _vuMTIR(VURegs * VU) {  static __fi void _vuMTIR(VURegs * VU) {
1560          if(_It_ == 0) return;          if(_It_ == 0) return;
1561          VU->VI[_It_].US[0] =  *(u16*)&VU->VF[_Fs_].F[_Fsf_];          VU->VI[_It_].US[0] =  *(u16*)&VU->VF[_Fs_].F[_Fsf_];
1562  }  }
1563    
1564  void _vuMR32(VURegs * VU) {  static __fi void _vuMR32(VURegs * VU) {
1565          u32 tx;          u32 tx;
1566          if (_Ft_ == 0) return;          if (_Ft_ == 0) return;
1567    
# Line 1577  void _vuMR32(VURegs * VU) { Line 1576  void _vuMR32(VURegs * VU) {
1576  //  Load / Store Instructions (VU Interpreter)  //  Load / Store Instructions (VU Interpreter)
1577  // --------------------------------------------------------------------------------------  // --------------------------------------------------------------------------------------
1578    
1579  __forceinline u32* GET_VU_MEM(VURegs* VU, u32 addr)             // non-static, also used by sVU for now.  __fi u32* GET_VU_MEM(VURegs* VU, u32 addr)              // non-static, also used by sVU for now.
1580  {  {
1581          if( VU == g_pVU1 ) return (u32*)(VU1.Mem+(addr&0x3fff));          if( VU == &vuRegs[1] ) return (u32*)(vuRegs[1].Mem+(addr&0x3fff));
1582          if( addr >= 0x4000 ) return (u32*)(VU0.Mem+(addr&0x43f0)); // get VF and VI regs (they're mapped to 0x4xx0 in VU0 mem!)          if( addr & 0x4000 ) return (u32*)(vuRegs[1].VF+(addr&0x3f0)); // get VF and VI regs (they're mapped to 0x4xx0 in VU0 mem!)
1583          return (u32*)(VU0.Mem+(addr&0x0fff)); // for addr 0x0000 to 0x4000 just wrap around          return (u32*)(vuRegs[0].Mem+(addr&0x0fff)); // for addr 0x0000 to 0x4000 just wrap around
1584  }  }
1585    
1586  void _vuLQ(VURegs * VU) {  static __ri void _vuLQ(VURegs * VU) {
         s16 imm;  
         u16 addr;  
         u32 *ptr;  
   
1587          if (_Ft_ == 0) return;          if (_Ft_ == 0) return;
1588    
1589          imm = (VU->code & 0x400) ? (VU->code & 0x3ff) | 0xfc00 : (VU->code & 0x3ff);          s16 imm = (VU->code & 0x400) ? (VU->code & 0x3ff) | 0xfc00 : (VU->code & 0x3ff);
1590          addr = ((imm + VU->VI[_Is_].SS[0]) * 16)& (VU == &VU1 ? 0x3fff : 0xfff);          u16 addr = ((imm + VU->VI[_Is_].SS[0]) * 16);
1591    
1592          ptr = (u32*)GET_VU_MEM(VU, addr);          u32* ptr = (u32*)GET_VU_MEM(VU, addr);
1593          if (_X) VU->VF[_Ft_].UL[0] = ptr[0];          if (_X) VU->VF[_Ft_].UL[0] = ptr[0];
1594          if (_Y) VU->VF[_Ft_].UL[1] = ptr[1];          if (_Y) VU->VF[_Ft_].UL[1] = ptr[1];
1595          if (_Z) VU->VF[_Ft_].UL[2] = ptr[2];          if (_Z) VU->VF[_Ft_].UL[2] = ptr[2];
1596          if (_W) VU->VF[_Ft_].UL[3] = ptr[3];          if (_W) VU->VF[_Ft_].UL[3] = ptr[3];
1597  }  }
1598    
1599  void _vuLQD( VURegs * VU ) {  static __ri void _vuLQD( VURegs * VU ) {
         u32 addr;  
         u32 *ptr;  
   
1600          if (_Is_ != 0) VU->VI[_Is_].US[0]--;          if (_Is_ != 0) VU->VI[_Is_].US[0]--;
1601          if (_Ft_ == 0) return;          if (_Ft_ == 0) return;
1602    
1603          addr = (VU->VI[_Is_].US[0] * 16) & (VU == &VU1 ? 0x3fff : 0xfff);          u32 addr = (VU->VI[_Is_].US[0] * 16);
1604          ptr = (u32*)GET_VU_MEM(VU, addr);          u32* ptr = (u32*)GET_VU_MEM(VU, addr);
1605          if (_X) VU->VF[_Ft_].UL[0] = ptr[0];          if (_X) VU->VF[_Ft_].UL[0] = ptr[0];
1606          if (_Y) VU->VF[_Ft_].UL[1] = ptr[1];          if (_Y) VU->VF[_Ft_].UL[1] = ptr[1];
1607          if (_Z) VU->VF[_Ft_].UL[2] = ptr[2];          if (_Z) VU->VF[_Ft_].UL[2] = ptr[2];
1608          if (_W) VU->VF[_Ft_].UL[3] = ptr[3];          if (_W) VU->VF[_Ft_].UL[3] = ptr[3];
1609  }  }
1610    
1611  void _vuLQI(VURegs * VU) {  static __ri void _vuLQI(VURegs * VU) {
1612          if (_Ft_) {          if (_Ft_) {
1613                  u32 addr;                  u32 addr = (VU->VI[_Is_].US[0] * 16);
1614                  u32 *ptr;                  u32* ptr = (u32*)GET_VU_MEM(VU, addr);
   
                 addr = (VU->VI[_Is_].US[0] * 16)& (VU == &VU1 ? 0x3fff : 0xfff);  
                 ptr = (u32*)GET_VU_MEM(VU, addr);  
1615                  if (_X) VU->VF[_Ft_].UL[0] = ptr[0];                  if (_X) VU->VF[_Ft_].UL[0] = ptr[0];
1616                  if (_Y) VU->VF[_Ft_].UL[1] = ptr[1];                  if (_Y) VU->VF[_Ft_].UL[1] = ptr[1];
1617                  if (_Z) VU->VF[_Ft_].UL[2] = ptr[2];                  if (_Z) VU->VF[_Ft_].UL[2] = ptr[2];
# Line 1632  void _vuLQI(VURegs * VU) { Line 1621  void _vuLQI(VURegs * VU) {
1621  }  }
1622    
1623  /* addr is now signed. Asadr */  /* addr is now signed. Asadr */
1624  void _vuSQ(VURegs * VU) {  static __ri void _vuSQ(VURegs * VU) {
1625          s16 imm;          s16 imm = (VU->code & 0x400) ? (VU->code & 0x3ff) | 0xfc00 : (VU->code & 0x3ff);
1626          u16 addr;          u16 addr = ((imm + VU->VI[_It_].SS[0]) * 16);
1627          u32 *ptr;          u32* ptr = (u32*)GET_VU_MEM(VU, addr);
   
         imm = (VU->code & 0x400) ? (VU->code & 0x3ff) | 0xfc00 : (VU->code & 0x3ff);  
         addr = ((imm + VU->VI[_It_].SS[0]) * 16)& (VU == &VU1 ? 0x3fff : 0xfff);  
         ptr = (u32*)GET_VU_MEM(VU, addr);  
1628          if (_X) ptr[0] = VU->VF[_Fs_].UL[0];          if (_X) ptr[0] = VU->VF[_Fs_].UL[0];
1629          if (_Y) ptr[1] = VU->VF[_Fs_].UL[1];          if (_Y) ptr[1] = VU->VF[_Fs_].UL[1];
1630          if (_Z) ptr[2] = VU->VF[_Fs_].UL[2];          if (_Z) ptr[2] = VU->VF[_Fs_].UL[2];
1631          if (_W) ptr[3] = VU->VF[_Fs_].UL[3];          if (_W) ptr[3] = VU->VF[_Fs_].UL[3];
1632  }  }
1633    
1634  void _vuSQD(VURegs * VU) {  static __ri void _vuSQD(VURegs * VU) {
         u32 addr;  
         u32 *ptr;  
   
1635          if(_Ft_ != 0) VU->VI[_It_].US[0]--;          if(_Ft_ != 0) VU->VI[_It_].US[0]--;
1636          addr = (VU->VI[_It_].US[0] * 16)& (VU == &VU1 ? 0x3fff : 0xfff);          u32 addr = (VU->VI[_It_].US[0] * 16);
1637          ptr = (u32*)GET_VU_MEM(VU, addr);          u32* ptr = (u32*)GET_VU_MEM(VU, addr);
1638          if (_X) ptr[0] = VU->VF[_Fs_].UL[0];          if (_X) ptr[0] = VU->VF[_Fs_].UL[0];
1639          if (_Y) ptr[1] = VU->VF[_Fs_].UL[1];          if (_Y) ptr[1] = VU->VF[_Fs_].UL[1];
1640          if (_Z) ptr[2] = VU->VF[_Fs_].UL[2];          if (_Z) ptr[2] = VU->VF[_Fs_].UL[2];
1641          if (_W) ptr[3] = VU->VF[_Fs_].UL[3];          if (_W) ptr[3] = VU->VF[_Fs_].UL[3];
1642  }  }
1643    
1644  void _vuSQI(VURegs * VU) {  static __ri void _vuSQI(VURegs * VU) {
1645          u32 addr;          u32 addr = (VU->VI[_It_].US[0] * 16);
1646          u32 *ptr;          u32* ptr = (u32*)GET_VU_MEM(VU, addr);
   
         addr = (VU->VI[_It_].US[0] * 16)& (VU == &VU1 ? 0x3fff : 0xfff);  
         ptr = (u32*)GET_VU_MEM(VU, addr);  
1647          if (_X) ptr[0] = VU->VF[_Fs_].UL[0];          if (_X) ptr[0] = VU->VF[_Fs_].UL[0];
1648          if (_Y) ptr[1] = VU->VF[_Fs_].UL[1];          if (_Y) ptr[1] = VU->VF[_Fs_].UL[1];
1649          if (_Z) ptr[2] = VU->VF[_Fs_].UL[2];          if (_Z) ptr[2] = VU->VF[_Fs_].UL[2];
# Line 1673  void _vuSQI(VURegs * VU) { Line 1652  void _vuSQI(VURegs * VU) {
1652  }  }
1653    
1654  /* addr now signed. asadr */  /* addr now signed. asadr */
1655  void _vuILW(VURegs * VU) {  static __ri void _vuILW(VURegs * VU) {
         s16 imm;  
         u16 addr;  
         u16 *ptr;  
1656          if (_It_ == 0) return;          if (_It_ == 0) return;
1657    
1658          imm = (VU->code & 0x400) ? (VU->code & 0x3ff) | 0xfc00 : (VU->code & 0x3ff);          s16 imm = (VU->code & 0x400) ? (VU->code & 0x3ff) | 0xfc00 : (VU->code & 0x3ff);
1659          addr = ((imm + VU->VI[_Is_].SS[0]) * 16)& (VU == &VU1 ? 0x3fff : 0xfff);          u16 addr = ((imm + VU->VI[_Is_].SS[0]) * 16);
1660          ptr = (u16*)GET_VU_MEM(VU, addr);          u16* ptr = (u16*)GET_VU_MEM(VU, addr);
1661          if (_X) VU->VI[_It_].US[0] = ptr[0];          if (_X) VU->VI[_It_].US[0] = ptr[0];
1662          if (_Y) VU->VI[_It_].US[0] = ptr[2];          if (_Y) VU->VI[_It_].US[0] = ptr[2];
1663          if (_Z) VU->VI[_It_].US[0] = ptr[4];          if (_Z) VU->VI[_It_].US[0] = ptr[4];
1664          if (_W) VU->VI[_It_].US[0] = ptr[6];          if (_W) VU->VI[_It_].US[0] = ptr[6];
1665  }  }
1666    
1667  void _vuISW(VURegs * VU) {  static __fi void _vuISW(VURegs * VU) {
1668          s16 imm;          s16 imm = (VU->code & 0x400) ? (VU->code & 0x3ff) | 0xfc00 : (VU->code & 0x3ff);
1669          u16 addr;          u16 addr = ((imm + VU->VI[_Is_].SS[0]) * 16);
1670          u16 *ptr;          u16* ptr = (u16*)GET_VU_MEM(VU, addr);
   
         imm = (VU->code & 0x400) ? (VU->code & 0x3ff) | 0xfc00 : (VU->code & 0x3ff);  
         addr = ((imm + VU->VI[_Is_].SS[0]) * 16)& (VU == &VU1 ? 0x3fff : 0xfff);  
         ptr = (u16*)GET_VU_MEM(VU, addr);  
1671          if (_X) { ptr[0] = VU->VI[_It_].US[0]; ptr[1] = 0; }          if (_X) { ptr[0] = VU->VI[_It_].US[0]; ptr[1] = 0; }
1672          if (_Y) { ptr[2] = VU->VI[_It_].US[0]; ptr[3] = 0; }          if (_Y) { ptr[2] = VU->VI[_It_].US[0]; ptr[3] = 0; }
1673          if (_Z) { ptr[4] = VU->VI[_It_].US[0]; ptr[5] = 0; }          if (_Z) { ptr[4] = VU->VI[_It_].US[0]; ptr[5] = 0; }
1674          if (_W) { ptr[6] = VU->VI[_It_].US[0]; ptr[7] = 0; }          if (_W) { ptr[6] = VU->VI[_It_].US[0]; ptr[7] = 0; }
1675  }  }
1676    
1677  void _vuILWR(VURegs * VU) {  static __ri void _vuILWR(VURegs * VU) {
         u32 addr;  
         u16 *ptr;  
1678          if (_It_ == 0) return;          if (_It_ == 0) return;
1679    
1680          addr = (VU->VI[_Is_].US[0] * 16)& (VU == &VU1 ? 0x3fff : 0xfff);          u32 addr = (VU->VI[_Is_].US[0] * 16);
1681          ptr = (u16*)GET_VU_MEM(VU, addr);          u16* ptr = (u16*)GET_VU_MEM(VU, addr);
1682          if (_X) VU->VI[_It_].US[0] = ptr[0];          if (_X) VU->VI[_It_].US[0] = ptr[0];
1683          if (_Y) VU->VI[_It_].US[0] = ptr[2];          if (_Y) VU->VI[_It_].US[0] = ptr[2];
1684          if (_Z) VU->VI[_It_].US[0] = ptr[4];          if (_Z) VU->VI[_It_].US[0] = ptr[4];
1685          if (_W) VU->VI[_It_].US[0] = ptr[6];          if (_W) VU->VI[_It_].US[0] = ptr[6];
1686  }  }
1687    
1688  void _vuISWR(VURegs * VU) {  static __ri void _vuISWR(VURegs * VU) {
1689          u32 addr;          u32 addr = (VU->VI[_Is_].US[0] * 16);
1690          u16 *ptr;          u16* ptr = (u16*)GET_VU_MEM(VU, addr);
   
         addr = (VU->VI[_Is_].US[0] * 16) & (VU == &VU1 ? 0x3fff : 0xfff);  
         ptr = (u16*)GET_VU_MEM(VU, addr);  
1691          if (_X) { ptr[0] = VU->VI[_It_].US[0]; ptr[1] = 0; }          if (_X) { ptr[0] = VU->VI[_It_].US[0]; ptr[1] = 0; }
1692          if (_Y) { ptr[2] = VU->VI[_It_].US[0]; ptr[3] = 0; }          if (_Y) { ptr[2] = VU->VI[_It_].US[0]; ptr[3] = 0; }
1693          if (_Z) { ptr[4] = VU->VI[_It_].US[0]; ptr[5] = 0; }          if (_Z) { ptr[4] = VU->VI[_It_].US[0]; ptr[5] = 0; }
# Line 1740  As an example for setting the polynomial Line 1707  As an example for setting the polynomial
1707    
1708  //The two-tap 23 stage M-series polynomials are x23+x18 and x23+x14 ((1 << 18) and (1 << 14), respectively).  //The two-tap 23 stage M-series polynomials are x23+x18 and x23+x14 ((1 << 18) and (1 << 14), respectively).
1709  //The reverse sequences can be generated by x23+x(23-18) and x23+x(23-14) ((1 << 9) and (1 << 5), respectively)  //The reverse sequences can be generated by x23+x(23-18) and x23+x(23-14) ((1 << 9) and (1 << 5), respectively)
1710  u32 poly = 1 << 5;  static u32 poly = 1 << 5;
1711    
1712  void SetPoly(u32 newPoly) {  static __ri void SetPoly(u32 newPoly) {
1713          poly = poly & ~1;          poly = poly & ~1;
1714  }  }
1715    
1716  void AdvanceLFSR(VURegs * VU) {  static __ri void AdvanceLFSR(VURegs * VU) {
1717          // code from www.project-fao.org (which is no longer there)          // code from www.project-fao.org (which is no longer there)
1718          int x = (VU->VI[REG_R].UL >> 4) & 1;          int x = (VU->VI[REG_R].UL >> 4) & 1;
1719          int y = (VU->VI[REG_R].UL >> 22) & 1;          int y = (VU->VI[REG_R].UL >> 22) & 1;
# Line 1755  void AdvanceLFSR(VURegs * VU) { Line 1722  void AdvanceLFSR(VURegs * VU) {
1722          VU->VI[REG_R].UL = (VU->VI[REG_R].UL&0x7fffff)|0x3f800000;          VU->VI[REG_R].UL = (VU->VI[REG_R].UL&0x7fffff)|0x3f800000;
1723  }  }
1724    
1725  void _vuRINIT(VURegs * VU) {  static __ri void _vuRINIT(VURegs * VU) {
1726          VU->VI[REG_R].UL = 0x3F800000 | (VU->VF[_Fs_].UL[_Fsf_] & 0x007FFFFF);          VU->VI[REG_R].UL = 0x3F800000 | (VU->VF[_Fs_].UL[_Fsf_] & 0x007FFFFF);
1727  }  }
1728    
1729  void _vuRGET(VURegs * VU) {  static __ri void _vuRGET(VURegs * VU) {
1730          if (_Ft_ == 0) return;          if (_Ft_ == 0) return;
1731    
1732          if (_X) VU->VF[_Ft_].UL[0] = VU->VI[REG_R].UL;          if (_X) VU->VF[_Ft_].UL[0] = VU->VI[REG_R].UL;
# Line 1768  void _vuRGET(VURegs * VU) { Line 1735  void _vuRGET(VURegs * VU) {
1735          if (_W) VU->VF[_Ft_].UL[3] = VU->VI[REG_R].UL;          if (_W) VU->VF[_Ft_].UL[3] = VU->VI[REG_R].UL;
1736  }  }
1737    
1738  void _vuRNEXT(VURegs * VU) {  static __ri void _vuRNEXT(VURegs * VU) {
1739          if (_Ft_ == 0) return;          if (_Ft_ == 0) return;
1740          AdvanceLFSR(VU);          AdvanceLFSR(VU);
1741          if (_X) VU->VF[_Ft_].UL[0] = VU->VI[REG_R].UL;          if (_X) VU->VF[_Ft_].UL[0] = VU->VI[REG_R].UL;
# Line 1777  void _vuRNEXT(VURegs * VU) { Line 1744  void _vuRNEXT(VURegs * VU) {
1744          if (_W) VU->VF[_Ft_].UL[3] = VU->VI[REG_R].UL;          if (_W) VU->VF[_Ft_].UL[3] = VU->VI[REG_R].UL;
1745  }  }
1746    
1747  void _vuRXOR(VURegs * VU) {  static __ri void _vuRXOR(VURegs * VU) {
1748          VU->VI[REG_R].UL = 0x3F800000 | ((VU->VI[REG_R].UL ^ VU->VF[_Fs_].UL[_Fsf_]) & 0x007FFFFF);          VU->VI[REG_R].UL = 0x3F800000 | ((VU->VI[REG_R].UL ^ VU->VF[_Fs_].UL[_Fsf_]) & 0x007FFFFF);
1749  }  }
1750    
1751  void _vuWAITQ(VURegs * VU) {  static __ri void _vuWAITQ(VURegs * VU) {
1752  }  }
1753    
1754  void _vuFSAND(VURegs * VU) {  static __ri void _vuFSAND(VURegs * VU) {
1755          u16 imm;          u16 imm;
1756          imm = (((VU->code >> 21 ) & 0x1) << 11) | (VU->code & 0x7ff);          imm = (((VU->code >> 21 ) & 0x1) << 11) | (VU->code & 0x7ff);
1757          if(_It_ == 0) return;          if(_It_ == 0) return;
1758          VU->VI[_It_].US[0] = (VU->VI[REG_STATUS_FLAG].US[0] & 0xFFF) & imm;          VU->VI[_It_].US[0] = (VU->VI[REG_STATUS_FLAG].US[0] & 0xFFF) & imm;
1759  }  }
1760    
1761  void _vuFSEQ(VURegs * VU) {  static __ri void _vuFSEQ(VURegs * VU) {
1762          u16 imm;          u16 imm;
1763          imm = (((VU->code >> 21 ) & 0x1) << 11) | (VU->code & 0x7ff);          imm = (((VU->code >> 21 ) & 0x1) << 11) | (VU->code & 0x7ff);
1764          if(_It_ == 0) return;          if(_It_ == 0) return;
# Line 1799  void _vuFSEQ(VURegs * VU) { Line 1766  void _vuFSEQ(VURegs * VU) {
1766          else VU->VI[_It_].US[0] = 0;          else VU->VI[_It_].US[0] = 0;
1767  }  }
1768    
1769  void _vuFSOR(VURegs * VU) {  static __ri void _vuFSOR(VURegs * VU) {
1770          u16 imm;          u16 imm;
1771          imm = (((VU->code >> 21 ) & 0x1) << 11) | (VU->code & 0x7ff);          imm = (((VU->code >> 21 ) & 0x1) << 11) | (VU->code & 0x7ff);
1772          if(_It_ == 0) return;          if(_It_ == 0) return;
1773          VU->VI[_It_].US[0] = (VU->VI[REG_STATUS_FLAG].US[0] & 0xFFF) | imm;          VU->VI[_It_].US[0] = (VU->VI[REG_STATUS_FLAG].US[0] & 0xFFF) | imm;
1774  }  }
1775    
1776  void _vuFSSET(VURegs * VU) {  static __ri void _vuFSSET(VURegs * VU) {
1777          u16 imm = 0;          u16 imm = 0;
1778          imm = (((VU->code >> 21 ) & 0x1) << 11) | (VU->code & 0x7FF);          imm = (((VU->code >> 21 ) & 0x1) << 11) | (VU->code & 0x7FF);
1779          VU->statusflag = (imm & 0xFC0) | (VU->VI[REG_STATUS_FLAG].US[0] & 0x3F);          VU->statusflag = (imm & 0xFC0) | (VU->VI[REG_STATUS_FLAG].US[0] & 0x3F);
1780  }  }
1781    
1782  void _vuFMAND(VURegs * VU) {  static __ri void _vuFMAND(VURegs * VU) {
1783          if(_It_ == 0) return;          if(_It_ == 0) return;
1784          VU->VI[_It_].US[0] = VU->VI[_Is_].US[0] & (VU->VI[REG_MAC_FLAG].UL & 0xFFFF);          VU->VI[_It_].US[0] = VU->VI[_Is_].US[0] & (VU->VI[REG_MAC_FLAG].UL & 0xFFFF);
1785  }  }
1786    
1787  void _vuFMEQ(VURegs * VU) {  static __fi void _vuFMEQ(VURegs * VU) {
1788          if(_It_ == 0) return;          if(_It_ == 0) return;
1789          if((VU->VI[REG_MAC_FLAG].UL & 0xFFFF) == VU->VI[_Is_].US[0]){          if((VU->VI[REG_MAC_FLAG].UL & 0xFFFF) == VU->VI[_Is_].US[0]){
1790          VU->VI[_It_].US[0] =1;} else { VU->VI[_It_].US[0] =0; }          VU->VI[_It_].US[0] =1;} else { VU->VI[_It_].US[0] =0; }
1791  }  }
1792    
1793  void _vuFMOR(VURegs * VU) {  static __fi void _vuFMOR(VURegs * VU) {
1794          if(_It_ == 0) return;          if(_It_ == 0) return;
1795          VU->VI[_It_].US[0] = (VU->VI[REG_MAC_FLAG].UL & 0xFFFF) | VU->VI[_Is_].US[0];          VU->VI[_It_].US[0] = (VU->VI[REG_MAC_FLAG].UL & 0xFFFF) | VU->VI[_Is_].US[0];
1796  }  }
1797    
1798  void _vuFCAND(VURegs * VU) {  static __fi void _vuFCAND(VURegs * VU) {
1799          if((VU->VI[REG_CLIP_FLAG].UL & 0xFFFFFF) & (VU->code & 0xFFFFFF)) VU->VI[1].US[0] = 1;          if((VU->VI[REG_CLIP_FLAG].UL & 0xFFFFFF) & (VU->code & 0xFFFFFF)) VU->VI[1].US[0] = 1;
1800          else VU->VI[1].US[0] = 0;          else VU->VI[1].US[0] = 0;
1801  }  }
1802    
1803  void _vuFCEQ(VURegs * VU) {  static __fi void _vuFCEQ(VURegs * VU) {
1804          if((VU->VI[REG_CLIP_FLAG].UL & 0xFFFFFF) == (VU->code & 0xFFFFFF)) VU->VI[1].US[0] = 1;          if((VU->VI[REG_CLIP_FLAG].UL & 0xFFFFFF) == (VU->code & 0xFFFFFF)) VU->VI[1].US[0] = 1;
1805          else VU->VI[1].US[0] = 0;          else VU->VI[1].US[0] = 0;
1806  }  }
1807    
1808  void _vuFCOR(VURegs * VU) {  static __fi void _vuFCOR(VURegs * VU) {
1809          u32 hold = (VU->VI[REG_CLIP_FLAG].UL & 0xFFFFFF) | ( VU->code & 0xFFFFFF);          u32 hold = (VU->VI[REG_CLIP_FLAG].UL & 0xFFFFFF) | ( VU->code & 0xFFFFFF);
1810          if(hold == 0xFFFFFF) VU->VI[1].US[0] = 1;          if(hold == 0xFFFFFF) VU->VI[1].US[0] = 1;
1811          else VU->VI[1].US[0] = 0;          else VU->VI[1].US[0] = 0;
1812  }  }
1813    
1814  void _vuFCSET(VURegs * VU) {  static __fi void _vuFCSET(VURegs * VU) {
1815          VU->clipflag = (u32) (VU->code & 0xFFFFFF);          VU->clipflag = (u32) (VU->code & 0xFFFFFF);
1816          VU->VI[REG_CLIP_FLAG].UL = (u32) (VU->code & 0xFFFFFF);          VU->VI[REG_CLIP_FLAG].UL = (u32) (VU->code & 0xFFFFFF);
1817  }  }
1818    
1819  void _vuFCGET(VURegs * VU) {  static __fi void _vuFCGET(VURegs * VU) {
1820          if(_It_ == 0) return;          if(_It_ == 0) return;
1821          VU->VI[_It_].US[0] = VU->VI[REG_CLIP_FLAG].UL & 0x0FFF;          VU->VI[_It_].US[0] = VU->VI[REG_CLIP_FLAG].UL & 0x0FFF;
1822  }  }
# Line 1860  s32 _branchAddr(VURegs * VU) { Line 1827  s32 _branchAddr(VURegs * VU) {
1827          return bpc;          return bpc;
1828  }  }
1829    
1830  void _setBranch(VURegs * VU, u32 bpc) {  static __fi void _setBranch(VURegs * VU, u32 bpc) {
1831          VU->branch = 2;          VU->branch = 2;
1832          VU->branchpc = bpc;          VU->branchpc = bpc;
1833  }  }
1834    
1835  void _vuIBEQ(VURegs * VU) {  static __ri void _vuIBEQ(VURegs * VU) {
1836          if (VU->VI[_It_].US[0] == VU->VI[_Is_].US[0]) {          if (VU->VI[_It_].US[0] == VU->VI[_Is_].US[0]) {
1837                  s32 bpc = _branchAddr(VU);                  s32 bpc = _branchAddr(VU);
1838                  _setBranch(VU, bpc);                  _setBranch(VU, bpc);
1839          }          }
1840  }  }
1841    
1842  void _vuIBGEZ(VURegs * VU) {  static __ri void _vuIBGEZ(VURegs * VU) {
1843          if (VU->VI[_Is_].SS[0] >= 0) {          if (VU->VI[_Is_].SS[0] >= 0) {
1844                  s32 bpc = _branchAddr(VU);                  s32 bpc = _branchAddr(VU);
1845                  _setBranch(VU, bpc);                  _setBranch(VU, bpc);
1846          }          }
1847  }  }
1848    
1849  void _vuIBGTZ(VURegs * VU) {  static __ri void _vuIBGTZ(VURegs * VU) {
1850          if (VU->VI[_Is_].SS[0] > 0) {          if (VU->VI[_Is_].SS[0] > 0) {
1851                  s32 bpc = _branchAddr(VU);                  s32 bpc = _branchAddr(VU);
1852                  _setBranch(VU, bpc);                  _setBranch(VU, bpc);
1853          }          }
1854  }  }
1855    
1856  void _vuIBLEZ(VURegs * VU) {  static __ri void _vuIBLEZ(VURegs * VU) {
1857          if (VU->VI[_Is_].SS[0] <= 0) {          if (VU->VI[_Is_].SS[0] <= 0) {
1858                  s32 bpc = _branchAddr(VU);                  s32 bpc = _branchAddr(VU);
1859                  _setBranch(VU, bpc);                  _setBranch(VU, bpc);
1860          }          }
1861  }  }
1862    
1863  void _vuIBLTZ(VURegs * VU) {  static __ri void _vuIBLTZ(VURegs * VU) {
1864          if (VU->VI[_Is_].SS[0] < 0) {          if (VU->VI[_Is_].SS[0] < 0) {
1865                  s32 bpc = _branchAddr(VU);                  s32 bpc = _branchAddr(VU);
1866                  _setBranch(VU, bpc);                  _setBranch(VU, bpc);
1867          }          }
1868  }  }
1869    
1870  void _vuIBNE(VURegs * VU) {  static __ri void _vuIBNE(VURegs * VU) {
1871          if (VU->VI[_It_].US[0] != VU->VI[_Is_].US[0]) {          if (VU->VI[_It_].US[0] != VU->VI[_Is_].US[0]) {
1872                  s32 bpc = _branchAddr(VU);                  s32 bpc = _branchAddr(VU);
1873                  _setBranch(VU, bpc);                  _setBranch(VU, bpc);
1874          }          }
1875  }  }
1876    
1877  void _vuB(VURegs * VU) {  static __ri void _vuB(VURegs * VU) {
1878          s32 bpc = _branchAddr(VU);          s32 bpc = _branchAddr(VU);
1879          _setBranch(VU, bpc);          _setBranch(VU, bpc);
1880  }  }
1881    
1882  void _vuBAL(VURegs * VU) {  static __ri void _vuBAL(VURegs * VU) {
1883          s32 bpc = _branchAddr(VU);          s32 bpc = _branchAddr(VU);
1884    
1885          if (_It_) VU->VI[_It_].US[0] = (VU->VI[REG_TPC].UL + 8)/8;          if (_It_) VU->VI[_It_].US[0] = (VU->VI[REG_TPC].UL + 8)/8;
# Line 1920  void _vuBAL(VURegs * VU) { Line 1887  void _vuBAL(VURegs * VU) {
1887          _setBranch(VU, bpc);          _setBranch(VU, bpc);
1888  }  }
1889    
1890  void _vuJR(VURegs * VU) {  static __ri void _vuJR(VURegs * VU) {
1891      u32 bpc = VU->VI[_Is_].US[0] * 8;      u32 bpc = VU->VI[_Is_].US[0] * 8;
1892          _setBranch(VU, bpc);          _setBranch(VU, bpc);
1893  }  }
1894    
1895  void _vuJALR(VURegs * VU) {  static __ri void _vuJALR(VURegs * VU) {
1896      u32 bpc = VU->VI[_Is_].US[0] * 8;      u32 bpc = VU->VI[_Is_].US[0] * 8;
1897          if (_It_) VU->VI[_It_].US[0] = (VU->VI[REG_TPC].UL + 8)/8;          if (_It_) VU->VI[_It_].US[0] = (VU->VI[REG_TPC].UL + 8)/8;
1898    
1899          _setBranch(VU, bpc);          _setBranch(VU, bpc);
1900  }  }
1901    
1902  void _vuMFP(VURegs * VU) {  static __ri void _vuMFP(VURegs * VU) {
1903          if (_Ft_ == 0) return;          if (_Ft_ == 0) return;
1904    
1905          if (_X) VU->VF[_Ft_].i.x = VU->VI[REG_P].UL;          if (_X) VU->VF[_Ft_].i.x = VU->VI[REG_P].UL;
# Line 1941  void _vuMFP(VURegs * VU) { Line 1908  void _vuMFP(VURegs * VU) {
1908          if (_W) VU->VF[_Ft_].i.w = VU->VI[REG_P].UL;          if (_W) VU->VF[_Ft_].i.w = VU->VI[REG_P].UL;
1909  }  }
1910    
1911  void _vuWAITP(VURegs * VU) {  static __ri void _vuWAITP(VURegs * VU) {
1912  }  }
1913    
1914  void _vuESADD(VURegs * VU) {  static __ri void _vuESADD(VURegs * VU) {
1915          float p = vuDouble(VU->VF[_Fs_].i.x) * vuDouble(VU->VF[_Fs_].i.x) + vuDouble(VU->VF[_Fs_].i.y) * vuDouble(VU->VF[_Fs_].i.y) + vuDouble(VU->VF[_Fs_].i.z) * vuDouble(VU->VF[_Fs_].i.z);          float p = vuDouble(VU->VF[_Fs_].i.x) * vuDouble(VU->VF[_Fs_].i.x) + vuDouble(VU->VF[_Fs_].i.y) * vuDouble(VU->VF[_Fs_].i.y) + vuDouble(VU->VF[_Fs_].i.z) * vuDouble(VU->VF[_Fs_].i.z);
1916          VU->p.F = p;          VU->p.F = p;
1917  }  }
1918    
1919  void _vuERSADD(VURegs * VU) {  static __ri void _vuERSADD(VURegs * VU) {
1920          float p = (vuDouble(VU->VF[_Fs_].i.x) * vuDouble(VU->VF[_Fs_].i.x)) + (vuDouble(VU->VF[_Fs_].i.y) * vuDouble(VU->VF[_Fs_].i.y)) + (vuDouble(VU->VF[_Fs_].i.z) * vuDouble(VU->VF[_Fs_].i.z));          float p = (vuDouble(VU->VF[_Fs_].i.x) * vuDouble(VU->VF[_Fs_].i.x)) + (vuDouble(VU->VF[_Fs_].i.y) * vuDouble(VU->VF[_Fs_].i.y)) + (vuDouble(VU->VF[_Fs_].i.z) * vuDouble(VU->VF[_Fs_].i.z));
1921          if (p != 0.0)          if (p != 0.0)
1922                  p = 1.0f / p;                  p = 1.0f / p;
# Line 1957  void _vuERSADD(VURegs * VU) { Line 1924  void _vuERSADD(VURegs * VU) {
1924  }  }
1925    
1926  /* Fixed. Could have caused crash due to value being -ve for sqrt *asadr */  /* Fixed. Could have caused crash due to value being -ve for sqrt *asadr */
1927  void _vuELENG(VURegs * VU) {  static __ri void _vuELENG(VURegs * VU) {
1928          float p = vuDouble(VU->VF[_Fs_].i.x) * vuDouble(VU->VF[_Fs_].i.x) + vuDouble(VU->VF[_Fs_].i.y) * vuDouble(VU->VF[_Fs_].i.y) + vuDouble(VU->VF[_Fs_].i.z) * vuDouble(VU->VF[_Fs_].i.z);          float p = vuDouble(VU->VF[_Fs_].i.x) * vuDouble(VU->VF[_Fs_].i.x) + vuDouble(VU->VF[_Fs_].i.y) * vuDouble(VU->VF[_Fs_].i.y) + vuDouble(VU->VF[_Fs_].i.z) * vuDouble(VU->VF[_Fs_].i.z);
1929          if(p >= 0){          if(p >= 0){
1930                  p = sqrt(p);                  p = sqrt(p);
# Line 1966  void _vuELENG(VURegs * VU) { Line 1933  void _vuELENG(VURegs * VU) {
1933  }  }
1934    
1935  /* Fixed. Could have caused crash due to divisor being = 0 *asadr */  /* Fixed. Could have caused crash due to divisor being = 0 *asadr */
1936  void _vuERLENG(VURegs * VU) {  static __ri void _vuERLENG(VURegs * VU) {
1937          float p = vuDouble(VU->VF[_Fs_].i.x) * vuDouble(VU->VF[_Fs_].i.x) + vuDouble(VU->VF[_Fs_].i.y) * vuDouble(VU->VF[_Fs_].i.y) + vuDouble(VU->VF[_Fs_].i.z) * vuDouble(VU->VF[_Fs_].i.z);          float p = vuDouble(VU->VF[_Fs_].i.x) * vuDouble(VU->VF[_Fs_].i.x) + vuDouble(VU->VF[_Fs_].i.y) * vuDouble(VU->VF[_Fs_].i.y) + vuDouble(VU->VF[_Fs_].i.z) * vuDouble(VU->VF[_Fs_].i.z);
1938          if (p >= 0) {          if (p >= 0) {
1939                  p = sqrt(p);                  p = sqrt(p);
# Line 1978  void _vuERLENG(VURegs * VU) { Line 1945  void _vuERLENG(VURegs * VU) {
1945  }  }
1946    
1947  /* Fixed. Could have caused crash due to divisor being = 0 *asadr */  /* Fixed. Could have caused crash due to divisor being = 0 *asadr */
1948  void _vuEATANxy(VURegs * VU) {  static __ri void _vuEATANxy(VURegs * VU) {
1949          float p = 0;          float p = 0;
1950          if(vuDouble(VU->VF[_Fs_].i.x) != 0) {          if(vuDouble(VU->VF[_Fs_].i.x) != 0) {
1951                  p = atan2(vuDouble(VU->VF[_Fs_].i.y), vuDouble(VU->VF[_Fs_].i.x));                  p = atan2(vuDouble(VU->VF[_Fs_].i.y), vuDouble(VU->VF[_Fs_].i.x));
# Line 1987  void _vuEATANxy(VURegs * VU) { Line 1954  void _vuEATANxy(VURegs * VU) {
1954  }  }
1955    
1956  /* Fixed. Could have caused crash due to divisor being = 0 *asadr */  /* Fixed. Could have caused crash due to divisor being = 0 *asadr */
1957  void _vuEATANxz(VURegs * VU) {  static __ri void _vuEATANxz(VURegs * VU) {
1958          float p = 0;          float p = 0;
1959          if(vuDouble(VU->VF[_Fs_].i.x) != 0) {          if(vuDouble(VU->VF[_Fs_].i.x) != 0) {
1960                  p = atan2(vuDouble(VU->VF[_Fs_].i.z), vuDouble(VU->VF[_Fs_].i.x));                  p = atan2(vuDouble(VU->VF[_Fs_].i.z), vuDouble(VU->VF[_Fs_].i.x));
# Line 1995  void _vuEATANxz(VURegs * VU) { Line 1962  void _vuEATANxz(VURegs * VU) {
1962          VU->p.F = p;          VU->p.F = p;
1963  }  }
1964    
1965  void _vuESUM(VURegs * VU) {  static __ri void _vuESUM(VURegs * VU) {
1966          float p = vuDouble(VU->VF[_Fs_].i.x) + vuDouble(VU->VF[_Fs_].i.y) + vuDouble(VU->VF[_Fs_].i.z) + vuDouble(VU->VF[_Fs_].i.w);          float p = vuDouble(VU->VF[_Fs_].i.x) + vuDouble(VU->VF[_Fs_].i.y) + vuDouble(VU->VF[_Fs_].i.z) + vuDouble(VU->VF[_Fs_].i.w);
1967          VU->p.F = p;          VU->p.F = p;
1968  }  }
1969    
1970  /* Fixed. Could have caused crash due to divisor being = 0 *asadr */  /* Fixed. Could have caused crash due to divisor being = 0 *asadr */
1971  void _vuERCPR(VURegs * VU) {  static __ri void _vuERCPR(VURegs * VU) {
1972          float p = vuDouble(VU->VF[_Fs_].UL[_Fsf_]);          float p = vuDouble(VU->VF[_Fs_].UL[_Fsf_]);
1973          if (p != 0){          if (p != 0){
1974                  p = 1.0 / p;                  p = 1.0 / p;
# Line 2010  void _vuERCPR(VURegs * VU) { Line 1977  void _vuERCPR(VURegs * VU) {
1977  }  }
1978    
1979  /* Fixed. Could have caused crash due to Value being -ve for sqrt *asadr */  /* Fixed. Could have caused crash due to Value being -ve for sqrt *asadr */
1980  void _vuESQRT(VURegs * VU) {  static __ri void _vuESQRT(VURegs * VU) {
1981          float p = vuDouble(VU->VF[_Fs_].UL[_Fsf_]);          float p = vuDouble(VU->VF[_Fs_].UL[_Fsf_]);
1982          if (p >= 0){          if (p >= 0){
1983                  p = sqrt(p);                  p = sqrt(p);
# Line 2019  void _vuESQRT(VURegs * VU) { Line 1986  void _vuESQRT(VURegs * VU) {
1986  }  }
1987    
1988  /* Fixed. Could have caused crash due to divisor being = 0 *asadr */  /* Fixed. Could have caused crash due to divisor being = 0 *asadr */
1989  void _vuERSQRT(VURegs * VU) {  static __ri void _vuERSQRT(VURegs * VU) {
1990          float p = vuDouble(VU->VF[_Fs_].UL[_Fsf_]);          float p = vuDouble(VU->VF[_Fs_].UL[_Fsf_]);
1991          if (p >= 0) {          if (p >= 0) {
1992                  p = sqrt(p);                  p = sqrt(p);
# Line 2030  void _vuERSQRT(VURegs * VU) { Line 1997  void _vuERSQRT(VURegs * VU) {
1997          VU->p.F = p;          VU->p.F = p;
1998  }  }
1999    
2000  void _vuESIN(VURegs * VU) {  static __ri void _vuESIN(VURegs * VU) {
2001          float p = sin(vuDouble(VU->VF[_Fs_].UL[_Fsf_]));          float p = sin(vuDouble(VU->VF[_Fs_].UL[_Fsf_]));
2002          VU->p.F = p;          VU->p.F = p;
2003  }  }
2004    
2005  void _vuEATAN(VURegs * VU) {  static __ri void _vuEATAN(VURegs * VU) {
2006          float p = atan(vuDouble(VU->VF[_Fs_].UL[_Fsf_]));          float p = atan(vuDouble(VU->VF[_Fs_].UL[_Fsf_]));
2007          VU->p.F = p;          VU->p.F = p;
2008  }  }
2009    
2010  void _vuEEXP(VURegs * VU) {  static __ri void _vuEEXP(VURegs * VU) {
2011          float p = exp(-(vuDouble(VU->VF[_Fs_].UL[_Fsf_])));          float p = exp(-(vuDouble(VU->VF[_Fs_].UL[_Fsf_])));
2012          VU->p.F = p;          VU->p.F = p;
2013  }  }
2014    
2015  void _vuXITOP(VURegs * VU) {  static __ri void _vuXITOP(VURegs * VU) {
2016          if (_It_ == 0) return;          if (_It_ == 0) return;
2017          VU->VI[_It_].US[0] = VU->vifRegs->itop;          VU->VI[_It_].US[0] = VU->GetVifRegs().itop;
2018  }  }
2019    
2020  void _vuXGKICK(VURegs * VU)  static __ri void _vuXGKICK(VURegs * VU)
2021  {  {
2022          // flush all pipelines first (in the right order)          // flush all pipelines first (in the right order)
2023          _vuFlushAll(VU);          _vuFlushAll(VU);
2024    
2025          u8* data = ((u8*)VU->Mem + ((VU->VI[_Is_].US[0]*16) & 0x3fff));          u8* data = ((u8*)VU->Mem + ((VU->VI[_Is_].US[0]*16) & 0x3fff));
2026          u32 size;          u32 size;
2027          size = GetMTGS().PrepDataPacket( GIF_PATH_1, data, (0x4000-((VU->VI[_Is_].US[0]*16) & 0x3fff)) >> 4);          GetMTGS().PrepDataPacket( GIF_PATH_1, 0x400 );
2028          u8* pmem = GetMTGS().GetDataPacketPtr();          size = GIFPath_CopyTag( GIF_PATH_1, (u128*)data, (0x400-(VU->VI[_Is_].US[0] & 0x3ff)) );
   
         if((size << 4) > (u32)(0x4000-((VU->VI[_Is_].US[0]*16) & 0x3fff)))  
         {  
                 //DevCon.Warning("addr + Size = 0x%x, transferring %x then doing %x", ((VU->VI[_Is_].US[0]*16) & 0x3fff) + (size << 4), (0x4000-((VU->VI[_Is_].US[0]*16) & 0x3fff)) >> 4, size - (0x4000-((VU->VI[_Is_].US[0]*16) & 0x3fff) >> 4));  
                 memcpy_aligned(pmem, (u8*)VU->Mem+((VU->VI[_Is_].US[0]*16) & 0x3fff), 0x4000-((VU->VI[_Is_].US[0]*16) & 0x3fff));  
                 size -= (0x4000-((VU->VI[_Is_].US[0]*16) & 0x3fff)) >> 4;  
                 //DevCon.Warning("Size left %x", size);  
                 pmem += 0x4000-((VU->VI[_Is_].US[0]*16) & 0x3fff);  
                 memcpy_aligned(pmem, (u8*)VU->Mem, size<<4);  
         }  
         else {  
                 memcpy_aligned(pmem, (u8*)VU->Mem+((VU->VI[_Is_].US[0]*16) & 0x3fff), size<<4);  
         }  
2029          GetMTGS().SendDataPacket();          GetMTGS().SendDataPacket();
2030  }  }
2031    
2032  void _vuXTOP(VURegs * VU) {  static __ri void _vuXTOP(VURegs * VU) {
2033          if(_It_ == 0) return;          if(_It_ == 0) return;
2034          VU->VI[_It_].US[0] = (u16)VU->vifRegs->top;          VU->VI[_It_].US[0] = (u16)VU->GetVifRegs().top;
2035  }  }
2036    
2037  #define GET_VF0_FLAG(reg) (((reg)==0)?(1<<REG_VF0_FLAG):0)  #define GET_VF0_FLAG(reg) (((reg)==0)?(1<<REG_VF0_FLAG):0)
2038    
2039  #define VUREGS_FDFSI(OP, ACC) \  #define VUREGS_FDFSI(OP, ACC) \
2040  void _vuRegs##OP(VURegs * VU, _VURegsNum *VUregsn) { \  static __ri void _vuRegs##OP(const VURegs* VU, _VURegsNum *VUregsn) { \
2041          VUregsn->pipe = VUPIPE_FMAC; \          VUregsn->pipe = VUPIPE_FMAC; \
2042          VUregsn->VFwrite = _Fd_; \          VUregsn->VFwrite = _Fd_; \
2043          VUregsn->VFwxyzw = _XYZW; \          VUregsn->VFwxyzw = _XYZW; \
# Line 2095  void _vuRegs##OP(VURegs * VU, _VURegsNum Line 2049  void _vuRegs##OP(VURegs * VU, _VURegsNum
2049  }  }
2050    
2051  #define VUREGS_FDFSQ(OP, ACC) \  #define VUREGS_FDFSQ(OP, ACC) \
2052  void _vuRegs##OP(VURegs * VU, _VURegsNum *VUregsn) { \  static __ri void _vuRegs##OP(const VURegs* VU, _VURegsNum *VUregsn) { \
2053          VUregsn->pipe = VUPIPE_FMAC; \          VUregsn->pipe = VUPIPE_FMAC; \
2054          VUregsn->VFwrite = _Fd_; \          VUregsn->VFwrite = _Fd_; \
2055          VUregsn->VFwxyzw = _XYZW; \          VUregsn->VFwxyzw = _XYZW; \
# Line 2107  void _vuRegs##OP(VURegs * VU, _VURegsNum Line 2061  void _vuRegs##OP(VURegs * VU, _VURegsNum
2061  }  }
2062    
2063  #define VUREGS_FDFSFT(OP, ACC) \  #define VUREGS_FDFSFT(OP, ACC) \
2064  void _vuRegs##OP(VURegs * VU, _VURegsNum *VUregsn) { \  static __ri void _vuRegs##OP(const VURegs* VU, _VURegsNum *VUregsn) { \
2065          VUregsn->pipe = VUPIPE_FMAC; \          VUregsn->pipe = VUPIPE_FMAC; \
2066          VUregsn->VFwrite = _Fd_; \          VUregsn->VFwrite = _Fd_; \
2067          VUregsn->VFwxyzw = _XYZW; \          VUregsn->VFwxyzw = _XYZW; \
# Line 2120  void _vuRegs##OP(VURegs * VU, _VURegsNum Line 2074  void _vuRegs##OP(VURegs * VU, _VURegsNum
2074  }  }
2075    
2076  #define VUREGS_FDFSFTxyzw(OP, xyzw, ACC) \  #define VUREGS_FDFSFTxyzw(OP, xyzw, ACC) \
2077  void _vuRegs##OP(VURegs * VU, _VURegsNum *VUregsn) { \  static __ri void _vuRegs##OP(const VURegs* VU, _VURegsNum *VUregsn) { \
2078          VUregsn->pipe = VUPIPE_FMAC; \          VUregsn->pipe = VUPIPE_FMAC; \
2079          VUregsn->VFwrite = _Fd_; \          VUregsn->VFwrite = _Fd_; \
2080          VUregsn->VFwxyzw = _XYZW; \          VUregsn->VFwxyzw = _XYZW; \
# Line 2139  void _vuRegs##OP(VURegs * VU, _VURegsNum Line 2093  void _vuRegs##OP(VURegs * VU, _VURegsNum
2093    
2094    
2095  #define VUREGS_ACCFSI(OP, readacc) \  #define VUREGS_ACCFSI(OP, readacc) \
2096  void _vuRegs##OP(VURegs * VU, _VURegsNum *VUregsn) { \  static __ri void _vuRegs##OP(const VURegs* VU, _VURegsNum *VUregsn) { \
2097          VUregsn->pipe = VUPIPE_FMAC; \          VUregsn->pipe = VUPIPE_FMAC; \
2098          VUregsn->VFwrite = 0; \          VUregsn->VFwrite = 0; \
2099          VUregsn->VFwxyzw= _XYZW; \          VUregsn->VFwxyzw= _XYZW; \
# Line 2151  void _vuRegs##OP(VURegs * VU, _VURegsNum Line 2105  void _vuRegs##OP(VURegs * VU, _VURegsNum
2105  }  }
2106    
2107  #define VUREGS_ACCFSQ(OP, readacc) \  #define VUREGS_ACCFSQ(OP, readacc) \
2108  void _vuRegs##OP(VURegs * VU, _VURegsNum *VUregsn) { \  static __ri void _vuRegs##OP(const VURegs* VU, _VURegsNum *VUregsn) { \
2109          VUregsn->pipe = VUPIPE_FMAC; \          VUregsn->pipe = VUPIPE_FMAC; \
2110          VUregsn->VFwrite = 0; \          VUregsn->VFwrite = 0; \
2111          VUregsn->VFwxyzw= _XYZW; \          VUregsn->VFwxyzw= _XYZW; \
# Line 2163  void _vuRegs##OP(VURegs * VU, _VURegsNum Line 2117  void _vuRegs##OP(VURegs * VU, _VURegsNum
2117  }  }
2118    
2119  #define VUREGS_ACCFSFT(OP, readacc) \  #define VUREGS_ACCFSFT(OP, readacc) \
2120  void _vuRegs##OP(VURegs * VU, _VURegsNum *VUregsn) { \  static __ri void _vuRegs##OP(const VURegs* VU, _VURegsNum *VUregsn) { \
2121          VUregsn->pipe = VUPIPE_FMAC; \          VUregsn->pipe = VUPIPE_FMAC; \
2122          VUregsn->VFwrite = 0; \          VUregsn->VFwrite = 0; \
2123          VUregsn->VFwxyzw= _XYZW; \          VUregsn->VFwxyzw= _XYZW; \
# Line 2176  void _vuRegs##OP(VURegs * VU, _VURegsNum Line 2130  void _vuRegs##OP(VURegs * VU, _VURegsNum
2130  }  }
2131    
2132  #define VUREGS_ACCFSFTxyzw(OP, xyzw, readacc) \  #define VUREGS_ACCFSFTxyzw(OP, xyzw, readacc) \
2133  void _vuRegs##OP(VURegs * VU, _VURegsNum *VUregsn) { \  static __ri void _vuRegs##OP(const VURegs* VU, _VURegsNum *VUregsn) { \
2134          VUregsn->pipe = VUPIPE_FMAC; \          VUregsn->pipe = VUPIPE_FMAC; \
2135          VUregsn->VFwrite = 0; \          VUregsn->VFwrite = 0; \
2136          VUregsn->VFwxyzw= _XYZW; \          VUregsn->VFwxyzw= _XYZW; \
# Line 2194  void _vuRegs##OP(VURegs * VU, _VURegsNum Line 2148  void _vuRegs##OP(VURegs * VU, _VURegsNum
2148  #define VUREGS_ACCFSFTw(OP, readacc) VUREGS_ACCFSFTxyzw(OP, 1, readacc)  #define VUREGS_ACCFSFTw(OP, readacc) VUREGS_ACCFSFTxyzw(OP, 1, readacc)
2149    
2150  #define VUREGS_FTFS(OP) \  #define VUREGS_FTFS(OP) \
2151  void _vuRegs##OP(VURegs * VU, _VURegsNum *VUregsn) { \  static __ri void _vuRegs##OP(const VURegs* VU, _VURegsNum *VUregsn) { \
2152          VUregsn->pipe = VUPIPE_FMAC; \          VUregsn->pipe = VUPIPE_FMAC; \
2153          VUregsn->VFwrite = _Ft_; \          VUregsn->VFwrite = _Ft_; \
2154          VUregsn->VFwxyzw = _XYZW; \          VUregsn->VFwxyzw = _XYZW; \
# Line 2207  void _vuRegs##OP(VURegs * VU, _VURegsNum Line 2161  void _vuRegs##OP(VURegs * VU, _VURegsNum
2161  }  }
2162    
2163  #define VUREGS_IDISIT(OP) \  #define VUREGS_IDISIT(OP) \
2164  void _vuRegs##OP(VURegs * VU, _VURegsNum *VUregsn) { \  static __ri void _vuRegs##OP(const VURegs* VU, _VURegsNum *VUregsn) { \
2165          VUregsn->pipe = VUPIPE_IALU; \          VUregsn->pipe = VUPIPE_IALU; \
2166          VUregsn->VFwrite = 0; \          VUregsn->VFwrite = 0; \
2167          VUregsn->VFread0 = 0; \          VUregsn->VFread0 = 0; \
# Line 2218  void _vuRegs##OP(VURegs * VU, _VURegsNum Line 2172  void _vuRegs##OP(VURegs * VU, _VURegsNum
2172  }  }
2173    
2174  #define VUREGS_ITIS(OP) \  #define VUREGS_ITIS(OP) \
2175  void _vuRegs##OP(VURegs * VU, _VURegsNum *VUregsn) { \  static __ri void _vuRegs##OP(const VURegs* VU, _VURegsNum *VUregsn) { \
2176          VUregsn->pipe = VUPIPE_IALU; \          VUregsn->pipe = VUPIPE_IALU; \
2177          VUregsn->VFwrite = 0; \          VUregsn->VFwrite = 0; \
2178          VUregsn->VFread0 = 0; \          VUregsn->VFread0 = 0; \
# Line 2229  void _vuRegs##OP(VURegs * VU, _VURegsNum Line 2183  void _vuRegs##OP(VURegs * VU, _VURegsNum
2183  }  }
2184    
2185  #define VUREGS_PFS_xyzw(OP, _cycles) \  #define VUREGS_PFS_xyzw(OP, _cycles) \
2186  void _vuRegs##OP(VURegs * VU, _VURegsNum *VUregsn) { \  static __ri void _vuRegs##OP(const VURegs* VU, _VURegsNum *VUregsn) { \
2187          VUregsn->pipe = VUPIPE_EFU; \          VUregsn->pipe = VUPIPE_EFU; \
2188          VUregsn->VFwrite = 0; \          VUregsn->VFwrite = 0; \
2189          VUregsn->VFread0 = _Fs_; \          VUregsn->VFread0 = _Fs_; \
# Line 2241  void _vuRegs##OP(VURegs * VU, _VURegsNum Line 2195  void _vuRegs##OP(VURegs * VU, _VURegsNum
2195  }  }
2196    
2197  #define VUREGS_PFS_fsf(OP, _cycles) \  #define VUREGS_PFS_fsf(OP, _cycles) \
2198  void _vuRegs##OP(VURegs * VU, _VURegsNum *VUregsn) { \  static __ri void _vuRegs##OP(const VURegs* VU, _VURegsNum *VUregsn) { \
2199          VUregsn->pipe = VUPIPE_EFU; \          VUregsn->pipe = VUPIPE_EFU; \
2200          VUregsn->VFwrite = 0; \          VUregsn->VFwrite = 0; \
2201          VUregsn->VFread0 = _Fs_; \          VUregsn->VFread0 = _Fs_; \
# Line 2287  VUREGS_ACCFSFTz(SUBAz, 0); Line 2241  VUREGS_ACCFSFTz(SUBAz, 0);
2241  VUREGS_ACCFSFTw(SUBAw, 0);  VUREGS_ACCFSFTw(SUBAw, 0);
2242    
2243  #define VUREGS_FDFSFTxyzw_MUL(OP, ACC, xyzw) \  #define VUREGS_FDFSFTxyzw_MUL(OP, ACC, xyzw) \
2244  void _vuRegs##OP(VURegs * VU, _VURegsNum *VUregsn) { \  static __ri void _vuRegs##OP(const VURegs* VU, _VURegsNum *VUregsn) { \
2245          if( _Ft_ == 0 && xyzw > 1 && _XYZW == 0xf ) { /* resetting to 0 */ \          if( _Ft_ == 0 && xyzw > 1 && _XYZW == 0xf ) { /* resetting to 0 */ \
2246                  VUregsn->pipe = VUPIPE_FMAC; \                  VUregsn->pipe = VUPIPE_FMAC; \
2247                  VUregsn->VFwrite = ACC?0:_Fd_; \                  VUregsn->VFwrite = ACC?0:_Fd_; \
# Line 2333  VUREGS_FDFSI(MADDi, 1); Line 2287  VUREGS_FDFSI(MADDi, 1);
2287  VUREGS_FDFSQ(MADDq, 1);  VUREGS_FDFSQ(MADDq, 1);
2288    
2289  #define VUREGS_FDFSFT_0_xyzw(OP, xyzw) \  #define VUREGS_FDFSFT_0_xyzw(OP, xyzw) \
2290  void _vuRegs##OP(VURegs * VU, _VURegsNum *VUregsn) { \  static __ri void _vuRegs##OP(const VURegs* VU, _VURegsNum *VUregsn) { \
2291          VUregsn->pipe = VUPIPE_FMAC; \          VUregsn->pipe = VUPIPE_FMAC; \
2292          VUregsn->VFwrite = _Fd_; \          VUregsn->VFwrite = _Fd_; \
2293          VUregsn->VFwxyzw = _XYZW; \          VUregsn->VFwxyzw = _XYZW; \
# Line 2349  VUREGS_FDFSFT_0_xyzw(MADDx, 8); Line 2303  VUREGS_FDFSFT_0_xyzw(MADDx, 8);
2303  VUREGS_FDFSFT_0_xyzw(MADDy, 4);  VUREGS_FDFSFT_0_xyzw(MADDy, 4);
2304  VUREGS_FDFSFT_0_xyzw(MADDz, 2);  VUREGS_FDFSFT_0_xyzw(MADDz, 2);
2305    
2306  void _vuRegsMADDw(VURegs * VU, _VURegsNum *VUregsn) {  static __ri void _vuRegsMADDw(const VURegs* VU, _VURegsNum *VUregsn) {
2307          VUregsn->pipe = VUPIPE_FMAC;          VUregsn->pipe = VUPIPE_FMAC;
2308          VUregsn->VFwrite = _Fd_;          VUregsn->VFwrite = _Fd_;
2309          VUregsn->VFwxyzw = _XYZW;          VUregsn->VFwxyzw = _XYZW;
# Line 2392  VUREGS_FDFSFTy(MAXy_, 0); Line 2346  VUREGS_FDFSFTy(MAXy_, 0);
2346  VUREGS_FDFSFTz(MAXz_, 0);  VUREGS_FDFSFTz(MAXz_, 0);
2347  VUREGS_FDFSFTw(MAXw_, 0);  VUREGS_FDFSFTw(MAXw_, 0);
2348    
2349  void _vuRegsMAXx(VURegs * VU, _VURegsNum *VUregsn) {  static __ri void _vuRegsMAXx(const VURegs* VU, _VURegsNum *VUregsn) {
2350          _vuRegsMAXx_(VU, VUregsn);          _vuRegsMAXx_(VU, VUregsn);
2351          if( _Fs_ == 0 && _Ft_ == 0 ) VUregsn->VIread &= ~(1<<REG_VF0_FLAG);          if( _Fs_ == 0 && _Ft_ == 0 ) VUregsn->VIread &= ~(1<<REG_VF0_FLAG);
2352  }  }
2353  void _vuRegsMAXy(VURegs * VU, _VURegsNum *VUregsn) {  static __ri void _vuRegsMAXy(const VURegs* VU, _VURegsNum *VUregsn) {
2354          _vuRegsMAXy_(VU, VUregsn);          _vuRegsMAXy_(VU, VUregsn);
2355          if( _Fs_ == 0 && _Ft_ == 0 ) VUregsn->VIread &= ~(1<<REG_VF0_FLAG);          if( _Fs_ == 0 && _Ft_ == 0 ) VUregsn->VIread &= ~(1<<REG_VF0_FLAG);
2356  }  }
2357  void _vuRegsMAXz(VURegs * VU, _VURegsNum *VUregsn) {  static __ri void _vuRegsMAXz(const VURegs* VU, _VURegsNum *VUregsn) {
2358          _vuRegsMAXz_(VU, VUregsn);          _vuRegsMAXz_(VU, VUregsn);
2359          if( _Fs_ == 0 && _Ft_ == 0 ) VUregsn->VIread &= ~(1<<REG_VF0_FLAG);          if( _Fs_ == 0 && _Ft_ == 0 ) VUregsn->VIread &= ~(1<<REG_VF0_FLAG);
2360  }  }
2361  void _vuRegsMAXw(VURegs * VU, _VURegsNum *VUregsn) {  static __ri void _vuRegsMAXw(const VURegs* VU, _VURegsNum *VUregsn) {
2362          _vuRegsMAXw_(VU, VUregsn);          _vuRegsMAXw_(VU, VUregsn);
2363          if( _Fs_ == 0 && _Ft_ == 0 ) VUregsn->VIread &= ~(1<<REG_VF0_FLAG);          if( _Fs_ == 0 && _Ft_ == 0 ) VUregsn->VIread &= ~(1<<REG_VF0_FLAG);
2364  }  }
# Line 2416  VUREGS_FDFSFTy(MINIy, 0); Line 2370  VUREGS_FDFSFTy(MINIy, 0);
2370  VUREGS_FDFSFTz(MINIz, 0);  VUREGS_FDFSFTz(MINIz, 0);
2371  VUREGS_FDFSFTw(MINIw, 0);  VUREGS_FDFSFTw(MINIw, 0);
2372    
2373  void _vuRegsOPMULA(VURegs * VU, _VURegsNum *VUregsn) {  static __ri void _vuRegsOPMULA(const VURegs* VU, _VURegsNum *VUregsn) {
2374          VUregsn->pipe = VUPIPE_FMAC;          VUregsn->pipe = VUPIPE_FMAC;
2375          VUregsn->VFwrite = 0;          VUregsn->VFwrite = 0;
2376          VUregsn->VFwxyzw= 0xE;          VUregsn->VFwxyzw= 0xE;
# Line 2428  void _vuRegsOPMULA(VURegs * VU, _VURegsN Line 2382  void _vuRegsOPMULA(VURegs * VU, _VURegsN
2382          VUregsn->VIread  = GET_VF0_FLAG(_Fs_)|GET_VF0_FLAG(_Ft_)|(1<<REG_ACC_FLAG);          VUregsn->VIread  = GET_VF0_FLAG(_Fs_)|GET_VF0_FLAG(_Ft_)|(1<<REG_ACC_FLAG);
2383  }  }
2384    
2385  void _vuRegsOPMSUB(VURegs * VU, _VURegsNum *VUregsn) {  static __ri void _vuRegsOPMSUB(const VURegs* VU, _VURegsNum *VUregsn) {
2386          VUregsn->pipe = VUPIPE_FMAC;          VUregsn->pipe = VUPIPE_FMAC;
2387          VUregsn->VFwrite = _Fd_;          VUregsn->VFwrite = _Fd_;
2388          VUregsn->VFwxyzw= 0xE;          VUregsn->VFwxyzw= 0xE;
# Line 2440  void _vuRegsOPMSUB(VURegs * VU, _VURegsN Line 2394  void _vuRegsOPMSUB(VURegs * VU, _VURegsN
2394          VUregsn->VIread  = GET_VF0_FLAG(_Fs_)|GET_VF0_FLAG(_Ft_)|(1<<REG_ACC_FLAG);          VUregsn->VIread  = GET_VF0_FLAG(_Fs_)|GET_VF0_FLAG(_Ft_)|(1<<REG_ACC_FLAG);
2395  }  }
2396    
2397  void _vuRegsNOP(VURegs * VU, _VURegsNum *VUregsn) {  static __ri void _vuRegsNOP(const VURegs* VU, _VURegsNum *VUregsn) {
2398          VUregsn->pipe = VUPIPE_NONE;          VUregsn->pipe = VUPIPE_NONE;
2399      VUregsn->VFwrite = 0;      VUregsn->VFwrite = 0;
2400      VUregsn->VFread0 = 0;      VUregsn->VFread0 = 0;
# Line 2458  VUREGS_FTFS(ITOF4); Line 2412  VUREGS_FTFS(ITOF4);
2412  VUREGS_FTFS(ITOF12);  VUREGS_FTFS(ITOF12);
2413  VUREGS_FTFS(ITOF15);  VUREGS_FTFS(ITOF15);
2414    
2415  void _vuRegsCLIP(VURegs * VU, _VURegsNum *VUregsn) {  static __ri void _vuRegsCLIP(const VURegs* VU, _VURegsNum *VUregsn) {
2416          VUregsn->pipe = VUPIPE_FMAC;          VUregsn->pipe = VUPIPE_FMAC;
2417      VUregsn->VFwrite = 0;      VUregsn->VFwrite = 0;
2418          VUregsn->VFread0 = _Fs_;          VUregsn->VFread0 = _Fs_;
# Line 2473  void _vuRegsCLIP(VURegs * VU, _VURegsNum Line 2427  void _vuRegsCLIP(VURegs * VU, _VURegsNum
2427  /*   VU Lower instructions    */  /*   VU Lower instructions    */
2428  /******************************/  /******************************/
2429    
2430  void _vuRegsDIV(VURegs * VU, _VURegsNum *VUregsn) {  static __ri void _vuRegsDIV(const VURegs* VU, _VURegsNum *VUregsn) {
2431          VUregsn->pipe = VUPIPE_FDIV;          VUregsn->pipe = VUPIPE_FDIV;
2432      VUregsn->VFwrite = 0;      VUregsn->VFwrite = 0;
2433          VUregsn->VFread0 = _Fs_;          VUregsn->VFread0 = _Fs_;
# Line 2485  void _vuRegsDIV(VURegs * VU, _VURegsNum Line 2439  void _vuRegsDIV(VURegs * VU, _VURegsNum
2439          VUregsn->cycles  = 6;          VUregsn->cycles  = 6;
2440  }  }
2441    
2442  void _vuRegsSQRT(VURegs * VU, _VURegsNum *VUregsn) {  static __ri void _vuRegsSQRT(const VURegs* VU, _VURegsNum *VUregsn) {
2443          VUregsn->pipe = VUPIPE_FDIV;          VUregsn->pipe = VUPIPE_FDIV;
2444      VUregsn->VFwrite = 0;      VUregsn->VFwrite = 0;
2445          VUregsn->VFread0 = 0;          VUregsn->VFread0 = 0;
# Line 2497  void _vuRegsSQRT(VURegs * VU, _VURegsNum Line 2451  void _vuRegsSQRT(VURegs * VU, _VURegsNum
2451          VUregsn->cycles  = 6;          VUregsn->cycles  = 6;
2452  }  }
2453    
2454  void _vuRegsRSQRT(VURegs * VU, _VURegsNum *VUregsn) {  static __ri void _vuRegsRSQRT(const VURegs* VU, _VURegsNum *VUregsn) {
2455          VUregsn->pipe = VUPIPE_FDIV;          VUregsn->pipe = VUPIPE_FDIV;
2456      VUregsn->VFwrite = 0;      VUregsn->VFwrite = 0;
2457          VUregsn->VFread0 = _Fs_;          VUregsn->VFread0 = _Fs_;
# Line 2519  VUREGS_ITIS(ISUBIU); Line 2473  VUREGS_ITIS(ISUBIU);
2473    
2474  VUREGS_FTFS(MOVE);  VUREGS_FTFS(MOVE);
2475    
2476  void _vuRegsMFIR(VURegs * VU, _VURegsNum *VUregsn) {  static __ri void _vuRegsMFIR(const VURegs* VU, _VURegsNum *VUregsn) {
2477          VUregsn->pipe = VUPIPE_FMAC;          VUregsn->pipe = VUPIPE_FMAC;
2478      VUregsn->VFwrite = _Ft_;      VUregsn->VFwrite = _Ft_;
2479      VUregsn->VFwxyzw = _XYZW;      VUregsn->VFwxyzw = _XYZW;
# Line 2529  void _vuRegsMFIR(VURegs * VU, _VURegsNum Line 2483  void _vuRegsMFIR(VURegs * VU, _VURegsNum
2483      VUregsn->VIread  = 1 << _Is_;      VUregsn->VIread  = 1 << _Is_;
2484  }  }
2485    
2486  void _vuRegsMTIR(VURegs * VU, _VURegsNum *VUregsn) {  static __ri void _vuRegsMTIR(const VURegs* VU, _VURegsNum *VUregsn) {
2487          VUregsn->pipe = VUPIPE_FMAC;          VUregsn->pipe = VUPIPE_FMAC;
2488      VUregsn->VFwrite = 0;      VUregsn->VFwrite = 0;
2489          VUregsn->VFread0 = _Fs_;          VUregsn->VFread0 = _Fs_;
# Line 2539  void _vuRegsMTIR(VURegs * VU, _VURegsNum Line 2493  void _vuRegsMTIR(VURegs * VU, _VURegsNum
2493      VUregsn->VIread  = GET_VF0_FLAG(_Fs_);      VUregsn->VIread  = GET_VF0_FLAG(_Fs_);
2494  }  }
2495    
2496  void _vuRegsMR32(VURegs * VU, _VURegsNum *VUregsn) {  static __ri void _vuRegsMR32(const VURegs* VU, _VURegsNum *VUregsn) {
2497          VUregsn->pipe = VUPIPE_FMAC;          VUregsn->pipe = VUPIPE_FMAC;
2498          VUregsn->VFwrite = _Ft_;          VUregsn->VFwrite = _Ft_;
2499          VUregsn->VFwxyzw = _XYZW;          VUregsn->VFwxyzw = _XYZW;
# Line 2551  void _vuRegsMR32(VURegs * VU, _VURegsNum Line 2505  void _vuRegsMR32(VURegs * VU, _VURegsNum
2505          VUregsn->VIread  = (_Ft_ ? GET_VF0_FLAG(_Fs_) : 0);          VUregsn->VIread  = (_Ft_ ? GET_VF0_FLAG(_Fs_) : 0);
2506  }  }
2507    
2508  void _vuRegsLQ(VURegs * VU, _VURegsNum *VUregsn) {  static __ri void _vuRegsLQ(const VURegs* VU, _VURegsNum *VUregsn) {
2509          VUregsn->pipe = VUPIPE_FMAC;          VUregsn->pipe = VUPIPE_FMAC;
2510      VUregsn->VFwrite = _Ft_;      VUregsn->VFwrite = _Ft_;
2511      VUregsn->VFwxyzw = _XYZW;      VUregsn->VFwxyzw = _XYZW;
# Line 2561  void _vuRegsLQ(VURegs * VU, _VURegsNum * Line 2515  void _vuRegsLQ(VURegs * VU, _VURegsNum *
2515      VUregsn->VIread  = 1 << _Is_;      VUregsn->VIread  = 1 << _Is_;
2516  }  }
2517    
2518  void _vuRegsLQD(VURegs * VU, _VURegsNum *VUregsn) {  static __ri void _vuRegsLQD(const VURegs* VU, _VURegsNum *VUregsn) {
2519          VUregsn->pipe = VUPIPE_FMAC;          VUregsn->pipe = VUPIPE_FMAC;
2520      VUregsn->VFwrite = _Ft_;      VUregsn->VFwrite = _Ft_;
2521      VUregsn->VFwxyzw = _XYZW;      VUregsn->VFwxyzw = _XYZW;
# Line 2571  void _vuRegsLQD(VURegs * VU, _VURegsNum Line 2525  void _vuRegsLQD(VURegs * VU, _VURegsNum
2525      VUregsn->VIread  = 1 << _Is_;      VUregsn->VIread  = 1 << _Is_;
2526  }  }
2527    
2528  void _vuRegsLQI(VURegs * VU, _VURegsNum *VUregsn) {  static __ri void _vuRegsLQI(const VURegs* VU, _VURegsNum *VUregsn) {
2529          VUregsn->pipe = VUPIPE_FMAC;          VUregsn->pipe = VUPIPE_FMAC;
2530      VUregsn->VFwrite = _Ft_;      VUregsn->VFwrite = _Ft_;
2531      VUregsn->VFwxyzw = _XYZW;      VUregsn->VFwxyzw = _XYZW;
# Line 2581  void _vuRegsLQI(VURegs * VU, _VURegsNum Line 2535  void _vuRegsLQI(VURegs * VU, _VURegsNum
2535      VUregsn->VIread  = 1 << _Is_;      VUregsn->VIread  = 1 << _Is_;
2536  }  }
2537    
2538  void _vuRegsSQ(VURegs * VU, _VURegsNum *VUregsn) {  static __ri void _vuRegsSQ(const VURegs* VU, _VURegsNum *VUregsn) {
2539          VUregsn->pipe = VUPIPE_FMAC;          VUregsn->pipe = VUPIPE_FMAC;
2540      VUregsn->VFwrite = 0;      VUregsn->VFwrite = 0;
2541          VUregsn->VFread0 = _Fs_;          VUregsn->VFread0 = _Fs_;
# Line 2591  void _vuRegsSQ(VURegs * VU, _VURegsNum * Line 2545  void _vuRegsSQ(VURegs * VU, _VURegsNum *
2545      VUregsn->VIread  = 1 << _It_;      VUregsn->VIread  = 1 << _It_;
2546  }  }
2547    
2548  void _vuRegsSQD(VURegs * VU, _VURegsNum *VUregsn) {  static __ri void _vuRegsSQD(const VURegs* VU, _VURegsNum *VUregsn) {
2549          VUregsn->pipe = VUPIPE_FMAC;          VUregsn->pipe = VUPIPE_FMAC;
2550      VUregsn->VFwrite = 0;      VUregsn->VFwrite = 0;
2551          VUregsn->VFread0 = _Fs_;          VUregsn->VFread0 = _Fs_;
# Line 2601  void _vuRegsSQD(VURegs * VU, _VURegsNum Line 2555  void _vuRegsSQD(VURegs * VU, _VURegsNum
2555      VUregsn->VIread  = 1 << _It_;      VUregsn->VIread  = 1 << _It_;
2556  }  }
2557    
2558  void _vuRegsSQI(VURegs * VU, _VURegsNum *VUregsn) {  static __ri void _vuRegsSQI(const VURegs* VU, _VURegsNum *VUregsn) {
2559          VUregsn->pipe = VUPIPE_FMAC;          VUregsn->pipe = VUPIPE_FMAC;
2560      VUregsn->VFwrite = 0;      VUregsn->VFwrite = 0;
2561          VUregsn->VFread0 = _Fs_;          VUregsn->VFread0 = _Fs_;
# Line 2611  void _vuRegsSQI(VURegs * VU, _VURegsNum Line 2565  void _vuRegsSQI(VURegs * VU, _VURegsNum
2565      VUregsn->VIread  = 1 << _It_;      VUregsn->VIread  = 1 << _It_;
2566  }  }
2567    
2568  void _vuRegsILW(VURegs * VU, _VURegsNum *VUregsn) {  static __ri void _vuRegsILW(const VURegs* VU, _VURegsNum *VUregsn) {
2569          VUregsn->pipe = VUPIPE_IALU;          VUregsn->pipe = VUPIPE_IALU;
2570      VUregsn->VFwrite = 0;      VUregsn->VFwrite = 0;
2571          VUregsn->VFread0 = 0;          VUregsn->VFread0 = 0;
# Line 2621  void _vuRegsILW(VURegs * VU, _VURegsNum Line 2575  void _vuRegsILW(VURegs * VU, _VURegsNum
2575          VUregsn->cycles  = 3;          VUregsn->cycles  = 3;
2576  }  }
2577    
2578  void _vuRegsISW(VURegs * VU, _VURegsNum *VUregsn) {  static __ri void _vuRegsISW(const VURegs* VU, _VURegsNum *VUregsn) {
2579          VUregsn->pipe = VUPIPE_IALU;          VUregsn->pipe = VUPIPE_IALU;
2580      VUregsn->VFwrite = 0;      VUregsn->VFwrite = 0;
2581          VUregsn->VFread0 = 0;          VUregsn->VFread0 = 0;
# Line 2630  void _vuRegsISW(VURegs * VU, _VURegsNum Line 2584  void _vuRegsISW(VURegs * VU, _VURegsNum
2584      VUregsn->VIread  = (1 << _Is_) | (1 << _It_);      VUregsn->VIread  = (1 << _Is_) | (1 << _It_);
2585  }  }
2586    
2587  void _vuRegsILWR(VURegs * VU, _VURegsNum *VUregsn) {  static __ri void _vuRegsILWR(const VURegs* VU, _VURegsNum *VUregsn) {
2588          VUregsn->pipe = VUPIPE_IALU;          VUregsn->pipe = VUPIPE_IALU;
2589      VUregsn->VFwrite = 0;      VUregsn->VFwrite = 0;
2590          VUregsn->VFread0 = 0;          VUregsn->VFread0 = 0;
# Line 2640  void _vuRegsILWR(VURegs * VU, _VURegsNum Line 2594  void _vuRegsILWR(VURegs * VU, _VURegsNum
2594          VUregsn->cycles  = 3;          VUregsn->cycles  = 3;
2595  }  }
2596    
2597  void _vuRegsISWR(VURegs * VU, _VURegsNum *VUregsn) {  static __ri void _vuRegsISWR(const VURegs* VU, _VURegsNum *VUregsn) {
2598          VUregsn->pipe = VUPIPE_IALU;          VUregsn->pipe = VUPIPE_IALU;
2599      VUregsn->VFwrite = 0;      VUregsn->VFwrite = 0;
2600          VUregsn->VFread0 = 0;          VUregsn->VFread0 = 0;
# Line 2649  void _vuRegsISWR(VURegs * VU, _VURegsNum Line 2603  void _vuRegsISWR(VURegs * VU, _VURegsNum
2603      VUregsn->VIread  = (1 << _Is_) | (1 << _It_);      VUregsn->VIread  = (1 << _Is_) | (1 << _It_);
2604  }  }
2605    
2606  void _vuRegsRINIT(VURegs * VU, _VURegsNum *VUregsn) {  static __ri void _vuRegsRINIT(const VURegs* VU, _VURegsNum *VUregsn) {
2607          VUregsn->pipe = VUPIPE_FMAC;          VUregsn->pipe = VUPIPE_FMAC;
2608      VUregsn->VFwrite = 0;      VUregsn->VFwrite = 0;
2609          VUregsn->VFread0 = _Fs_;          VUregsn->VFread0 = _Fs_;
# Line 2659  void _vuRegsRINIT(VURegs * VU, _VURegsNu Line 2613  void _vuRegsRINIT(VURegs * VU, _VURegsNu
2613      VUregsn->VIread  = GET_VF0_FLAG(_Fs_);      VUregsn->VIread  = GET_VF0_FLAG(_Fs_);
2614  }  }
2615    
2616  void _vuRegsRGET(VURegs * VU, _VURegsNum *VUregsn) {  static __ri void _vuRegsRGET(const VURegs* VU, _VURegsNum *VUregsn) {
2617          VUregsn->pipe = VUPIPE_FMAC;          VUregsn->pipe = VUPIPE_FMAC;
2618      VUregsn->VFwrite = _Ft_;      VUregsn->VFwrite = _Ft_;
2619      VUregsn->VFwxyzw = _XYZW;      VUregsn->VFwxyzw = _XYZW;
# Line 2669  void _vuRegsRGET(VURegs * VU, _VURegsNum Line 2623  void _vuRegsRGET(VURegs * VU, _VURegsNum
2623      VUregsn->VIread  = 1 << REG_R;      VUregsn->VIread  = 1 << REG_R;
2624  }  }
2625    
2626  void _vuRegsRNEXT(VURegs * VU, _VURegsNum *VUregsn) {  static __ri void _vuRegsRNEXT(const VURegs* VU, _VURegsNum *VUregsn) {
2627          VUregsn->pipe = VUPIPE_FMAC;          VUregsn->pipe = VUPIPE_FMAC;
2628      VUregsn->VFwrite = _Ft_;      VUregsn->VFwrite = _Ft_;
2629      VUregsn->VFwxyzw = _XYZW;      VUregsn->VFwxyzw = _XYZW;
# Line 2679  void _vuRegsRNEXT(VURegs * VU, _VURegsNu Line 2633  void _vuRegsRNEXT(VURegs * VU, _VURegsNu
2633      VUregsn->VIread  = 1 << REG_R;      VUregsn->VIread  = 1 << REG_R;
2634  }  }
2635    
2636  void _vuRegsRXOR(VURegs * VU, _VURegsNum *VUregsn) {  static __ri void _vuRegsRXOR(const VURegs* VU, _VURegsNum *VUregsn) {
2637          VUregsn->pipe = VUPIPE_FMAC;          VUregsn->pipe = VUPIPE_FMAC;
2638      VUregsn->VFwrite = 0;      VUregsn->VFwrite = 0;
2639          VUregsn->VFread0 = _Fs_;          VUregsn->VFread0 = _Fs_;
# Line 2689  void _vuRegsRXOR(VURegs * VU, _VURegsNum Line 2643  void _vuRegsRXOR(VURegs * VU, _VURegsNum
2643      VUregsn->VIread  = (1 << REG_R)|GET_VF0_FLAG(_Fs_);      VUregsn->VIread  = (1 << REG_R)|GET_VF0_FLAG(_Fs_);
2644  }  }
2645    
2646  void _vuRegsWAITQ(VURegs * VU, _VURegsNum *VUregsn) {  static __ri void _vuRegsWAITQ(const VURegs* VU, _VURegsNum *VUregsn) {
2647          VUregsn->pipe = VUPIPE_FDIV;          VUregsn->pipe = VUPIPE_FDIV;
2648      VUregsn->VFwrite = 0;      VUregsn->VFwrite = 0;
2649      VUregsn->VFread0 = 0;      VUregsn->VFread0 = 0;
# Line 2698  void _vuRegsWAITQ(VURegs * VU, _VURegsNu Line 2652  void _vuRegsWAITQ(VURegs * VU, _VURegsNu
2652      VUregsn->VIread  = 0;      VUregsn->VIread  = 0;
2653  }  }
2654    
2655  void _vuRegsFSAND(VURegs * VU, _VURegsNum *VUregsn) {  static __ri void _vuRegsFSAND(const VURegs* VU, _VURegsNum *VUregsn) {
2656          VUregsn->pipe = VUPIPE_FMAC;          VUregsn->pipe = VUPIPE_FMAC;
2657      VUregsn->VFwrite = 0;      VUregsn->VFwrite = 0;
2658      VUregsn->VFread0 = 0;      VUregsn->VFread0 = 0;
# Line 2707  void _vuRegsFSAND(VURegs * VU, _VURegsNu Line 2661  void _vuRegsFSAND(VURegs * VU, _VURegsNu
2661      VUregsn->VIread  = 1 << REG_STATUS_FLAG;      VUregsn->VIread  = 1 << REG_STATUS_FLAG;
2662  }  }
2663    
2664  void _vuRegsFSEQ(VURegs * VU, _VURegsNum *VUregsn) {  static __ri void _vuRegsFSEQ(const VURegs* VU, _VURegsNum *VUregsn) {
2665          VUregsn->pipe = VUPIPE_FMAC;          VUregsn->pipe = VUPIPE_FMAC;
2666      VUregsn->VFwrite = 0;      VUregsn->VFwrite = 0;
2667      VUregsn->VFread0 = 0;      VUregsn->VFread0 = 0;
# Line 2716  void _vuRegsFSEQ(VURegs * VU, _VURegsNum Line 2670  void _vuRegsFSEQ(VURegs * VU, _VURegsNum
2670      VUregsn->VIread  = 1 << REG_STATUS_FLAG;      VUregsn->VIread  = 1 << REG_STATUS_FLAG;
2671  }  }
2672    
2673  void _vuRegsFSOR(VURegs * VU, _VURegsNum *VUregsn) {  static __ri void _vuRegsFSOR(const VURegs* VU, _VURegsNum *VUregsn) {
2674          VUregsn->pipe = VUPIPE_FMAC;          VUregsn->pipe = VUPIPE_FMAC;
2675      VUregsn->VFwrite = 0;      VUregsn->VFwrite = 0;
2676      VUregsn->VFread0 = 0;      VUregsn->VFread0 = 0;
# Line 2725  void _vuRegsFSOR(VURegs * VU, _VURegsNum Line 2679  void _vuRegsFSOR(VURegs * VU, _VURegsNum
2679      VUregsn->VIread  = 1 << REG_STATUS_FLAG;      VUregsn->VIread  = 1 << REG_STATUS_FLAG;
2680  }  }
2681    
2682  void _vuRegsFSSET(VURegs * VU, _VURegsNum *VUregsn) {  static __ri void _vuRegsFSSET(const VURegs* VU, _VURegsNum *VUregsn) {
2683          VUregsn->pipe = VUPIPE_FMAC;          VUregsn->pipe = VUPIPE_FMAC;
2684      VUregsn->VFwrite = 0;      VUregsn->VFwrite = 0;
2685      VUregsn->VFread0 = 0;      VUregsn->VFread0 = 0;
# Line 2734  void _vuRegsFSSET(VURegs * VU, _VURegsNu Line 2688  void _vuRegsFSSET(VURegs * VU, _VURegsNu
2688          VUregsn->VIread  = 0;          VUregsn->VIread  = 0;
2689  }  }
2690    
2691  void _vuRegsFMAND(VURegs * VU, _VURegsNum *VUregsn) {  static __ri void _vuRegsFMAND(const VURegs* VU, _VURegsNum *VUregsn) {
2692          VUregsn->pipe = VUPIPE_FMAC;          VUregsn->pipe = VUPIPE_FMAC;
2693      VUregsn->VFwrite = 0;      VUregsn->VFwrite = 0;
2694      VUregsn->VFread0 = 0;      VUregsn->VFread0 = 0;
# Line 2743  void _vuRegsFMAND(VURegs * VU, _VURegsNu Line 2697  void _vuRegsFMAND(VURegs * VU, _VURegsNu
2697      VUregsn->VIread  = (1 << REG_MAC_FLAG) | (1 << _Is_);      VUregsn->VIread  = (1 << REG_MAC_FLAG) | (1 << _Is_);
2698  }  }
2699    
2700  void _vuRegsFMEQ(VURegs * VU, _VURegsNum *VUregsn) {  static __ri void _vuRegsFMEQ(const VURegs* VU, _VURegsNum *VUregsn) {
2701          VUregsn->pipe = VUPIPE_FMAC;          VUregsn->pipe = VUPIPE_FMAC;
2702      VUregsn->VFwrite = 0;      VUregsn->VFwrite = 0;
2703      VUregsn->VFread0 = 0;      VUregsn->VFread0 = 0;
# Line 2752  void _vuRegsFMEQ(VURegs * VU, _VURegsNum Line 2706  void _vuRegsFMEQ(VURegs * VU, _VURegsNum
2706      VUregsn->VIread  = (1 << REG_MAC_FLAG) | (1 << _Is_);      VUregsn->VIread  = (1 << REG_MAC_FLAG) | (1 << _Is_);
2707  }  }
2708    
2709  void _vuRegsFMOR(VURegs * VU, _VURegsNum *VUregsn) {  static __ri void _vuRegsFMOR(const VURegs* VU, _VURegsNum *VUregsn) {
2710          VUregsn->pipe = VUPIPE_FMAC;          VUregsn->pipe = VUPIPE_FMAC;
2711      VUregsn->VFwrite = 0;      VUregsn->VFwrite = 0;
2712      VUregsn->VFread0 = 0;      VUregsn->VFread0 = 0;
# Line 2761  void _vuRegsFMOR(VURegs * VU, _VURegsNum Line 2715  void _vuRegsFMOR(VURegs * VU, _VURegsNum
2715      VUregsn->VIread  = (1 << REG_MAC_FLAG) | (1 << _Is_);      VUregsn->VIread  = (1 << REG_MAC_FLAG) | (1 << _Is_);
2716  }  }
2717    
2718  void _vuRegsFCAND(VURegs * VU, _VURegsNum *VUregsn) {  static __ri void _vuRegsFCAND(const VURegs* VU, _VURegsNum *VUregsn) {
2719          VUregsn->pipe = VUPIPE_FMAC;          VUregsn->pipe = VUPIPE_FMAC;
2720      VUregsn->VFwrite = 0;      VUregsn->VFwrite = 0;
2721      VUregsn->VFread0 = 0;      VUregsn->VFread0 = 0;
# Line 2770  void _vuRegsFCAND(VURegs * VU, _VURegsNu Line 2724  void _vuRegsFCAND(VURegs * VU, _VURegsNu
2724      VUregsn->VIread  = 1 << REG_CLIP_FLAG;      VUregsn->VIread  = 1 << REG_CLIP_FLAG;
2725  }  }
2726    
2727  void _vuRegsFCEQ(VURegs * VU, _VURegsNum *VUregsn) {  static __ri void _vuRegsFCEQ(const VURegs* VU, _VURegsNum *VUregsn) {
2728          VUregsn->pipe = VUPIPE_FMAC;          VUregsn->pipe = VUPIPE_FMAC;
2729      VUregsn->VFwrite = 0;      VUregsn->VFwrite = 0;
2730      VUregsn->VFread0 = 0;      VUregsn->VFread0 = 0;
# Line 2779  void _vuRegsFCEQ(VURegs * VU, _VURegsNum Line 2733  void _vuRegsFCEQ(VURegs * VU, _VURegsNum
2733      VUregsn->VIread  = 1 << REG_CLIP_FLAG;      VUregsn->VIread  = 1 << REG_CLIP_FLAG;
2734  }  }
2735    
2736  void _vuRegsFCOR(VURegs * VU, _VURegsNum *VUregsn) {  static __ri void _vuRegsFCOR(const VURegs* VU, _VURegsNum *VUregsn) {
2737          VUregsn->pipe = VUPIPE_FMAC;          VUregsn->pipe = VUPIPE_FMAC;
2738      VUregsn->VFwrite = 0;      VUregsn->VFwrite = 0;
2739      VUregsn->VFread0 = 0;      VUregsn->VFread0 = 0;
# Line 2788  void _vuRegsFCOR(VURegs * VU, _VURegsNum Line 2742  void _vuRegsFCOR(VURegs * VU, _VURegsNum
2742      VUregsn->VIread  = 1 << REG_CLIP_FLAG;      VUregsn->VIread  = 1 << REG_CLIP_FLAG;
2743  }  }
2744    
2745  void _vuRegsFCSET(VURegs * VU, _VURegsNum *VUregsn) {  static __ri void _vuRegsFCSET(const VURegs* VU, _VURegsNum *VUregsn) {
2746          VUregsn->pipe = VUPIPE_FMAC;          VUregsn->pipe = VUPIPE_FMAC;
2747      VUregsn->VFwrite = 0;      VUregsn->VFwrite = 0;
2748      VUregsn->VFread0 = 0;      VUregsn->VFread0 = 0;
# Line 2797  void _vuRegsFCSET(VURegs * VU, _VURegsNu Line 2751  void _vuRegsFCSET(VURegs * VU, _VURegsNu
2751      VUregsn->VIread  = 0;      VUregsn->VIread  = 0;
2752  }  }
2753    
2754  void _vuRegsFCGET(VURegs * VU, _VURegsNum *VUregsn) {  static __ri void _vuRegsFCGET(const VURegs* VU, _VURegsNum *VUregsn) {
2755          VUregsn->pipe = VUPIPE_FMAC;          VUregsn->pipe = VUPIPE_FMAC;
2756      VUregsn->VFwrite = 0;      VUregsn->VFwrite = 0;
2757      VUregsn->VFread0 = 0;      VUregsn->VFread0 = 0;
# Line 2806  void _vuRegsFCGET(VURegs * VU, _VURegsNu Line 2760  void _vuRegsFCGET(VURegs * VU, _VURegsNu
2760      VUregsn->VIread  = 1 << REG_CLIP_FLAG;      VUregsn->VIread  = 1 << REG_CLIP_FLAG;
2761  }  }
2762    
2763  void _vuRegsIBEQ(VURegs * VU, _VURegsNum *VUregsn) {  static __ri void _vuRegsIBEQ(const VURegs* VU, _VURegsNum *VUregsn) {
2764          VUregsn->pipe = VUPIPE_BRANCH;          VUregsn->pipe = VUPIPE_BRANCH;
2765      VUregsn->VFwrite = 0;      VUregsn->VFwrite = 0;
2766      VUregsn->VFread0 = 0;      VUregsn->VFread0 = 0;
# Line 2815  void _vuRegsIBEQ(VURegs * VU, _VURegsNum Line 2769  void _vuRegsIBEQ(VURegs * VU, _VURegsNum
2769      VUregsn->VIread  = (1 << _Is_) | (1 << _It_);      VUregsn->VIread  = (1 << _Is_) | (1 << _It_);
2770  }  }
2771    
2772  void _vuRegsIBGEZ(VURegs * VU, _VURegsNum *VUregsn) {  static __ri void _vuRegsIBGEZ(const VURegs* VU, _VURegsNum *VUregsn) {
2773          VUregsn->pipe = VUPIPE_BRANCH;          VUregsn->pipe = VUPIPE_BRANCH;
2774      VUregsn->VFwrite = 0;      VUregsn->VFwrite = 0;
2775      VUregsn->VFread0 = 0;      VUregsn->VFread0 = 0;
# Line 2824  void _vuRegsIBGEZ(VURegs * VU, _VURegsNu Line 2778  void _vuRegsIBGEZ(VURegs * VU, _VURegsNu
2778          VUregsn->VIread  = 1 << _Is_;          VUregsn->VIread  = 1 << _Is_;
2779  }  }
2780    
2781  void _vuRegsIBGTZ(VURegs * VU, _VURegsNum *VUregsn) {  static __ri void _vuRegsIBGTZ(const VURegs* VU, _VURegsNum *VUregsn) {
2782          VUregsn->pipe = VUPIPE_BRANCH;          VUregsn->pipe = VUPIPE_BRANCH;
2783      VUregsn->VFwrite = 0;      VUregsn->VFwrite = 0;
2784      VUregsn->VFread0 = 0;      VUregsn->VFread0 = 0;
# Line 2833  void _vuRegsIBGTZ(VURegs * VU, _VURegsNu Line 2787  void _vuRegsIBGTZ(VURegs * VU, _VURegsNu
2787          VUregsn->VIread  = 1 << _Is_;          VUregsn->VIread  = 1 << _Is_;
2788  }  }
2789    
2790  void _vuRegsIBLEZ(VURegs * VU, _VURegsNum *VUregsn) {  static __ri void _vuRegsIBLEZ(const VURegs* VU, _VURegsNum *VUregsn) {
2791          VUregsn->pipe = VUPIPE_BRANCH;          VUregsn->pipe = VUPIPE_BRANCH;
2792      VUregsn->VFwrite = 0;      VUregsn->VFwrite = 0;
2793      VUregsn->VFread0 = 0;      VUregsn->VFread0 = 0;
# Line 2842  void _vuRegsIBLEZ(VURegs * VU, _VURegsNu Line 2796  void _vuRegsIBLEZ(VURegs * VU, _VURegsNu
2796          VUregsn->VIread  = 1 << _Is_;          VUregsn->VIread  = 1 << _Is_;
2797  }  }
2798    
2799  void _vuRegsIBLTZ(VURegs * VU, _VURegsNum *VUregsn) {  static __ri void _vuRegsIBLTZ(const VURegs* VU, _VURegsNum *VUregsn) {
2800          VUregsn->pipe = VUPIPE_BRANCH;          VUregsn->pipe = VUPIPE_BRANCH;
2801      VUregsn->VFwrite = 0;      VUregsn->VFwrite = 0;
2802      VUregsn->VFread0 = 0;      VUregsn->VFread0 = 0;
# Line 2851  void _vuRegsIBLTZ(VURegs * VU, _VURegsNu Line 2805  void _vuRegsIBLTZ(VURegs * VU, _VURegsNu
2805          VUregsn->VIread  = 1 << _Is_;          VUregsn->VIread  = 1 << _Is_;
2806  }  }
2807    
2808  void _vuRegsIBNE(VURegs * VU, _VURegsNum *VUregsn) {  static __ri void _vuRegsIBNE(const VURegs* VU, _VURegsNum *VUregsn) {
2809          VUregsn->pipe = VUPIPE_BRANCH;          VUregsn->pipe = VUPIPE_BRANCH;
2810      VUregsn->VFwrite = 0;      VUregsn->VFwrite = 0;
2811      VUregsn->VFread0 = 0;      VUregsn->VFread0 = 0;
# Line 2860  void _vuRegsIBNE(VURegs * VU, _VURegsNum Line 2814  void _vuRegsIBNE(VURegs * VU, _VURegsNum
2814      VUregsn->VIread  = (1 << _Is_) | (1 << _It_);      VUregsn->VIread  = (1 << _Is_) | (1 << _It_);
2815  }  }
2816    
2817  void _vuRegsB(VURegs * VU, _VURegsNum *VUregsn) {  static __ri void _vuRegsB(const VURegs* VU, _VURegsNum *VUregsn) {
2818          VUregsn->pipe = VUPIPE_BRANCH;          VUregsn->pipe = VUPIPE_BRANCH;
2819      VUregsn->VFwrite = 0;      VUregsn->VFwrite = 0;
2820      VUregsn->VFread0 = 0;      VUregsn->VFread0 = 0;
# Line 2869  void _vuRegsB(VURegs * VU, _VURegsNum *V Line 2823  void _vuRegsB(VURegs * VU, _VURegsNum *V
2823      VUregsn->VIread  = 0;      VUregsn->VIread  = 0;
2824  }  }
2825    
2826  void _vuRegsBAL(VURegs * VU, _VURegsNum *VUregsn) {  static __ri void _vuRegsBAL(const VURegs* VU, _VURegsNum *VUregsn) {
2827          VUregsn->pipe = VUPIPE_BRANCH;          VUregsn->pipe = VUPIPE_BRANCH;
2828      VUregsn->VFwrite = 0;      VUregsn->VFwrite = 0;
2829      VUregsn->VFread0 = 0;      VUregsn->VFread0 = 0;
# Line 2878  void _vuRegsBAL(VURegs * VU, _VURegsNum Line 2832  void _vuRegsBAL(VURegs * VU, _VURegsNum
2832      VUregsn->VIread  = 0;      VUregsn->VIread  = 0;
2833  }  }
2834    
2835  void _vuRegsJR(VURegs * VU, _VURegsNum *VUregsn) {  static __ri void _vuRegsJR(const VURegs* VU, _VURegsNum *VUregsn) {
2836          VUregsn->pipe = VUPIPE_BRANCH;          VUregsn->pipe = VUPIPE_BRANCH;
2837      VUregsn->VFwrite = 0;      VUregsn->VFwrite = 0;
2838      VUregsn->VFread0 = 0;      VUregsn->VFread0 = 0;
# Line 2887  void _vuRegsJR(VURegs * VU, _VURegsNum * Line 2841  void _vuRegsJR(VURegs * VU, _VURegsNum *
2841          VUregsn->VIread  = 1 << _Is_;          VUregsn->VIread  = 1 << _Is_;
2842  }  }
2843    
2844  void _vuRegsJALR(VURegs * VU, _VURegsNum *VUregsn) {  static __ri void _vuRegsJALR(const VURegs* VU, _VURegsNum *VUregsn) {
2845          VUregsn->pipe = VUPIPE_BRANCH;          VUregsn->pipe = VUPIPE_BRANCH;
2846      VUregsn->VFwrite = 0;      VUregsn->VFwrite = 0;
2847      VUregsn->VFread0 = 0;      VUregsn->VFread0 = 0;
# Line 2896  void _vuRegsJALR(VURegs * VU, _VURegsNum Line 2850  void _vuRegsJALR(VURegs * VU, _VURegsNum
2850          VUregsn->VIread  = 1 << _Is_;          VUregsn->VIread  = 1 << _Is_;
2851  }  }
2852    
2853  void _vuRegsMFP(VURegs * VU, _VURegsNum *VUregsn) {  static __ri void _vuRegsMFP(const VURegs* VU, _VURegsNum *VUregsn) {
2854          VUregsn->pipe = VUPIPE_FMAC;          VUregsn->pipe = VUPIPE_FMAC;
2855      VUregsn->VFwrite = _Ft_;      VUregsn->VFwrite = _Ft_;
2856      VUregsn->VFwxyzw = _XYZW;      VUregsn->VFwxyzw = _XYZW;
# Line 2906  void _vuRegsMFP(VURegs * VU, _VURegsNum Line 2860  void _vuRegsMFP(VURegs * VU, _VURegsNum
2860          VUregsn->VIread  = 1 << REG_P;          VUregsn->VIread  = 1 << REG_P;
2861  }  }
2862    
2863  void _vuRegsWAITP(VURegs * VU, _VURegsNum *VUregsn) {  static __ri void _vuRegsWAITP(const VURegs* VU, _VURegsNum *VUregsn) {
2864          VUregsn->pipe = VUPIPE_EFU;          VUregsn->pipe = VUPIPE_EFU;
2865      VUregsn->VFwrite = 0;      VUregsn->VFwrite = 0;
2866      VUregsn->VFread0 = 0;      VUregsn->VFread0 = 0;
# Line 2929  VUREGS_PFS_fsf(ESIN, 28); Line 2883  VUREGS_PFS_fsf(ESIN, 28);
2883  VUREGS_PFS_fsf(EATAN, 53);  VUREGS_PFS_fsf(EATAN, 53);
2884  VUREGS_PFS_fsf(EEXP, 43);  VUREGS_PFS_fsf(EEXP, 43);
2885    
2886  void _vuRegsXITOP(VURegs * VU, _VURegsNum *VUregsn) {  static __ri void _vuRegsXITOP(const VURegs* VU, _VURegsNum *VUregsn) {
2887          VUregsn->pipe = VUPIPE_IALU;          VUregsn->pipe = VUPIPE_IALU;
2888      VUregsn->VFwrite = 0;      VUregsn->VFwrite = 0;
2889      VUregsn->VFread0 = 0;      VUregsn->VFread0 = 0;
# Line 2939  void _vuRegsXITOP(VURegs * VU, _VURegsNu Line 2893  void _vuRegsXITOP(VURegs * VU, _VURegsNu
2893          VUregsn->cycles  = 0;          VUregsn->cycles  = 0;
2894  }  }
2895    
2896  void _vuRegsXGKICK(VURegs * VU, _VURegsNum *VUregsn) {  static __ri void _vuRegsXGKICK(const VURegs* VU, _VURegsNum *VUregsn) {
2897          VUregsn->pipe = VUPIPE_XGKICK;          VUregsn->pipe = VUPIPE_XGKICK;
2898      VUregsn->VFwrite = 0;      VUregsn->VFwrite = 0;
2899      VUregsn->VFread0 = 0;      VUregsn->VFread0 = 0;
# Line 2948  void _vuRegsXGKICK(VURegs * VU, _VURegsN Line 2902  void _vuRegsXGKICK(VURegs * VU, _VURegsN
2902      VUregsn->VIread  = 1 << _Is_;      VUregsn->VIread  = 1 << _Is_;
2903  }  }
2904    
2905  void _vuRegsXTOP(VURegs * VU, _VURegsNum *VUregsn) {  static __ri void _vuRegsXTOP(const VURegs* VU, _VURegsNum *VUregsn) {
2906          VUregsn->pipe = VUPIPE_IALU;          VUregsn->pipe = VUPIPE_IALU;
2907      VUregsn->VFwrite = 0;      VUregsn->VFwrite = 0;
2908      VUregsn->VFread0 = 0;      VUregsn->VFread0 = 0;
# Line 2957  void _vuRegsXTOP(VURegs * VU, _VURegsNum Line 2911  void _vuRegsXTOP(VURegs * VU, _VURegsNum
2911      VUregsn->VIread  = 0;      VUregsn->VIread  = 0;
2912          VUregsn->cycles  = 0;          VUregsn->cycles  = 0;
2913  }  }
2914    
2915    // --------------------------------------------------------------------------------------
2916    //  VU0
2917    // --------------------------------------------------------------------------------------
2918    
2919    /****************************************/
2920    /*   VU Micromode Upper instructions    */
2921    /****************************************/
2922    
2923    static void VU0MI_ABS()  { _vuABS(&VU0); }
2924    static void VU0MI_ADD()  { _vuADD(&VU0); }
2925    static void VU0MI_ADDi() { _vuADDi(&VU0); }
2926    static void VU0MI_ADDq() { _vuADDq(&VU0); }
2927    static void VU0MI_ADDx() { _vuADDx(&VU0); }
2928    static void VU0MI_ADDy() { _vuADDy(&VU0); }
2929    static void VU0MI_ADDz() { _vuADDz(&VU0); }
2930    static void VU0MI_ADDw() { _vuADDw(&VU0); }
2931    static void VU0MI_ADDA() { _vuADDA(&VU0); }
2932    static void VU0MI_ADDAi() { _vuADDAi(&VU0); }
2933    static void VU0MI_ADDAq() { _vuADDAq(&VU0); }
2934    static void VU0MI_ADDAx() { _vuADDAx(&VU0); }
2935    static void VU0MI_ADDAy() { _vuADDAy(&VU0); }
2936    static void VU0MI_ADDAz() { _vuADDAz(&VU0); }
2937    static void VU0MI_ADDAw() { _vuADDAw(&VU0); }
2938    static void VU0MI_SUB()  { _vuSUB(&VU0); }
2939    static void VU0MI_SUBi() { _vuSUBi(&VU0); }
2940    static void VU0MI_SUBq() { _vuSUBq(&VU0); }
2941    static void VU0MI_SUBx() { _vuSUBx(&VU0); }
2942    static void VU0MI_SUBy() { _vuSUBy(&VU0); }
2943    static void VU0MI_SUBz() { _vuSUBz(&VU0); }
2944    static void VU0MI_SUBw() { _vuSUBw(&VU0); }
2945    static void VU0MI_SUBA()  { _vuSUBA(&VU0); }
2946    static void VU0MI_SUBAi() { _vuSUBAi(&VU0); }
2947    static void VU0MI_SUBAq() { _vuSUBAq(&VU0); }
2948    static void VU0MI_SUBAx() { _vuSUBAx(&VU0); }
2949    static void VU0MI_SUBAy() { _vuSUBAy(&VU0); }
2950    static void VU0MI_SUBAz() { _vuSUBAz(&VU0); }
2951    static void VU0MI_SUBAw() { _vuSUBAw(&VU0); }
2952    static void VU0MI_MUL()  { _vuMUL(&VU0); }
2953    static void VU0MI_MULi() { _vuMULi(&VU0); }
2954    static void VU0MI_MULq() { _vuMULq(&VU0); }
2955    static void VU0MI_MULx() { _vuMULx(&VU0); }
2956    static void VU0MI_MULy() { _vuMULy(&VU0); }
2957    static void VU0MI_MULz() { _vuMULz(&VU0); }
2958    static void VU0MI_MULw() { _vuMULw(&VU0); }
2959    static void VU0MI_MULA()  { _vuMULA(&VU0); }
2960    static void VU0MI_MULAi() { _vuMULAi(&VU0); }
2961    static void VU0MI_MULAq() { _vuMULAq(&VU0); }
2962    static void VU0MI_MULAx() { _vuMULAx(&VU0); }
2963    static void VU0MI_MULAy() { _vuMULAy(&VU0); }
2964    static void VU0MI_MULAz() { _vuMULAz(&VU0); }
2965    static void VU0MI_MULAw() { _vuMULAw(&VU0); }
2966    static void VU0MI_MADD()  { _vuMADD(&VU0); }
2967    static void VU0MI_MADDi() { _vuMADDi(&VU0); }
2968    static void VU0MI_MADDq() { _vuMADDq(&VU0); }
2969    static void VU0MI_MADDx() { _vuMADDx(&VU0); }
2970    static void VU0MI_MADDy() { _vuMADDy(&VU0); }
2971    static void VU0MI_MADDz() { _vuMADDz(&VU0); }
2972    static void VU0MI_MADDw() { _vuMADDw(&VU0); }
2973    static void VU0MI_MADDA()  { _vuMADDA(&VU0); }
2974    static void VU0MI_MADDAi() { _vuMADDAi(&VU0); }
2975    static void VU0MI_MADDAq() { _vuMADDAq(&VU0); }
2976    static void VU0MI_MADDAx() { _vuMADDAx(&VU0); }
2977    static void VU0MI_MADDAy() { _vuMADDAy(&VU0); }
2978    static void VU0MI_MADDAz() { _vuMADDAz(&VU0); }
2979    static void VU0MI_MADDAw() { _vuMADDAw(&VU0); }
2980    static void VU0MI_MSUB()  { _vuMSUB(&VU0); }
2981    static void VU0MI_MSUBi() { _vuMSUBi(&VU0); }
2982    static void VU0MI_MSUBq() { _vuMSUBq(&VU0); }
2983    static void VU0MI_MSUBx() { _vuMSUBx(&VU0); }
2984    static void VU0MI_MSUBy() { _vuMSUBy(&VU0); }
2985    static void VU0MI_MSUBz() { _vuMSUBz(&VU0); }
2986    static void VU0MI_MSUBw() { _vuMSUBw(&VU0); }
2987    static void VU0MI_MSUBA()  { _vuMSUBA(&VU0); }
2988    static void VU0MI_MSUBAi() { _vuMSUBAi(&VU0); }
2989    static void VU0MI_MSUBAq() { _vuMSUBAq(&VU0); }
2990    static void VU0MI_MSUBAx() { _vuMSUBAx(&VU0); }
2991    static void VU0MI_MSUBAy() { _vuMSUBAy(&VU0); }
2992    static void VU0MI_MSUBAz() { _vuMSUBAz(&VU0); }
2993    static void VU0MI_MSUBAw() { _vuMSUBAw(&VU0); }
2994    static void VU0MI_MAX()  { _vuMAX(&VU0); }
2995    static void VU0MI_MAXi() { _vuMAXi(&VU0); }
2996    static void VU0MI_MAXx() { _vuMAXx(&VU0); }
2997    static void VU0MI_MAXy() { _vuMAXy(&VU0); }
2998    static void VU0MI_MAXz() { _vuMAXz(&VU0); }
2999    static void VU0MI_MAXw() { _vuMAXw(&VU0); }
3000    static void VU0MI_MINI()  { _vuMINI(&VU0); }
3001    static void VU0MI_MINIi() { _vuMINIi(&VU0); }
3002    static void VU0MI_MINIx() { _vuMINIx(&VU0); }
3003    static void VU0MI_MINIy() { _vuMINIy(&VU0); }
3004    static void VU0MI_MINIz() { _vuMINIz(&VU0); }
3005    static void VU0MI_MINIw() { _vuMINIw(&VU0); }
3006    static void VU0MI_OPMULA() { _vuOPMULA(&VU0); }
3007    static void VU0MI_OPMSUB() { _vuOPMSUB(&VU0); }
3008    static void VU0MI_NOP() { _vuNOP(&VU0); }
3009    static void VU0MI_FTOI0()  { _vuFTOI0(&VU0); }
3010    static void VU0MI_FTOI4()  { _vuFTOI4(&VU0); }
3011    static void VU0MI_FTOI12() { _vuFTOI12(&VU0); }
3012    static void VU0MI_FTOI15() { _vuFTOI15(&VU0); }
3013    static void VU0MI_ITOF0()  { _vuITOF0(&VU0); }
3014    static void VU0MI_ITOF4()  { _vuITOF4(&VU0); }
3015    static void VU0MI_ITOF12() { _vuITOF12(&VU0); }
3016    static void VU0MI_ITOF15() { _vuITOF15(&VU0); }
3017    static void VU0MI_CLIP() { _vuCLIP(&VU0); }
3018    
3019    /*****************************************/
3020    /*   VU Micromode Lower instructions    */
3021    /*****************************************/
3022    
3023    static void VU0MI_DIV() { _vuDIV(&VU0); }
3024    static void VU0MI_SQRT() { _vuSQRT(&VU0); }
3025    static void VU0MI_RSQRT() { _vuRSQRT(&VU0); }
3026    static void VU0MI_IADD() { _vuIADD(&VU0); }
3027    static void VU0MI_IADDI() { _vuIADDI(&VU0); }
3028    static void VU0MI_IADDIU() { _vuIADDIU(&VU0); }
3029    static void VU0MI_IAND() { _vuIAND(&VU0); }
3030    static void VU0MI_IOR() { _vuIOR(&VU0); }
3031    static void VU0MI_ISUB() { _vuISUB(&VU0); }
3032    static void VU0MI_ISUBIU() { _vuISUBIU(&VU0); }
3033    static void VU0MI_MOVE() { _vuMOVE(&VU0); }
3034    static void VU0MI_MFIR() { _vuMFIR(&VU0); }
3035    static void VU0MI_MTIR() { _vuMTIR(&VU0); }
3036    static void VU0MI_MR32() { _vuMR32(&VU0); }
3037    static void VU0MI_LQ() { _vuLQ(&VU0); }
3038    static void VU0MI_LQD() { _vuLQD(&VU0); }
3039    static void VU0MI_LQI() { _vuLQI(&VU0); }
3040    static void VU0MI_SQ() { _vuSQ(&VU0); }
3041    static void VU0MI_SQD() { _vuSQD(&VU0); }
3042    static void VU0MI_SQI() { _vuSQI(&VU0); }
3043    static void VU0MI_ILW() { _vuILW(&VU0); }
3044    static void VU0MI_ISW() { _vuISW(&VU0); }
3045    static void VU0MI_ILWR() { _vuILWR(&VU0); }
3046    static void VU0MI_ISWR() { _vuISWR(&VU0); }
3047    static void VU0MI_RINIT() { _vuRINIT(&VU0); }
3048    static void VU0MI_RGET()  { _vuRGET(&VU0); }
3049    static void VU0MI_RNEXT() { _vuRNEXT(&VU0); }
3050    static void VU0MI_RXOR()  { _vuRXOR(&VU0); }
3051    static void VU0MI_WAITQ() { _vuWAITQ(&VU0); }
3052    static void VU0MI_FSAND() { _vuFSAND(&VU0); }
3053    static void VU0MI_FSEQ()  { _vuFSEQ(&VU0); }
3054    static void VU0MI_FSOR()  { _vuFSOR(&VU0); }
3055    static void VU0MI_FSSET() { _vuFSSET(&VU0); }
3056    static void VU0MI_FMAND() { _vuFMAND(&VU0); }
3057    static void VU0MI_FMEQ()  { _vuFMEQ(&VU0); }
3058    static void VU0MI_FMOR()  { _vuFMOR(&VU0); }
3059    static void VU0MI_FCAND() { _vuFCAND(&VU0); }
3060    static void VU0MI_FCEQ()  { _vuFCEQ(&VU0); }
3061    static void VU0MI_FCOR()  { _vuFCOR(&VU0); }
3062    static void VU0MI_FCSET() { _vuFCSET(&VU0); }
3063    static void VU0MI_FCGET() { _vuFCGET(&VU0); }
3064    static void VU0MI_IBEQ() { _vuIBEQ(&VU0); }
3065    static void VU0MI_IBGEZ() { _vuIBGEZ(&VU0); }
3066    static void VU0MI_IBGTZ() { _vuIBGTZ(&VU0); }
3067    static void VU0MI_IBLTZ() { _vuIBLTZ(&VU0); }
3068    static void VU0MI_IBLEZ() { _vuIBLEZ(&VU0); }
3069    static void VU0MI_IBNE() { _vuIBNE(&VU0); }
3070    static void VU0MI_B()   { _vuB(&VU0); }
3071    static void VU0MI_BAL() { _vuBAL(&VU0); }
3072    static void VU0MI_JR()   { _vuJR(&VU0); }
3073    static void VU0MI_JALR() { _vuJALR(&VU0); }
3074    static void VU0MI_MFP() { _vuMFP(&VU0); }
3075    static void VU0MI_WAITP() { _vuWAITP(&VU0); }
3076    static void VU0MI_ESADD()   { _vuESADD(&VU0); }
3077    static void VU0MI_ERSADD()  { _vuERSADD(&VU0); }
3078    static void VU0MI_ELENG()   { _vuELENG(&VU0); }
3079    static void VU0MI_ERLENG()  { _vuERLENG(&VU0); }
3080    static void VU0MI_EATANxy() { _vuEATANxy(&VU0); }
3081    static void VU0MI_EATANxz() { _vuEATANxz(&VU0); }
3082    static void VU0MI_ESUM()    { _vuESUM(&VU0); }
3083    static void VU0MI_ERCPR()   { _vuERCPR(&VU0); }
3084    static void VU0MI_ESQRT()   { _vuESQRT(&VU0); }
3085    static void VU0MI_ERSQRT()  { _vuERSQRT(&VU0); }
3086    static void VU0MI_ESIN()    { _vuESIN(&VU0); }
3087    static void VU0MI_EATAN()   { _vuEATAN(&VU0); }
3088    static void VU0MI_EEXP()    { _vuEEXP(&VU0); }
3089    static void VU0MI_XITOP() { _vuXITOP(&VU0); }
3090    static void VU0MI_XGKICK() {}
3091    static void VU0MI_XTOP() {}
3092    
3093    /****************************************/
3094    /*   VU Micromode Upper instructions    */
3095    /****************************************/
3096    
3097    static void __vuRegsCall VU0regsMI_ABS(_VURegsNum *VUregsn)  { _vuRegsABS(&VU0, VUregsn); }
3098    static void __vuRegsCall VU0regsMI_ADD(_VURegsNum *VUregsn)  { _vuRegsADD(&VU0, VUregsn); }
3099    static void __vuRegsCall VU0regsMI_ADDi(_VURegsNum *VUregsn) { _vuRegsADDi(&VU0, VUregsn); }
3100    static void __vuRegsCall VU0regsMI_ADDq(_VURegsNum *VUregsn) { _vuRegsADDq(&VU0, VUregsn); }
3101    static void __vuRegsCall VU0regsMI_ADDx(_VURegsNum *VUregsn) { _vuRegsADDx(&VU0, VUregsn); }
3102    static void __vuRegsCall VU0regsMI_ADDy(_VURegsNum *VUregsn) { _vuRegsADDy(&VU0, VUregsn); }
3103    static void __vuRegsCall VU0regsMI_ADDz(_VURegsNum *VUregsn) { _vuRegsADDz(&VU0, VUregsn); }
3104    static void __vuRegsCall VU0regsMI_ADDw(_VURegsNum *VUregsn) { _vuRegsADDw(&VU0, VUregsn); }
3105    static void __vuRegsCall VU0regsMI_ADDA(_VURegsNum *VUregsn) { _vuRegsADDA(&VU0, VUregsn); }
3106    static void __vuRegsCall VU0regsMI_ADDAi(_VURegsNum *VUregsn) { _vuRegsADDAi(&VU0, VUregsn); }
3107    static void __vuRegsCall VU0regsMI_ADDAq(_VURegsNum *VUregsn) { _vuRegsADDAq(&VU0, VUregsn); }
3108    static void __vuRegsCall VU0regsMI_ADDAx(_VURegsNum *VUregsn) { _vuRegsADDAx(&VU0, VUregsn); }
3109    static void __vuRegsCall VU0regsMI_ADDAy(_VURegsNum *VUregsn) { _vuRegsADDAy(&VU0, VUregsn); }
3110    static void __vuRegsCall VU0regsMI_ADDAz(_VURegsNum *VUregsn) { _vuRegsADDAz(&VU0, VUregsn); }
3111    static void __vuRegsCall VU0regsMI_ADDAw(_VURegsNum *VUregsn) { _vuRegsADDAw(&VU0, VUregsn); }
3112    static void __vuRegsCall VU0regsMI_SUB(_VURegsNum *VUregsn)  { _vuRegsSUB(&VU0, VUregsn); }
3113    static void __vuRegsCall VU0regsMI_SUBi(_VURegsNum *VUregsn) { _vuRegsSUBi(&VU0, VUregsn); }
3114    static void __vuRegsCall VU0regsMI_SUBq(_VURegsNum *VUregsn) { _vuRegsSUBq(&VU0, VUregsn); }
3115    static void __vuRegsCall VU0regsMI_SUBx(_VURegsNum *VUregsn) { _vuRegsSUBx(&VU0, VUregsn); }
3116    static void __vuRegsCall VU0regsMI_SUBy(_VURegsNum *VUregsn) { _vuRegsSUBy(&VU0, VUregsn); }
3117    static void __vuRegsCall VU0regsMI_SUBz(_VURegsNum *VUregsn) { _vuRegsSUBz(&VU0, VUregsn); }
3118    static void __vuRegsCall VU0regsMI_SUBw(_VURegsNum *VUregsn) { _vuRegsSUBw(&VU0, VUregsn); }
3119    static void __vuRegsCall VU0regsMI_SUBA(_VURegsNum *VUregsn)  { _vuRegsSUBA(&VU0, VUregsn); }
3120    static void __vuRegsCall VU0regsMI_SUBAi(_VURegsNum *VUregsn) { _vuRegsSUBAi(&VU0, VUregsn); }
3121    static void __vuRegsCall VU0regsMI_SUBAq(_VURegsNum *VUregsn) { _vuRegsSUBAq(&VU0, VUregsn); }
3122    static void __vuRegsCall VU0regsMI_SUBAx(_VURegsNum *VUregsn) { _vuRegsSUBAx(&VU0, VUregsn); }
3123    static void __vuRegsCall VU0regsMI_SUBAy(_VURegsNum *VUregsn) { _vuRegsSUBAy(&VU0, VUregsn); }
3124    static void __vuRegsCall VU0regsMI_SUBAz(_VURegsNum *VUregsn) { _vuRegsSUBAz(&VU0, VUregsn); }
3125    static void __vuRegsCall VU0regsMI_SUBAw(_VURegsNum *VUregsn) { _vuRegsSUBAw(&VU0, VUregsn); }
3126    static void __vuRegsCall VU0regsMI_MUL(_VURegsNum *VUregsn)  { _vuRegsMUL(&VU0, VUregsn); }
3127    static void __vuRegsCall VU0regsMI_MULi(_VURegsNum *VUregsn) { _vuRegsMULi(&VU0, VUregsn); }
3128    static void __vuRegsCall VU0regsMI_MULq(_VURegsNum *VUregsn) { _vuRegsMULq(&VU0, VUregsn); }
3129    static void __vuRegsCall VU0regsMI_MULx(_VURegsNum *VUregsn) { _vuRegsMULx(&VU0, VUregsn); }
3130    static void __vuRegsCall VU0regsMI_MULy(_VURegsNum *VUregsn) { _vuRegsMULy(&VU0, VUregsn); }
3131    static void __vuRegsCall VU0regsMI_MULz(_VURegsNum *VUregsn) { _vuRegsMULz(&VU0, VUregsn); }
3132    static void __vuRegsCall VU0regsMI_MULw(_VURegsNum *VUregsn) { _vuRegsMULw(&VU0, VUregsn); }
3133    static void __vuRegsCall VU0regsMI_MULA(_VURegsNum *VUregsn)  { _vuRegsMULA(&VU0, VUregsn); }
3134    static void __vuRegsCall VU0regsMI_MULAi(_VURegsNum *VUregsn) { _vuRegsMULAi(&VU0, VUregsn); }
3135    static void __vuRegsCall VU0regsMI_MULAq(_VURegsNum *VUregsn) { _vuRegsMULAq(&VU0, VUregsn); }
3136    static void __vuRegsCall VU0regsMI_MULAx(_VURegsNum *VUregsn) { _vuRegsMULAx(&VU0, VUregsn); }
3137    static void __vuRegsCall VU0regsMI_MULAy(_VURegsNum *VUregsn) { _vuRegsMULAy(&VU0, VUregsn); }
3138    static void __vuRegsCall VU0regsMI_MULAz(_VURegsNum *VUregsn) { _vuRegsMULAz(&VU0, VUregsn); }
3139    static void __vuRegsCall VU0regsMI_MULAw(_VURegsNum *VUregsn) { _vuRegsMULAw(&VU0, VUregsn); }
3140    static void __vuRegsCall VU0regsMI_MADD(_VURegsNum *VUregsn)  { _vuRegsMADD(&VU0, VUregsn); }
3141    static void __vuRegsCall VU0regsMI_MADDi(_VURegsNum *VUregsn) { _vuRegsMADDi(&VU0, VUregsn); }
3142    static void __vuRegsCall VU0regsMI_MADDq(_VURegsNum *VUregsn) { _vuRegsMADDq(&VU0, VUregsn); }
3143    static void __vuRegsCall VU0regsMI_MADDx(_VURegsNum *VUregsn) { _vuRegsMADDx(&VU0, VUregsn); }
3144    static void __vuRegsCall VU0regsMI_MADDy(_VURegsNum *VUregsn) { _vuRegsMADDy(&VU0, VUregsn); }
3145    static void __vuRegsCall VU0regsMI_MADDz(_VURegsNum *VUregsn) { _vuRegsMADDz(&VU0, VUregsn); }
3146    static void __vuRegsCall VU0regsMI_MADDw(_VURegsNum *VUregsn) { _vuRegsMADDw(&VU0, VUregsn); }
3147    static void __vuRegsCall VU0regsMI_MADDA(_VURegsNum *VUregsn)  { _vuRegsMADDA(&VU0, VUregsn); }
3148    static void __vuRegsCall VU0regsMI_MADDAi(_VURegsNum *VUregsn) { _vuRegsMADDAi(&VU0, VUregsn); }
3149    static void __vuRegsCall VU0regsMI_MADDAq(_VURegsNum *VUregsn) { _vuRegsMADDAq(&VU0, VUregsn); }
3150    static void __vuRegsCall VU0regsMI_MADDAx(_VURegsNum *VUregsn) { _vuRegsMADDAx(&VU0, VUregsn); }
3151    static void __vuRegsCall VU0regsMI_MADDAy(_VURegsNum *VUregsn) { _vuRegsMADDAy(&VU0, VUregsn); }
3152    static void __vuRegsCall VU0regsMI_MADDAz(_VURegsNum *VUregsn) { _vuRegsMADDAz(&VU0, VUregsn); }
3153    static void __vuRegsCall VU0regsMI_MADDAw(_VURegsNum *VUregsn) { _vuRegsMADDAw(&VU0, VUregsn); }
3154    static void __vuRegsCall VU0regsMI_MSUB(_VURegsNum *VUregsn)  { _vuRegsMSUB(&VU0, VUregsn); }
3155    static void __vuRegsCall VU0regsMI_MSUBi(_VURegsNum *VUregsn) { _vuRegsMSUBi(&VU0, VUregsn); }
3156    static void __vuRegsCall VU0regsMI_MSUBq(_VURegsNum *VUregsn) { _vuRegsMSUBq(&VU0, VUregsn); }
3157    static void __vuRegsCall VU0regsMI_MSUBx(_VURegsNum *VUregsn) { _vuRegsMSUBx(&VU0, VUregsn); }
3158    static void __vuRegsCall VU0regsMI_MSUBy(_VURegsNum *VUregsn) { _vuRegsMSUBy(&VU0, VUregsn); }
3159    static void __vuRegsCall VU0regsMI_MSUBz(_VURegsNum *VUregsn) { _vuRegsMSUBz(&VU0, VUregsn); }
3160    static void __vuRegsCall VU0regsMI_MSUBw(_VURegsNum *VUregsn) { _vuRegsMSUBw(&VU0, VUregsn); }
3161    static void __vuRegsCall VU0regsMI_MSUBA(_VURegsNum *VUregsn)  { _vuRegsMSUBA(&VU0, VUregsn); }
3162    static void __vuRegsCall VU0regsMI_MSUBAi(_VURegsNum *VUregsn) { _vuRegsMSUBAi(&VU0, VUregsn); }
3163    static void __vuRegsCall VU0regsMI_MSUBAq(_VURegsNum *VUregsn) { _vuRegsMSUBAq(&VU0, VUregsn); }
3164    static void __vuRegsCall VU0regsMI_MSUBAx(_VURegsNum *VUregsn) { _vuRegsMSUBAx(&VU0, VUregsn); }
3165    static void __vuRegsCall VU0regsMI_MSUBAy(_VURegsNum *VUregsn) { _vuRegsMSUBAy(&VU0, VUregsn); }
3166    static void __vuRegsCall VU0regsMI_MSUBAz(_VURegsNum *VUregsn) { _vuRegsMSUBAz(&VU0, VUregsn); }
3167    static void __vuRegsCall VU0regsMI_MSUBAw(_VURegsNum *VUregsn) { _vuRegsMSUBAw(&VU0, VUregsn); }
3168    static void __vuRegsCall VU0regsMI_MAX(_VURegsNum *VUregsn)  { _vuRegsMAX(&VU0, VUregsn); }
3169    static void __vuRegsCall VU0regsMI_MAXi(_VURegsNum *VUregsn) { _vuRegsMAXi(&VU0, VUregsn); }
3170    static void __vuRegsCall VU0regsMI_MAXx(_VURegsNum *VUregsn) { _vuRegsMAXx(&VU0, VUregsn); }
3171    static void __vuRegsCall VU0regsMI_MAXy(_VURegsNum *VUregsn) { _vuRegsMAXy(&VU0, VUregsn); }
3172    static void __vuRegsCall VU0regsMI_MAXz(_VURegsNum *VUregsn) { _vuRegsMAXz(&VU0, VUregsn); }
3173    static void __vuRegsCall VU0regsMI_MAXw(_VURegsNum *VUregsn) { _vuRegsMAXw(&VU0, VUregsn); }
3174    static void __vuRegsCall VU0regsMI_MINI(_VURegsNum *VUregsn)  { _vuRegsMINI(&VU0, VUregsn); }
3175    static void __vuRegsCall VU0regsMI_MINIi(_VURegsNum *VUregsn) { _vuRegsMINIi(&VU0, VUregsn); }
3176    static void __vuRegsCall VU0regsMI_MINIx(_VURegsNum *VUregsn) { _vuRegsMINIx(&VU0, VUregsn); }
3177    static void __vuRegsCall VU0regsMI_MINIy(_VURegsNum *VUregsn) { _vuRegsMINIy(&VU0, VUregsn); }
3178    static void __vuRegsCall VU0regsMI_MINIz(_VURegsNum *VUregsn) { _vuRegsMINIz(&VU0, VUregsn); }
3179    static void __vuRegsCall VU0regsMI_MINIw(_VURegsNum *VUregsn) { _vuRegsMINIw(&VU0, VUregsn); }
3180    static void __vuRegsCall VU0regsMI_OPMULA(_VURegsNum *VUregsn) { _vuRegsOPMULA(&VU0, VUregsn); }
3181    static void __vuRegsCall VU0regsMI_OPMSUB(_VURegsNum *VUregsn) { _vuRegsOPMSUB(&VU0, VUregsn); }
3182    static void __vuRegsCall VU0regsMI_NOP(_VURegsNum *VUregsn) { _vuRegsNOP(&VU0, VUregsn); }
3183    static void __vuRegsCall VU0regsMI_FTOI0(_VURegsNum *VUregsn)  { _vuRegsFTOI0(&VU0, VUregsn); }
3184    static void __vuRegsCall VU0regsMI_FTOI4(_VURegsNum *VUregsn)  { _vuRegsFTOI4(&VU0, VUregsn); }
3185    static void __vuRegsCall VU0regsMI_FTOI12(_VURegsNum *VUregsn) { _vuRegsFTOI12(&VU0, VUregsn); }
3186    static void __vuRegsCall VU0regsMI_FTOI15(_VURegsNum *VUregsn) { _vuRegsFTOI15(&VU0, VUregsn); }
3187    static void __vuRegsCall VU0regsMI_ITOF0(_VURegsNum *VUregsn)  { _vuRegsITOF0(&VU0, VUregsn); }
3188    static void __vuRegsCall VU0regsMI_ITOF4(_VURegsNum *VUregsn)  { _vuRegsITOF4(&VU0, VUregsn); }
3189    static void __vuRegsCall VU0regsMI_ITOF12(_VURegsNum *VUregsn) { _vuRegsITOF12(&VU0, VUregsn); }
3190    static void __vuRegsCall VU0regsMI_ITOF15(_VURegsNum *VUregsn) { _vuRegsITOF15(&VU0, VUregsn); }
3191    static void __vuRegsCall VU0regsMI_CLIP(_VURegsNum *VUregsn) { _vuRegsCLIP(&VU0, VUregsn); }
3192    
3193    /*****************************************/
3194    /*   VU Micromode Lower instructions    */
3195    /*****************************************/
3196    
3197    static void __vuRegsCall VU0regsMI_DIV(_VURegsNum *VUregsn) { _vuRegsDIV(&VU0, VUregsn); }
3198    static void __vuRegsCall VU0regsMI_SQRT(_VURegsNum *VUregsn) { _vuRegsSQRT(&VU0, VUregsn); }
3199    static void __vuRegsCall VU0regsMI_RSQRT(_VURegsNum *VUregsn) { _vuRegsRSQRT(&VU0, VUregsn); }
3200    static void __vuRegsCall VU0regsMI_IADD(_VURegsNum *VUregsn) { _vuRegsIADD(&VU0, VUregsn); }
3201    static void __vuRegsCall VU0regsMI_IADDI(_VURegsNum *VUregsn) { _vuRegsIADDI(&VU0, VUregsn); }
3202    static void __vuRegsCall VU0regsMI_IADDIU(_VURegsNum *VUregsn) { _vuRegsIADDIU(&VU0, VUregsn); }
3203    static void __vuRegsCall VU0regsMI_IAND(_VURegsNum *VUregsn) { _vuRegsIAND(&VU0, VUregsn); }
3204    static void __vuRegsCall VU0regsMI_IOR(_VURegsNum *VUregsn) { _vuRegsIOR(&VU0, VUregsn); }
3205    static void __vuRegsCall VU0regsMI_ISUB(_VURegsNum *VUregsn) { _vuRegsISUB(&VU0, VUregsn); }
3206    static void __vuRegsCall VU0regsMI_ISUBIU(_VURegsNum *VUregsn) { _vuRegsISUBIU(&VU0, VUregsn); }
3207    static void __vuRegsCall VU0regsMI_MOVE(_VURegsNum *VUregsn) { _vuRegsMOVE(&VU0, VUregsn); }
3208    static void __vuRegsCall VU0regsMI_MFIR(_VURegsNum *VUregsn) { _vuRegsMFIR(&VU0, VUregsn); }
3209    static void __vuRegsCall VU0regsMI_MTIR(_VURegsNum *VUregsn) { _vuRegsMTIR(&VU0, VUregsn); }
3210    static void __vuRegsCall VU0regsMI_MR32(_VURegsNum *VUregsn) { _vuRegsMR32(&VU0, VUregsn); }
3211    static void __vuRegsCall VU0regsMI_LQ(_VURegsNum *VUregsn) { _vuRegsLQ(&VU0, VUregsn); }
3212    static void __vuRegsCall VU0regsMI_LQD(_VURegsNum *VUregsn) { _vuRegsLQD(&VU0, VUregsn); }
3213    static void __vuRegsCall VU0regsMI_LQI(_VURegsNum *VUregsn) { _vuRegsLQI(&VU0, VUregsn); }
3214    static void __vuRegsCall VU0regsMI_SQ(_VURegsNum *VUregsn) { _vuRegsSQ(&VU0, VUregsn); }
3215    static void __vuRegsCall VU0regsMI_SQD(_VURegsNum *VUregsn) { _vuRegsSQD(&VU0, VUregsn); }
3216    static void __vuRegsCall VU0regsMI_SQI(_VURegsNum *VUregsn) { _vuRegsSQI(&VU0, VUregsn); }
3217    static void __vuRegsCall VU0regsMI_ILW(_VURegsNum *VUregsn) { _vuRegsILW(&VU0, VUregsn); }
3218    static void __vuRegsCall VU0regsMI_ISW(_VURegsNum *VUregsn) { _vuRegsISW(&VU0, VUregsn); }
3219    static void __vuRegsCall VU0regsMI_ILWR(_VURegsNum *VUregsn) { _vuRegsILWR(&VU0, VUregsn); }
3220    static void __vuRegsCall VU0regsMI_ISWR(_VURegsNum *VUregsn) { _vuRegsISWR(&VU0, VUregsn); }
3221    static void __vuRegsCall VU0regsMI_RINIT(_VURegsNum *VUregsn) { _vuRegsRINIT(&VU0, VUregsn); }
3222    static void __vuRegsCall VU0regsMI_RGET(_VURegsNum *VUregsn)  { _vuRegsRGET(&VU0, VUregsn); }
3223    static void __vuRegsCall VU0regsMI_RNEXT(_VURegsNum *VUregsn) { _vuRegsRNEXT(&VU0, VUregsn); }
3224    static void __vuRegsCall VU0regsMI_RXOR(_VURegsNum *VUregsn)  { _vuRegsRXOR(&VU0, VUregsn); }
3225    static void __vuRegsCall VU0regsMI_WAITQ(_VURegsNum *VUregsn) { _vuRegsWAITQ(&VU0, VUregsn); }
3226    static void __vuRegsCall VU0regsMI_FSAND(_VURegsNum *VUregsn) { _vuRegsFSAND(&VU0, VUregsn); }
3227    static void __vuRegsCall VU0regsMI_FSEQ(_VURegsNum *VUregsn)  { _vuRegsFSEQ(&VU0, VUregsn); }
3228    static void __vuRegsCall VU0regsMI_FSOR(_VURegsNum *VUregsn)  { _vuRegsFSOR(&VU0, VUregsn); }
3229    static void __vuRegsCall VU0regsMI_FSSET(_VURegsNum *VUregsn) { _vuRegsFSSET(&VU0, VUregsn); }
3230    static void __vuRegsCall VU0regsMI_FMAND(_VURegsNum *VUregsn) { _vuRegsFMAND(&VU0, VUregsn); }
3231    static void __vuRegsCall VU0regsMI_FMEQ(_VURegsNum *VUregsn)  { _vuRegsFMEQ(&VU0, VUregsn); }
3232    static void __vuRegsCall VU0regsMI_FMOR(_VURegsNum *VUregsn)  { _vuRegsFMOR(&VU0, VUregsn); }
3233    static void __vuRegsCall VU0regsMI_FCAND(_VURegsNum *VUregsn) { _vuRegsFCAND(&VU0, VUregsn); }
3234    static void __vuRegsCall VU0regsMI_FCEQ(_VURegsNum *VUregsn)  { _vuRegsFCEQ(&VU0, VUregsn); }
3235    static void __vuRegsCall VU0regsMI_FCOR(_VURegsNum *VUregsn)  { _vuRegsFCOR(&VU0, VUregsn); }
3236    static void __vuRegsCall VU0regsMI_FCSET(_VURegsNum *VUregsn) { _vuRegsFCSET(&VU0, VUregsn); }
3237    static void __vuRegsCall VU0regsMI_FCGET(_VURegsNum *VUregsn) { _vuRegsFCGET(&VU0, VUregsn); }
3238    static void __vuRegsCall VU0regsMI_IBEQ(_VURegsNum *VUregsn) { _vuRegsIBEQ(&VU0, VUregsn); }
3239    static void __vuRegsCall VU0regsMI_IBGEZ(_VURegsNum *VUregsn) { _vuRegsIBGEZ(&VU0, VUregsn); }
3240    static void __vuRegsCall VU0regsMI_IBGTZ(_VURegsNum *VUregsn) { _vuRegsIBGTZ(&VU0, VUregsn); }
3241    static void __vuRegsCall VU0regsMI_IBLTZ(_VURegsNum *VUregsn) { _vuRegsIBLTZ(&VU0, VUregsn); }
3242    static void __vuRegsCall VU0regsMI_IBLEZ(_VURegsNum *VUregsn) { _vuRegsIBLEZ(&VU0, VUregsn); }
3243    static void __vuRegsCall VU0regsMI_IBNE(_VURegsNum *VUregsn) { _vuRegsIBNE(&VU0, VUregsn); }
3244    static void __vuRegsCall VU0regsMI_B(_VURegsNum *VUregsn)   { _vuRegsB(&VU0, VUregsn); }
3245    static void __vuRegsCall VU0regsMI_BAL(_VURegsNum *VUregsn) { _vuRegsBAL(&VU0, VUregsn); }
3246    static void __vuRegsCall VU0regsMI_JR(_VURegsNum *VUregsn)   { _vuRegsJR(&VU0, VUregsn); }
3247    static void __vuRegsCall VU0regsMI_JALR(_VURegsNum *VUregsn) { _vuRegsJALR(&VU0, VUregsn); }
3248    static void __vuRegsCall VU0regsMI_MFP(_VURegsNum *VUregsn) { _vuRegsMFP(&VU0, VUregsn); }
3249    static void __vuRegsCall VU0regsMI_WAITP(_VURegsNum *VUregsn) { _vuRegsWAITP(&VU0, VUregsn); }
3250    static void __vuRegsCall VU0regsMI_ESADD(_VURegsNum *VUregsn)   { _vuRegsESADD(&VU0, VUregsn); }
3251    static void __vuRegsCall VU0regsMI_ERSADD(_VURegsNum *VUregsn)  { _vuRegsERSADD(&VU0, VUregsn); }
3252    static void __vuRegsCall VU0regsMI_ELENG(_VURegsNum *VUregsn)   { _vuRegsELENG(&VU0, VUregsn); }
3253    static void __vuRegsCall VU0regsMI_ERLENG(_VURegsNum *VUregsn)  { _vuRegsERLENG(&VU0, VUregsn); }
3254    static void __vuRegsCall VU0regsMI_EATANxy(_VURegsNum *VUregsn) { _vuRegsEATANxy(&VU0, VUregsn); }
3255    static void __vuRegsCall VU0regsMI_EATANxz(_VURegsNum *VUregsn) { _vuRegsEATANxz(&VU0, VUregsn); }
3256    static void __vuRegsCall VU0regsMI_ESUM(_VURegsNum *VUregsn)    { _vuRegsESUM(&VU0, VUregsn); }
3257    static void __vuRegsCall VU0regsMI_ERCPR(_VURegsNum *VUregsn)   { _vuRegsERCPR(&VU0, VUregsn); }
3258    static void __vuRegsCall VU0regsMI_ESQRT(_VURegsNum *VUregsn)   { _vuRegsESQRT(&VU0, VUregsn); }
3259    static void __vuRegsCall VU0regsMI_ERSQRT(_VURegsNum *VUregsn)  { _vuRegsERSQRT(&VU0, VUregsn); }
3260    static void __vuRegsCall VU0regsMI_ESIN(_VURegsNum *VUregsn)    { _vuRegsESIN(&VU0, VUregsn); }
3261    static void __vuRegsCall VU0regsMI_EATAN(_VURegsNum *VUregsn)   { _vuRegsEATAN(&VU0, VUregsn); }
3262    static void __vuRegsCall VU0regsMI_EEXP(_VURegsNum *VUregsn)    { _vuRegsEEXP(&VU0, VUregsn); }
3263    static void __vuRegsCall VU0regsMI_XITOP(_VURegsNum *VUregsn)   { _vuRegsXITOP(&VU0, VUregsn); }
3264    static void __vuRegsCall VU0regsMI_XGKICK(_VURegsNum *VUregsn)  { _vuRegsXGKICK(&VU0, VUregsn); }
3265    static void __vuRegsCall VU0regsMI_XTOP(_VURegsNum *VUregsn)    { _vuRegsXTOP(&VU0, VUregsn); }
3266    
3267    void VU0unknown() {
3268            pxFailDev("Unknown VU micromode opcode called");
3269            CPU_LOG("Unknown VU micromode opcode called");
3270    }
3271    
3272    static void __vuRegsCall VU0regsunknown(_VURegsNum *VUregsn) {
3273            pxFailDev("Unknown VU micromode opcode called");
3274            CPU_LOG("Unknown VU micromode opcode called");
3275    }
3276    
3277    // --------------------------------------------------------------------------------------
3278    //  VU1
3279    // --------------------------------------------------------------------------------------
3280    
3281    /****************************************/
3282    /*   VU Micromode Upper instructions    */
3283    /****************************************/
3284    
3285    static void VU1MI_ABS()  { _vuABS(&VU1); }
3286    static void VU1MI_ADD()  { _vuADD(&VU1); }
3287    static void VU1MI_ADDi() { _vuADDi(&VU1); }
3288    static void VU1MI_ADDq() { _vuADDq(&VU1); }
3289    static void VU1MI_ADDx() { _vuADDx(&VU1); }
3290    static void VU1MI_ADDy() { _vuADDy(&VU1); }
3291    static void VU1MI_ADDz() { _vuADDz(&VU1); }
3292    static void VU1MI_ADDw() { _vuADDw(&VU1); }
3293    static void VU1MI_ADDA() { _vuADDA(&VU1); }
3294    static void VU1MI_ADDAi() { _vuADDAi(&VU1); }
3295    static void VU1MI_ADDAq() { _vuADDAq(&VU1); }
3296    static void VU1MI_ADDAx() { _vuADDAx(&VU1); }
3297    static void VU1MI_ADDAy() { _vuADDAy(&VU1); }
3298    static void VU1MI_ADDAz() { _vuADDAz(&VU1); }
3299    static void VU1MI_ADDAw() { _vuADDAw(&VU1); }
3300    static void VU1MI_SUB()  { _vuSUB(&VU1); }
3301    static void VU1MI_SUBi() { _vuSUBi(&VU1); }
3302    static void VU1MI_SUBq() { _vuSUBq(&VU1); }
3303    static void VU1MI_SUBx() { _vuSUBx(&VU1); }
3304    static void VU1MI_SUBy() { _vuSUBy(&VU1); }
3305    static void VU1MI_SUBz() { _vuSUBz(&VU1); }
3306    static void VU1MI_SUBw() { _vuSUBw(&VU1); }
3307    static void VU1MI_SUBA()  { _vuSUBA(&VU1); }
3308    static void VU1MI_SUBAi() { _vuSUBAi(&VU1); }
3309    static void VU1MI_SUBAq() { _vuSUBAq(&VU1); }
3310    static void VU1MI_SUBAx() { _vuSUBAx(&VU1); }
3311    static void VU1MI_SUBAy() { _vuSUBAy(&VU1); }
3312    static void VU1MI_SUBAz() { _vuSUBAz(&VU1); }
3313    static void VU1MI_SUBAw() { _vuSUBAw(&VU1); }
3314    static void VU1MI_MUL()  { _vuMUL(&VU1); }
3315    static void VU1MI_MULi() { _vuMULi(&VU1); }
3316    static void VU1MI_MULq() { _vuMULq(&VU1); }
3317    static void VU1MI_MULx() { _vuMULx(&VU1); }
3318    static void VU1MI_MULy() { _vuMULy(&VU1); }
3319    static void VU1MI_MULz() { _vuMULz(&VU1); }
3320    static void VU1MI_MULw() { _vuMULw(&VU1); }
3321    static void VU1MI_MULA()  { _vuMULA(&VU1); }
3322    static void VU1MI_MULAi() { _vuMULAi(&VU1); }
3323    static void VU1MI_MULAq() { _vuMULAq(&VU1); }
3324    static void VU1MI_MULAx() { _vuMULAx(&VU1); }
3325    static void VU1MI_MULAy() { _vuMULAy(&VU1); }
3326    static void VU1MI_MULAz() { _vuMULAz(&VU1); }
3327    static void VU1MI_MULAw() { _vuMULAw(&VU1); }
3328    static void VU1MI_MADD()  { _vuMADD(&VU1); }
3329    static void VU1MI_MADDi() { _vuMADDi(&VU1); }
3330    static void VU1MI_MADDq() { _vuMADDq(&VU1); }
3331    static void VU1MI_MADDx() { _vuMADDx(&VU1); }
3332    static void VU1MI_MADDy() { _vuMADDy(&VU1); }
3333    static void VU1MI_MADDz() { _vuMADDz(&VU1); }
3334    static void VU1MI_MADDw() { _vuMADDw(&VU1); }
3335    static void VU1MI_MADDA()  { _vuMADDA(&VU1); }
3336    static void VU1MI_MADDAi() { _vuMADDAi(&VU1); }
3337    static void VU1MI_MADDAq() { _vuMADDAq(&VU1); }
3338    static void VU1MI_MADDAx() { _vuMADDAx(&VU1); }
3339    static void VU1MI_MADDAy() { _vuMADDAy(&VU1); }
3340    static void VU1MI_MADDAz() { _vuMADDAz(&VU1); }
3341    static void VU1MI_MADDAw() { _vuMADDAw(&VU1); }
3342    static void VU1MI_MSUB()  { _vuMSUB(&VU1); }
3343    static void VU1MI_MSUBi() { _vuMSUBi(&VU1); }
3344    static void VU1MI_MSUBq() { _vuMSUBq(&VU1); }
3345    static void VU1MI_MSUBx() { _vuMSUBx(&VU1); }
3346    static void VU1MI_MSUBy() { _vuMSUBy(&VU1); }
3347    static void VU1MI_MSUBz() { _vuMSUBz(&VU1); }
3348    static void VU1MI_MSUBw() { _vuMSUBw(&VU1); }
3349    static void VU1MI_MSUBA()  { _vuMSUBA(&VU1); }
3350    static void VU1MI_MSUBAi() { _vuMSUBAi(&VU1); }
3351    static void VU1MI_MSUBAq() { _vuMSUBAq(&VU1); }
3352    static void VU1MI_MSUBAx() { _vuMSUBAx(&VU1); }
3353    static void VU1MI_MSUBAy() { _vuMSUBAy(&VU1); }
3354    static void VU1MI_MSUBAz() { _vuMSUBAz(&VU1); }
3355    static void VU1MI_MSUBAw() { _vuMSUBAw(&VU1); }
3356    static void VU1MI_MAX()  { _vuMAX(&VU1); }
3357    static void VU1MI_MAXi() { _vuMAXi(&VU1); }
3358    static void VU1MI_MAXx() { _vuMAXx(&VU1); }
3359    static void VU1MI_MAXy() { _vuMAXy(&VU1); }
3360    static void VU1MI_MAXz() { _vuMAXz(&VU1); }
3361    static void VU1MI_MAXw() { _vuMAXw(&VU1); }
3362    static void VU1MI_MINI()  { _vuMINI(&VU1); }
3363    static void VU1MI_MINIi() { _vuMINIi(&VU1); }
3364    static void VU1MI_MINIx() { _vuMINIx(&VU1); }
3365    static void VU1MI_MINIy() { _vuMINIy(&VU1); }
3366    static void VU1MI_MINIz() { _vuMINIz(&VU1); }
3367    static void VU1MI_MINIw() { _vuMINIw(&VU1); }
3368    static void VU1MI_OPMULA() { _vuOPMULA(&VU1); }
3369    static void VU1MI_OPMSUB() { _vuOPMSUB(&VU1); }
3370    static void VU1MI_NOP() { _vuNOP(&VU1); }
3371    static void VU1MI_FTOI0()  { _vuFTOI0(&VU1); }
3372    static void VU1MI_FTOI4()  { _vuFTOI4(&VU1); }
3373    static void VU1MI_FTOI12() { _vuFTOI12(&VU1); }
3374    static void VU1MI_FTOI15() { _vuFTOI15(&VU1); }
3375    static void VU1MI_ITOF0()  { _vuITOF0(&VU1); }
3376    static void VU1MI_ITOF4()  { _vuITOF4(&VU1); }
3377    static void VU1MI_ITOF12() { _vuITOF12(&VU1); }
3378    static void VU1MI_ITOF15() { _vuITOF15(&VU1); }
3379    static void VU1MI_CLIP() { _vuCLIP(&VU1); }
3380    
3381    /*****************************************/
3382    /*   VU Micromode Lower instructions    */
3383    /*****************************************/
3384    
3385    static void VU1MI_DIV() { _vuDIV(&VU1); }
3386    static void VU1MI_SQRT() { _vuSQRT(&VU1); }
3387    static void VU1MI_RSQRT() { _vuRSQRT(&VU1); }
3388    static void VU1MI_IADD() { _vuIADD(&VU1); }
3389    static void VU1MI_IADDI() { _vuIADDI(&VU1); }
3390    static void VU1MI_IADDIU() { _vuIADDIU(&VU1); }
3391    static void VU1MI_IAND() { _vuIAND(&VU1); }
3392    static void VU1MI_IOR() { _vuIOR(&VU1); }
3393    static void VU1MI_ISUB() { _vuISUB(&VU1); }
3394    static void VU1MI_ISUBIU() { _vuISUBIU(&VU1); }
3395    static void VU1MI_MOVE() { _vuMOVE(&VU1); }
3396    static void VU1MI_MFIR() { _vuMFIR(&VU1); }
3397    static void VU1MI_MTIR() { _vuMTIR(&VU1); }
3398    static void VU1MI_MR32() { _vuMR32(&VU1); }
3399    static void VU1MI_LQ() { _vuLQ(&VU1); }
3400    static void VU1MI_LQD() { _vuLQD(&VU1); }
3401    static void VU1MI_LQI() { _vuLQI(&VU1); }
3402    static void VU1MI_SQ() { _vuSQ(&VU1); }
3403    static void VU1MI_SQD() { _vuSQD(&VU1); }
3404    static void VU1MI_SQI() { _vuSQI(&VU1); }
3405    static void VU1MI_ILW() { _vuILW(&VU1); }
3406    static void VU1MI_ISW() { _vuISW(&VU1); }
3407    static void VU1MI_ILWR() { _vuILWR(&VU1); }
3408    static void VU1MI_ISWR() { _vuISWR(&VU1); }
3409    static void VU1MI_RINIT() { _vuRINIT(&VU1); }
3410    static void VU1MI_RGET()  { _vuRGET(&VU1); }
3411    static void VU1MI_RNEXT() { _vuRNEXT(&VU1); }
3412    static void VU1MI_RXOR()  { _vuRXOR(&VU1); }
3413    static void VU1MI_WAITQ() { _vuWAITQ(&VU1); }
3414    static void VU1MI_FSAND() { _vuFSAND(&VU1); }
3415    static void VU1MI_FSEQ()  { _vuFSEQ(&VU1); }
3416    static void VU1MI_FSOR()  { _vuFSOR(&VU1); }
3417    static void VU1MI_FSSET() { _vuFSSET(&VU1); }
3418    static void VU1MI_FMAND() { _vuFMAND(&VU1); }
3419    static void VU1MI_FMEQ()  { _vuFMEQ(&VU1); }
3420    static void VU1MI_FMOR()  { _vuFMOR(&VU1); }
3421    static void VU1MI_FCAND() { _vuFCAND(&VU1); }
3422    static void VU1MI_FCEQ()  { _vuFCEQ(&VU1); }
3423    static void VU1MI_FCOR()  { _vuFCOR(&VU1); }
3424    static void VU1MI_FCSET() { _vuFCSET(&VU1); }
3425    static void VU1MI_FCGET() { _vuFCGET(&VU1); }
3426    static void VU1MI_IBEQ() { _vuIBEQ(&VU1); }
3427    static void VU1MI_IBGEZ() { _vuIBGEZ(&VU1); }
3428    static void VU1MI_IBGTZ() { _vuIBGTZ(&VU1); }
3429    static void VU1MI_IBLTZ() { _vuIBLTZ(&VU1); }
3430    static void VU1MI_IBLEZ() { _vuIBLEZ(&VU1); }
3431    static void VU1MI_IBNE() { _vuIBNE(&VU1); }
3432    static void VU1MI_B()   { _vuB(&VU1); }
3433    static void VU1MI_BAL() { _vuBAL(&VU1); }
3434    static void VU1MI_JR()   { _vuJR(&VU1); }
3435    static void VU1MI_JALR() { _vuJALR(&VU1); }
3436    static void VU1MI_MFP() { _vuMFP(&VU1); }
3437    static void VU1MI_WAITP() { _vuWAITP(&VU1); }
3438    static void VU1MI_ESADD()   { _vuESADD(&VU1); }
3439    static void VU1MI_ERSADD()  { _vuERSADD(&VU1); }
3440    static void VU1MI_ELENG()   { _vuELENG(&VU1); }
3441    static void VU1MI_ERLENG()  { _vuERLENG(&VU1); }
3442    static void VU1MI_EATANxy() { _vuEATANxy(&VU1); }
3443    static void VU1MI_EATANxz() { _vuEATANxz(&VU1); }
3444    static void VU1MI_ESUM()    { _vuESUM(&VU1); }
3445    static void VU1MI_ERCPR()   { _vuERCPR(&VU1); }
3446    static void VU1MI_ESQRT()   { _vuESQRT(&VU1); }
3447    static void VU1MI_ERSQRT()  { _vuERSQRT(&VU1); }
3448    static void VU1MI_ESIN()    { _vuESIN(&VU1); }
3449    static void VU1MI_EATAN()   { _vuEATAN(&VU1); }
3450    static void VU1MI_EEXP()    { _vuEEXP(&VU1); }
3451    static void VU1MI_XITOP()   { _vuXITOP(&VU1); }
3452    static void VU1MI_XGKICK()  { _vuXGKICK(&VU1); }
3453    static void VU1MI_XTOP()    { _vuXTOP(&VU1); }
3454    
3455    
3456    
3457    /****************************************/
3458    /*   VU Micromode Upper instructions    */
3459    /****************************************/
3460    
3461    static void __vuRegsCall VU1regsMI_ABS(_VURegsNum *VUregsn)  { _vuRegsABS(&VU1, VUregsn); }
3462    static void __vuRegsCall VU1regsMI_ADD(_VURegsNum *VUregsn)  { _vuRegsADD(&VU1, VUregsn); }
3463    static void __vuRegsCall VU1regsMI_ADDi(_VURegsNum *VUregsn) { _vuRegsADDi(&VU1, VUregsn); }
3464    static void __vuRegsCall VU1regsMI_ADDq(_VURegsNum *VUregsn) { _vuRegsADDq(&VU1, VUregsn); }
3465    static void __vuRegsCall VU1regsMI_ADDx(_VURegsNum *VUregsn) { _vuRegsADDx(&VU1, VUregsn); }
3466    static void __vuRegsCall VU1regsMI_ADDy(_VURegsNum *VUregsn) { _vuRegsADDy(&VU1, VUregsn); }
3467    static void __vuRegsCall VU1regsMI_ADDz(_VURegsNum *VUregsn) { _vuRegsADDz(&VU1, VUregsn); }
3468    static void __vuRegsCall VU1regsMI_ADDw(_VURegsNum *VUregsn) { _vuRegsADDw(&VU1, VUregsn); }
3469    static void __vuRegsCall VU1regsMI_ADDA(_VURegsNum *VUregsn) { _vuRegsADDA(&VU1, VUregsn); }
3470    static void __vuRegsCall VU1regsMI_ADDAi(_VURegsNum *VUregsn) { _vuRegsADDAi(&VU1, VUregsn); }
3471    static void __vuRegsCall VU1regsMI_ADDAq(_VURegsNum *VUregsn) { _vuRegsADDAq(&VU1, VUregsn); }
3472    static void __vuRegsCall VU1regsMI_ADDAx(_VURegsNum *VUregsn) { _vuRegsADDAx(&VU1, VUregsn); }
3473    static void __vuRegsCall VU1regsMI_ADDAy(_VURegsNum *VUregsn) { _vuRegsADDAy(&VU1, VUregsn); }
3474    static void __vuRegsCall VU1regsMI_ADDAz(_VURegsNum *VUregsn) { _vuRegsADDAz(&VU1, VUregsn); }
3475    static void __vuRegsCall VU1regsMI_ADDAw(_VURegsNum *VUregsn) { _vuRegsADDAw(&VU1, VUregsn); }
3476    static void __vuRegsCall VU1regsMI_SUB(_VURegsNum *VUregsn)  { _vuRegsSUB(&VU1, VUregsn); }
3477    static void __vuRegsCall VU1regsMI_SUBi(_VURegsNum *VUregsn) { _vuRegsSUBi(&VU1, VUregsn); }
3478    static void __vuRegsCall VU1regsMI_SUBq(_VURegsNum *VUregsn) { _vuRegsSUBq(&VU1, VUregsn); }
3479    static void __vuRegsCall VU1regsMI_SUBx(_VURegsNum *VUregsn) { _vuRegsSUBx(&VU1, VUregsn); }
3480    static void __vuRegsCall VU1regsMI_SUBy(_VURegsNum *VUregsn) { _vuRegsSUBy(&VU1, VUregsn); }
3481    static void __vuRegsCall VU1regsMI_SUBz(_VURegsNum *VUregsn) { _vuRegsSUBz(&VU1, VUregsn); }
3482    static void __vuRegsCall VU1regsMI_SUBw(_VURegsNum *VUregsn) { _vuRegsSUBw(&VU1, VUregsn); }
3483    static void __vuRegsCall VU1regsMI_SUBA(_VURegsNum *VUregsn)  { _vuRegsSUBA(&VU1, VUregsn); }
3484    static void __vuRegsCall VU1regsMI_SUBAi(_VURegsNum *VUregsn) { _vuRegsSUBAi(&VU1, VUregsn); }
3485    static void __vuRegsCall VU1regsMI_SUBAq(_VURegsNum *VUregsn) { _vuRegsSUBAq(&VU1, VUregsn); }
3486    static void __vuRegsCall VU1regsMI_SUBAx(_VURegsNum *VUregsn) { _vuRegsSUBAx(&VU1, VUregsn); }
3487    static void __vuRegsCall VU1regsMI_SUBAy(_VURegsNum *VUregsn) { _vuRegsSUBAy(&VU1, VUregsn); }
3488    static void __vuRegsCall VU1regsMI_SUBAz(_VURegsNum *VUregsn) { _vuRegsSUBAz(&VU1, VUregsn); }
3489    static void __vuRegsCall VU1regsMI_SUBAw(_VURegsNum *VUregsn) { _vuRegsSUBAw(&VU1, VUregsn); }
3490    static void __vuRegsCall VU1regsMI_MUL(_VURegsNum *VUregsn)  { _vuRegsMUL(&VU1, VUregsn); }
3491    static void __vuRegsCall VU1regsMI_MULi(_VURegsNum *VUregsn) { _vuRegsMULi(&VU1, VUregsn); }
3492    static void __vuRegsCall VU1regsMI_MULq(_VURegsNum *VUregsn) { _vuRegsMULq(&VU1, VUregsn); }
3493    static void __vuRegsCall VU1regsMI_MULx(_VURegsNum *VUregsn) { _vuRegsMULx(&VU1, VUregsn); }
3494    static void __vuRegsCall VU1regsMI_MULy(_VURegsNum *VUregsn) { _vuRegsMULy(&VU1, VUregsn); }
3495    static void __vuRegsCall VU1regsMI_MULz(_VURegsNum *VUregsn) { _vuRegsMULz(&VU1, VUregsn); }
3496    static void __vuRegsCall VU1regsMI_MULw(_VURegsNum *VUregsn) { _vuRegsMULw(&VU1, VUregsn); }
3497    static void __vuRegsCall VU1regsMI_MULA(_VURegsNum *VUregsn)  { _vuRegsMULA(&VU1, VUregsn); }
3498    static void __vuRegsCall VU1regsMI_MULAi(_VURegsNum *VUregsn) { _vuRegsMULAi(&VU1, VUregsn); }
3499    static void __vuRegsCall VU1regsMI_MULAq(_VURegsNum *VUregsn) { _vuRegsMULAq(&VU1, VUregsn); }
3500    static void __vuRegsCall VU1regsMI_MULAx(_VURegsNum *VUregsn) { _vuRegsMULAx(&VU1, VUregsn); }
3501    static void __vuRegsCall VU1regsMI_MULAy(_VURegsNum *VUregsn) { _vuRegsMULAy(&VU1, VUregsn); }
3502    static void __vuRegsCall VU1regsMI_MULAz(_VURegsNum *VUregsn) { _vuRegsMULAz(&VU1, VUregsn); }
3503    static void __vuRegsCall VU1regsMI_MULAw(_VURegsNum *VUregsn) { _vuRegsMULAw(&VU1, VUregsn); }
3504    static void __vuRegsCall VU1regsMI_MADD(_VURegsNum *VUregsn)  { _vuRegsMADD(&VU1, VUregsn); }
3505    static void __vuRegsCall VU1regsMI_MADDi(_VURegsNum *VUregsn) { _vuRegsMADDi(&VU1, VUregsn); }
3506    static void __vuRegsCall VU1regsMI_MADDq(_VURegsNum *VUregsn) { _vuRegsMADDq(&VU1, VUregsn); }
3507    static void __vuRegsCall VU1regsMI_MADDx(_VURegsNum *VUregsn) { _vuRegsMADDx(&VU1, VUregsn); }
3508    static void __vuRegsCall VU1regsMI_MADDy(_VURegsNum *VUregsn) { _vuRegsMADDy(&VU1, VUregsn); }
3509    static void __vuRegsCall VU1regsMI_MADDz(_VURegsNum *VUregsn) { _vuRegsMADDz(&VU1, VUregsn); }
3510    static void __vuRegsCall VU1regsMI_MADDw(_VURegsNum *VUregsn) { _vuRegsMADDw(&VU1, VUregsn); }
3511    static void __vuRegsCall VU1regsMI_MADDA(_VURegsNum *VUregsn)  { _vuRegsMADDA(&VU1, VUregsn); }
3512    static void __vuRegsCall VU1regsMI_MADDAi(_VURegsNum *VUregsn) { _vuRegsMADDAi(&VU1, VUregsn); }
3513    static void __vuRegsCall VU1regsMI_MADDAq(_VURegsNum *VUregsn) { _vuRegsMADDAq(&VU1, VUregsn); }
3514    static void __vuRegsCall VU1regsMI_MADDAx(_VURegsNum *VUregsn) { _vuRegsMADDAx(&VU1, VUregsn); }
3515    static void __vuRegsCall VU1regsMI_MADDAy(_VURegsNum *VUregsn) { _vuRegsMADDAy(&VU1, VUregsn); }
3516    static void __vuRegsCall VU1regsMI_MADDAz(_VURegsNum *VUregsn) { _vuRegsMADDAz(&VU1, VUregsn); }
3517    static void __vuRegsCall VU1regsMI_MADDAw(_VURegsNum *VUregsn) { _vuRegsMADDAw(&VU1, VUregsn); }
3518    static void __vuRegsCall VU1regsMI_MSUB(_VURegsNum *VUregsn)  { _vuRegsMSUB(&VU1, VUregsn); }
3519    static void __vuRegsCall VU1regsMI_MSUBi(_VURegsNum *VUregsn) { _vuRegsMSUBi(&VU1, VUregsn); }
3520    static void __vuRegsCall VU1regsMI_MSUBq(_VURegsNum *VUregsn) { _vuRegsMSUBq(&VU1, VUregsn); }
3521    static void __vuRegsCall VU1regsMI_MSUBx(_VURegsNum *VUregsn) { _vuRegsMSUBx(&VU1, VUregsn); }
3522    static void __vuRegsCall VU1regsMI_MSUBy(_VURegsNum *VUregsn) { _vuRegsMSUBy(&VU1, VUregsn); }
3523    static void __vuRegsCall VU1regsMI_MSUBz(_VURegsNum *VUregsn) { _vuRegsMSUBz(&VU1, VUregsn); }
3524    static void __vuRegsCall VU1regsMI_MSUBw(_VURegsNum *VUregsn) { _vuRegsMSUBw(&VU1, VUregsn); }
3525    static void __vuRegsCall VU1regsMI_MSUBA(_VURegsNum *VUregsn)  { _vuRegsMSUBA(&VU1, VUregsn); }
3526    static void __vuRegsCall VU1regsMI_MSUBAi(_VURegsNum *VUregsn) { _vuRegsMSUBAi(&VU1, VUregsn); }
3527    static void __vuRegsCall VU1regsMI_MSUBAq(_VURegsNum *VUregsn) { _vuRegsMSUBAq(&VU1, VUregsn); }
3528    static void __vuRegsCall VU1regsMI_MSUBAx(_VURegsNum *VUregsn) { _vuRegsMSUBAx(&VU1, VUregsn); }
3529    static void __vuRegsCall VU1regsMI_MSUBAy(_VURegsNum *VUregsn) { _vuRegsMSUBAy(&VU1, VUregsn); }
3530    static void __vuRegsCall VU1regsMI_MSUBAz(_VURegsNum *VUregsn) { _vuRegsMSUBAz(&VU1, VUregsn); }
3531    static void __vuRegsCall VU1regsMI_MSUBAw(_VURegsNum *VUregsn) { _vuRegsMSUBAw(&VU1, VUregsn); }
3532    static void __vuRegsCall VU1regsMI_MAX(_VURegsNum *VUregsn)  { _vuRegsMAX(&VU1, VUregsn); }
3533    static void __vuRegsCall VU1regsMI_MAXi(_VURegsNum *VUregsn) { _vuRegsMAXi(&VU1, VUregsn); }
3534    static void __vuRegsCall VU1regsMI_MAXx(_VURegsNum *VUregsn) { _vuRegsMAXx(&VU1, VUregsn); }
3535    static void __vuRegsCall VU1regsMI_MAXy(_VURegsNum *VUregsn) { _vuRegsMAXy(&VU1, VUregsn); }
3536    static void __vuRegsCall VU1regsMI_MAXz(_VURegsNum *VUregsn) { _vuRegsMAXz(&VU1, VUregsn); }
3537    static void __vuRegsCall VU1regsMI_MAXw(_VURegsNum *VUregsn) { _vuRegsMAXw(&VU1, VUregsn); }
3538    static void __vuRegsCall VU1regsMI_MINI(_VURegsNum *VUregsn)  { _vuRegsMINI(&VU1, VUregsn); }
3539    static void __vuRegsCall VU1regsMI_MINIi(_VURegsNum *VUregsn) { _vuRegsMINIi(&VU1, VUregsn); }
3540    static void __vuRegsCall VU1regsMI_MINIx(_VURegsNum *VUregsn) { _vuRegsMINIx(&VU1, VUregsn); }
3541    static void __vuRegsCall VU1regsMI_MINIy(_VURegsNum *VUregsn) { _vuRegsMINIy(&VU1, VUregsn); }
3542    static void __vuRegsCall VU1regsMI_MINIz(_VURegsNum *VUregsn) { _vuRegsMINIz(&VU1, VUregsn); }
3543    static void __vuRegsCall VU1regsMI_MINIw(_VURegsNum *VUregsn) { _vuRegsMINIw(&VU1, VUregsn); }
3544    static void __vuRegsCall VU1regsMI_OPMULA(_VURegsNum *VUregsn) { _vuRegsOPMULA(&VU1, VUregsn); }
3545    static void __vuRegsCall VU1regsMI_OPMSUB(_VURegsNum *VUregsn) { _vuRegsOPMSUB(&VU1, VUregsn); }
3546    static void __vuRegsCall VU1regsMI_NOP(_VURegsNum *VUregsn) { _vuRegsNOP(&VU1, VUregsn); }
3547    static void __vuRegsCall VU1regsMI_FTOI0(_VURegsNum *VUregsn)  { _vuRegsFTOI0(&VU1, VUregsn); }
3548    static void __vuRegsCall VU1regsMI_FTOI4(_VURegsNum *VUregsn)  { _vuRegsFTOI4(&VU1, VUregsn); }
3549    static void __vuRegsCall VU1regsMI_FTOI12(_VURegsNum *VUregsn) { _vuRegsFTOI12(&VU1, VUregsn); }
3550    static void __vuRegsCall VU1regsMI_FTOI15(_VURegsNum *VUregsn) { _vuRegsFTOI15(&VU1, VUregsn); }
3551    static void __vuRegsCall VU1regsMI_ITOF0(_VURegsNum *VUregsn)  { _vuRegsITOF0(&VU1, VUregsn); }
3552    static void __vuRegsCall VU1regsMI_ITOF4(_VURegsNum *VUregsn)  { _vuRegsITOF4(&VU1, VUregsn); }
3553    static void __vuRegsCall VU1regsMI_ITOF12(_VURegsNum *VUregsn) { _vuRegsITOF12(&VU1, VUregsn); }
3554    static void __vuRegsCall VU1regsMI_ITOF15(_VURegsNum *VUregsn) { _vuRegsITOF15(&VU1, VUregsn); }
3555    static void __vuRegsCall VU1regsMI_CLIP(_VURegsNum *VUregsn) { _vuRegsCLIP(&VU1, VUregsn); }
3556    
3557    /*****************************************/
3558    /*   VU Micromode Lower instructions    */
3559    /*****************************************/
3560    
3561    static void __vuRegsCall VU1regsMI_DIV(_VURegsNum *VUregsn) { _vuRegsDIV(&VU1, VUregsn); }
3562    static void __vuRegsCall VU1regsMI_SQRT(_VURegsNum *VUregsn) { _vuRegsSQRT(&VU1, VUregsn); }
3563    static void __vuRegsCall VU1regsMI_RSQRT(_VURegsNum *VUregsn) { _vuRegsRSQRT(&VU1, VUregsn); }
3564    static void __vuRegsCall VU1regsMI_IADD(_VURegsNum *VUregsn) { _vuRegsIADD(&VU1, VUregsn); }
3565    static void __vuRegsCall VU1regsMI_IADDI(_VURegsNum *VUregsn) { _vuRegsIADDI(&VU1, VUregsn); }
3566    static void __vuRegsCall VU1regsMI_IADDIU(_VURegsNum *VUregsn) { _vuRegsIADDIU(&VU1, VUregsn); }
3567    static void __vuRegsCall VU1regsMI_IAND(_VURegsNum *VUregsn) { _vuRegsIAND(&VU1, VUregsn); }
3568    static void __vuRegsCall VU1regsMI_IOR(_VURegsNum *VUregsn) { _vuRegsIOR(&VU1, VUregsn); }
3569    static void __vuRegsCall VU1regsMI_ISUB(_VURegsNum *VUregsn) { _vuRegsISUB(&VU1, VUregsn); }
3570    static void __vuRegsCall VU1regsMI_ISUBIU(_VURegsNum *VUregsn) { _vuRegsISUBIU(&VU1, VUregsn); }
3571    static void __vuRegsCall VU1regsMI_MOVE(_VURegsNum *VUregsn) { _vuRegsMOVE(&VU1, VUregsn); }
3572    static void __vuRegsCall VU1regsMI_MFIR(_VURegsNum *VUregsn) { _vuRegsMFIR(&VU1, VUregsn); }
3573    static void __vuRegsCall VU1regsMI_MTIR(_VURegsNum *VUregsn) { _vuRegsMTIR(&VU1, VUregsn); }
3574    static void __vuRegsCall VU1regsMI_MR32(_VURegsNum *VUregsn) { _vuRegsMR32(&VU1, VUregsn); }
3575    static void __vuRegsCall VU1regsMI_LQ(_VURegsNum *VUregsn) { _vuRegsLQ(&VU1, VUregsn); }
3576    static void __vuRegsCall VU1regsMI_LQD(_VURegsNum *VUregsn) { _vuRegsLQD(&VU1, VUregsn); }
3577    static void __vuRegsCall VU1regsMI_LQI(_VURegsNum *VUregsn) { _vuRegsLQI(&VU1, VUregsn); }
3578    static void __vuRegsCall VU1regsMI_SQ(_VURegsNum *VUregsn) { _vuRegsSQ(&VU1, VUregsn); }
3579    static void __vuRegsCall VU1regsMI_SQD(_VURegsNum *VUregsn) { _vuRegsSQD(&VU1, VUregsn); }
3580    static void __vuRegsCall VU1regsMI_SQI(_VURegsNum *VUregsn) { _vuRegsSQI(&VU1, VUregsn); }
3581    static void __vuRegsCall VU1regsMI_ILW(_VURegsNum *VUregsn) { _vuRegsILW(&VU1, VUregsn); }
3582    static void __vuRegsCall VU1regsMI_ISW(_VURegsNum *VUregsn) { _vuRegsISW(&VU1, VUregsn); }
3583    static void __vuRegsCall VU1regsMI_ILWR(_VURegsNum *VUregsn) { _vuRegsILWR(&VU1, VUregsn); }
3584    static void __vuRegsCall VU1regsMI_ISWR(_VURegsNum *VUregsn) { _vuRegsISWR(&VU1, VUregsn); }
3585    static void __vuRegsCall VU1regsMI_RINIT(_VURegsNum *VUregsn) { _vuRegsRINIT(&VU1, VUregsn); }
3586    static void __vuRegsCall VU1regsMI_RGET(_VURegsNum *VUregsn)  { _vuRegsRGET(&VU1, VUregsn); }
3587    static void __vuRegsCall VU1regsMI_RNEXT(_VURegsNum *VUregsn) { _vuRegsRNEXT(&VU1, VUregsn); }
3588    static void __vuRegsCall VU1regsMI_RXOR(_VURegsNum *VUregsn)  { _vuRegsRXOR(&VU1, VUregsn); }
3589    static void __vuRegsCall VU1regsMI_WAITQ(_VURegsNum *VUregsn) { _vuRegsWAITQ(&VU1, VUregsn); }
3590    static void __vuRegsCall VU1regsMI_FSAND(_VURegsNum *VUregsn) { _vuRegsFSAND(&VU1, VUregsn); }
3591    static void __vuRegsCall VU1regsMI_FSEQ(_VURegsNum *VUregsn)  { _vuRegsFSEQ(&VU1, VUregsn); }
3592    static void __vuRegsCall VU1regsMI_FSOR(_VURegsNum *VUregsn)  { _vuRegsFSOR(&VU1, VUregsn); }
3593    static void __vuRegsCall VU1regsMI_FSSET(_VURegsNum *VUregsn) { _vuRegsFSSET(&VU1, VUregsn); }
3594    static void __vuRegsCall VU1regsMI_FMAND(_VURegsNum *VUregsn) { _vuRegsFMAND(&VU1, VUregsn); }
3595    static void __vuRegsCall VU1regsMI_FMEQ(_VURegsNum *VUregsn)  { _vuRegsFMEQ(&VU1, VUregsn); }
3596    static void __vuRegsCall VU1regsMI_FMOR(_VURegsNum *VUregsn)  { _vuRegsFMOR(&VU1, VUregsn); }
3597    static void __vuRegsCall VU1regsMI_FCAND(_VURegsNum *VUregsn) { _vuRegsFCAND(&VU1, VUregsn); }
3598    static void __vuRegsCall VU1regsMI_FCEQ(_VURegsNum *VUregsn)  { _vuRegsFCEQ(&VU1, VUregsn); }
3599    static void __vuRegsCall VU1regsMI_FCOR(_VURegsNum *VUregsn)  { _vuRegsFCOR(&VU1, VUregsn); }
3600    static void __vuRegsCall VU1regsMI_FCSET(_VURegsNum *VUregsn) { _vuRegsFCSET(&VU1, VUregsn); }
3601    static void __vuRegsCall VU1regsMI_FCGET(_VURegsNum *VUregsn) { _vuRegsFCGET(&VU1, VUregsn); }
3602    static void __vuRegsCall VU1regsMI_IBEQ(_VURegsNum *VUregsn) { _vuRegsIBEQ(&VU1, VUregsn); }
3603    static void __vuRegsCall VU1regsMI_IBGEZ(_VURegsNum *VUregsn) { _vuRegsIBGEZ(&VU1, VUregsn); }
3604    static void __vuRegsCall VU1regsMI_IBGTZ(_VURegsNum *VUregsn) { _vuRegsIBGTZ(&VU1, VUregsn); }
3605    static void __vuRegsCall VU1regsMI_IBLTZ(_VURegsNum *VUregsn) { _vuRegsIBLTZ(&VU1, VUregsn); }
3606    static void __vuRegsCall VU1regsMI_IBLEZ(_VURegsNum *VUregsn) { _vuRegsIBLEZ(&VU1, VUregsn); }
3607    static void __vuRegsCall VU1regsMI_IBNE(_VURegsNum *VUregsn) { _vuRegsIBNE(&VU1, VUregsn); }
3608    static void __vuRegsCall VU1regsMI_B(_VURegsNum *VUregsn)   { _vuRegsB(&VU1, VUregsn); }
3609    static void __vuRegsCall VU1regsMI_BAL(_VURegsNum *VUregsn) { _vuRegsBAL(&VU1, VUregsn); }
3610    static void __vuRegsCall VU1regsMI_JR(_VURegsNum *VUregsn)   { _vuRegsJR(&VU1, VUregsn); }
3611    static void __vuRegsCall VU1regsMI_JALR(_VURegsNum *VUregsn) { _vuRegsJALR(&VU1, VUregsn); }
3612    static void __vuRegsCall VU1regsMI_MFP(_VURegsNum *VUregsn) { _vuRegsMFP(&VU1, VUregsn); }
3613    static void __vuRegsCall VU1regsMI_WAITP(_VURegsNum *VUregsn) { _vuRegsWAITP(&VU1, VUregsn); }
3614    static void __vuRegsCall VU1regsMI_ESADD(_VURegsNum *VUregsn)   { _vuRegsESADD(&VU1, VUregsn); }
3615    static void __vuRegsCall VU1regsMI_ERSADD(_VURegsNum *VUregsn)  { _vuRegsERSADD(&VU1, VUregsn); }
3616    static void __vuRegsCall VU1regsMI_ELENG(_VURegsNum *VUregsn)   { _vuRegsELENG(&VU1, VUregsn); }
3617    static void __vuRegsCall VU1regsMI_ERLENG(_VURegsNum *VUregsn)  { _vuRegsERLENG(&VU1, VUregsn); }
3618    static void __vuRegsCall VU1regsMI_EATANxy(_VURegsNum *VUregsn) { _vuRegsEATANxy(&VU1, VUregsn); }
3619    static void __vuRegsCall VU1regsMI_EATANxz(_VURegsNum *VUregsn) { _vuRegsEATANxz(&VU1, VUregsn); }
3620    static void __vuRegsCall VU1regsMI_ESUM(_VURegsNum *VUregsn)    { _vuRegsESUM(&VU1, VUregsn); }
3621    static void __vuRegsCall VU1regsMI_ERCPR(_VURegsNum *VUregsn)   { _vuRegsERCPR(&VU1, VUregsn); }
3622    static void __vuRegsCall VU1regsMI_ESQRT(_VURegsNum *VUregsn)   { _vuRegsESQRT(&VU1, VUregsn); }
3623    static void __vuRegsCall VU1regsMI_ERSQRT(_VURegsNum *VUregsn)  { _vuRegsERSQRT(&VU1, VUregsn); }
3624    static void __vuRegsCall VU1regsMI_ESIN(_VURegsNum *VUregsn)    { _vuRegsESIN(&VU1, VUregsn); }
3625    static void __vuRegsCall VU1regsMI_EATAN(_VURegsNum *VUregsn)   { _vuRegsEATAN(&VU1, VUregsn); }
3626    static void __vuRegsCall VU1regsMI_EEXP(_VURegsNum *VUregsn)    { _vuRegsEEXP(&VU1, VUregsn); }
3627    static void __vuRegsCall VU1regsMI_XITOP(_VURegsNum *VUregsn)   { _vuRegsXITOP(&VU1, VUregsn); }
3628    static void __vuRegsCall VU1regsMI_XGKICK(_VURegsNum *VUregsn)  { _vuRegsXGKICK(&VU1, VUregsn); }
3629    static void __vuRegsCall VU1regsMI_XTOP(_VURegsNum *VUregsn)    { _vuRegsXTOP(&VU1, VUregsn); }
3630    
3631    static void VU1unknown() {
3632            pxFailDev("Unknown VU micromode opcode called");
3633            CPU_LOG("Unknown VU micromode opcode called");
3634    }
3635    
3636    static void __vuRegsCall VU1regsunknown(_VURegsNum *VUregsn) {
3637            pxFailDev("Unknown VU micromode opcode called");
3638            CPU_LOG("Unknown VU micromode opcode called");
3639    }
3640    
3641    
3642    
3643    // --------------------------------------------------------------------------------------
3644    //  VU Micromode Tables/Opcodes defs macros
3645    // --------------------------------------------------------------------------------------
3646    
3647    #define _vuTablesMess(PREFIX, FNTYPE) \
3648     static __aligned16 const FNTYPE PREFIX##LowerOP_T3_00_OPCODE[32] = { \
3649            PREFIX##unknown  , PREFIX##unknown  , PREFIX##unknown , PREFIX##unknown, \
3650            PREFIX##unknown  , PREFIX##unknown  , PREFIX##unknown , PREFIX##unknown,  \
3651            PREFIX##unknown  , PREFIX##unknown  , PREFIX##unknown , PREFIX##unknown,  \
3652            PREFIX##MI_MOVE  , PREFIX##MI_LQI   , PREFIX##MI_DIV  , PREFIX##MI_MTIR,  \
3653            PREFIX##MI_RNEXT , PREFIX##unknown  , PREFIX##unknown , PREFIX##unknown, /* 0x10 */ \
3654            PREFIX##unknown  , PREFIX##unknown  , PREFIX##unknown , PREFIX##unknown,  \
3655            PREFIX##unknown  , PREFIX##MI_MFP   , PREFIX##MI_XTOP , PREFIX##MI_XGKICK,  \
3656            PREFIX##MI_ESADD , PREFIX##MI_EATANxy, PREFIX##MI_ESQRT, PREFIX##MI_ESIN,  \
3657    }; \
3658     \
3659     static __aligned16 const FNTYPE PREFIX##LowerOP_T3_01_OPCODE[32] = { \
3660            PREFIX##unknown  , PREFIX##unknown  , PREFIX##unknown , PREFIX##unknown, \
3661            PREFIX##unknown  , PREFIX##unknown  , PREFIX##unknown , PREFIX##unknown,  \
3662            PREFIX##unknown  , PREFIX##unknown  , PREFIX##unknown , PREFIX##unknown,  \
3663            PREFIX##MI_MR32  , PREFIX##MI_SQI   , PREFIX##MI_SQRT , PREFIX##MI_MFIR,  \
3664            PREFIX##MI_RGET  , PREFIX##unknown  , PREFIX##unknown , PREFIX##unknown, /* 0x10 */ \
3665            PREFIX##unknown  , PREFIX##unknown  , PREFIX##unknown , PREFIX##unknown,  \
3666            PREFIX##unknown  , PREFIX##unknown  , PREFIX##MI_XITOP, PREFIX##unknown,  \
3667            PREFIX##MI_ERSADD, PREFIX##MI_EATANxz, PREFIX##MI_ERSQRT, PREFIX##MI_EATAN, \
3668    }; \
3669     \
3670     static __aligned16 const FNTYPE PREFIX##LowerOP_T3_10_OPCODE[32] = { \
3671            PREFIX##unknown  , PREFIX##unknown  , PREFIX##unknown , PREFIX##unknown, \
3672            PREFIX##unknown  , PREFIX##unknown  , PREFIX##unknown , PREFIX##unknown,  \
3673            PREFIX##unknown  , PREFIX##unknown  , PREFIX##unknown , PREFIX##unknown,  \
3674            PREFIX##unknown  , PREFIX##MI_LQD   , PREFIX##MI_RSQRT, PREFIX##MI_ILWR,  \
3675            PREFIX##MI_RINIT , PREFIX##unknown  , PREFIX##unknown , PREFIX##unknown, /* 0x10 */ \
3676            PREFIX##unknown  , PREFIX##unknown  , PREFIX##unknown , PREFIX##unknown,  \
3677            PREFIX##unknown  , PREFIX##unknown  , PREFIX##unknown , PREFIX##unknown,  \
3678            PREFIX##MI_ELENG , PREFIX##MI_ESUM  , PREFIX##MI_ERCPR, PREFIX##MI_EEXP,  \
3679    }; \
3680     \
3681     static __aligned16 const FNTYPE PREFIX##LowerOP_T3_11_OPCODE[32] = { \
3682            PREFIX##unknown  , PREFIX##unknown  , PREFIX##unknown , PREFIX##unknown, \
3683            PREFIX##unknown  , PREFIX##unknown  , PREFIX##unknown , PREFIX##unknown,  \
3684            PREFIX##unknown  , PREFIX##unknown  , PREFIX##unknown , PREFIX##unknown,  \
3685            PREFIX##unknown  , PREFIX##MI_SQD   , PREFIX##MI_WAITQ, PREFIX##MI_ISWR,  \
3686            PREFIX##MI_RXOR  , PREFIX##unknown  , PREFIX##unknown , PREFIX##unknown, /* 0x10 */ \
3687            PREFIX##unknown  , PREFIX##unknown  , PREFIX##unknown , PREFIX##unknown,  \
3688            PREFIX##unknown  , PREFIX##unknown  , PREFIX##unknown , PREFIX##unknown,  \
3689            PREFIX##MI_ERLENG, PREFIX##unknown  , PREFIX##MI_WAITP, PREFIX##unknown,  \
3690    }; \
3691     \
3692     static __aligned16 const FNTYPE PREFIX##LowerOP_OPCODE[64] = { \
3693            PREFIX##unknown  , PREFIX##unknown  , PREFIX##unknown , PREFIX##unknown, \
3694            PREFIX##unknown  , PREFIX##unknown  , PREFIX##unknown , PREFIX##unknown,  \
3695            PREFIX##unknown  , PREFIX##unknown  , PREFIX##unknown , PREFIX##unknown,  \
3696            PREFIX##unknown  , PREFIX##unknown  , PREFIX##unknown , PREFIX##unknown,  \
3697            PREFIX##unknown  , PREFIX##unknown  , PREFIX##unknown , PREFIX##unknown, /* 0x10 */  \
3698            PREFIX##unknown  , PREFIX##unknown  , PREFIX##unknown , PREFIX##unknown,  \
3699            PREFIX##unknown  , PREFIX##unknown  , PREFIX##unknown , PREFIX##unknown,  \
3700            PREFIX##unknown  , PREFIX##unknown  , PREFIX##unknown , PREFIX##unknown,  \
3701            PREFIX##unknown  , PREFIX##unknown  , PREFIX##unknown , PREFIX##unknown, /* 0x20 */  \
3702            PREFIX##unknown  , PREFIX##unknown  , PREFIX##unknown , PREFIX##unknown,  \
3703            PREFIX##unknown  , PREFIX##unknown  , PREFIX##unknown , PREFIX##unknown,  \
3704            PREFIX##unknown  , PREFIX##unknown  , PREFIX##unknown , PREFIX##unknown,  \
3705            PREFIX##MI_IADD  , PREFIX##MI_ISUB  , PREFIX##MI_IADDI, PREFIX##unknown, /* 0x30 */ \
3706            PREFIX##MI_IAND  , PREFIX##MI_IOR   , PREFIX##unknown , PREFIX##unknown,  \
3707            PREFIX##unknown  , PREFIX##unknown  , PREFIX##unknown , PREFIX##unknown,  \
3708            PREFIX##LowerOP_T3_00, PREFIX##LowerOP_T3_01, PREFIX##LowerOP_T3_10, PREFIX##LowerOP_T3_11,  \
3709    }; \
3710     \
3711    __aligned16 const FNTYPE PREFIX##_LOWER_OPCODE[128] = { \
3712            PREFIX##MI_LQ    , PREFIX##MI_SQ    , PREFIX##unknown , PREFIX##unknown,  \
3713            PREFIX##MI_ILW   , PREFIX##MI_ISW   , PREFIX##unknown , PREFIX##unknown,  \
3714            PREFIX##MI_IADDIU, PREFIX##MI_ISUBIU, PREFIX##unknown , PREFIX##unknown,  \
3715            PREFIX##unknown  , PREFIX##unknown  , PREFIX##unknown , PREFIX##unknown, \
3716            PREFIX##MI_FCEQ  , PREFIX##MI_FCSET , PREFIX##MI_FCAND, PREFIX##MI_FCOR, /* 0x10 */ \
3717            PREFIX##MI_FSEQ  , PREFIX##MI_FSSET , PREFIX##MI_FSAND, PREFIX##MI_FSOR, \
3718            PREFIX##MI_FMEQ  , PREFIX##unknown  , PREFIX##MI_FMAND, PREFIX##MI_FMOR, \
3719            PREFIX##MI_FCGET , PREFIX##unknown  , PREFIX##unknown , PREFIX##unknown, \
3720            PREFIX##MI_B     , PREFIX##MI_BAL   , PREFIX##unknown , PREFIX##unknown, /* 0x20 */  \
3721            PREFIX##MI_JR    , PREFIX##MI_JALR  , PREFIX##unknown , PREFIX##unknown, \
3722            PREFIX##MI_IBEQ  , PREFIX##MI_IBNE  , PREFIX##unknown , PREFIX##unknown, \
3723            PREFIX##MI_IBLTZ , PREFIX##MI_IBGTZ , PREFIX##MI_IBLEZ, PREFIX##MI_IBGEZ, \
3724            PREFIX##unknown  , PREFIX##unknown  , PREFIX##unknown , PREFIX##unknown, /* 0x30 */ \
3725            PREFIX##unknown  , PREFIX##unknown  , PREFIX##unknown , PREFIX##unknown,  \
3726            PREFIX##unknown  , PREFIX##unknown  , PREFIX##unknown , PREFIX##unknown,  \
3727            PREFIX##unknown  , PREFIX##unknown  , PREFIX##unknown , PREFIX##unknown,  \
3728            PREFIX##LowerOP  , PREFIX##unknown  , PREFIX##unknown , PREFIX##unknown, /* 0x40*/  \
3729            PREFIX##unknown  , PREFIX##unknown  , PREFIX##unknown , PREFIX##unknown,  \
3730            PREFIX##unknown  , PREFIX##unknown  , PREFIX##unknown , PREFIX##unknown,  \
3731            PREFIX##unknown  , PREFIX##unknown  , PREFIX##unknown , PREFIX##unknown,  \
3732            PREFIX##unknown  , PREFIX##unknown  , PREFIX##unknown , PREFIX##unknown, /* 0x50 */ \
3733            PREFIX##unknown  , PREFIX##unknown  , PREFIX##unknown , PREFIX##unknown,  \
3734            PREFIX##unknown  , PREFIX##unknown  , PREFIX##unknown , PREFIX##unknown,  \
3735            PREFIX##unknown  , PREFIX##unknown  , PREFIX##unknown , PREFIX##unknown,  \
3736            PREFIX##unknown  , PREFIX##unknown  , PREFIX##unknown , PREFIX##unknown, /* 0x60 */ \
3737            PREFIX##unknown  , PREFIX##unknown  , PREFIX##unknown , PREFIX##unknown,  \
3738            PREFIX##unknown  , PREFIX##unknown  , PREFIX##unknown , PREFIX##unknown,  \
3739            PREFIX##unknown  , PREFIX##unknown  , PREFIX##unknown , PREFIX##unknown,  \
3740            PREFIX##unknown  , PREFIX##unknown  , PREFIX##unknown , PREFIX##unknown, /* 0x70 */ \
3741            PREFIX##unknown  , PREFIX##unknown  , PREFIX##unknown , PREFIX##unknown,  \
3742            PREFIX##unknown  , PREFIX##unknown  , PREFIX##unknown , PREFIX##unknown,  \
3743            PREFIX##unknown  , PREFIX##unknown  , PREFIX##unknown , PREFIX##unknown,  \
3744    }; \
3745     \
3746     static __aligned16 const FNTYPE PREFIX##_UPPER_FD_00_TABLE[32] = { \
3747            PREFIX##MI_ADDAx, PREFIX##MI_SUBAx , PREFIX##MI_MADDAx, PREFIX##MI_MSUBAx, \
3748            PREFIX##MI_ITOF0, PREFIX##MI_FTOI0, PREFIX##MI_MULAx , PREFIX##MI_MULAq , \
3749            PREFIX##MI_ADDAq, PREFIX##MI_SUBAq, PREFIX##MI_ADDA  , PREFIX##MI_SUBA  , \
3750            PREFIX##unknown , PREFIX##unknown , PREFIX##unknown  , PREFIX##unknown  , \
3751            PREFIX##unknown , PREFIX##unknown , PREFIX##unknown  , PREFIX##unknown  , \
3752            PREFIX##unknown , PREFIX##unknown , PREFIX##unknown  , PREFIX##unknown  , \
3753            PREFIX##unknown , PREFIX##unknown , PREFIX##unknown  , PREFIX##unknown  , \
3754            PREFIX##unknown , PREFIX##unknown , PREFIX##unknown  , PREFIX##unknown  , \
3755    }; \
3756     \
3757     static __aligned16 const FNTYPE PREFIX##_UPPER_FD_01_TABLE[32] = { \
3758            PREFIX##MI_ADDAy , PREFIX##MI_SUBAy  , PREFIX##MI_MADDAy, PREFIX##MI_MSUBAy, \
3759            PREFIX##MI_ITOF4 , PREFIX##MI_FTOI4 , PREFIX##MI_MULAy , PREFIX##MI_ABS   , \
3760            PREFIX##MI_MADDAq, PREFIX##MI_MSUBAq, PREFIX##MI_MADDA , PREFIX##MI_MSUBA , \
3761            PREFIX##unknown  , PREFIX##unknown  , PREFIX##unknown  , PREFIX##unknown  , \
3762            PREFIX##unknown  , PREFIX##unknown  , PREFIX##unknown  , PREFIX##unknown  , \
3763            PREFIX##unknown  , PREFIX##unknown  , PREFIX##unknown  , PREFIX##unknown  , \
3764            PREFIX##unknown  , PREFIX##unknown  , PREFIX##unknown  , PREFIX##unknown  , \
3765            PREFIX##unknown  , PREFIX##unknown  , PREFIX##unknown  , PREFIX##unknown  , \
3766    }; \
3767     \
3768     static __aligned16 const FNTYPE PREFIX##_UPPER_FD_10_TABLE[32] = { \
3769            PREFIX##MI_ADDAz , PREFIX##MI_SUBAz  , PREFIX##MI_MADDAz, PREFIX##MI_MSUBAz, \
3770            PREFIX##MI_ITOF12, PREFIX##MI_FTOI12, PREFIX##MI_MULAz , PREFIX##MI_MULAi , \
3771            PREFIX##MI_ADDAi, PREFIX##MI_SUBAi , PREFIX##MI_MULA  , PREFIX##MI_OPMULA, \
3772            PREFIX##unknown  , PREFIX##unknown  , PREFIX##unknown  , PREFIX##unknown  , \
3773            PREFIX##unknown  , PREFIX##unknown  , PREFIX##unknown  , PREFIX##unknown  , \
3774            PREFIX##unknown  , PREFIX##unknown  , PREFIX##unknown  , PREFIX##unknown  , \
3775            PREFIX##unknown  , PREFIX##unknown  , PREFIX##unknown  , PREFIX##unknown  , \
3776            PREFIX##unknown  , PREFIX##unknown  , PREFIX##unknown  , PREFIX##unknown  , \
3777    }; \
3778     \
3779     static __aligned16 const FNTYPE PREFIX##_UPPER_FD_11_TABLE[32] = { \
3780            PREFIX##MI_ADDAw , PREFIX##MI_SUBAw  , PREFIX##MI_MADDAw, PREFIX##MI_MSUBAw, \
3781            PREFIX##MI_ITOF15, PREFIX##MI_FTOI15, PREFIX##MI_MULAw , PREFIX##MI_CLIP  , \
3782            PREFIX##MI_MADDAi, PREFIX##MI_MSUBAi, PREFIX##unknown  , PREFIX##MI_NOP   , \
3783            PREFIX##unknown  , PREFIX##unknown  , PREFIX##unknown  , PREFIX##unknown  , \
3784            PREFIX##unknown  , PREFIX##unknown  , PREFIX##unknown  , PREFIX##unknown  , \
3785            PREFIX##unknown  , PREFIX##unknown  , PREFIX##unknown  , PREFIX##unknown  , \
3786            PREFIX##unknown  , PREFIX##unknown  , PREFIX##unknown  , PREFIX##unknown  , \
3787            PREFIX##unknown  , PREFIX##unknown  , PREFIX##unknown  , PREFIX##unknown  , \
3788    }; \
3789     \
3790      __aligned16 const FNTYPE PREFIX##_UPPER_OPCODE[64] = { \
3791            PREFIX##MI_ADDx  , PREFIX##MI_ADDy  , PREFIX##MI_ADDz  , PREFIX##MI_ADDw, \<