libpcsxcore/gte.c

   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
  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])
 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   (regs->CP2C.p[26].sw.l)
 158 #define gteH   (regs->CP2C.p[26].w.l)
 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])
 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
 177 #ifndef FLAGLESS
 178
 179 static inline s64 BOUNDS_(psxCP2Regs *regs, s64 n_value, s64 n_max, int n_maxflag, s64 n_min, int n_minflag) {
 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
 188 static inline s32 LIM_(psxCP2Regs *regs, s32 value, s32 max, s32 min, u32 flag) {
 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
 200 static inline u32 limE_(psxCP2Regs *regs, u32 result) {
 201         if (result > 0x1ffff) {
 202                 gteFLAG |= (1 << 31) | (1 << 17);
 203                 return 0x1ffff;
 204         }
 205         return result;
 206 }
 207
 208 #else
 209
 210 #define BOUNDS_(regs, a, ...) (a)
 211
 212 static inline s32 LIM_(psxCP2Regs *regs, s32 value, s32 max, s32 min, u32 flag_unused) {
 213         s32 ret = value;
 214         if (value > max)
 215                 ret = max;
 216         else if (value < min)
 217                 ret = min;
 218         return ret;
 219 }
 220
 221 static inline u32 limE_(psxCP2Regs *regs, u32 result) {
 222         if (result > 0x1ffff)
 223                 return 0x1ffff;
 224         return result;
 225 }
 226
 227 #endif
 228
 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
 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
 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))
 250 #define limH(a) LIM((a), 0x1000, 0x0000, (1 << 12))
 251
 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
 263
 264 //senquack - n param should be unsigned (will be 'gteH' reg which is u16)
 265 #ifdef GTE_USE_NATIVE_DIVIDE
 266 INLINE u32 DIVIDE(u16 n, u16 d) {
 267         if (n < d * 2) {
 268                 return ((u32)n << 16) / d;
 269         }
 270         return 0xffffffff;
 271 }
 272 #else
 273 #include "gte_divider.h"
 274 #endif // GTE_USE_NATIVE_DIVIDE
 275
 276 #ifndef FLAGLESS
 277
 278 const unsigned char gte_cycletab[64] = {
 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
 287 int 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
 300 void gteCheckStall(u32 op) {
 301         gteCheckStallRaw(gte_cycletab[op], &psxRegs);
 302 }
 303
 304 u32 MFC2(struct psxCP2Regs *regs, int reg) {
 305         switch (reg) {
 306                 case 1:
 307                 case 3:
 308                 case 5:
 309                 case 8:
 310                 case 9:
 311                 case 10:
 312                 case 11:
 313                         regs->CP2D.r[reg] = (s32)regs->CP2D.p[reg].sw.l;
 314                         break;
 315
 316                 case 7:
 317                 case 16:
 318                 case 17:
 319                 case 18:
 320                 case 19:
 321                         regs->CP2D.r[reg] = (u32)regs->CP2D.p[reg].w.l;
 322                         break;
 323
 324                 case 15:
 325                         regs->CP2D.r[reg] = gteSXY2;
 326                         break;
 327
 328                 case 28:
 329                 case 29:
 330                         regs->CP2D.r[reg] = LIM(gteIR1 >> 7, 0x1f, 0, 0) |
 331                                                                         (LIM(gteIR2 >> 7, 0x1f, 0, 0) << 5) |
 332                                                                         (LIM(gteIR3 >> 7, 0x1f, 0, 0) << 10);
 333                         break;
 334         }
 335         return regs->CP2D.r[reg];
 336 }
 337
 338 void MTC2(struct psxCP2Regs *regs, u32 value, int reg) {
 339         switch (reg) {
 340                 case 15:
 341                         gteSXY0 = gteSXY1;
 342                         gteSXY1 = gteSXY2;
 343                         gteSXY2 = value;
 344                         gteSXYP = value;
 345                         break;
 346
 347                 case 28:
 348                         gteIRGB = value;
 349                         // not gteIR1 etc. just to be consistent with dynarec
 350                         regs->CP2D.n.ir1 = (value & 0x1f) << 7;
 351                         regs->CP2D.n.ir2 = (value & 0x3e0) << 2;
 352                         regs->CP2D.n.ir3 = (value & 0x7c00) >> 3;
 353                         break;
 354
 355                 case 30:
 356                         {
 357                                 int a;
 358                                 gteLZCS = value;
 359
 360                                 a = gteLZCS;
 361                                 if (a > 0) {
 362                                         int i;
 363                                         for (i = 31; (a & (1 << i)) == 0 && i >= 0; i--);
 364                                         gteLZCR = 31 - i;
 365                                 } else if (a < 0) {
 366                                         int i;
 367                                         a ^= 0xffffffff;
 368                                         for (i = 31; (a & (1 << i)) == 0 && i >= 0; i--);
 369                                         gteLZCR = 31 - i;
 370                                 } else {
 371                                         gteLZCR = 32;
 372                                 }
 373                         }
 374                         break;
 375
 376                 case 31:
 377                         return;
 378
 379                 default:
 380                         regs->CP2D.r[reg] = value;
 381         }
 382 }
 383
 384 void CTC2(struct psxCP2Regs *regs, u32 value, int reg) {
 385         switch (reg) {
 386                 case 4:
 387                 case 12:
 388                 case 20:
 389                 case 26:
 390                 case 27:
 391                 case 29:
 392                 case 30:
 393                         value = (s32)(s16)value;
 394                         break;
 395
 396                 case 31:
 397                         value = value & 0x7ffff000;
 398                         if (value & 0x7f87e000) value |= 0x80000000;
 399                         break;
 400         }
 401
 402         regs->CP2C.r[reg] = value;
 403 }
 404
 405 #endif // FLAGLESS
 406
 407 #if 0
 408 #define DIVIDE DIVIDE_
 409 static u32 DIVIDE_(s16 n, u16 d) {
 410         if (n >= 0 && n < d * 2) {
 411                 s32 n_ = n;
 412                 return ((n_ << 16) + d / 2) / d;
 413                 //return (u32)((float)(n_ << 16) / (float)d + (float)0.5);
 414         }
 415         return 0xffffffff;
 416 }
 417 #endif
 418
 419 void gteRTPS(psxCP2Regs *regs) {
 420         int quotient;
 421         s64 tmp;
 422
 423 #ifdef GTE_LOG
 424         GTE_LOG("GTE RTPS\n");
 425 #endif
 426         gteFLAG = 0;
 427
 428         gteMAC1 = A1((((s64)gteTRX << 12) + (gteR11 * gteVX0) + (gteR12 * gteVY0) + (gteR13 * gteVZ0)) >> 12);
 429         gteMAC2 = A2((((s64)gteTRY << 12) + (gteR21 * gteVX0) + (gteR22 * gteVY0) + (gteR23 * gteVZ0)) >> 12);
 430         gteMAC3 = A3((((s64)gteTRZ << 12) + (gteR31 * gteVX0) + (gteR32 * gteVY0) + (gteR33 * gteVZ0)) >> 12);
 431         gteIR1 = limB1(gteMAC1, 0);
 432         gteIR2 = limB2(gteMAC2, 0);
 433         gteIR3 = limB3(gteMAC3, 0);
 434         gteSZ0 = gteSZ1;
 435         gteSZ1 = gteSZ2;
 436         gteSZ2 = gteSZ3;
 437         gteSZ3 = limD(gteMAC3);
 438         quotient = limE(DIVIDE(gteH, gteSZ3));
 439         gteSXY0 = gteSXY1;
 440         gteSXY1 = gteSXY2;
 441         gteSX2 = limG1(F((s64)gteOFX + ((s64)gteIR1 * quotient)) >> 16);
 442         gteSY2 = limG2(F((s64)gteOFY + ((s64)gteIR2 * quotient)) >> 16);
 443
 444         tmp = (s64)gteDQB + ((s64)gteDQA * quotient);
 445         gteMAC0 = F(tmp);
 446         gteIR0 = limH(tmp >> 12);
 447 }
 448
 449 void gteRTPT(psxCP2Regs *regs) {
 450         int quotient;
 451         int v;
 452         s32 vx, vy, vz;
 453         s64 tmp;
 454
 455 #ifdef GTE_LOG
 456         GTE_LOG("GTE RTPT\n");
 457 #endif
 458         gteFLAG = 0;
 459
 460         gteSZ0 = gteSZ3;
 461         for (v = 0; v < 3; v++) {
 462                 vx = VX(v);
 463                 vy = VY(v);
 464                 vz = VZ(v);
 465                 gteMAC1 = A1((((s64)gteTRX << 12) + (gteR11 * vx) + (gteR12 * vy) + (gteR13 * vz)) >> 12);
 466                 gteMAC2 = A2((((s64)gteTRY << 12) + (gteR21 * vx) + (gteR22 * vy) + (gteR23 * vz)) >> 12);
 467                 gteMAC3 = A3((((s64)gteTRZ << 12) + (gteR31 * vx) + (gteR32 * vy) + (gteR33 * vz)) >> 12);
 468                 gteIR1 = limB1(gteMAC1, 0);
 469                 gteIR2 = limB2(gteMAC2, 0);
 470                 gteIR3 = limB3(gteMAC3, 0);
 471                 fSZ(v) = limD(gteMAC3);
 472                 quotient = limE(DIVIDE(gteH, fSZ(v)));
 473                 fSX(v) = limG1(F((s64)gteOFX + ((s64)gteIR1 * quotient)) >> 16);
 474                 fSY(v) = limG2(F((s64)gteOFY + ((s64)gteIR2 * quotient)) >> 16);
 475         }
 476
 477         tmp = (s64)gteDQB + ((s64)gteDQA * quotient);
 478         gteMAC0 = F(tmp);
 479         gteIR0 = limH(tmp >> 12);
 480 }
 481
 482 void gteMVMVA(psxCP2Regs *regs) {
 483         int shift = 12 * GTE_SF(gteop);
 484         int mx = GTE_MX(gteop);
 485         int v = GTE_V(gteop);
 486         int cv = GTE_CV(gteop);
 487         int lm = GTE_LM(gteop);
 488         s32 vx = VX(v);
 489         s32 vy = VY(v);
 490         s32 vz = VZ(v);
 491
 492 #ifdef GTE_LOG
 493         GTE_LOG("GTE MVMVA\n");
 494 #endif
 495         gteFLAG = 0;
 496
 497         gteMAC1 = A1((((s64)CV1(cv) << 12) + (MX11(mx) * vx) + (MX12(mx) * vy) + (MX13(mx) * vz)) >> shift);
 498         gteMAC2 = A2((((s64)CV2(cv) << 12) + (MX21(mx) * vx) + (MX22(mx) * vy) + (MX23(mx) * vz)) >> shift);
 499         gteMAC3 = A3((((s64)CV3(cv) << 12) + (MX31(mx) * vx) + (MX32(mx) * vy) + (MX33(mx) * vz)) >> shift);
 500
 501         gteIR1 = limB1(gteMAC1, lm);
 502         gteIR2 = limB2(gteMAC2, lm);
 503         gteIR3 = limB3(gteMAC3, lm);
 504 }
 505
 506 void gteNCLIP(psxCP2Regs *regs) {
 507 #ifdef GTE_LOG
 508         GTE_LOG("GTE NCLIP\n");
 509 #endif
 510         gteFLAG = 0;
 511
 512         gteMAC0 = F((s64)gteSX0 * (gteSY1 - gteSY2) +
 513                                 gteSX1 * (gteSY2 - gteSY0) +
 514                                 gteSX2 * (gteSY0 - gteSY1));
 515 }
 516
 517 void gteAVSZ3(psxCP2Regs *regs) {
 518 #ifdef GTE_LOG
 519         GTE_LOG("GTE AVSZ3\n");
 520 #endif
 521         gteFLAG = 0;
 522
 523         gteMAC0 = F((s64)gteZSF3 * (gteSZ1 + gteSZ2 + gteSZ3));
 524         gteOTZ = limD(gteMAC0 >> 12);
 525 }
 526
 527 void gteAVSZ4(psxCP2Regs *regs) {
 528 #ifdef GTE_LOG
 529         GTE_LOG("GTE AVSZ4\n");
 530 #endif
 531         gteFLAG = 0;
 532
 533         gteMAC0 = F((s64)gteZSF4 * (gteSZ0 + gteSZ1 + gteSZ2 + gteSZ3));
 534         gteOTZ = limD(gteMAC0 >> 12);
 535 }
 536
 537 void gteSQR(psxCP2Regs *regs) {
 538         int shift = 12 * GTE_SF(gteop);
 539         int lm = GTE_LM(gteop);
 540
 541 #ifdef GTE_LOG
 542         GTE_LOG("GTE SQR\n");
 543 #endif
 544         gteFLAG = 0;
 545
 546         gteMAC1 = (gteIR1 * gteIR1) >> shift;
 547         gteMAC2 = (gteIR2 * gteIR2) >> shift;
 548         gteMAC3 = (gteIR3 * gteIR3) >> shift;
 549         gteIR1 = limB1(gteMAC1, lm);
 550         gteIR2 = limB2(gteMAC2, lm);
 551         gteIR3 = limB3(gteMAC3, lm);
 552 }
 553
 554 void gteNCCS(psxCP2Regs *regs) {
 555 #ifdef GTE_LOG
 556         GTE_LOG("GTE NCCS\n");
 557 #endif
 558         gteFLAG = 0;
 559
 560         gteMAC1 = ((s64)(gteL11 * gteVX0) + (gteL12 * gteVY0) + (gteL13 * gteVZ0)) >> 12;
 561         gteMAC2 = ((s64)(gteL21 * gteVX0) + (gteL22 * gteVY0) + (gteL23 * gteVZ0)) >> 12;
 562         gteMAC3 = ((s64)(gteL31 * gteVX0) + (gteL32 * gteVY0) + (gteL33 * gteVZ0)) >> 12;
 563         gteIR1 = limB1(gteMAC1, 1);
 564         gteIR2 = limB2(gteMAC2, 1);
 565         gteIR3 = limB3(gteMAC3, 1);
 566         gteMAC1 = A1((((s64)gteRBK << 12) + (gteLR1 * gteIR1) + (gteLR2 * gteIR2) + (gteLR3 * gteIR3)) >> 12);
 567         gteMAC2 = A2((((s64)gteGBK << 12) + (gteLG1 * gteIR1) + (gteLG2 * gteIR2) + (gteLG3 * gteIR3)) >> 12);
 568         gteMAC3 = A3((((s64)gteBBK << 12) + (gteLB1 * gteIR1) + (gteLB2 * gteIR2) + (gteLB3 * gteIR3)) >> 12);
 569         gteIR1 = limB1(gteMAC1, 1);
 570         gteIR2 = limB2(gteMAC2, 1);
 571         gteIR3 = limB3(gteMAC3, 1);
 572         gteMAC1 = ((s32)gteR * gteIR1) >> 8;
 573         gteMAC2 = ((s32)gteG * gteIR2) >> 8;
 574         gteMAC3 = ((s32)gteB * gteIR3) >> 8;
 575         gteIR1 = gteMAC1;
 576         gteIR2 = gteMAC2;
 577         gteIR3 = gteMAC3;
 578
 579         gteRGB0 = gteRGB1;
 580         gteRGB1 = gteRGB2;
 581         gteCODE2 = gteCODE;
 582         gteR2 = limC1(gteMAC1 >> 4);
 583         gteG2 = limC2(gteMAC2 >> 4);
 584         gteB2 = limC3(gteMAC3 >> 4);
 585 }
 586
 587 void gteNCCT(psxCP2Regs *regs) {
 588         int v;
 589         s32 vx, vy, vz;
 590
 591 #ifdef GTE_LOG
 592         GTE_LOG("GTE NCCT\n");
 593 #endif
 594         gteFLAG = 0;
 595
 596         for (v = 0; v < 3; v++) {
 597                 vx = VX(v);
 598                 vy = VY(v);
 599                 vz = VZ(v);
 600                 gteMAC1 = ((s64)(gteL11 * vx) + (gteL12 * vy) + (gteL13 * vz)) >> 12;
 601                 gteMAC2 = ((s64)(gteL21 * vx) + (gteL22 * vy) + (gteL23 * vz)) >> 12;
 602                 gteMAC3 = ((s64)(gteL31 * vx) + (gteL32 * vy) + (gteL33 * vz)) >> 12;
 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);
 612                 gteMAC1 = ((s32)gteR * gteIR1) >> 8;
 613                 gteMAC2 = ((s32)gteG * gteIR2) >> 8;
 614                 gteMAC3 = ((s32)gteB * gteIR3) >> 8;
 615
 616                 gteRGB0 = gteRGB1;
 617                 gteRGB1 = gteRGB2;
 618                 gteCODE2 = gteCODE;
 619                 gteR2 = limC1(gteMAC1 >> 4);
 620                 gteG2 = limC2(gteMAC2 >> 4);
 621                 gteB2 = limC3(gteMAC3 >> 4);
 622         }
 623         gteIR1 = gteMAC1;
 624         gteIR2 = gteMAC2;
 625         gteIR3 = gteMAC3;
 626 }
 627
 628 void gteNCDS(psxCP2Regs *regs) {
 629 #ifdef GTE_LOG
 630         GTE_LOG("GTE NCDS\n");
 631 #endif
 632         gteFLAG = 0;
 633
 634         gteMAC1 = ((s64)(gteL11 * gteVX0) + (gteL12 * gteVY0) + (gteL13 * gteVZ0)) >> 12;
 635         gteMAC2 = ((s64)(gteL21 * gteVX0) + (gteL22 * gteVY0) + (gteL23 * gteVZ0)) >> 12;
 636         gteMAC3 = ((s64)(gteL31 * gteVX0) + (gteL32 * gteVY0) + (gteL33 * gteVZ0)) >> 12;
 637         gteIR1 = limB1(gteMAC1, 1);
 638         gteIR2 = limB2(gteMAC2, 1);
 639         gteIR3 = limB3(gteMAC3, 1);
 640         gteMAC1 = A1((((s64)gteRBK << 12) + (gteLR1 * gteIR1) + (gteLR2 * gteIR2) + (gteLR3 * gteIR3)) >> 12);
 641         gteMAC2 = A2((((s64)gteGBK << 12) + (gteLG1 * gteIR1) + (gteLG2 * gteIR2) + (gteLG3 * gteIR3)) >> 12);
 642         gteMAC3 = A3((((s64)gteBBK << 12) + (gteLB1 * gteIR1) + (gteLB2 * gteIR2) + (gteLB3 * gteIR3)) >> 12);
 643         gteIR1 = limB1(gteMAC1, 1);
 644         gteIR2 = limB2(gteMAC2, 1);
 645         gteIR3 = limB3(gteMAC3, 1);
 646         gteMAC1 = (((gteR << 4) * gteIR1) + (gteIR0 * limB1(A1U((s64)gteRFC - ((gteR * gteIR1) >> 8)), 0))) >> 12;
 647         gteMAC2 = (((gteG << 4) * gteIR2) + (gteIR0 * limB2(A2U((s64)gteGFC - ((gteG * gteIR2) >> 8)), 0))) >> 12;
 648         gteMAC3 = (((gteB << 4) * gteIR3) + (gteIR0 * limB3(A3U((s64)gteBFC - ((gteB * gteIR3) >> 8)), 0))) >> 12;
 649         gteIR1 = limB1(gteMAC1, 1);
 650         gteIR2 = limB2(gteMAC2, 1);
 651         gteIR3 = limB3(gteMAC3, 1);
 652
 653         gteRGB0 = gteRGB1;
 654         gteRGB1 = gteRGB2;
 655         gteCODE2 = gteCODE;
 656         gteR2 = limC1(gteMAC1 >> 4);
 657         gteG2 = limC2(gteMAC2 >> 4);
 658         gteB2 = limC3(gteMAC3 >> 4);
 659 }
 660
 661 void gteNCDT(psxCP2Regs *regs) {
 662         int v;
 663         s32 vx, vy, vz;
 664
 665 #ifdef GTE_LOG
 666         GTE_LOG("GTE NCDT\n");
 667 #endif
 668         gteFLAG = 0;
 669
 670         for (v = 0; v < 3; v++) {
 671                 vx = VX(v);
 672                 vy = VY(v);
 673                 vz = VZ(v);
 674                 gteMAC1 = ((s64)(gteL11 * vx) + (gteL12 * vy) + (gteL13 * vz)) >> 12;
 675                 gteMAC2 = ((s64)(gteL21 * vx) + (gteL22 * vy) + (gteL23 * vz)) >> 12;
 676                 gteMAC3 = ((s64)(gteL31 * vx) + (gteL32 * vy) + (gteL33 * vz)) >> 12;
 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);
 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;
 689
 690                 gteRGB0 = gteRGB1;
 691                 gteRGB1 = gteRGB2;
 692                 gteCODE2 = gteCODE;
 693                 gteR2 = limC1(gteMAC1 >> 4);
 694                 gteG2 = limC2(gteMAC2 >> 4);
 695                 gteB2 = limC3(gteMAC3 >> 4);
 696         }
 697         gteIR1 = limB1(gteMAC1, 1);
 698         gteIR2 = limB2(gteMAC2, 1);
 699         gteIR3 = limB3(gteMAC3, 1);
 700 }
 701
 702 void gteOP(psxCP2Regs *regs) {
 703         int shift = 12 * GTE_SF(gteop);
 704         int lm = GTE_LM(gteop);
 705
 706 #ifdef GTE_LOG
 707         GTE_LOG("GTE OP\n");
 708 #endif
 709         gteFLAG = 0;
 710
 711         gteMAC1 = ((gteR22 * gteIR3) - (gteR33 * gteIR2)) >> shift;
 712         gteMAC2 = ((gteR33 * gteIR1) - (gteR11 * gteIR3)) >> shift;
 713         gteMAC3 = ((gteR11 * gteIR2) - (gteR22 * gteIR1)) >> shift;
 714         gteIR1 = limB1(gteMAC1, lm);
 715         gteIR2 = limB2(gteMAC2, lm);
 716         gteIR3 = limB3(gteMAC3, lm);
 717 }
 718
 719 void gteDCPL(psxCP2Regs *regs) {
 720         int lm = GTE_LM(gteop);
 721
 722         s32 RIR1 = ((s32)gteR * gteIR1) >> 8;
 723         s32 GIR2 = ((s32)gteG * gteIR2) >> 8;
 724         s32 BIR3 = ((s32)gteB * gteIR3) >> 8;
 725
 726 #ifdef GTE_LOG
 727         GTE_LOG("GTE DCPL\n");
 728 #endif
 729         gteFLAG = 0;
 730
 731         gteMAC1 = RIR1 + ((gteIR0 * limB1(A1U((s64)gteRFC - RIR1), 0)) >> 12);
 732         gteMAC2 = GIR2 + ((gteIR0 * limB1(A2U((s64)gteGFC - GIR2), 0)) >> 12);
 733         gteMAC3 = BIR3 + ((gteIR0 * limB1(A3U((s64)gteBFC - BIR3), 0)) >> 12);
 734
 735         gteIR1 = limB1(gteMAC1, lm);
 736         gteIR2 = limB2(gteMAC2, lm);
 737         gteIR3 = limB3(gteMAC3, lm);
 738
 739         gteRGB0 = gteRGB1;
 740         gteRGB1 = gteRGB2;
 741         gteCODE2 = gteCODE;
 742         gteR2 = limC1(gteMAC1 >> 4);
 743         gteG2 = limC2(gteMAC2 >> 4);
 744         gteB2 = limC3(gteMAC3 >> 4);
 745 }
 746
 747 void gteGPF(psxCP2Regs *regs) {
 748         int shift = 12 * GTE_SF(gteop);
 749
 750 #ifdef GTE_LOG
 751         GTE_LOG("GTE GPF\n");
 752 #endif
 753         gteFLAG = 0;
 754
 755         gteMAC1 = (gteIR0 * gteIR1) >> shift;
 756         gteMAC2 = (gteIR0 * gteIR2) >> shift;
 757         gteMAC3 = (gteIR0 * gteIR3) >> shift;
 758         gteIR1 = limB1(gteMAC1, 0);
 759         gteIR2 = limB2(gteMAC2, 0);
 760         gteIR3 = limB3(gteMAC3, 0);
 761
 762         gteRGB0 = gteRGB1;
 763         gteRGB1 = gteRGB2;
 764         gteCODE2 = gteCODE;
 765         gteR2 = limC1(gteMAC1 >> 4);
 766         gteG2 = limC2(gteMAC2 >> 4);
 767         gteB2 = limC3(gteMAC3 >> 4);
 768 }
 769
 770 void gteGPL(psxCP2Regs *regs) {
 771         int shift = 12 * GTE_SF(gteop);
 772
 773 #ifdef GTE_LOG
 774         GTE_LOG("GTE GPL\n");
 775 #endif
 776         gteFLAG = 0;
 777
 778         gteMAC1 = A1((((s64)gteMAC1 << shift) + (gteIR0 * gteIR1)) >> shift);
 779         gteMAC2 = A2((((s64)gteMAC2 << shift) + (gteIR0 * gteIR2)) >> shift);
 780         gteMAC3 = A3((((s64)gteMAC3 << shift) + (gteIR0 * gteIR3)) >> shift);
 781         gteIR1 = limB1(gteMAC1, 0);
 782         gteIR2 = limB2(gteMAC2, 0);
 783         gteIR3 = limB3(gteMAC3, 0);
 784
 785         gteRGB0 = gteRGB1;
 786         gteRGB1 = gteRGB2;
 787         gteCODE2 = gteCODE;
 788         gteR2 = limC1(gteMAC1 >> 4);
 789         gteG2 = limC2(gteMAC2 >> 4);
 790         gteB2 = limC3(gteMAC3 >> 4);
 791 }
 792
 793 void gteDPCS(psxCP2Regs *regs) {
 794         int shift = 12 * GTE_SF(gteop);
 795
 796 #ifdef GTE_LOG
 797         GTE_LOG("GTE DPCS\n");
 798 #endif
 799         gteFLAG = 0;
 800
 801         gteMAC1 = ((gteR << 16) + (gteIR0 * limB1(A1U(((s64)gteRFC - (gteR << 4)) << (12 - shift)), 0))) >> 12;
 802         gteMAC2 = ((gteG << 16) + (gteIR0 * limB2(A2U(((s64)gteGFC - (gteG << 4)) << (12 - shift)), 0))) >> 12;
 803         gteMAC3 = ((gteB << 16) + (gteIR0 * limB3(A3U(((s64)gteBFC - (gteB << 4)) << (12 - shift)), 0))) >> 12;
 804
 805         gteIR1 = limB1(gteMAC1, 0);
 806         gteIR2 = limB2(gteMAC2, 0);
 807         gteIR3 = limB3(gteMAC3, 0);
 808         gteRGB0 = gteRGB1;
 809         gteRGB1 = gteRGB2;
 810         gteCODE2 = gteCODE;
 811         gteR2 = limC1(gteMAC1 >> 4);
 812         gteG2 = limC2(gteMAC2 >> 4);
 813         gteB2 = limC3(gteMAC3 >> 4);
 814 }
 815
 816 void gteDPCT(psxCP2Regs *regs) {
 817         int v;
 818
 819 #ifdef GTE_LOG
 820         GTE_LOG("GTE DPCT\n");
 821 #endif
 822         gteFLAG = 0;
 823
 824         for (v = 0; v < 3; v++) {
 825                 gteMAC1 = ((gteR0 << 16) + (gteIR0 * limB1(A1U((s64)gteRFC - (gteR0 << 4)), 0))) >> 12;
 826                 gteMAC2 = ((gteG0 << 16) + (gteIR0 * limB1(A2U((s64)gteGFC - (gteG0 << 4)), 0))) >> 12;
 827                 gteMAC3 = ((gteB0 << 16) + (gteIR0 * limB1(A3U((s64)gteBFC - (gteB0 << 4)), 0))) >> 12;
 828
 829                 gteRGB0 = gteRGB1;
 830                 gteRGB1 = gteRGB2;
 831                 gteCODE2 = gteCODE;
 832                 gteR2 = limC1(gteMAC1 >> 4);
 833                 gteG2 = limC2(gteMAC2 >> 4);
 834                 gteB2 = limC3(gteMAC3 >> 4);
 835         }
 836         gteIR1 = limB1(gteMAC1, 0);
 837         gteIR2 = limB2(gteMAC2, 0);
 838         gteIR3 = limB3(gteMAC3, 0);
 839 }
 840
 841 void gteNCS(psxCP2Regs *regs) {
 842 #ifdef GTE_LOG
 843         GTE_LOG("GTE NCS\n");
 844 #endif
 845         gteFLAG = 0;
 846
 847         gteMAC1 = ((s64)(gteL11 * gteVX0) + (gteL12 * gteVY0) + (gteL13 * gteVZ0)) >> 12;
 848         gteMAC2 = ((s64)(gteL21 * gteVX0) + (gteL22 * gteVY0) + (gteL23 * gteVZ0)) >> 12;
 849         gteMAC3 = ((s64)(gteL31 * gteVX0) + (gteL32 * gteVY0) + (gteL33 * gteVZ0)) >> 12;
 850         gteIR1 = limB1(gteMAC1, 1);
 851         gteIR2 = limB2(gteMAC2, 1);
 852         gteIR3 = limB3(gteMAC3, 1);
 853         gteMAC1 = A1((((s64)gteRBK << 12) + (gteLR1 * gteIR1) + (gteLR2 * gteIR2) + (gteLR3 * gteIR3)) >> 12);
 854         gteMAC2 = A2((((s64)gteGBK << 12) + (gteLG1 * gteIR1) + (gteLG2 * gteIR2) + (gteLG3 * gteIR3)) >> 12);
 855         gteMAC3 = A3((((s64)gteBBK << 12) + (gteLB1 * gteIR1) + (gteLB2 * gteIR2) + (gteLB3 * gteIR3)) >> 12);
 856         gteIR1 = limB1(gteMAC1, 1);
 857         gteIR2 = limB2(gteMAC2, 1);
 858         gteIR3 = limB3(gteMAC3, 1);
 859
 860         gteRGB0 = gteRGB1;
 861         gteRGB1 = gteRGB2;
 862         gteCODE2 = gteCODE;
 863         gteR2 = limC1(gteMAC1 >> 4);
 864         gteG2 = limC2(gteMAC2 >> 4);
 865         gteB2 = limC3(gteMAC3 >> 4);
 866 }
 867
 868 void gteNCT(psxCP2Regs *regs) {
 869         int v;
 870         s32 vx, vy, vz;
 871
 872 #ifdef GTE_LOG
 873         GTE_LOG("GTE NCT\n");
 874 #endif
 875         gteFLAG = 0;
 876
 877         for (v = 0; v < 3; v++) {
 878                 vx = VX(v);
 879                 vy = VY(v);
 880                 vz = VZ(v);
 881                 gteMAC1 = ((s64)(gteL11 * vx) + (gteL12 * vy) + (gteL13 * vz)) >> 12;
 882                 gteMAC2 = ((s64)(gteL21 * vx) + (gteL22 * vy) + (gteL23 * vz)) >> 12;
 883                 gteMAC3 = ((s64)(gteL31 * vx) + (gteL32 * vy) + (gteL33 * vz)) >> 12;
 884                 gteIR1 = limB1(gteMAC1, 1);
 885                 gteIR2 = limB2(gteMAC2, 1);
 886                 gteIR3 = limB3(gteMAC3, 1);
 887                 gteMAC1 = A1((((s64)gteRBK << 12) + (gteLR1 * gteIR1) + (gteLR2 * gteIR2) + (gteLR3 * gteIR3)) >> 12);
 888                 gteMAC2 = A2((((s64)gteGBK << 12) + (gteLG1 * gteIR1) + (gteLG2 * gteIR2) + (gteLG3 * gteIR3)) >> 12);
 889                 gteMAC3 = A3((((s64)gteBBK << 12) + (gteLB1 * gteIR1) + (gteLB2 * gteIR2) + (gteLB3 * gteIR3)) >> 12);
 890                 gteRGB0 = gteRGB1;
 891                 gteRGB1 = gteRGB2;
 892                 gteCODE2 = gteCODE;
 893                 gteR2 = limC1(gteMAC1 >> 4);
 894                 gteG2 = limC2(gteMAC2 >> 4);
 895                 gteB2 = limC3(gteMAC3 >> 4);
 896         }
 897         gteIR1 = limB1(gteMAC1, 1);
 898         gteIR2 = limB2(gteMAC2, 1);
 899         gteIR3 = limB3(gteMAC3, 1);
 900 }
 901
 902 void gteCC(psxCP2Regs *regs) {
 903 #ifdef GTE_LOG
 904         GTE_LOG("GTE CC\n");
 905 #endif
 906         gteFLAG = 0;
 907
 908         gteMAC1 = A1((((s64)gteRBK << 12) + (gteLR1 * gteIR1) + (gteLR2 * gteIR2) + (gteLR3 * gteIR3)) >> 12);
 909         gteMAC2 = A2((((s64)gteGBK << 12) + (gteLG1 * gteIR1) + (gteLG2 * gteIR2) + (gteLG3 * gteIR3)) >> 12);
 910         gteMAC3 = A3((((s64)gteBBK << 12) + (gteLB1 * gteIR1) + (gteLB2 * gteIR2) + (gteLB3 * gteIR3)) >> 12);
 911         gteIR1 = limB1(gteMAC1, 1);
 912         gteIR2 = limB2(gteMAC2, 1);
 913         gteIR3 = limB3(gteMAC3, 1);
 914         gteMAC1 = ((s32)gteR * gteIR1) >> 8;
 915         gteMAC2 = ((s32)gteG * gteIR2) >> 8;
 916         gteMAC3 = ((s32)gteB * gteIR3) >> 8;
 917         gteIR1 = limB1(gteMAC1, 1);
 918         gteIR2 = limB2(gteMAC2, 1);
 919         gteIR3 = limB3(gteMAC3, 1);
 920
 921         gteRGB0 = gteRGB1;
 922         gteRGB1 = gteRGB2;
 923         gteCODE2 = gteCODE;
 924         gteR2 = limC1(gteMAC1 >> 4);
 925         gteG2 = limC2(gteMAC2 >> 4);
 926         gteB2 = limC3(gteMAC3 >> 4);
 927 }
 928
 929 void gteINTPL(psxCP2Regs *regs) {
 930         int shift = 12 * GTE_SF(gteop);
 931         int lm = GTE_LM(gteop);
 932
 933 #ifdef GTE_LOG
 934         GTE_LOG("GTE INTPL\n");
 935 #endif
 936         gteFLAG = 0;
 937
 938         gteMAC1 = ((gteIR1 << 12) + (gteIR0 * limB1(A1U((s64)gteRFC - gteIR1), 0))) >> shift;
 939         gteMAC2 = ((gteIR2 << 12) + (gteIR0 * limB2(A2U((s64)gteGFC - gteIR2), 0))) >> shift;
 940         gteMAC3 = ((gteIR3 << 12) + (gteIR0 * limB3(A3U((s64)gteBFC - gteIR3), 0))) >> shift;
 941         gteIR1 = limB1(gteMAC1, lm);
 942         gteIR2 = limB2(gteMAC2, lm);
 943         gteIR3 = limB3(gteMAC3, lm);
 944         gteRGB0 = gteRGB1;
 945         gteRGB1 = gteRGB2;
 946         gteCODE2 = gteCODE;
 947         gteR2 = limC1(gteMAC1 >> 4);
 948         gteG2 = limC2(gteMAC2 >> 4);
 949         gteB2 = limC3(gteMAC3 >> 4);
 950 }
 951
 952 void gteCDP(psxCP2Regs *regs) {
 953 #ifdef GTE_LOG
 954         GTE_LOG("GTE CDP\n");
 955 #endif
 956         gteFLAG = 0;
 957
 958         gteMAC1 = A1((((s64)gteRBK << 12) + (gteLR1 * gteIR1) + (gteLR2 * gteIR2) + (gteLR3 * gteIR3)) >> 12);
 959         gteMAC2 = A2((((s64)gteGBK << 12) + (gteLG1 * gteIR1) + (gteLG2 * gteIR2) + (gteLG3 * gteIR3)) >> 12);
 960         gteMAC3 = A3((((s64)gteBBK << 12) + (gteLB1 * gteIR1) + (gteLB2 * gteIR2) + (gteLB3 * gteIR3)) >> 12);
 961         gteIR1 = limB1(gteMAC1, 1);
 962         gteIR2 = limB2(gteMAC2, 1);
 963         gteIR3 = limB3(gteMAC3, 1);
 964         gteMAC1 = (((gteR << 4) * gteIR1) + (gteIR0 * limB1(A1U((s64)gteRFC - ((gteR * gteIR1) >> 8)), 0))) >> 12;
 965         gteMAC2 = (((gteG << 4) * gteIR2) + (gteIR0 * limB2(A2U((s64)gteGFC - ((gteG * gteIR2) >> 8)), 0))) >> 12;
 966         gteMAC3 = (((gteB << 4) * gteIR3) + (gteIR0 * limB3(A3U((s64)gteBFC - ((gteB * gteIR3) >> 8)), 0))) >> 12;
 967         gteIR1 = limB1(gteMAC1, 1);
 968         gteIR2 = limB2(gteMAC2, 1);
 969         gteIR3 = limB3(gteMAC3, 1);
 970
 971         gteRGB0 = gteRGB1;
 972         gteRGB1 = gteRGB2;
 973         gteCODE2 = gteCODE;
 974         gteR2 = limC1(gteMAC1 >> 4);
 975         gteG2 = limC2(gteMAC2 >> 4);
 976         gteB2 = limC3(gteMAC3 >> 4);
 977 }
 978
 979 /* decomposed/parametrized versions for the recompiler */
 980
 981 #ifndef FLAGLESS
 982
 983 void gteSQR_part_noshift(psxCP2Regs *regs) {
 984         gteFLAG = 0;
 985
 986         gteMAC1 = gteIR1 * gteIR1;
 987         gteMAC2 = gteIR2 * gteIR2;
 988         gteMAC3 = gteIR3 * gteIR3;
 989 }
 990
 991 void gteSQR_part_shift(psxCP2Regs *regs) {
 992         gteFLAG = 0;
 993
 994         gteMAC1 = (gteIR1 * gteIR1) >> 12;
 995         gteMAC2 = (gteIR2 * gteIR2) >> 12;
 996         gteMAC3 = (gteIR3 * gteIR3) >> 12;
 997 }
 998
 999 void gteOP_part_noshift(psxCP2Regs *regs) {
1000         gteFLAG = 0;
1001
1002         gteMAC1 = (gteR22 * gteIR3) - (gteR33 * gteIR2);
1003         gteMAC2 = (gteR33 * gteIR1) - (gteR11 * gteIR3);
1004         gteMAC3 = (gteR11 * gteIR2) - (gteR22 * gteIR1);
1005 }
1006
1007 void gteOP_part_shift(psxCP2Regs *regs) {
1008         gteFLAG = 0;
1009
1010         gteMAC1 = ((gteR22 * gteIR3) - (gteR33 * gteIR2)) >> 12;
1011         gteMAC2 = ((gteR33 * gteIR1) - (gteR11 * gteIR3)) >> 12;
1012         gteMAC3 = ((gteR11 * gteIR2) - (gteR22 * gteIR1)) >> 12;
1013 }
1014
1015 void gteDCPL_part(psxCP2Regs *regs) {
1016         s32 RIR1 = ((s32)gteR * gteIR1) >> 8;
1017         s32 GIR2 = ((s32)gteG * gteIR2) >> 8;
1018         s32 BIR3 = ((s32)gteB * gteIR3) >> 8;
1019
1020         gteFLAG = 0;
1021
1022         gteMAC1 = RIR1 + ((gteIR0 * limB1(A1U((s64)gteRFC - RIR1), 0)) >> 12);
1023         gteMAC2 = GIR2 + ((gteIR0 * limB1(A2U((s64)gteGFC - GIR2), 0)) >> 12);
1024         gteMAC3 = BIR3 + ((gteIR0 * limB1(A3U((s64)gteBFC - BIR3), 0)) >> 12);
1025 }
1026
1027 void gteGPF_part_noshift(psxCP2Regs *regs) {
1028         gteFLAG = 0;
1029
1030         gteMAC1 = gteIR0 * gteIR1;
1031         gteMAC2 = gteIR0 * gteIR2;
1032         gteMAC3 = gteIR0 * gteIR3;
1033 }
1034
1035 void gteGPF_part_shift(psxCP2Regs *regs) {
1036         gteFLAG = 0;
1037
1038         gteMAC1 = (gteIR0 * gteIR1) >> 12;
1039         gteMAC2 = (gteIR0 * gteIR2) >> 12;
1040         gteMAC3 = (gteIR0 * gteIR3) >> 12;
1041 }
1042
1043 #endif // !FLAGLESS
1044
1045 void gteGPL_part_noshift(psxCP2Regs *regs) {
1046         gteFLAG = 0;
1047
1048         gteMAC1 = A1((s64)gteMAC1 + (gteIR0 * gteIR1));
1049         gteMAC2 = A2((s64)gteMAC2 + (gteIR0 * gteIR2));
1050         gteMAC3 = A3((s64)gteMAC3 + (gteIR0 * gteIR3));
1051 }
1052
1053 void gteGPL_part_shift(psxCP2Regs *regs) {
1054         gteFLAG = 0;
1055
1056         gteMAC1 = A1((s64)gteMAC1 + ((gteIR0 * gteIR1) >> 12));
1057         gteMAC2 = A2((s64)gteMAC2 + ((gteIR0 * gteIR2) >> 12));
1058         gteMAC3 = A3((s64)gteMAC3 + ((gteIR0 * gteIR3) >> 12));
1059 }
1060
1061 void gteDPCS_part_noshift(psxCP2Regs *regs) {
1062         int shift = 0;
1063
1064         gteFLAG = 0;
1065
1066         gteMAC1 = ((gteR << 16) + (gteIR0 * limB1(A1U((s64)gteRFC - (gteR << 4)) << (12 - shift), 0))) >> 12;
1067         gteMAC2 = ((gteG << 16) + (gteIR0 * limB2(A2U((s64)gteGFC - (gteG << 4)) << (12 - shift), 0))) >> 12;
1068         gteMAC3 = ((gteB << 16) + (gteIR0 * limB3(A3U((s64)gteBFC - (gteB << 4)) << (12 - shift), 0))) >> 12;
1069 }
1070
1071 void gteDPCS_part_shift(psxCP2Regs *regs) {
1072         int shift = 12;
1073
1074         gteFLAG = 0;
1075
1076         gteMAC1 = ((gteR << 16) + (gteIR0 * limB1(A1U((s64)gteRFC - (gteR << 4)) << (12 - shift), 0))) >> 12;
1077         gteMAC2 = ((gteG << 16) + (gteIR0 * limB2(A2U((s64)gteGFC - (gteG << 4)) << (12 - shift), 0))) >> 12;
1078         gteMAC3 = ((gteB << 16) + (gteIR0 * limB3(A3U((s64)gteBFC - (gteB << 4)) << (12 - shift), 0))) >> 12;
1079 }
1080
1081 void gteINTPL_part_noshift(psxCP2Regs *regs) {
1082         gteFLAG = 0;
1083
1084         gteMAC1 = ((gteIR1 << 12) + (gteIR0 * limB1(A1U((s64)gteRFC - gteIR1), 0)));
1085         gteMAC2 = ((gteIR2 << 12) + (gteIR0 * limB2(A2U((s64)gteGFC - gteIR2), 0)));
1086         gteMAC3 = ((gteIR3 << 12) + (gteIR0 * limB3(A3U((s64)gteBFC - gteIR3), 0)));
1087 }
1088
1089 void gteINTPL_part_shift(psxCP2Regs *regs) {
1090         gteFLAG = 0;
1091
1092         gteMAC1 = ((gteIR1 << 12) + (gteIR0 * limB1(A1U((s64)gteRFC - gteIR1), 0))) >> 12;
1093         gteMAC2 = ((gteIR2 << 12) + (gteIR0 * limB2(A2U((s64)gteGFC - gteIR2), 0))) >> 12;
1094         gteMAC3 = ((gteIR3 << 12) + (gteIR0 * limB3(A3U((s64)gteBFC - gteIR3), 0))) >> 12;
1095 }
1096
1097 void gteMACtoRGB(psxCP2Regs *regs) {
1098         gteRGB0 = gteRGB1;
1099         gteRGB1 = gteRGB2;
1100         gteCODE2 = gteCODE;
1101         gteR2 = limC1(gteMAC1 >> 4);
1102         gteG2 = limC2(gteMAC2 >> 4);
1103         gteB2 = limC3(gteMAC3 >> 4);
1104 }
1105