Shamusworld >> Repos - virtualjaguar/blob - src/include/mamegpu.h

   1 #define ZFLAG                           0x00001\r
   2 #define CFLAG                           0x00002\r
   3 #define NFLAG                           0x00004\r
   4 #define IFLAG                           0x00008\r
   5 static UINT8 *          condition_table=0;\r
   6 \r
   7 #define CONDITION(x)    condition_table[(x) + ((jaguar_FLAGS & 7) << 5)]\r
   8 static UINT16 *         mirror_table;\r
   9 \r
  10 \r
  11 \r
  12 \r
  13 /*###################################################################################################\r
  14 **      MEMORY ACCESSORS\r
  15 **#################################################################################################*/\r
  16 \r
  17 #define ROPCODE(pc)             (gpu_word_read(pc))\r
  18 uint16 jaguar_ppc;\r
  19 uint16 jaguar_op;\r
  20 int32 jaguar_icount;\r
  21 static const UINT32 convert_zero[32] =\r
  22 { 32,1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,17,18,19,20,21,22,23,24,25,26,27,28,29,30,31 };\r
  23 \r
  24 static uint32 cnt_opcode=0;\r
  25 int jaguargpu_execute(int cycles)\r
  26 {\r
  27         int i,j;\r
  28         /* allocate the mirror table */\r
  29         if (!mirror_table)\r
  30         {\r
  31                 mirror_table = (UINT16*)malloc(65536 * sizeof(mirror_table[0]));\r
  32 \r
  33                 /* fill in the mirror table */\r
  34                 if (mirror_table)\r
  35                         for (i = 0; i < 65536; i++)\r
  36                                 mirror_table[i] = ((i >> 15) & 0x0001) | ((i >> 13) & 0x0002) |\r
  37                                                                   ((i >> 11) & 0x0004) | ((i >> 9)  & 0x0008) |\r
  38                                                                   ((i >> 7)  & 0x0010) | ((i >> 5)  & 0x0020) |\r
  39                                                                   ((i >> 3)  & 0x0040) | ((i >> 1)  & 0x0080) |\r
  40                                                                   ((i << 1)  & 0x0100) | ((i << 3)  & 0x0200) |\r
  41                                                                   ((i << 5)  & 0x0400) | ((i << 7)  & 0x0800) |\r
  42                                                                   ((i << 9)  & 0x1000) | ((i << 11) & 0x2000) |\r
  43                                                                   ((i << 13) & 0x4000) | ((i << 15) & 0x8000);\r
  44         }\r
  45         \r
  46         if (!condition_table)\r
  47         {\r
  48                 condition_table = (uint8*)malloc(32 * 8 * sizeof(condition_table[0]));\r
  49 \r
  50                 /* fill in the condition table */\r
  51                 if (condition_table)\r
  52                         for (i = 0; i < 8; i++)\r
  53                                 for (j = 0; j < 32; j++)\r
  54                                 {\r
  55                                         int result = 1;\r
  56                                         if (j & 1)\r
  57                                                 if (i & ZFLAG) result = 0;\r
  58                                         if (j & 2)\r
  59                                                 if (!(i & ZFLAG)) result = 0;\r
  60                                         if (j & 4)\r
  61                                                 if (i & (CFLAG << (j >> 4))) result = 0;\r
  62                                         if (j & 8)\r
  63                                                 if (!(i & (CFLAG << (j >> 4)))) result = 0;\r
  64                                         condition_table[i * 32 + j] = result;\r
  65                                 }\r
  66         }\r
  67         /* if we're halted, we shouldn't be here */\r
  68         if (!gpu_running)\r
  69         {\r
  70                 return cycles;\r
  71         }\r
  72         jaguar_icount=cycles;\r
  73 \r
  74         do\r
  75         {\r
  76                 gpu_flag_c=(gpu_flag_c?1:0);\r
  77                 gpu_flag_z=(gpu_flag_z?1:0);\r
  78                 gpu_flag_n=(gpu_flag_n?1:0);\r
  79 \r
  80 //              fprintf(log_get(),"%i 0x%.8x [%i %i %i]\n",cnt_opcode++,gpu_pc,gpu_flag_c,gpu_flag_z,gpu_flag_n);\r
  81                 jaguar_ppc = gpu_pc;\r
  82 \r
  83                 /* instruction fetch */\r
  84                 jaguar_op = ROPCODE(gpu_pc);\r
  85                 gpu_pc += 2;\r
  86 \r
  87                 /* parse the instruction */\r
  88                 (*gpu_op_table[jaguar_op >> 10])();\r
  89                 jaguar_icount--;\r
  90 \r
  91         } while ((jaguar_icount > 0)&&(gpu_running));\r
  92 \r
  93         return cycles - jaguar_icount;\r
  94 }\r
  95 /*###################################################################################################\r
  96 **      OPCODES\r
  97 **#################################################################################################*/\r
  98 \r
  99 void abs_rn(void)\r
 100 {\r
 101         int dreg = jaguar_op & 31;\r
 102         UINT32 res = gpu_reg[dreg];\r
 103         CLR_ZNC;\r
 104         if (res & 0x80000000)\r
 105         {\r
 106                 gpu_reg[dreg] = res = -res;\r
 107                 SET_C\r
 108         }\r
 109         SET_Z(res);\r
 110 }\r
 111 \r
 112 void add_rn_rn(void)\r
 113 {\r
 114         int dreg = jaguar_op & 31;\r
 115         UINT32 r1 = gpu_reg[(jaguar_op >> 5) & 31];\r
 116         UINT32 r2 = gpu_reg[dreg];\r
 117         UINT32 res = r2 + r1;\r
 118         gpu_reg[dreg] = res;\r
 119         CLR_ZNC; SET_ZNC_ADD(r2,r1,res);\r
 120 }\r
 121 \r
 122 void addc_rn_rn(void)\r
 123 {\r
 124         int dreg = jaguar_op & 31;\r
 125         UINT32 r1 = gpu_reg[(jaguar_op >> 5) & 31];\r
 126         UINT32 r2 = gpu_reg[dreg];\r
 127         UINT32 res = r2 + r1 + gpu_flag_c;\r
 128         gpu_reg[dreg] = res;\r
 129         CLR_ZNC; SET_ZNC_ADD(r2,r1,res);\r
 130 }\r
 131 \r
 132 void addq_n_rn(void)\r
 133 {\r
 134         int dreg = jaguar_op & 31;\r
 135         UINT32 r1 = convert_zero[(jaguar_op >> 5) & 31];\r
 136         UINT32 r2 = gpu_reg[dreg];\r
 137         UINT32 res = r2 + r1;\r
 138         gpu_reg[dreg] = res;\r
 139         CLR_ZNC; SET_ZNC_ADD(r2,r1,res);\r
 140 }\r
 141 \r
 142 void addqmod_n_rn(void) /* DSP only */\r
 143 {\r
 144         int dreg = jaguar_op & 31;\r
 145         UINT32 r1 = convert_zero[(jaguar_op >> 5) & 31];\r
 146         UINT32 r2 = gpu_reg[dreg];\r
 147         UINT32 res = r2 + r1;\r
 148         res = (res & ~gpu_hidata) | (r2 & ~gpu_hidata);\r
 149         gpu_reg[dreg] = res;\r
 150         CLR_ZNC; SET_ZNC_ADD(r2,r1,res);\r
 151 }\r
 152 \r
 153 void addqt_n_rn(void)\r
 154 {\r
 155         int dreg = jaguar_op & 31;\r
 156         UINT32 r1 = convert_zero[(jaguar_op >> 5) & 31];\r
 157         UINT32 r2 = gpu_reg[dreg];\r
 158         UINT32 res = r2 + r1;\r
 159         gpu_reg[dreg] = res;\r
 160 }\r
 161 \r
 162 void and_rn_rn(void)\r
 163 {\r
 164         int dreg = jaguar_op & 31;\r
 165         UINT32 r1 = gpu_reg[(jaguar_op >> 5) & 31];\r
 166         UINT32 r2 = gpu_reg[dreg];\r
 167         UINT32 res = r2 & r1;\r
 168         gpu_reg[dreg] = res;\r
 169         CLR_ZN; SET_ZN(res);\r
 170 }\r
 171 \r
 172 void bclr_n_rn(void)\r
 173 {\r
 174         int dreg = jaguar_op & 31;\r
 175         UINT32 r1 = (jaguar_op >> 5) & 31;\r
 176         UINT32 r2 = gpu_reg[dreg];\r
 177         UINT32 res = r2 & ~(1 << r1);\r
 178         gpu_reg[dreg] = res;\r
 179         CLR_ZN; SET_ZN(res);\r
 180 }\r
 181 \r
 182 void bset_n_rn(void)\r
 183 {\r
 184         int dreg = jaguar_op & 31;\r
 185         UINT32 r1 = (jaguar_op >> 5) & 31;\r
 186         UINT32 r2 = gpu_reg[dreg];\r
 187         UINT32 res = r2 | (1 << r1);\r
 188         gpu_reg[dreg] = res;\r
 189         CLR_ZN; SET_ZN(res);\r
 190 }\r
 191 \r
 192 void btst_n_rn(void)\r
 193 {\r
 194         UINT32 r1 = (jaguar_op >> 5) & 31;\r
 195         UINT32 r2 = gpu_reg[jaguar_op & 31];\r
 196         CLR_Z; gpu_flag_z= (~r2 >> r1) & 1;\r
 197 }\r
 198 \r
 199 void cmp_rn_rn(void)\r
 200 {\r
 201         UINT32 r1 = gpu_reg[(jaguar_op >> 5) & 31];\r
 202         UINT32 r2 = gpu_reg[jaguar_op & 31];\r
 203         UINT32 res = r2 - r1;\r
 204         CLR_ZNC; SET_ZNC_SUB(r2,r1,res);\r
 205 }\r
 206 \r
 207 void cmpq_n_rn(void)\r
 208 {\r
 209         UINT32 r1 = (INT8)(jaguar_op >> 2) >> 3;\r
 210         UINT32 r2 = gpu_reg[jaguar_op & 31];\r
 211         UINT32 res = r2 - r1;\r
 212         CLR_ZNC; SET_ZNC_SUB(r2,r1,res);\r
 213 }\r
 214 \r
 215 void div_rn_rn(void)\r
 216 {\r
 217         int dreg = jaguar_op & 31;\r
 218         UINT32 r1 = gpu_reg[(jaguar_op >> 5) & 31];\r
 219         UINT32 r2 = gpu_reg[dreg];\r
 220         if (r1)\r
 221         {\r
 222                 if (gpu_div_control & 1)\r
 223                 {\r
 224                         gpu_reg[dreg] = ((UINT64)r2 << 16) / r1;\r
 225                         gpu_remain = ((UINT64)r2 << 16) % r1;\r
 226                 }\r
 227                 else\r
 228                 {\r
 229                         gpu_reg[dreg] = r2 / r1;\r
 230                         gpu_remain = r2 % r1;\r
 231                 }\r
 232         }\r
 233         else\r
 234                 gpu_reg[dreg] = 0xffffffff;\r
 235 }\r
 236 \r
 237 void illegal(void)\r
 238 {\r
 239 }\r
 240 \r
 241 void imacn_rn_rn(void)\r
 242 {\r
 243         UINT32 r1 = gpu_reg[(jaguar_op >> 5) & 31];\r
 244         UINT32 r2 = gpu_reg[jaguar_op & 31];\r
 245         gpu_acc += (INT64)((INT16)r1 * (INT16)r2);\r
 246 }\r
 247 \r
 248 void imult_rn_rn(void)\r
 249 {\r
 250         int dreg = jaguar_op & 31;\r
 251         UINT32 r1 = gpu_reg[(jaguar_op >> 5) & 31];\r
 252         UINT32 r2 = gpu_reg[dreg];\r
 253         UINT32 res = (INT16)r1 * (INT16)r2;\r
 254         gpu_reg[dreg] = res;\r
 255         CLR_ZN; SET_ZN(res);\r
 256 }\r
 257 \r
 258 void imultn_rn_rn(void)\r
 259 {\r
 260         int dreg = jaguar_op & 31;\r
 261         UINT32 r1 = gpu_reg[(jaguar_op >> 5) & 31];\r
 262         UINT32 r2 = gpu_reg[dreg];\r
 263         UINT32 res = (INT16)r1 * (INT16)r2;\r
 264         gpu_acc = (INT32)res;\r
 265         CLR_ZN; SET_ZN(res);\r
 266 \r
 267         jaguar_op = ROPCODE(gpu_pc);\r
 268         while ((jaguar_op >> 10) == 20)\r
 269         {\r
 270                 r1 = gpu_reg[(jaguar_op >> 5) & 31];\r
 271                 r2 = gpu_reg[jaguar_op & 31];\r
 272                 gpu_acc += (INT64)((INT16)r1 * (INT16)r2);\r
 273                 gpu_pc += 2;\r
 274                 jaguar_op = ROPCODE(gpu_pc);\r
 275         }\r
 276         if ((jaguar_op >> 10) == 19)\r
 277         {\r
 278                 gpu_pc += 2;\r
 279                 gpu_reg[jaguar_op & 31] = (UINT32)gpu_acc;\r
 280         }\r
 281 }\r
 282 \r
 283 void jr_cc_n(void)\r
 284 {\r
 285         UINT32 jaguar_FLAGS;\r
 286 \r
 287         gpu_flag_c?(gpu_flag_c=1):(gpu_flag_c=0);\r
 288         gpu_flag_z?(gpu_flag_z=1):(gpu_flag_z=0);\r
 289         gpu_flag_n?(gpu_flag_n=1):(gpu_flag_n=0);\r
 290 \r
 291         jaguar_FLAGS=(gpu_flag_n<<2)|(gpu_flag_c<<1)|gpu_flag_z;\r
 292 \r
 293         if (CONDITION(jaguar_op & 31))\r
 294         {\r
 295                 INT32 r1 = (INT8)((jaguar_op >> 2) & 0xf8) >> 2;\r
 296                 UINT32 newpc = gpu_pc + r1;\r
 297                 jaguar_op = ROPCODE(gpu_pc);\r
 298         //      fprintf(log_get(),"%i 0x%.8x [%i %i %i]\n",cnt_opcode++,gpu_pc,gpu_flag_c,gpu_flag_z,gpu_flag_n);\r
 299                 gpu_pc = newpc;\r
 300                 (*gpu_op_table[jaguar_op >> 10])();\r
 301 \r
 302                 jaguar_icount -= 3;     /* 3 wait states guaranteed */\r
 303         }\r
 304 }\r
 305 \r
 306 void jump_cc_rn(void)\r
 307 {\r
 308         UINT32 jaguar_FLAGS;\r
 309 \r
 310         gpu_flag_c?(gpu_flag_c=1):(gpu_flag_c=0);\r
 311         gpu_flag_z?(gpu_flag_z=1):(gpu_flag_z=0);\r
 312         gpu_flag_n?(gpu_flag_n=1):(gpu_flag_n=0);\r
 313 \r
 314         jaguar_FLAGS=(gpu_flag_n<<2)|(gpu_flag_c<<1)|gpu_flag_z;\r
 315         if (CONDITION(jaguar_op & 31))\r
 316         {\r
 317                 UINT8 reg = (jaguar_op >> 5) & 31;\r
 318 \r
 319                 /* special kludge for risky code in the cojag DSP interrupt handlers */\r
 320                 UINT32 newpc = /*(jaguar_icount == bankswitch_icount) ?*/ gpu_reg[reg];// : gpu_reg[reg];\r
 321                 jaguar_op = ROPCODE(gpu_pc);\r
 322         //      fprintf(log_get(),"%i 0x%.8x [%i %i %i]\n",cnt_opcode++,gpu_pc,gpu_flag_c,gpu_flag_z,gpu_flag_n);\r
 323                 gpu_pc = newpc;\r
 324                 (*gpu_op_table[jaguar_op >> 10])();\r
 325 \r
 326                 jaguar_icount -= 3;     /* 3 wait states guaranteed */\r
 327         }\r
 328 }\r
 329 \r
 330 void load_rn_rn(void)\r
 331 {\r
 332         UINT32 r1 = gpu_reg[(jaguar_op >> 5) & 31];\r
 333         gpu_reg[jaguar_op & 31] = gpu_long_read(r1);\r
 334 }\r
 335 \r
 336 void load_r14n_rn(void)\r
 337 {\r
 338         UINT32 r1 = convert_zero[(jaguar_op >> 5) & 31];\r
 339         gpu_reg[jaguar_op & 31] = gpu_long_read(gpu_reg[14] + 4 * r1);\r
 340 }\r
 341 \r
 342 void load_r15n_rn(void)\r
 343 {\r
 344         UINT32 r1 = convert_zero[(jaguar_op >> 5) & 31];\r
 345         gpu_reg[jaguar_op & 31] = gpu_long_read(gpu_reg[15] + 4 * r1);\r
 346 }\r
 347 \r
 348 void load_r14rn_rn(void)\r
 349 {\r
 350         UINT32 r1 = gpu_reg[(jaguar_op >> 5) & 31];\r
 351         gpu_reg[jaguar_op & 31] = gpu_long_read(gpu_reg[14] + r1);\r
 352 }\r
 353 \r
 354 void load_r15rn_rn(void)\r
 355 {\r
 356         UINT32 r1 = gpu_reg[(jaguar_op >> 5) & 31];\r
 357         gpu_reg[jaguar_op & 31] = gpu_long_read(gpu_reg[15] + r1);\r
 358 }\r
 359 \r
 360 void loadb_rn_rn(void)\r
 361 {\r
 362         UINT32 r1 = gpu_reg[(jaguar_op >> 5) & 31];\r
 363         gpu_reg[jaguar_op & 31] = gpu_byte_read(r1);\r
 364 }\r
 365 \r
 366 void loadw_rn_rn(void)\r
 367 {\r
 368         UINT32 r1 = gpu_reg[(jaguar_op >> 5) & 31];\r
 369         gpu_reg[jaguar_op & 31] = gpu_word_read(r1);\r
 370 }\r
 371 \r
 372 void loadp_rn_rn(void)  /* GPU only */\r
 373 {\r
 374         UINT32 r1 = gpu_reg[(jaguar_op >> 5) & 31];\r
 375         gpu_hidata = gpu_word_read(r1);\r
 376         gpu_reg[jaguar_op & 31] = gpu_word_read(r1+4);\r
 377 }\r
 378 \r
 379 void mirror_rn(void)    /* DSP only */\r
 380 {\r
 381         int dreg = jaguar_op & 31;\r
 382         UINT32 r1 = gpu_reg[dreg];\r
 383         UINT32 res = (mirror_table[r1 & 0xffff] << 16) | mirror_table[r1 >> 16];\r
 384         gpu_reg[dreg] = res;\r
 385         CLR_ZN; SET_ZN(res);\r
 386 }\r
 387 \r
 388 void mmult_rn_rn(void)\r
 389 {\r
 390         int count = gpu_matrix_control & 15, i;\r
 391         int sreg = (jaguar_op >> 5) & 31;\r
 392         int dreg = jaguar_op & 31;\r
 393         UINT32 addr = gpu_pointer_to_matrix;\r
 394         INT64 accum = 0;\r
 395         UINT32 res;\r
 396 \r
 397         if (!(gpu_matrix_control & 0x10))\r
 398         {\r
 399                 for (i = 0; i < count; i++)\r
 400                 {\r
 401                         accum += (INT16)(gpu_reg_bank_1[sreg + i/2] >> (16 * ((i & 1) ^ 1))) * (INT16)gpu_word_read(addr);\r
 402                         addr += 2;\r
 403                 }\r
 404         }\r
 405         else\r
 406         {\r
 407                 for (i = 0; i < count; i++)\r
 408                 {\r
 409                         accum += (INT16)(gpu_reg_bank_1[sreg + i/2] >> (16 * ((i & 1) ^ 1))) * (INT16)gpu_word_read(addr);\r
 410                         addr += 2 * count;\r
 411                 }\r
 412         }\r
 413         gpu_reg[dreg] = res = (UINT32)accum;\r
 414         CLR_ZN; SET_ZN(res);\r
 415 }\r
 416 \r
 417 void move_rn_rn(void)\r
 418 {\r
 419         gpu_reg[jaguar_op & 31] = gpu_reg[(jaguar_op >> 5) & 31];\r
 420 }\r
 421 \r
 422 void move_pc_rn(void)\r
 423 {\r
 424         gpu_reg[jaguar_op & 31] = jaguar_ppc;\r
 425 }\r
 426 \r
 427 void movefa_rn_rn(void)\r
 428 {\r
 429         gpu_reg[jaguar_op & 31] = gpu_alternate_reg[(jaguar_op >> 5) & 31];\r
 430 }\r
 431 \r
 432 void movei_n_rn(void)\r
 433 {\r
 434         UINT32 res = ROPCODE(gpu_pc) | (ROPCODE(gpu_pc + 2) << 16);\r
 435         gpu_pc += 4;\r
 436         gpu_reg[jaguar_op & 31] = res;\r
 437 }\r
 438 \r
 439 void moveq_n_rn(void)\r
 440 {\r
 441         gpu_reg[jaguar_op & 31] = (jaguar_op >> 5) & 31;\r
 442 }\r
 443 \r
 444 void moveta_rn_rn(void)\r
 445 {\r
 446         gpu_alternate_reg[jaguar_op & 31] = gpu_reg[(jaguar_op >> 5) & 31];\r
 447 }\r
 448 \r
 449 void mtoi_rn_rn(void)\r
 450 {\r
 451         UINT32 r1 = gpu_reg[(jaguar_op >> 5) & 31];\r
 452         gpu_reg[jaguar_op & 31] = (((INT32)r1 >> 8) & 0xff800000) | (r1 & 0x007fffff);\r
 453 }\r
 454 \r
 455 void mult_rn_rn(void)\r
 456 {\r
 457         int dreg = jaguar_op & 31;\r
 458         UINT32 r1 = gpu_reg[(jaguar_op >> 5) & 31];\r
 459         UINT32 r2 = gpu_reg[dreg];\r
 460         UINT32 res = (UINT16)r1 * (UINT16)r2;\r
 461         gpu_reg[dreg] = res;\r
 462         CLR_ZN; SET_ZN(res);\r
 463 }\r
 464 \r
 465 void neg_rn(void)\r
 466 {\r
 467         int dreg = jaguar_op & 31;\r
 468         UINT32 r2 = gpu_reg[dreg];\r
 469         UINT32 res = -r2;\r
 470         gpu_reg[dreg] = res;\r
 471         CLR_ZNC; SET_ZNC_SUB(0,r2,res);\r
 472 }\r
 473 \r
 474 void nop(void)\r
 475 {\r
 476 }\r
 477 \r
 478 void normi_rn_rn(void)\r
 479 {\r
 480         UINT32 r1 = gpu_reg[(jaguar_op >> 5) & 31];\r
 481         UINT32 res = 0;\r
 482         while ((r1 & 0xffc00000) == 0)\r
 483         {\r
 484                 r1 <<= 1;\r
 485                 res--;\r
 486         }\r
 487         while ((r1 & 0xff800000) != 0)\r
 488         {\r
 489                 r1 >>= 1;\r
 490                 res++;\r
 491         }\r
 492         gpu_reg[jaguar_op & 31] = res;\r
 493         CLR_ZN; SET_ZN(res);\r
 494 }\r
 495 \r
 496 void not_rn(void)\r
 497 {\r
 498         int dreg = jaguar_op & 31;\r
 499         UINT32 res = ~gpu_reg[dreg];\r
 500         gpu_reg[dreg] = res;\r
 501         CLR_ZN; SET_ZN(res);\r
 502 }\r
 503 \r
 504 void or_rn_rn(void)\r
 505 {\r
 506         int dreg = jaguar_op & 31;\r
 507         UINT32 r1 = gpu_reg[(jaguar_op >> 5) & 31];\r
 508         UINT32 r2 = gpu_reg[dreg];\r
 509         UINT32 res = r1 | r2;\r
 510         gpu_reg[dreg] = res;\r
 511         CLR_ZN; SET_ZN(res);\r
 512 }\r
 513 \r
 514 void pack_rn(void)              /* GPU only */\r
 515 {\r
 516         int dreg = jaguar_op & 31;\r
 517         UINT32 r1 = gpu_reg[(jaguar_op >> 5) & 31];\r
 518         UINT32 r2 = gpu_reg[dreg];\r
 519         UINT32 res;\r
 520         if (r1 == 0)    /* PACK */\r
 521                 res = ((r2 >> 10) & 0xf000) | ((r2 >> 5) & 0x0f00) | (r2 & 0xff);\r
 522         else                    /* UNPACK */\r
 523                 res = ((r2 & 0xf000) << 10) | ((r2 & 0x0f00) << 5) | (r2 & 0xff);\r
 524         gpu_reg[dreg] = res;\r
 525         CLR_ZN; SET_ZN(res);\r
 526 }\r
 527 \r
 528 void resmac_rn(void)\r
 529 {\r
 530         gpu_reg[jaguar_op & 31] = (UINT32)gpu_acc;\r
 531 }\r
 532 \r
 533 void ror_rn_rn(void)\r
 534 {\r
 535         int dreg = jaguar_op & 31;\r
 536         UINT32 r1 = gpu_reg[(jaguar_op >> 5) & 31] & 31;\r
 537         UINT32 r2 = gpu_reg[dreg];\r
 538         UINT32 res = (r2 >> r1) | (r2 << (32 - r1));\r
 539         gpu_reg[dreg] = res;\r
 540         CLR_ZNC; SET_ZN(res); gpu_flag_c = (r2 >> 30) & 2;\r
 541 }\r
 542 \r
 543 void rorq_n_rn(void)\r
 544 {\r
 545         int dreg = jaguar_op & 31;\r
 546         UINT32 r1 = convert_zero[(jaguar_op >> 5) & 31];\r
 547         UINT32 r2 = gpu_reg[dreg];\r
 548         UINT32 res = (r2 >> r1) | (r2 << (32 - r1));\r
 549         gpu_reg[dreg] = res;\r
 550         CLR_ZNC; SET_ZN(res); gpu_flag_c= (r2 >> 30) & 2;\r
 551 }\r
 552 \r
 553 void sat8_rn(void)              /* GPU only */\r
 554 {\r
 555         int dreg = jaguar_op & 31;\r
 556         INT32 r2 = gpu_reg[dreg];\r
 557         UINT32 res = (r2 < 0) ? 0 : (r2 > 255) ? 255 : r2;\r
 558         gpu_reg[dreg] = res;\r
 559         CLR_ZN; SET_ZN(res);\r
 560 }\r
 561 \r
 562 void sat16_rn(void)             /* GPU only */\r
 563 {\r
 564         int dreg = jaguar_op & 31;\r
 565         INT32 r2 = gpu_reg[dreg];\r
 566         UINT32 res = (r2 < 0) ? 0 : (r2 > 65535) ? 65535 : r2;\r
 567         gpu_reg[dreg] = res;\r
 568         CLR_ZN; SET_ZN(res);\r
 569 }\r
 570 \r
 571 void sat16s_rn(void)            /* DSP only */\r
 572 {\r
 573         int dreg = jaguar_op & 31;\r
 574         INT32 r2 = gpu_reg[dreg];\r
 575         UINT32 res = (r2 < -32768) ? -32768 : (r2 > 32767) ? 32767 : r2;\r
 576         gpu_reg[dreg] = res;\r
 577         CLR_ZN; SET_ZN(res);\r
 578 }\r
 579 \r
 580 void sat24_rn(void)                     /* GPU only */\r
 581 {\r
 582         int dreg = jaguar_op & 31;\r
 583         INT32 r2 = gpu_reg[dreg];\r
 584         UINT32 res = (r2 < 0) ? 0 : (r2 > 16777215) ? 16777215 : r2;\r
 585         gpu_reg[dreg] = res;\r
 586         CLR_ZN; SET_ZN(res);\r
 587 }\r
 588 \r
 589 void sat32s_rn(void)            /* DSP only */\r
 590 {\r
 591         int dreg = jaguar_op & 31;\r
 592         INT32 r2 = (UINT32)gpu_reg[dreg];\r
 593         INT32 temp = gpu_acc >> 32;\r
 594         UINT32 res = (temp < -1) ? (INT32)0x80000000 : (temp > 0) ? (INT32)0x7fffffff : r2;\r
 595         gpu_reg[dreg] = res;\r
 596         CLR_ZN; SET_ZN(res);\r
 597 }\r
 598 \r
 599 void sh_rn_rn(void)\r
 600 {\r
 601         int dreg = jaguar_op & 31;\r
 602         INT32 r1 = (INT32)gpu_reg[(jaguar_op >> 5) & 31];\r
 603         UINT32 r2 = gpu_reg[dreg];\r
 604         UINT32 res;\r
 605 \r
 606         CLR_ZNC;\r
 607         if (r1 < 0)\r
 608         {\r
 609                 res = (r1 <= -32) ? 0 : (r2 << -r1);\r
 610                 gpu_flag_c= (r2 >> 30) & 2;\r
 611         }\r
 612         else\r
 613         {\r
 614                 res = (r1 >= 32) ? 0 : (r2 >> r1);\r
 615                 gpu_flag_c= (r2 << 1) & 2;\r
 616         }\r
 617         gpu_reg[dreg] = res;\r
 618         SET_ZN(res);\r
 619 }\r
 620 \r
 621 void sha_rn_rn(void)\r
 622 {\r
 623         int dreg = jaguar_op & 31;\r
 624         INT32 r1 = (INT32)gpu_reg[(jaguar_op >> 5) & 31];\r
 625         UINT32 r2 = gpu_reg[dreg];\r
 626         UINT32 res;\r
 627 \r
 628         CLR_ZNC;\r
 629         if (r1 < 0)\r
 630         {\r
 631                 res = (r1 <= -32) ? 0 : (r2 << -r1);\r
 632                 gpu_flag_c= (r2 >> 30) & 2;\r
 633         }\r
 634         else\r
 635         {\r
 636                 res = (r1 >= 32) ? ((INT32)r2 >> 31) : ((INT32)r2 >> r1);\r
 637                 gpu_flag_c= (r2 << 1) & 2;\r
 638         }\r
 639         gpu_reg[dreg] = res;\r
 640         SET_ZN(res);\r
 641 }\r
 642 \r
 643 void sharq_n_rn(void)\r
 644 {\r
 645         int dreg = jaguar_op & 31;\r
 646         INT32 r1 = convert_zero[(jaguar_op >> 5) & 31];\r
 647         UINT32 r2 = gpu_reg[dreg];\r
 648         UINT32 res = (INT32)r2 >> r1;\r
 649         gpu_reg[dreg] = res;\r
 650         CLR_ZNC; SET_ZN(res); gpu_flag_c= (r2 << 1) & 2;\r
 651 }\r
 652 \r
 653 void shlq_n_rn(void)\r
 654 {\r
 655         int dreg = jaguar_op & 31;\r
 656         INT32 r1 = convert_zero[(jaguar_op >> 5) & 31];\r
 657         UINT32 r2 = gpu_reg[dreg];\r
 658         UINT32 res = r2 << (32 - r1);\r
 659         gpu_reg[dreg] = res;\r
 660         CLR_ZNC; SET_ZN(res); gpu_flag_c= (r2 >> 30) & 2;\r
 661 }\r
 662 \r
 663 void shrq_n_rn(void)\r
 664 {\r
 665         int dreg = jaguar_op & 31;\r
 666         INT32 r1 = convert_zero[(jaguar_op >> 5) & 31];\r
 667         UINT32 r2 = gpu_reg[dreg];\r
 668         UINT32 res = r2 >> r1;\r
 669         gpu_reg[dreg] = res;\r
 670         CLR_ZNC; SET_ZN(res); gpu_flag_c= (r2 << 1) & 2;\r
 671 }\r
 672 \r
 673 void store_rn_rn(void)\r
 674 {\r
 675         UINT32 r1 = gpu_reg[(jaguar_op >> 5) & 31];\r
 676         gpu_long_write(r1, gpu_reg[jaguar_op & 31]);\r
 677 }\r
 678 \r
 679 void store_rn_r14n(void)\r
 680 {\r
 681         UINT32 r1 = convert_zero[(jaguar_op >> 5) & 31];\r
 682         gpu_long_write(gpu_reg[14] + r1 * 4, gpu_reg[jaguar_op & 31]);\r
 683 }\r
 684 \r
 685 void store_rn_r15n(void)\r
 686 {\r
 687         UINT32 r1 = convert_zero[(jaguar_op >> 5) & 31];\r
 688         gpu_long_write(gpu_reg[15] + r1 * 4, gpu_reg[jaguar_op & 31]);\r
 689 }\r
 690 \r
 691 void store_rn_r14rn(void)\r
 692 {\r
 693         UINT32 r1 = gpu_reg[(jaguar_op >> 5) & 31];\r
 694         gpu_long_write(gpu_reg[14] + r1, gpu_reg[jaguar_op & 31]);\r
 695 }\r
 696 \r
 697 void store_rn_r15rn(void)\r
 698 {\r
 699         UINT32 r1 = gpu_reg[(jaguar_op >> 5) & 31];\r
 700         gpu_long_write(gpu_reg[15] + r1, gpu_reg[jaguar_op & 31]);\r
 701 }\r
 702 \r
 703 void storeb_rn_rn(void)\r
 704 {\r
 705         UINT32 r1 = gpu_reg[(jaguar_op >> 5) & 31];\r
 706         gpu_byte_write(r1, gpu_reg[jaguar_op & 31]);\r
 707 }\r
 708 \r
 709 void storew_rn_rn(void)\r
 710 {\r
 711         UINT32 r1 = gpu_reg[(jaguar_op >> 5) & 31];\r
 712         gpu_word_write(r1, gpu_reg[jaguar_op & 31]);\r
 713 }\r
 714 \r
 715 void storep_rn_rn(void) /* GPU only */\r
 716 {\r
 717         UINT32 r1 = gpu_reg[(jaguar_op >> 5) & 31];\r
 718         gpu_long_write(r1, gpu_hidata);\r
 719         gpu_long_write(r1+4, gpu_reg[jaguar_op & 31]);\r
 720 }\r
 721 \r
 722 void sub_rn_rn(void)\r
 723 {\r
 724         int dreg = jaguar_op & 31;\r
 725         UINT32 r1 = gpu_reg[(jaguar_op >> 5) & 31];\r
 726         UINT32 r2 = gpu_reg[dreg];\r
 727 //      fprintf(log_get(),"r%i=0x%.8x r%i=0x%.8x\n",(jaguar_op >> 5) & 31,r1,dreg,r2);\r
 728         UINT32 res = r2 - r1;\r
 729         gpu_reg[dreg] = res;\r
 730         CLR_ZNC; SET_ZNC_SUB(r2,r1,res);\r
 731 }\r
 732 \r
 733 void subc_rn_rn(void)\r
 734 {\r
 735         int dreg = jaguar_op & 31;\r
 736         UINT32 r1 = gpu_reg[(jaguar_op >> 5) & 31];\r
 737         UINT32 r2 = gpu_reg[dreg];\r
 738         UINT32 res = r2 - r1 - gpu_flag_c;\r
 739         gpu_reg[dreg] = res;\r
 740         CLR_ZNC; SET_ZNC_SUB(r2,r1,res);\r
 741 }\r
 742 \r
 743 void subq_n_rn(void)\r
 744 {\r
 745         int dreg = jaguar_op & 31;\r
 746         UINT32 r1 = convert_zero[(jaguar_op >> 5) & 31];\r
 747         UINT32 r2 = gpu_reg[dreg];\r
 748         UINT32 res = r2 - r1;\r
 749         gpu_reg[dreg] = res;\r
 750         CLR_ZNC; SET_ZNC_SUB(r2,r1,res);\r
 751 }\r
 752 \r
 753 void subqmod_n_rn(void) /* DSP only */\r
 754 {\r
 755         int dreg = jaguar_op & 31;\r
 756         UINT32 r1 = convert_zero[(jaguar_op >> 5) & 31];\r
 757         UINT32 r2 = gpu_reg[dreg];\r
 758         UINT32 res = r2 - r1;\r
 759 //      res = (res & ~jaguar.ctrl[D_MOD]) | (r2 & ~jaguar.ctrl[D_MOD]);\r
 760         gpu_reg[dreg] = res;\r
 761         CLR_ZNC; SET_ZNC_SUB(r2,r1,res);\r
 762 }\r
 763 \r
 764 void subqt_n_rn(void)\r
 765 {\r
 766         int dreg = jaguar_op & 31;\r
 767         UINT32 r1 = convert_zero[(jaguar_op >> 5) & 31];\r
 768         UINT32 r2 = gpu_reg[dreg];\r
 769         UINT32 res = r2 - r1;\r
 770         gpu_reg[dreg] = res;\r
 771 }\r
 772 \r
 773 void xor_rn_rn(void)\r
 774 {\r
 775         int dreg = jaguar_op & 31;\r
 776         UINT32 r1 = gpu_reg[(jaguar_op >> 5) & 31];\r
 777         UINT32 r2 = gpu_reg[dreg];\r
 778         UINT32 res = r1 ^ r2;\r
 779         gpu_reg[dreg] = res;\r
 780         CLR_ZN; SET_ZN(res);\r
 781 }\r