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