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

Contents of /trunk/pcsx2/VUops.cpp

Parent Directory Parent Directory | Revision Log Revision Log


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