notaz.gp2x.de / pcsx_rearmed.git / blame
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (incremental) | history | HEAD
drc: prefer callee-saved regs on alloc
[pcsx_rearmed.git] / libpcsxcore / gte.c
CommitLineData
ef79bbde
P		 1/***************************************************************************
2 * PCSX-Revolution - PlayStation Emulator for Nintendo Wii *
3 * Copyright (C) 2009-2010 PCSX-Revolution Dev Team *
4 * <http://code.google.com/p/pcsx-revolution/> *
5 * *
6 * This program is free software; you can redistribute it and/or modify *
7 * it under the terms of the GNU General Public License as published by *
8 * the Free Software Foundation; either version 2 of the License, or *
9 * (at your option) any later version. *
10 * *
11 * This program is distributed in the hope that it will be useful, *
12 * but WITHOUT ANY WARRANTY; without even the implied warranty of *
13 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the *
14 * GNU General Public License for more details. *
15 * *
16 * You should have received a copy of the GNU General Public License *
17 * along with this program; if not, write to the *
18 * Free Software Foundation, Inc., *
19 * 51 Franklin Street, Fifth Floor, Boston, MA 02111-1307 USA. *
20 ***************************************************************************/
21
22/*
23* GTE functions.
24*/
25
26#include "gte.h"
27#include "psxmem.h"
28
f74fb727 29#define VX(n) (n < 3 ? regs->CP2D.p[n << 1].sw.l : regs->CP2D.p[9].sw.l)
30#define VY(n) (n < 3 ? regs->CP2D.p[n << 1].sw.h : regs->CP2D.p[10].sw.l)
31#define VZ(n) (n < 3 ? regs->CP2D.p[(n << 1) + 1].sw.l : regs->CP2D.p[11].sw.l)
32#define MX11(n) (n < 3 ? regs->CP2C.p[(n << 3)].sw.l : 0)
33#define MX12(n) (n < 3 ? regs->CP2C.p[(n << 3)].sw.h : 0)
34#define MX13(n) (n < 3 ? regs->CP2C.p[(n << 3) + 1].sw.l : 0)
35#define MX21(n) (n < 3 ? regs->CP2C.p[(n << 3) + 1].sw.h : 0)
36#define MX22(n) (n < 3 ? regs->CP2C.p[(n << 3) + 2].sw.l : 0)
37#define MX23(n) (n < 3 ? regs->CP2C.p[(n << 3) + 2].sw.h : 0)
38#define MX31(n) (n < 3 ? regs->CP2C.p[(n << 3) + 3].sw.l : 0)
39#define MX32(n) (n < 3 ? regs->CP2C.p[(n << 3) + 3].sw.h : 0)
40#define MX33(n) (n < 3 ? regs->CP2C.p[(n << 3) + 4].sw.l : 0)
41#define CV1(n) (n < 3 ? (s32)regs->CP2C.r[(n << 3) + 5] : 0)
42#define CV2(n) (n < 3 ? (s32)regs->CP2C.r[(n << 3) + 6] : 0)
43#define CV3(n) (n < 3 ? (s32)regs->CP2C.r[(n << 3) + 7] : 0)
44
45#define fSX(n) ((regs->CP2D.p)[((n) + 12)].sw.l)
46#define fSY(n) ((regs->CP2D.p)[((n) + 12)].sw.h)
47#define fSZ(n) ((regs->CP2D.p)[((n) + 17)].w.l) /* (n == 0) => SZ1; */
48
49#define gteVXY0 (regs->CP2D.r[0])
50#define gteVX0 (regs->CP2D.p[0].sw.l)
51#define gteVY0 (regs->CP2D.p[0].sw.h)
52#define gteVZ0 (regs->CP2D.p[1].sw.l)
53#define gteVXY1 (regs->CP2D.r[2])
54#define gteVX1 (regs->CP2D.p[2].sw.l)
55#define gteVY1 (regs->CP2D.p[2].sw.h)
56#define gteVZ1 (regs->CP2D.p[3].sw.l)
57#define gteVXY2 (regs->CP2D.r[4])
58#define gteVX2 (regs->CP2D.p[4].sw.l)
59#define gteVY2 (regs->CP2D.p[4].sw.h)
60#define gteVZ2 (regs->CP2D.p[5].sw.l)
61#define gteRGB (regs->CP2D.r[6])
62#define gteR (regs->CP2D.p[6].b.l)
63#define gteG (regs->CP2D.p[6].b.h)
64#define gteB (regs->CP2D.p[6].b.h2)
65#define gteCODE (regs->CP2D.p[6].b.h3)
66#define gteOTZ (regs->CP2D.p[7].w.l)
67#define gteIR0 (regs->CP2D.p[8].sw.l)
68#define gteIR1 (regs->CP2D.p[9].sw.l)
69#define gteIR2 (regs->CP2D.p[10].sw.l)
70#define gteIR3 (regs->CP2D.p[11].sw.l)
71#define gteSXY0 (regs->CP2D.r[12])
72#define gteSX0 (regs->CP2D.p[12].sw.l)
73#define gteSY0 (regs->CP2D.p[12].sw.h)
74#define gteSXY1 (regs->CP2D.r[13])
75#define gteSX1 (regs->CP2D.p[13].sw.l)
76#define gteSY1 (regs->CP2D.p[13].sw.h)
77#define gteSXY2 (regs->CP2D.r[14])
78#define gteSX2 (regs->CP2D.p[14].sw.l)
79#define gteSY2 (regs->CP2D.p[14].sw.h)
80#define gteSXYP (regs->CP2D.r[15])
81#define gteSXP (regs->CP2D.p[15].sw.l)
82#define gteSYP (regs->CP2D.p[15].sw.h)
83#define gteSZ0 (regs->CP2D.p[16].w.l)
84#define gteSZ1 (regs->CP2D.p[17].w.l)
85#define gteSZ2 (regs->CP2D.p[18].w.l)
86#define gteSZ3 (regs->CP2D.p[19].w.l)
87#define gteRGB0 (regs->CP2D.r[20])
88#define gteR0 (regs->CP2D.p[20].b.l)
89#define gteG0 (regs->CP2D.p[20].b.h)
90#define gteB0 (regs->CP2D.p[20].b.h2)
91#define gteCODE0 (regs->CP2D.p[20].b.h3)
92#define gteRGB1 (regs->CP2D.r[21])
93#define gteR1 (regs->CP2D.p[21].b.l)
94#define gteG1 (regs->CP2D.p[21].b.h)
95#define gteB1 (regs->CP2D.p[21].b.h2)
96#define gteCODE1 (regs->CP2D.p[21].b.h3)
97#define gteRGB2 (regs->CP2D.r[22])
98#define gteR2 (regs->CP2D.p[22].b.l)
99#define gteG2 (regs->CP2D.p[22].b.h)
100#define gteB2 (regs->CP2D.p[22].b.h2)
101#define gteCODE2 (regs->CP2D.p[22].b.h3)
102#define gteRES1 (regs->CP2D.r[23])
103#define gteMAC0 (((s32 *)regs->CP2D.r)[24])
104#define gteMAC1 (((s32 *)regs->CP2D.r)[25])
105#define gteMAC2 (((s32 *)regs->CP2D.r)[26])
106#define gteMAC3 (((s32 *)regs->CP2D.r)[27])
107#define gteIRGB (regs->CP2D.r[28])
108#define gteORGB (regs->CP2D.r[29])
109#define gteLZCS (regs->CP2D.r[30])
110#define gteLZCR (regs->CP2D.r[31])
111
112#define gteR11R12 (((s32 *)regs->CP2C.r)[0])
113#define gteR22R23 (((s32 *)regs->CP2C.r)[2])
114#define gteR11 (regs->CP2C.p[0].sw.l)
115#define gteR12 (regs->CP2C.p[0].sw.h)
116#define gteR13 (regs->CP2C.p[1].sw.l)
117#define gteR21 (regs->CP2C.p[1].sw.h)
118#define gteR22 (regs->CP2C.p[2].sw.l)
119#define gteR23 (regs->CP2C.p[2].sw.h)
120#define gteR31 (regs->CP2C.p[3].sw.l)
121#define gteR32 (regs->CP2C.p[3].sw.h)
122#define gteR33 (regs->CP2C.p[4].sw.l)
123#define gteTRX (((s32 *)regs->CP2C.r)[5])
124#define gteTRY (((s32 *)regs->CP2C.r)[6])
125#define gteTRZ (((s32 *)regs->CP2C.r)[7])
126#define gteL11 (regs->CP2C.p[8].sw.l)
127#define gteL12 (regs->CP2C.p[8].sw.h)
128#define gteL13 (regs->CP2C.p[9].sw.l)
129#define gteL21 (regs->CP2C.p[9].sw.h)
130#define gteL22 (regs->CP2C.p[10].sw.l)
131#define gteL23 (regs->CP2C.p[10].sw.h)
132#define gteL31 (regs->CP2C.p[11].sw.l)
133#define gteL32 (regs->CP2C.p[11].sw.h)
134#define gteL33 (regs->CP2C.p[12].sw.l)
135#define gteRBK (((s32 *)regs->CP2C.r)[13])
136#define gteGBK (((s32 *)regs->CP2C.r)[14])
137#define gteBBK (((s32 *)regs->CP2C.r)[15])
138#define gteLR1 (regs->CP2C.p[16].sw.l)
139#define gteLR2 (regs->CP2C.p[16].sw.h)
140#define gteLR3 (regs->CP2C.p[17].sw.l)
141#define gteLG1 (regs->CP2C.p[17].sw.h)
142#define gteLG2 (regs->CP2C.p[18].sw.l)
143#define gteLG3 (regs->CP2C.p[18].sw.h)
144#define gteLB1 (regs->CP2C.p[19].sw.l)
145#define gteLB2 (regs->CP2C.p[19].sw.h)
146#define gteLB3 (regs->CP2C.p[20].sw.l)
147#define gteRFC (((s32 *)regs->CP2C.r)[21])
148#define gteGFC (((s32 *)regs->CP2C.r)[22])
149#define gteBFC (((s32 *)regs->CP2C.r)[23])
150#define gteOFX (((s32 *)regs->CP2C.r)[24])
151#define gteOFY (((s32 *)regs->CP2C.r)[25])
b7159e1a 152// senquack - gteH register is u16, not s16, and used in GTE that way.
153// HOWEVER when read back by CPU using CFC2, it will be incorrectly
154// sign-extended by bug in original hardware, according to Nocash docs
155// GTE section 'Screen Offset and Distance'. The emulator does this
156// sign extension when it is loaded to GTE by CTC2.
157//#define gteH (psxRegs.CP2C.p[26].sw.l)
158#define gteH (psxRegs.CP2C.p[26].w.l)
f74fb727 159#define gteDQA (regs->CP2C.p[27].sw.l)
160#define gteDQB (((s32 *)regs->CP2C.r)[28])
161#define gteZSF3 (regs->CP2C.p[29].sw.l)
162#define gteZSF4 (regs->CP2C.p[30].sw.l)
163#define gteFLAG (regs->CP2C.r[31])
ef79bbde
P		 164
165#define GTE_OP(op) ((op >> 20) & 31)
166#define GTE_SF(op) ((op >> 19) & 1)
167#define GTE_MX(op) ((op >> 17) & 3)
168#define GTE_V(op) ((op >> 15) & 3)
169#define GTE_CV(op) ((op >> 13) & 3)
170#define GTE_CD(op) ((op >> 11) & 3) /* not used */
171#define GTE_LM(op) ((op >> 10) & 1)
172#define GTE_CT(op) ((op >> 6) & 15) /* not used */
173#define GTE_FUNCT(op) (op & 63)
174
175#define gteop (psxRegs.code & 0x1ffffff)
176
59774ed0 177#ifndef FLAGLESS
178
669fed93 179static inline s64 BOUNDS_(psxCP2Regs *regs, s64 n_value, s64 n_max, int n_maxflag, s64 n_min, int n_minflag) {
ef79bbde
P		 180 if (n_value > n_max) {
181 gteFLAG |= n_maxflag;
182 } else if (n_value < n_min) {
183 gteFLAG |= n_minflag;
184 }
185 return n_value;
186}
187
f74fb727 188static inline s32 LIM_(psxCP2Regs *regs, s32 value, s32 max, s32 min, u32 flag) {
ef79bbde
P		 189 s32 ret = value;
190 if (value > max) {
191 gteFLAG |= flag;
192 ret = max;
193 } else if (value < min) {
194 gteFLAG |= flag;
195 ret = min;
196 }
197 return ret;
198}
199
f74fb727 200static inline u32 limE_(psxCP2Regs *regs, u32 result) {
59774ed0 201 if (result > 0x1ffff) {
202 gteFLAG |= (1 << 31) | (1 << 17);
203 return 0x1ffff;
204 }
205 return result;
206}
207
208#else
209
f74fb727 210#define BOUNDS_(regs, a, ...) (a)
59774ed0 211
f74fb727 212static inline s32 LIM_(psxCP2Regs *regs, s32 value, s32 max, s32 min, u32 flag_unused) {
59774ed0 213 s32 ret = value;
214 if (value > max)
215 ret = max;
216 else if (value < min)
217 ret = min;
218 return ret;
219}
220
f74fb727 221static inline u32 limE_(psxCP2Regs *regs, u32 result) {
bedfea38 222 if (result > 0x1ffff)
223 return 0x1ffff;
224 return result;
225}
59774ed0 226
227#endif
228
f74fb727 229#define BOUNDS(n_value,n_max,n_maxflag,n_min,n_minflag) \
230 BOUNDS_(regs,n_value,n_max,n_maxflag,n_min,n_minflag)
231#define LIM(value,max,min,flag) \
232 LIM_(regs,value,max,min,flag)
233#define limE(result) \
234 limE_(regs,result)
235
ef79bbde
P		 236#define A1(a) BOUNDS((a), 0x7fffffff, (1 << 30), -(s64)0x80000000, (1 << 31) | (1 << 27))
237#define A2(a) BOUNDS((a), 0x7fffffff, (1 << 29), -(s64)0x80000000, (1 << 31) | (1 << 26))
238#define A3(a) BOUNDS((a), 0x7fffffff, (1 << 28), -(s64)0x80000000, (1 << 31) | (1 << 25))
239#define limB1(a, l) LIM((a), 0x7fff, -0x8000 * !l, (1 << 31) | (1 << 24))
240#define limB2(a, l) LIM((a), 0x7fff, -0x8000 * !l, (1 << 31) | (1 << 23))
241#define limB3(a, l) LIM((a), 0x7fff, -0x8000 * !l, (1 << 22))
242#define limC1(a) LIM((a), 0x00ff, 0x0000, (1 << 21))
243#define limC2(a) LIM((a), 0x00ff, 0x0000, (1 << 20))
244#define limC3(a) LIM((a), 0x00ff, 0x0000, (1 << 19))
245#define limD(a) LIM((a), 0xffff, 0x0000, (1 << 31) | (1 << 18))
246
ef79bbde
P		 247#define F(a) BOUNDS((a), 0x7fffffff, (1 << 31) | (1 << 16), -(s64)0x80000000, (1 << 31) | (1 << 15))
248#define limG1(a) LIM((a), 0x3ff, -0x400, (1 << 31) | (1 << 14))
249#define limG2(a) LIM((a), 0x3ff, -0x400, (1 << 31) | (1 << 13))
7384197d 250#define limH(a) LIM((a), 0x1000, 0x0000, (1 << 12))
ef79bbde 251
6c6c9590 252#ifndef __arm__
253#define A1U A1
254#define A2U A2
255#define A3U A3
256#else
257/* these are unlikely to be hit and usually waste cycles, don't want them on ARM */
258#define A1U(x) (x)
259#define A2U(x) (x)
260#define A3U(x) (x)
261#endif
262
b7159e1a 263
264//senquack - n param should be unsigned (will be 'gteH' reg which is u16)
265#ifdef GTE_USE_NATIVE_DIVIDE
266INLINE u32 DIVIDE(u16 n, u16 d) {
267 if (n < d * 2) {
268 return ((u32)n << 16) / d;
269 }
270 return 0xffffffff;
271}
272#else
ef79bbde 273#include "gte_divider.h"
b7159e1a 274#endif // GTE_USE_NATIVE_DIVIDE
ef79bbde 275
59774ed0 276#ifndef FLAGLESS
277
32631e6a 278const unsigned char gte_cycletab[64] = {
81dbbf4c 279 /* 1 2 3 4 5 6 7 8 9 a b c d e f */
280 0, 15, 0, 0, 0, 0, 8, 0, 0, 0, 0, 0, 6, 0, 0, 0,
281 8, 8, 8, 19, 13, 0, 44, 0, 0, 0, 0, 17, 11, 0, 14, 0,
282 30, 0, 0, 0, 0, 0, 0, 0, 5, 8, 17, 0, 0, 5, 6, 0,
283 23, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 5, 5, 39,
284};
285
286// warning: called by the dynarec
287int gteCheckStallRaw(u32 op_cycles, psxRegisters *regs) {
288 u32 left = regs->gteBusyCycle - regs->cycle;
289 int stall = 0;
290
291 if (left <= 44) {
292 //printf("c %2u stall %2u %u\n", op_cycles, left, regs->cycle);
293 regs->cycle = regs->gteBusyCycle;
294 stall = left;
295 }
296 regs->gteBusyCycle = regs->cycle + op_cycles;
297 return stall;
298}
299
300void gteCheckStall(u32 op) {
301 gteCheckStallRaw(gte_cycletab[op], &psxRegs);
302}
303
ef79bbde 304static inline u32 MFC2(int reg) {
eac38522 305 psxCP2Regs *regs = &psxRegs.CP2;
ef79bbde
P		 306 switch (reg) {
307 case 1:
308 case 3:
309 case 5:
310 case 8:
311 case 9:
312 case 10:
313 case 11:
314 psxRegs.CP2D.r[reg] = (s32)psxRegs.CP2D.p[reg].sw.l;
315 break;
316
317 case 7:
318 case 16:
319 case 17:
320 case 18:
321 case 19:
322 psxRegs.CP2D.r[reg] = (u32)psxRegs.CP2D.p[reg].w.l;
323 break;
324
325 case 15:
326 psxRegs.CP2D.r[reg] = gteSXY2;
327 break;
328
329 case 28:
ef79bbde
P		 330 case 29:
331 psxRegs.CP2D.r[reg] = LIM(gteIR1 >> 7, 0x1f, 0, 0) |
332 (LIM(gteIR2 >> 7, 0x1f, 0, 0) << 5) |
333 (LIM(gteIR3 >> 7, 0x1f, 0, 0) << 10);
334 break;
335 }
336 return psxRegs.CP2D.r[reg];
337}
338
339static inline void MTC2(u32 value, int reg) {
eac38522 340 psxCP2Regs *regs = &psxRegs.CP2;
ef79bbde
P		 341 switch (reg) {
342 case 15:
343 gteSXY0 = gteSXY1;
344 gteSXY1 = gteSXY2;
345 gteSXY2 = value;
346 gteSXYP = value;
347 break;
348
349 case 28:
350 gteIRGB = value;
3968e69e 351 // not gteIR1 etc. just to be consistent with dynarec
352 regs->CP2D.n.ir1 = (value & 0x1f) << 7;
353 regs->CP2D.n.ir2 = (value & 0x3e0) << 2;
354 regs->CP2D.n.ir3 = (value & 0x7c00) >> 3;
ef79bbde
P		 355 break;
356
357 case 30:
358 {
359 int a;
360 gteLZCS = value;
361
362 a = gteLZCS;
363 if (a > 0) {
364 int i;
365 for (i = 31; (a & (1 << i)) == 0 && i >= 0; i--);
366 gteLZCR = 31 - i;
367 } else if (a < 0) {
368 int i;
369 a ^= 0xffffffff;
370 for (i = 31; (a & (1 << i)) == 0 && i >= 0; i--);
371 gteLZCR = 31 - i;
372 } else {
373 gteLZCR = 32;
374 }
375 }
376 break;
377
ef79bbde
P		 378 case 31:
379 return;
380
381 default:
382 psxRegs.CP2D.r[reg] = value;
383 }
384}
385
386static inline void CTC2(u32 value, int reg) {
387 switch (reg) {
388 case 4:
389 case 12:
390 case 20:
391 case 26:
392 case 27:
393 case 29:
394 case 30:
395 value = (s32)(s16)value;
396 break;
397
398 case 31:
399 value = value & 0x7ffff000;
400 if (value & 0x7f87e000) value |= 0x80000000;
401 break;
402 }
403
404 psxRegs.CP2C.r[reg] = value;
405}
406
407void gteMFC2() {
408 if (!_Rt_) return;
409 psxRegs.GPR.r[_Rt_] = MFC2(_Rd_);
410}
411
412void gteCFC2() {
413 if (!_Rt_) return;
414 psxRegs.GPR.r[_Rt_] = psxRegs.CP2C.r[_Rd_];
415}
416
417void gteMTC2() {
418 MTC2(psxRegs.GPR.r[_Rt_], _Rd_);
419}
420
421void gteCTC2() {
422 CTC2(psxRegs.GPR.r[_Rt_], _Rd_);
423}
424
425#define _oB_ (psxRegs.GPR.r[_Rs_] + _Imm_)
426
427void gteLWC2() {
428 MTC2(psxMemRead32(_oB_), _Rt_);
429}
430
431void gteSWC2() {
432 psxMemWrite32(_oB_, MFC2(_Rt_));
433}
434
32631e6a 435void gteLWC2_stall() {
436 gteCheckStall(0);
437 gteLWC2();
438}
439
440void gteSWC2_stall() {
441 gteCheckStall(0);
442 gteSWC2();
443}
444
59774ed0 445#endif // FLAGLESS
446
3ebefe71 447#if 0
a2544c92 448#define DIVIDE DIVIDE_
449static u32 DIVIDE_(s16 n, u16 d) {
450 if (n >= 0 && n < d * 2) {
451 s32 n_ = n;
452 return ((n_ << 16) + d / 2) / d;
453 //return (u32)((float)(n_ << 16) / (float)d + (float)0.5);
454 }
455 return 0xffffffff;
456}
3ebefe71 457#endif
a2544c92 458
f74fb727 459void gteRTPS(psxCP2Regs *regs) {
ef79bbde 460 int quotient;
8cb04d22 461 s64 tmp;
ef79bbde
P		 462
463#ifdef GTE_LOG
464 GTE_LOG("GTE RTPS\n");
465#endif
466 gteFLAG = 0;
467
468 gteMAC1 = A1((((s64)gteTRX << 12) + (gteR11 * gteVX0) + (gteR12 * gteVY0) + (gteR13 * gteVZ0)) >> 12);
469 gteMAC2 = A2((((s64)gteTRY << 12) + (gteR21 * gteVX0) + (gteR22 * gteVY0) + (gteR23 * gteVZ0)) >> 12);
470 gteMAC3 = A3((((s64)gteTRZ << 12) + (gteR31 * gteVX0) + (gteR32 * gteVY0) + (gteR33 * gteVZ0)) >> 12);
471 gteIR1 = limB1(gteMAC1, 0);
472 gteIR2 = limB2(gteMAC2, 0);
473 gteIR3 = limB3(gteMAC3, 0);
474 gteSZ0 = gteSZ1;
475 gteSZ1 = gteSZ2;
476 gteSZ2 = gteSZ3;
477 gteSZ3 = limD(gteMAC3);
478 quotient = limE(DIVIDE(gteH, gteSZ3));
479 gteSXY0 = gteSXY1;
480 gteSXY1 = gteSXY2;
481 gteSX2 = limG1(F((s64)gteOFX + ((s64)gteIR1 * quotient)) >> 16);
482 gteSY2 = limG2(F((s64)gteOFY + ((s64)gteIR2 * quotient)) >> 16);
483
8cb04d22 484 tmp = (s64)gteDQB + ((s64)gteDQA * quotient);
485 gteMAC0 = F(tmp);
486 gteIR0 = limH(tmp >> 12);
ef79bbde
P		 487}
488
f74fb727 489void gteRTPT(psxCP2Regs *regs) {
ef79bbde
P		 490 int quotient;
491 int v;
492 s32 vx, vy, vz;
8cb04d22 493 s64 tmp;
ef79bbde
P		 494
495#ifdef GTE_LOG
496 GTE_LOG("GTE RTPT\n");
497#endif
498 gteFLAG = 0;
499
500 gteSZ0 = gteSZ3;
501 for (v = 0; v < 3; v++) {
502 vx = VX(v);
503 vy = VY(v);
504 vz = VZ(v);
505 gteMAC1 = A1((((s64)gteTRX << 12) + (gteR11 * vx) + (gteR12 * vy) + (gteR13 * vz)) >> 12);
506 gteMAC2 = A2((((s64)gteTRY << 12) + (gteR21 * vx) + (gteR22 * vy) + (gteR23 * vz)) >> 12);
507 gteMAC3 = A3((((s64)gteTRZ << 12) + (gteR31 * vx) + (gteR32 * vy) + (gteR33 * vz)) >> 12);
508 gteIR1 = limB1(gteMAC1, 0);
509 gteIR2 = limB2(gteMAC2, 0);
510 gteIR3 = limB3(gteMAC3, 0);
511 fSZ(v) = limD(gteMAC3);
512 quotient = limE(DIVIDE(gteH, fSZ(v)));
513 fSX(v) = limG1(F((s64)gteOFX + ((s64)gteIR1 * quotient)) >> 16);
514 fSY(v) = limG2(F((s64)gteOFY + ((s64)gteIR2 * quotient)) >> 16);
515 }
8cb04d22 516
517 tmp = (s64)gteDQB + ((s64)gteDQA * quotient);
518 gteMAC0 = F(tmp);
519 gteIR0 = limH(tmp >> 12);
ef79bbde
P		 520}
521
f74fb727 522void gteMVMVA(psxCP2Regs *regs) {
ef79bbde
P		 523 int shift = 12 * GTE_SF(gteop);
524 int mx = GTE_MX(gteop);
525 int v = GTE_V(gteop);
526 int cv = GTE_CV(gteop);
527 int lm = GTE_LM(gteop);
528 s32 vx = VX(v);
529 s32 vy = VY(v);
530 s32 vz = VZ(v);
531
532#ifdef GTE_LOG
533 GTE_LOG("GTE MVMVA\n");
534#endif
535 gteFLAG = 0;
536
537 gteMAC1 = A1((((s64)CV1(cv) << 12) + (MX11(mx) * vx) + (MX12(mx) * vy) + (MX13(mx) * vz)) >> shift);
538 gteMAC2 = A2((((s64)CV2(cv) << 12) + (MX21(mx) * vx) + (MX22(mx) * vy) + (MX23(mx) * vz)) >> shift);
539 gteMAC3 = A3((((s64)CV3(cv) << 12) + (MX31(mx) * vx) + (MX32(mx) * vy) + (MX33(mx) * vz)) >> shift);
540
541 gteIR1 = limB1(gteMAC1, lm);
542 gteIR2 = limB2(gteMAC2, lm);
543 gteIR3 = limB3(gteMAC3, lm);
544}
545
f74fb727 546void gteNCLIP(psxCP2Regs *regs) {
ef79bbde
P		 547#ifdef GTE_LOG
548 GTE_LOG("GTE NCLIP\n");
549#endif
550 gteFLAG = 0;
551
552 gteMAC0 = F((s64)gteSX0 * (gteSY1 - gteSY2) +
553 gteSX1 * (gteSY2 - gteSY0) +
554 gteSX2 * (gteSY0 - gteSY1));
555}
556
f74fb727 557void gteAVSZ3(psxCP2Regs *regs) {
ef79bbde
P		 558#ifdef GTE_LOG
559 GTE_LOG("GTE AVSZ3\n");
560#endif
561 gteFLAG = 0;
562
b3254af9 563 gteMAC0 = F((s64)gteZSF3 * (gteSZ1 + gteSZ2 + gteSZ3));
ef79bbde
P		 564 gteOTZ = limD(gteMAC0 >> 12);
565}
566
f74fb727 567void gteAVSZ4(psxCP2Regs *regs) {
ef79bbde
P		 568#ifdef GTE_LOG
569 GTE_LOG("GTE AVSZ4\n");
570#endif
571 gteFLAG = 0;
572
b3254af9 573 gteMAC0 = F((s64)gteZSF4 * (gteSZ0 + gteSZ1 + gteSZ2 + gteSZ3));
ef79bbde
P		 574 gteOTZ = limD(gteMAC0 >> 12);
575}
576
f74fb727 577void gteSQR(psxCP2Regs *regs) {
ef79bbde
P		 578 int shift = 12 * GTE_SF(gteop);
579 int lm = GTE_LM(gteop);
580
581#ifdef GTE_LOG
582 GTE_LOG("GTE SQR\n");
583#endif
584 gteFLAG = 0;
585
b3254af9 586 gteMAC1 = (gteIR1 * gteIR1) >> shift;
587 gteMAC2 = (gteIR2 * gteIR2) >> shift;
588 gteMAC3 = (gteIR3 * gteIR3) >> shift;
7384197d 589 gteIR1 = limB1(gteMAC1, lm);
590 gteIR2 = limB2(gteMAC2, lm);
591 gteIR3 = limB3(gteMAC3, lm);
ef79bbde
P		 592}
593
f74fb727 594void gteNCCS(psxCP2Regs *regs) {
ef79bbde
P		 595#ifdef GTE_LOG
596 GTE_LOG("GTE NCCS\n");
597#endif
598 gteFLAG = 0;
599
b3254af9 600 gteMAC1 = ((s64)(gteL11 * gteVX0) + (gteL12 * gteVY0) + (gteL13 * gteVZ0)) >> 12;
601 gteMAC2 = ((s64)(gteL21 * gteVX0) + (gteL22 * gteVY0) + (gteL23 * gteVZ0)) >> 12;
602 gteMAC3 = ((s64)(gteL31 * gteVX0) + (gteL32 * gteVY0) + (gteL33 * gteVZ0)) >> 12;
ef79bbde
P		 603 gteIR1 = limB1(gteMAC1, 1);
604 gteIR2 = limB2(gteMAC2, 1);
605 gteIR3 = limB3(gteMAC3, 1);
606 gteMAC1 = A1((((s64)gteRBK << 12) + (gteLR1 * gteIR1) + (gteLR2 * gteIR2) + (gteLR3 * gteIR3)) >> 12);
607 gteMAC2 = A2((((s64)gteGBK << 12) + (gteLG1 * gteIR1) + (gteLG2 * gteIR2) + (gteLG3 * gteIR3)) >> 12);
608 gteMAC3 = A3((((s64)gteBBK << 12) + (gteLB1 * gteIR1) + (gteLB2 * gteIR2) + (gteLB3 * gteIR3)) >> 12);
609 gteIR1 = limB1(gteMAC1, 1);
610 gteIR2 = limB2(gteMAC2, 1);
611 gteIR3 = limB3(gteMAC3, 1);
b3254af9 612 gteMAC1 = ((s32)gteR * gteIR1) >> 8;
613 gteMAC2 = ((s32)gteG * gteIR2) >> 8;
614 gteMAC3 = ((s32)gteB * gteIR3) >> 8;
615 gteIR1 = gteMAC1;
616 gteIR2 = gteMAC2;
617 gteIR3 = gteMAC3;
ef79bbde
P		 618
619 gteRGB0 = gteRGB1;
620 gteRGB1 = gteRGB2;
621 gteCODE2 = gteCODE;
622 gteR2 = limC1(gteMAC1 >> 4);
623 gteG2 = limC2(gteMAC2 >> 4);
624 gteB2 = limC3(gteMAC3 >> 4);
625}
626
f74fb727 627void gteNCCT(psxCP2Regs *regs) {
ef79bbde
P		 628 int v;
629 s32 vx, vy, vz;
630
631#ifdef GTE_LOG
632 GTE_LOG("GTE NCCT\n");
633#endif
634 gteFLAG = 0;
635
636 for (v = 0; v < 3; v++) {
637 vx = VX(v);
638 vy = VY(v);
639 vz = VZ(v);
b3254af9 640 gteMAC1 = ((s64)(gteL11 * vx) + (gteL12 * vy) + (gteL13 * vz)) >> 12;
641 gteMAC2 = ((s64)(gteL21 * vx) + (gteL22 * vy) + (gteL23 * vz)) >> 12;
642 gteMAC3 = ((s64)(gteL31 * vx) + (gteL32 * vy) + (gteL33 * vz)) >> 12;
ef79bbde
P		 643 gteIR1 = limB1(gteMAC1, 1);
644 gteIR2 = limB2(gteMAC2, 1);
645 gteIR3 = limB3(gteMAC3, 1);
646 gteMAC1 = A1((((s64)gteRBK << 12) + (gteLR1 * gteIR1) + (gteLR2 * gteIR2) + (gteLR3 * gteIR3)) >> 12);
647 gteMAC2 = A2((((s64)gteGBK << 12) + (gteLG1 * gteIR1) + (gteLG2 * gteIR2) + (gteLG3 * gteIR3)) >> 12);
648 gteMAC3 = A3((((s64)gteBBK << 12) + (gteLB1 * gteIR1) + (gteLB2 * gteIR2) + (gteLB3 * gteIR3)) >> 12);
649 gteIR1 = limB1(gteMAC1, 1);
650 gteIR2 = limB2(gteMAC2, 1);
651 gteIR3 = limB3(gteMAC3, 1);
b3254af9 652 gteMAC1 = ((s32)gteR * gteIR1) >> 8;
653 gteMAC2 = ((s32)gteG * gteIR2) >> 8;
654 gteMAC3 = ((s32)gteB * gteIR3) >> 8;
ef79bbde
P		 655
656 gteRGB0 = gteRGB1;
657 gteRGB1 = gteRGB2;
658 gteCODE2 = gteCODE;
659 gteR2 = limC1(gteMAC1 >> 4);
660 gteG2 = limC2(gteMAC2 >> 4);
661 gteB2 = limC3(gteMAC3 >> 4);
662 }
b3254af9 663 gteIR1 = gteMAC1;
664 gteIR2 = gteMAC2;
665 gteIR3 = gteMAC3;
ef79bbde
P		 666}
667
f74fb727 668void gteNCDS(psxCP2Regs *regs) {
ef79bbde
P		 669#ifdef GTE_LOG
670 GTE_LOG("GTE NCDS\n");
671#endif
672 gteFLAG = 0;
673
b3254af9 674 gteMAC1 = ((s64)(gteL11 * gteVX0) + (gteL12 * gteVY0) + (gteL13 * gteVZ0)) >> 12;
675 gteMAC2 = ((s64)(gteL21 * gteVX0) + (gteL22 * gteVY0) + (gteL23 * gteVZ0)) >> 12;
676 gteMAC3 = ((s64)(gteL31 * gteVX0) + (gteL32 * gteVY0) + (gteL33 * gteVZ0)) >> 12;
ef79bbde
P		 677 gteIR1 = limB1(gteMAC1, 1);
678 gteIR2 = limB2(gteMAC2, 1);
679 gteIR3 = limB3(gteMAC3, 1);
680 gteMAC1 = A1((((s64)gteRBK << 12) + (gteLR1 * gteIR1) + (gteLR2 * gteIR2) + (gteLR3 * gteIR3)) >> 12);
681 gteMAC2 = A2((((s64)gteGBK << 12) + (gteLG1 * gteIR1) + (gteLG2 * gteIR2) + (gteLG3 * gteIR3)) >> 12);
682 gteMAC3 = A3((((s64)gteBBK << 12) + (gteLB1 * gteIR1) + (gteLB2 * gteIR2) + (gteLB3 * gteIR3)) >> 12);
683 gteIR1 = limB1(gteMAC1, 1);
684 gteIR2 = limB2(gteMAC2, 1);
685 gteIR3 = limB3(gteMAC3, 1);
6c6c9590 686 gteMAC1 = (((gteR << 4) * gteIR1) + (gteIR0 * limB1(A1U((s64)gteRFC - ((gteR * gteIR1) >> 8)), 0))) >> 12;
687 gteMAC2 = (((gteG << 4) * gteIR2) + (gteIR0 * limB2(A2U((s64)gteGFC - ((gteG * gteIR2) >> 8)), 0))) >> 12;
688 gteMAC3 = (((gteB << 4) * gteIR3) + (gteIR0 * limB3(A3U((s64)gteBFC - ((gteB * gteIR3) >> 8)), 0))) >> 12;
ef79bbde
P		 689 gteIR1 = limB1(gteMAC1, 1);
690 gteIR2 = limB2(gteMAC2, 1);
691 gteIR3 = limB3(gteMAC3, 1);
692
693 gteRGB0 = gteRGB1;
694 gteRGB1 = gteRGB2;
695 gteCODE2 = gteCODE;
696 gteR2 = limC1(gteMAC1 >> 4);
697 gteG2 = limC2(gteMAC2 >> 4);
698 gteB2 = limC3(gteMAC3 >> 4);
699}
700
f74fb727 701void gteNCDT(psxCP2Regs *regs) {
ef79bbde
P		 702 int v;
703 s32 vx, vy, vz;
704
705#ifdef GTE_LOG
706 GTE_LOG("GTE NCDT\n");
707#endif
708 gteFLAG = 0;
709
710 for (v = 0; v < 3; v++) {
711 vx = VX(v);
712 vy = VY(v);
713 vz = VZ(v);
b3254af9 714 gteMAC1 = ((s64)(gteL11 * vx) + (gteL12 * vy) + (gteL13 * vz)) >> 12;
715 gteMAC2 = ((s64)(gteL21 * vx) + (gteL22 * vy) + (gteL23 * vz)) >> 12;
716 gteMAC3 = ((s64)(gteL31 * vx) + (gteL32 * vy) + (gteL33 * vz)) >> 12;
ef79bbde
P		 717 gteIR1 = limB1(gteMAC1, 1);
718 gteIR2 = limB2(gteMAC2, 1);
719 gteIR3 = limB3(gteMAC3, 1);
720 gteMAC1 = A1((((s64)gteRBK << 12) + (gteLR1 * gteIR1) + (gteLR2 * gteIR2) + (gteLR3 * gteIR3)) >> 12);
721 gteMAC2 = A2((((s64)gteGBK << 12) + (gteLG1 * gteIR1) + (gteLG2 * gteIR2) + (gteLG3 * gteIR3)) >> 12);
722 gteMAC3 = A3((((s64)gteBBK << 12) + (gteLB1 * gteIR1) + (gteLB2 * gteIR2) + (gteLB3 * gteIR3)) >> 12);
723 gteIR1 = limB1(gteMAC1, 1);
724 gteIR2 = limB2(gteMAC2, 1);
725 gteIR3 = limB3(gteMAC3, 1);
6c6c9590 726 gteMAC1 = (((gteR << 4) * gteIR1) + (gteIR0 * limB1(A1U((s64)gteRFC - ((gteR * gteIR1) >> 8)), 0))) >> 12;
727 gteMAC2 = (((gteG << 4) * gteIR2) + (gteIR0 * limB2(A2U((s64)gteGFC - ((gteG * gteIR2) >> 8)), 0))) >> 12;
728 gteMAC3 = (((gteB << 4) * gteIR3) + (gteIR0 * limB3(A3U((s64)gteBFC - ((gteB * gteIR3) >> 8)), 0))) >> 12;
ef79bbde
P		 729
730 gteRGB0 = gteRGB1;
731 gteRGB1 = gteRGB2;
732 gteCODE2 = gteCODE;
733 gteR2 = limC1(gteMAC1 >> 4);
734 gteG2 = limC2(gteMAC2 >> 4);
735 gteB2 = limC3(gteMAC3 >> 4);
736 }
737 gteIR1 = limB1(gteMAC1, 1);
738 gteIR2 = limB2(gteMAC2, 1);
739 gteIR3 = limB3(gteMAC3, 1);
740}
741
f74fb727 742void gteOP(psxCP2Regs *regs) {
ef79bbde
P		 743 int shift = 12 * GTE_SF(gteop);
744 int lm = GTE_LM(gteop);
745
746#ifdef GTE_LOG
747 GTE_LOG("GTE OP\n");
748#endif
749 gteFLAG = 0;
750
b3254af9 751 gteMAC1 = ((gteR22 * gteIR3) - (gteR33 * gteIR2)) >> shift;
752 gteMAC2 = ((gteR33 * gteIR1) - (gteR11 * gteIR3)) >> shift;
753 gteMAC3 = ((gteR11 * gteIR2) - (gteR22 * gteIR1)) >> shift;
ef79bbde
P		 754 gteIR1 = limB1(gteMAC1, lm);
755 gteIR2 = limB2(gteMAC2, lm);
756 gteIR3 = limB3(gteMAC3, lm);
757}
758
f74fb727 759void gteDCPL(psxCP2Regs *regs) {
ef79bbde
P		 760 int lm = GTE_LM(gteop);
761
b3254af9 762 s32 RIR1 = ((s32)gteR * gteIR1) >> 8;
763 s32 GIR2 = ((s32)gteG * gteIR2) >> 8;
764 s32 BIR3 = ((s32)gteB * gteIR3) >> 8;
ef79bbde
P		 765
766#ifdef GTE_LOG
767 GTE_LOG("GTE DCPL\n");
768#endif
769 gteFLAG = 0;
770
6c6c9590 771 gteMAC1 = RIR1 + ((gteIR0 * limB1(A1U((s64)gteRFC - RIR1), 0)) >> 12);
772 gteMAC2 = GIR2 + ((gteIR0 * limB1(A2U((s64)gteGFC - GIR2), 0)) >> 12);
773 gteMAC3 = BIR3 + ((gteIR0 * limB1(A3U((s64)gteBFC - BIR3), 0)) >> 12);
ef79bbde
P		 774
775 gteIR1 = limB1(gteMAC1, lm);
776 gteIR2 = limB2(gteMAC2, lm);
777 gteIR3 = limB3(gteMAC3, lm);
778
779 gteRGB0 = gteRGB1;
780 gteRGB1 = gteRGB2;
781 gteCODE2 = gteCODE;
782 gteR2 = limC1(gteMAC1 >> 4);
783 gteG2 = limC2(gteMAC2 >> 4);
784 gteB2 = limC3(gteMAC3 >> 4);
785}
786
f74fb727 787void gteGPF(psxCP2Regs *regs) {
ef79bbde
P		 788 int shift = 12 * GTE_SF(gteop);
789
790#ifdef GTE_LOG
791 GTE_LOG("GTE GPF\n");
792#endif
793 gteFLAG = 0;
794
b3254af9 795 gteMAC1 = (gteIR0 * gteIR1) >> shift;
796 gteMAC2 = (gteIR0 * gteIR2) >> shift;
797 gteMAC3 = (gteIR0 * gteIR3) >> shift;
ef79bbde
P		 798 gteIR1 = limB1(gteMAC1, 0);
799 gteIR2 = limB2(gteMAC2, 0);
800 gteIR3 = limB3(gteMAC3, 0);
801
802 gteRGB0 = gteRGB1;
803 gteRGB1 = gteRGB2;
804 gteCODE2 = gteCODE;
805 gteR2 = limC1(gteMAC1 >> 4);
806 gteG2 = limC2(gteMAC2 >> 4);
807 gteB2 = limC3(gteMAC3 >> 4);
808}
809
f74fb727 810void gteGPL(psxCP2Regs *regs) {
ef79bbde
P		 811 int shift = 12 * GTE_SF(gteop);
812
813#ifdef GTE_LOG
814 GTE_LOG("GTE GPL\n");
815#endif
816 gteFLAG = 0;
817
818 gteMAC1 = A1((((s64)gteMAC1 << shift) + (gteIR0 * gteIR1)) >> shift);
819 gteMAC2 = A2((((s64)gteMAC2 << shift) + (gteIR0 * gteIR2)) >> shift);
820 gteMAC3 = A3((((s64)gteMAC3 << shift) + (gteIR0 * gteIR3)) >> shift);
821 gteIR1 = limB1(gteMAC1, 0);
822 gteIR2 = limB2(gteMAC2, 0);
823 gteIR3 = limB3(gteMAC3, 0);
824
825 gteRGB0 = gteRGB1;
826 gteRGB1 = gteRGB2;
827 gteCODE2 = gteCODE;
828 gteR2 = limC1(gteMAC1 >> 4);
829 gteG2 = limC2(gteMAC2 >> 4);
830 gteB2 = limC3(gteMAC3 >> 4);
831}
832
f74fb727 833void gteDPCS(psxCP2Regs *regs) {
ef79bbde
P		 834 int shift = 12 * GTE_SF(gteop);
835
836#ifdef GTE_LOG
837 GTE_LOG("GTE DPCS\n");
838#endif
839 gteFLAG = 0;
840
6c6c9590 841 gteMAC1 = ((gteR << 16) + (gteIR0 * limB1(A1U(((s64)gteRFC - (gteR << 4)) << (12 - shift)), 0))) >> 12;
842 gteMAC2 = ((gteG << 16) + (gteIR0 * limB2(A2U(((s64)gteGFC - (gteG << 4)) << (12 - shift)), 0))) >> 12;
843 gteMAC3 = ((gteB << 16) + (gteIR0 * limB3(A3U(((s64)gteBFC - (gteB << 4)) << (12 - shift)), 0))) >> 12;
ef79bbde
P		 844
845 gteIR1 = limB1(gteMAC1, 0);
846 gteIR2 = limB2(gteMAC2, 0);
847 gteIR3 = limB3(gteMAC3, 0);
848 gteRGB0 = gteRGB1;
849 gteRGB1 = gteRGB2;
850 gteCODE2 = gteCODE;
851 gteR2 = limC1(gteMAC1 >> 4);
852 gteG2 = limC2(gteMAC2 >> 4);
853 gteB2 = limC3(gteMAC3 >> 4);
854}
855
f74fb727 856void gteDPCT(psxCP2Regs *regs) {
ef79bbde
P		 857 int v;
858
859#ifdef GTE_LOG
860 GTE_LOG("GTE DPCT\n");
861#endif
862 gteFLAG = 0;
863
864 for (v = 0; v < 3; v++) {
6c6c9590 865 gteMAC1 = ((gteR0 << 16) + (gteIR0 * limB1(A1U((s64)gteRFC - (gteR0 << 4)), 0))) >> 12;
866 gteMAC2 = ((gteG0 << 16) + (gteIR0 * limB1(A2U((s64)gteGFC - (gteG0 << 4)), 0))) >> 12;
867 gteMAC3 = ((gteB0 << 16) + (gteIR0 * limB1(A3U((s64)gteBFC - (gteB0 << 4)), 0))) >> 12;
ef79bbde
P		 868
869 gteRGB0 = gteRGB1;
870 gteRGB1 = gteRGB2;
871 gteCODE2 = gteCODE;
872 gteR2 = limC1(gteMAC1 >> 4);
873 gteG2 = limC2(gteMAC2 >> 4);
874 gteB2 = limC3(gteMAC3 >> 4);
875 }
876 gteIR1 = limB1(gteMAC1, 0);
877 gteIR2 = limB2(gteMAC2, 0);
878 gteIR3 = limB3(gteMAC3, 0);
879}
880
f74fb727 881void gteNCS(psxCP2Regs *regs) {
ef79bbde
P		 882#ifdef GTE_LOG
883 GTE_LOG("GTE NCS\n");
884#endif
885 gteFLAG = 0;
886
b3254af9 887 gteMAC1 = ((s64)(gteL11 * gteVX0) + (gteL12 * gteVY0) + (gteL13 * gteVZ0)) >> 12;
888 gteMAC2 = ((s64)(gteL21 * gteVX0) + (gteL22 * gteVY0) + (gteL23 * gteVZ0)) >> 12;
889 gteMAC3 = ((s64)(gteL31 * gteVX0) + (gteL32 * gteVY0) + (gteL33 * gteVZ0)) >> 12;
ef79bbde
P		 890 gteIR1 = limB1(gteMAC1, 1);
891 gteIR2 = limB2(gteMAC2, 1);
892 gteIR3 = limB3(gteMAC3, 1);
893 gteMAC1 = A1((((s64)gteRBK << 12) + (gteLR1 * gteIR1) + (gteLR2 * gteIR2) + (gteLR3 * gteIR3)) >> 12);
894 gteMAC2 = A2((((s64)gteGBK << 12) + (gteLG1 * gteIR1) + (gteLG2 * gteIR2) + (gteLG3 * gteIR3)) >> 12);
895 gteMAC3 = A3((((s64)gteBBK << 12) + (gteLB1 * gteIR1) + (gteLB2 * gteIR2) + (gteLB3 * gteIR3)) >> 12);
896 gteIR1 = limB1(gteMAC1, 1);
897 gteIR2 = limB2(gteMAC2, 1);
898 gteIR3 = limB3(gteMAC3, 1);
899
900 gteRGB0 = gteRGB1;
901 gteRGB1 = gteRGB2;
902 gteCODE2 = gteCODE;
903 gteR2 = limC1(gteMAC1 >> 4);
904 gteG2 = limC2(gteMAC2 >> 4);
905 gteB2 = limC3(gteMAC3 >> 4);
906}
907
f74fb727 908void gteNCT(psxCP2Regs *regs) {
ef79bbde
P		 909 int v;
910 s32 vx, vy, vz;
911
912#ifdef GTE_LOG
913 GTE_LOG("GTE NCT\n");
914#endif
915 gteFLAG = 0;
916
917 for (v = 0; v < 3; v++) {
918 vx = VX(v);
919 vy = VY(v);
920 vz = VZ(v);
b3254af9 921 gteMAC1 = ((s64)(gteL11 * vx) + (gteL12 * vy) + (gteL13 * vz)) >> 12;
922 gteMAC2 = ((s64)(gteL21 * vx) + (gteL22 * vy) + (gteL23 * vz)) >> 12;
923 gteMAC3 = ((s64)(gteL31 * vx) + (gteL32 * vy) + (gteL33 * vz)) >> 12;
ef79bbde
P		 924 gteIR1 = limB1(gteMAC1, 1);
925 gteIR2 = limB2(gteMAC2, 1);
926 gteIR3 = limB3(gteMAC3, 1);
927 gteMAC1 = A1((((s64)gteRBK << 12) + (gteLR1 * gteIR1) + (gteLR2 * gteIR2) + (gteLR3 * gteIR3)) >> 12);
928 gteMAC2 = A2((((s64)gteGBK << 12) + (gteLG1 * gteIR1) + (gteLG2 * gteIR2) + (gteLG3 * gteIR3)) >> 12);
929 gteMAC3 = A3((((s64)gteBBK << 12) + (gteLB1 * gteIR1) + (gteLB2 * gteIR2) + (gteLB3 * gteIR3)) >> 12);
930 gteRGB0 = gteRGB1;
931 gteRGB1 = gteRGB2;
932 gteCODE2 = gteCODE;
933 gteR2 = limC1(gteMAC1 >> 4);
934 gteG2 = limC2(gteMAC2 >> 4);
935 gteB2 = limC3(gteMAC3 >> 4);
936 }
937 gteIR1 = limB1(gteMAC1, 1);
938 gteIR2 = limB2(gteMAC2, 1);
939 gteIR3 = limB3(gteMAC3, 1);
940}
941
f74fb727 942void gteCC(psxCP2Regs *regs) {
ef79bbde
P		 943#ifdef GTE_LOG
944 GTE_LOG("GTE CC\n");
945#endif
946 gteFLAG = 0;
947
948 gteMAC1 = A1((((s64)gteRBK << 12) + (gteLR1 * gteIR1) + (gteLR2 * gteIR2) + (gteLR3 * gteIR3)) >> 12);
949 gteMAC2 = A2((((s64)gteGBK << 12) + (gteLG1 * gteIR1) + (gteLG2 * gteIR2) + (gteLG3 * gteIR3)) >> 12);
950 gteMAC3 = A3((((s64)gteBBK << 12) + (gteLB1 * gteIR1) + (gteLB2 * gteIR2) + (gteLB3 * gteIR3)) >> 12);
951 gteIR1 = limB1(gteMAC1, 1);
952 gteIR2 = limB2(gteMAC2, 1);
953 gteIR3 = limB3(gteMAC3, 1);
b3254af9 954 gteMAC1 = ((s32)gteR * gteIR1) >> 8;
955 gteMAC2 = ((s32)gteG * gteIR2) >> 8;
956 gteMAC3 = ((s32)gteB * gteIR3) >> 8;
ef79bbde
P		 957 gteIR1 = limB1(gteMAC1, 1);
958 gteIR2 = limB2(gteMAC2, 1);
959 gteIR3 = limB3(gteMAC3, 1);
960
961 gteRGB0 = gteRGB1;
962 gteRGB1 = gteRGB2;
963 gteCODE2 = gteCODE;
964 gteR2 = limC1(gteMAC1 >> 4);
965 gteG2 = limC2(gteMAC2 >> 4);
966 gteB2 = limC3(gteMAC3 >> 4);
967}
968
f74fb727 969void gteINTPL(psxCP2Regs *regs) {
ef79bbde
P		 970 int shift = 12 * GTE_SF(gteop);
971 int lm = GTE_LM(gteop);
972
973#ifdef GTE_LOG
974 GTE_LOG("GTE INTPL\n");
975#endif
976 gteFLAG = 0;
977
6c6c9590 978 gteMAC1 = ((gteIR1 << 12) + (gteIR0 * limB1(A1U((s64)gteRFC - gteIR1), 0))) >> shift;
979 gteMAC2 = ((gteIR2 << 12) + (gteIR0 * limB2(A2U((s64)gteGFC - gteIR2), 0))) >> shift;
980 gteMAC3 = ((gteIR3 << 12) + (gteIR0 * limB3(A3U((s64)gteBFC - gteIR3), 0))) >> shift;
ef79bbde
P		 981 gteIR1 = limB1(gteMAC1, lm);
982 gteIR2 = limB2(gteMAC2, lm);
983 gteIR3 = limB3(gteMAC3, lm);
984 gteRGB0 = gteRGB1;
985 gteRGB1 = gteRGB2;
986 gteCODE2 = gteCODE;
987 gteR2 = limC1(gteMAC1 >> 4);
988 gteG2 = limC2(gteMAC2 >> 4);
989 gteB2 = limC3(gteMAC3 >> 4);
990}
991
f74fb727 992void gteCDP(psxCP2Regs *regs) {
ef79bbde
P		 993#ifdef GTE_LOG
994 GTE_LOG("GTE CDP\n");
995#endif
996 gteFLAG = 0;
997
998 gteMAC1 = A1((((s64)gteRBK << 12) + (gteLR1 * gteIR1) + (gteLR2 * gteIR2) + (gteLR3 * gteIR3)) >> 12);
999 gteMAC2 = A2((((s64)gteGBK << 12) + (gteLG1 * gteIR1) + (gteLG2 * gteIR2) + (gteLG3 * gteIR3)) >> 12);
1000 gteMAC3 = A3((((s64)gteBBK << 12) + (gteLB1 * gteIR1) + (gteLB2 * gteIR2) + (gteLB3 * gteIR3)) >> 12);
1001 gteIR1 = limB1(gteMAC1, 1);
1002 gteIR2 = limB2(gteMAC2, 1);
1003 gteIR3 = limB3(gteMAC3, 1);
6c6c9590 1004 gteMAC1 = (((gteR << 4) * gteIR1) + (gteIR0 * limB1(A1U((s64)gteRFC - ((gteR * gteIR1) >> 8)), 0))) >> 12;
1005 gteMAC2 = (((gteG << 4) * gteIR2) + (gteIR0 * limB2(A2U((s64)gteGFC - ((gteG * gteIR2) >> 8)), 0))) >> 12;
1006 gteMAC3 = (((gteB << 4) * gteIR3) + (gteIR0 * limB3(A3U((s64)gteBFC - ((gteB * gteIR3) >> 8)), 0))) >> 12;
ef79bbde
P		 1007 gteIR1 = limB1(gteMAC1, 1);
1008 gteIR2 = limB2(gteMAC2, 1);
1009 gteIR3 = limB3(gteMAC3, 1);
1010
1011 gteRGB0 = gteRGB1;
1012 gteRGB1 = gteRGB2;
1013 gteCODE2 = gteCODE;
1014 gteR2 = limC1(gteMAC1 >> 4);
1015 gteG2 = limC2(gteMAC2 >> 4);
1016 gteB2 = limC3(gteMAC3 >> 4);
1017}
6c0eefaf 1018
1019/* decomposed/parametrized versions for the recompiler */
1020
1021#ifndef FLAGLESS
1022
1023void gteSQR_part_noshift(psxCP2Regs *regs) {
1024 gteFLAG = 0;
1025
1026 gteMAC1 = gteIR1 * gteIR1;
1027 gteMAC2 = gteIR2 * gteIR2;
1028 gteMAC3 = gteIR3 * gteIR3;
1029}
1030
1031void gteSQR_part_shift(psxCP2Regs *regs) {
1032 gteFLAG = 0;
1033
1034 gteMAC1 = (gteIR1 * gteIR1) >> 12;
1035 gteMAC2 = (gteIR2 * gteIR2) >> 12;
1036 gteMAC3 = (gteIR3 * gteIR3) >> 12;
1037}
1038
1039void gteOP_part_noshift(psxCP2Regs *regs) {
1040 gteFLAG = 0;
1041
1042 gteMAC1 = (gteR22 * gteIR3) - (gteR33 * gteIR2);
1043 gteMAC2 = (gteR33 * gteIR1) - (gteR11 * gteIR3);
1044 gteMAC3 = (gteR11 * gteIR2) - (gteR22 * gteIR1);
1045}
1046
1047void gteOP_part_shift(psxCP2Regs *regs) {
1048 gteFLAG = 0;
1049
1050 gteMAC1 = ((gteR22 * gteIR3) - (gteR33 * gteIR2)) >> 12;
1051 gteMAC2 = ((gteR33 * gteIR1) - (gteR11 * gteIR3)) >> 12;
1052 gteMAC3 = ((gteR11 * gteIR2) - (gteR22 * gteIR1)) >> 12;
1053}
1054
1055void gteDCPL_part(psxCP2Regs *regs) {
1056 s32 RIR1 = ((s32)gteR * gteIR1) >> 8;
1057 s32 GIR2 = ((s32)gteG * gteIR2) >> 8;
1058 s32 BIR3 = ((s32)gteB * gteIR3) >> 8;
1059
1060 gteFLAG = 0;
1061
1062 gteMAC1 = RIR1 + ((gteIR0 * limB1(A1U((s64)gteRFC - RIR1), 0)) >> 12);
1063 gteMAC2 = GIR2 + ((gteIR0 * limB1(A2U((s64)gteGFC - GIR2), 0)) >> 12);
1064 gteMAC3 = BIR3 + ((gteIR0 * limB1(A3U((s64)gteBFC - BIR3), 0)) >> 12);
1065}
1066
1067void gteGPF_part_noshift(psxCP2Regs *regs) {
1068 gteFLAG = 0;
1069
1070 gteMAC1 = gteIR0 * gteIR1;
1071 gteMAC2 = gteIR0 * gteIR2;
1072 gteMAC3 = gteIR0 * gteIR3;
1073}
1074
1075void gteGPF_part_shift(psxCP2Regs *regs) {
1076 gteFLAG = 0;
1077
1078 gteMAC1 = (gteIR0 * gteIR1) >> 12;
1079 gteMAC2 = (gteIR0 * gteIR2) >> 12;
1080 gteMAC3 = (gteIR0 * gteIR3) >> 12;
1081}
1082
1083#endif // !FLAGLESS
1084
1085void gteGPL_part_noshift(psxCP2Regs *regs) {
1086 gteFLAG = 0;
1087
1088 gteMAC1 = A1((s64)gteMAC1 + (gteIR0 * gteIR1));
1089 gteMAC2 = A2((s64)gteMAC2 + (gteIR0 * gteIR2));
1090 gteMAC3 = A3((s64)gteMAC3 + (gteIR0 * gteIR3));
1091}
1092
1093void gteGPL_part_shift(psxCP2Regs *regs) {
1094 gteFLAG = 0;
1095
1096 gteMAC1 = A1((s64)gteMAC1 + ((gteIR0 * gteIR1) >> 12));
1097 gteMAC2 = A2((s64)gteMAC2 + ((gteIR0 * gteIR2) >> 12));
1098 gteMAC3 = A3((s64)gteMAC3 + ((gteIR0 * gteIR3) >> 12));
1099}
1100
1101void gteDPCS_part_noshift(psxCP2Regs *regs) {
1102 int shift = 0;
1103
1104 gteFLAG = 0;
1105
1106 gteMAC1 = ((gteR << 16) + (gteIR0 * limB1(A1U((s64)gteRFC - (gteR << 4)) << (12 - shift), 0))) >> 12;
1107 gteMAC2 = ((gteG << 16) + (gteIR0 * limB2(A2U((s64)gteGFC - (gteG << 4)) << (12 - shift), 0))) >> 12;
1108 gteMAC3 = ((gteB << 16) + (gteIR0 * limB3(A3U((s64)gteBFC - (gteB << 4)) << (12 - shift), 0))) >> 12;
1109}
1110
1111void gteDPCS_part_shift(psxCP2Regs *regs) {
1112 int shift = 12;
1113
1114 gteFLAG = 0;
1115
1116 gteMAC1 = ((gteR << 16) + (gteIR0 * limB1(A1U((s64)gteRFC - (gteR << 4)) << (12 - shift), 0))) >> 12;
1117 gteMAC2 = ((gteG << 16) + (gteIR0 * limB2(A2U((s64)gteGFC - (gteG << 4)) << (12 - shift), 0))) >> 12;
1118 gteMAC3 = ((gteB << 16) + (gteIR0 * limB3(A3U((s64)gteBFC - (gteB << 4)) << (12 - shift), 0))) >> 12;
1119}
1120
1121void gteINTPL_part_noshift(psxCP2Regs *regs) {
1122 gteFLAG = 0;
1123
1124 gteMAC1 = ((gteIR1 << 12) + (gteIR0 * limB1(A1U((s64)gteRFC - gteIR1), 0)));
1125 gteMAC2 = ((gteIR2 << 12) + (gteIR0 * limB2(A2U((s64)gteGFC - gteIR2), 0)));
1126 gteMAC3 = ((gteIR3 << 12) + (gteIR0 * limB3(A3U((s64)gteBFC - gteIR3), 0)));
1127}
1128
1129void gteINTPL_part_shift(psxCP2Regs *regs) {
1130 gteFLAG = 0;
1131
1132 gteMAC1 = ((gteIR1 << 12) + (gteIR0 * limB1(A1U((s64)gteRFC - gteIR1), 0))) >> 12;
1133 gteMAC2 = ((gteIR2 << 12) + (gteIR0 * limB2(A2U((s64)gteGFC - gteIR2), 0))) >> 12;
1134 gteMAC3 = ((gteIR3 << 12) + (gteIR0 * limB3(A3U((s64)gteBFC - gteIR3), 0))) >> 12;
1135}
1136
1137void gteMACtoRGB(psxCP2Regs *regs) {
1138 gteRGB0 = gteRGB1;
1139 gteRGB1 = gteRGB2;
1140 gteCODE2 = gteCODE;
1141 gteR2 = limC1(gteMAC1 >> 4);
1142 gteG2 = limC2(gteMAC2 >> 4);
1143 gteB2 = limC3(gteMAC3 >> 4);
1144}
1145
ARM optimized PCSX fork