Shamusworld >> Repos - virtualjaguar/blob - src/gpu4.cpp

   1 #include "core.h"
   2
   3 //#define  DEBUG_GPU
   4
   5 #define J_ALWAYS        0x00
   6 #define J_NZ            0x01
   7 #define J_Z             0x02
   8 #define J_NC            0x04
   9 #define J_NC_NZ         0x05
  10 #define J_NC_Z          0x06
  11 #define J_C             0x08
  12 #define J_C_NZ          0x09
  13 #define J_C_Z           0x0A
  14 #define J_NN            0x14
  15 #define J_NN_NZ         0x15
  16 #define J_NN_Z          0x16
  17 #define J_N             0x18
  18 #define J_N_NZ          0x19
  19 #define J_N_Z           0x1A
  20 #define J_NEVER         0x1F
  21
  22    // Opcode Function Prototypes
  23
  24    void G_ADD( void );          void G_ADDC( void );
  25    void G_ADDQ( void );         void G_ADDQT( void );
  26    void G_SUB( void );          void G_SUBC( void );
  27    void G_SUBQ( void );         void G_SUBQT( void );
  28    void G_NEG( void );          void G_AND( void );
  29    void G_OR( void );           void G_XOR( void );
  30    void G_NOT( void );          void G_BTST( void );
  31    void G_BSET( void );         void G_BCLR( void );
  32    void G_MULT( void );         void G_IMULT( void );
  33    void G_IMULTN( void );       void G_RESMAC( void );
  34    void G_IMACN( void );        void G_DIV( void );
  35    void G_ABS( void );          void G_SH( void );
  36    void G_SHLQ( void );         void G_SHRQ( void );
  37    void G_SHA( void );          void G_SHARQ( void );
  38    void G_ROR( void );          void G_RORQ( void );
  39    void G_CMP( void );          void G_CMPQ( void );
  40    void G_SAT8( void );         void G_SAT16( void );
  41    void G_MOVE( void );         void G_MOVEQ( void );
  42    void G_MOVETA( void );       void G_MOVEFA( void );
  43    void G_MOVEI( void );        void G_LOADB( void );
  44    void G_LOADW( void );        void G_LOAD( void );
  45    void G_LOADP( void );        void G_STORE_14I( void );
  46    void G_LOAD_14I( void );     void G_LOAD_15I( void );
  47    void G_STOREB( void );       void G_STOREW( void );
  48    void G_STORE( void );        void G_STOREP( void );
  49    void G_STORE_15I( void );    void G_MOVE_PC( void );
  50    void G_JUMP( void );         void G_JR( void );
  51    void G_MMULT( void );        void G_MTOI( void );
  52    void G_NORMI( void );        void G_NOP( void );
  53    void G_LOAD_14R( void );     void G_LOAD_15R( void );
  54    void G_STORE_14R( void );    void G_STORE_15R( void );
  55    void G_SAT24( void );        void G_PACK_UNPACK( void );
  56
  57    // Other Prototypes
  58
  59    unsigned mem_readword( unsigned );
  60    unsigned mem_readbyte( unsigned );
  61    void mem_writeword( unsigned, unsigned );
  62    void mem_writebyte( unsigned, unsigned );
  63
  64    // CPU Cycles for Each GPU Opcode
  65
  66    byte gpuCycles[64] = {
  67       3,  3,  3,  3,  3,  3,  3,  3,  3,  3,  3,  3,  3,  3,  3,  3,
  68       3,  3,  1,  3,  1, 18,  3,  3,  3,  3,  3,  3,  3,  3,  3,  3,
  69       3,  3,  2,  2,  2,  2,  3,  4,  5,  4,  5,  6,  6,  1,  1,  1,
  70       1,  2,  2,  2,  1,  1,  9,  3,  3,  0,  6,  6,  2,  2,  3,  3
  71
  72    };
  73
  74    // GPU Opcode Function Table
  75
  76    void (*gpuOp[64])()= {
  77       G_ADD,        G_ADDC,        G_ADDQ,       G_ADDQT,
  78       G_SUB,        G_SUBC,        G_SUBQ,       G_SUBQT,
  79       G_NEG,        G_AND,         G_OR,         G_XOR,
  80       G_NOT,        G_BTST,        G_BSET,       G_BCLR,
  81       G_MULT,       G_IMULT,       G_IMULTN,     G_RESMAC,
  82       G_IMACN,      G_DIV,         G_ABS,        G_SH,
  83       G_SHLQ,       G_SHRQ,        G_SHA,        G_SHARQ,
  84       G_ROR,        G_RORQ,        G_CMP,        G_CMPQ,
  85       G_SAT8,       G_SAT16,       G_MOVE,       G_MOVEQ,
  86       G_MOVETA,     G_MOVEFA,      G_MOVEI,      G_LOADB,
  87       G_LOADW,      G_LOAD,        G_LOADP,      G_LOAD_14I,
  88       G_LOAD_15I,   G_STOREB,      G_STOREW,     G_STORE,
  89       G_STOREP,     G_STORE_14I,   G_STORE_15I,  G_MOVE_PC,
  90       G_JUMP,       G_JR,          G_MMULT,      G_MTOI,
  91       G_NORMI,      G_NOP,         G_LOAD_14R,   G_LOAD_15R,
  92       G_STORE_14R,  G_STORE_15R,   G_SAT24,      G_PACK_UNPACK
  93    };
  94
  95    GPUSTATE gst;                       // GPU State Information
  96    dword GincPC;                       // PC Increment Flag
  97    dword GjmpPC;                       // PC Jump gdstination
  98    dword Gbranch;                      // Branch Flag
  99
 100 #ifdef DEBUG_GPU
 101    FILE *oo;
 102 #endif
 103 /*
 104       sdword arb[32];                  // GPU Active Register Bank
 105       sdword srb[32];                  // GPU Secondary Register Bank
 106       dword  acc;                      // Accumulator
 107       dword  pc;                       // Program Counter
 108       dword  src;                      // Source Register
 109       dword  dst;                      // Destination Register
 110       BOOL   z;                        // Zero Flag
 111       BOOL   n;                        // Negative Flag
 112       BOOL   c;                        // Carry Flag
 113       dword  ctrl;                     // GPU Control Word    (0xF02114 RW)
 114       BOOL   div16;                    // 16.16 Division Flag (0xF0211C WO)
 115       dword  divrem;                   // Division Remainder  (0xF0211C RO)
 116 */
 117
 118    dword gpc;                          // Program Counter
 119    dword gsrc;                         // Instruction Word Source
 120    dword gdst;                         // Instruction Word Destination
 121    BOOL gz;                            // Zero Flag
 122    BOOL gn;                            // Negative Flag
 123    BOOL gc;                            // Carry Flag
 124
 125
 126    // GPU Processor Emulation
 127
 128    DWORD gpu_exec( LPVOID lpParam )
 129    {
 130       dword iw;                        // Instruction Word
 131
 132 #ifdef DEBUG_GPU
 133          oo = fopen( "gpudbg.out", "w" );
 134
 135          {
 136             FILE *f;
 137             int i;
 138
 139             f = fopen( "gpudump.bin", "wb" );
 140             for( i = 0x3000; i < 0x4000; i += 2 )  // Dump GPU RAM
 141             {
 142                fwrite( &st.tom[i+1], 1, 1, f );
 143                fwrite( &st.tom[i],   1, 1, f );
 144             }
 145             fclose( f );
 146          }
 147 #endif
 148
 149       // Counter = InterruptPeriod;
 150
 151       while( gst.gpuActive )
 152       {
 153          if( gst.step )                // While Single Step Enabled
 154          {
 155             while( !gst.stepgo ) ;     // Wait Until StepGo Issued
 156             printf( "   GPU Released for One Instruction (SINGLE STEP)\n" );
 157          }
 158
 159          iw = mem_readword( gpc );       // Get Instruction Word
 160          gsrc = (iw & 0x03E0) >> 5;  // Get Source
 161          gdst = (iw & 0x001F);       // Get Destination
 162
 163          gpuOp[iw >> 10]();            // Jump to and Execute Opcode Routine
 164
 165 #ifdef DEBUG_GPU
 166             fflush( oo );
 167 #endif
 168
 169          // Counter -= Cycles[Opcode];
 170
 171          // if( Counter <= 0 )
 172          // {
 173          //    /* Check for Interrupts and do Other Cyclic tasks here
 174          //    Counter += InterruptPeriod
 175          // }
 176
 177          switch( Gbranch )             // Increment Program Counter
 178          {
 179             case 2:                    // Next Instruction is the Branch Address
 180                Gbranch = 0;
 181                gpc = GjmpPC;
 182                break;
 183
 184             // A Branch Address was Stored in the Branch Program Counter.
 185             // The Next Instruction is a PC + 4 (Case 0 is Executed).
 186             // The Next Instruction is at the Branch Program Counter
 187
 188             case 1:
 189                Gbranch = 2;
 190             case 0:                    // Normal Execution
 191                switch( GincPC )
 192                {
 193                   case 1:              // Opcode Used a 32-Bit Word
 194                      gpc += 6;
 195                      GincPC = 0;
 196                      break;
 197                   case 0:              // Normal Execution
 198                      gpc += 2;
 199                      break;
 200                }
 201                break;
 202          }
 203
 204          if( gst.step )                // If Single Step Mode Enabled
 205          {
 206             gst.stepgo = 0;            // Reset StepGo Flag
 207             printf( "   GPU Paused Until New SINGLE_GO (SINGLE STEP)\n" );
 208          }
 209       }
 210
 211       #ifdef DEBUG_GPU
 212          fclose( oo );
 213       #endif
 214
 215       return( TRUE );
 216    }
 217
 218    void G_ABS( void )
 219    {
 220       if( gst.arb[gdst] == 0x80000000 )
 221          gn = 1;
 222       else
 223          if( gst.arb[gdst] < 0 )
 224          {
 225             __asm {
 226                mov   ecx,[gdst]
 227                mov   eax,[ecx*4+gst.arb]
 228                neg   eax
 229                mov   [ecx*4+gst.arb],eax
 230             };
 231
 232             gz = (gst.arb[gdst] == 0) ? 1 : 0;
 233             gn = 0;
 234             gc = 1;
 235          }
 236
 237       #ifdef DEBUG_GPU
 238          fprintf( oo, "0x%06X ABS R%i\t\t\tR%02i = 0x%08X  Z:%i N:%i C:%i\n",
 239                  gpc, gdst, gdst, gst.arb[gdst],
 240                  gz, gn, gc );
 241       #endif
 242    }
 243
 244    void G_ADD( void )
 245    {
 246       __asm {
 247          mov   ecx,[gsrc]
 248          mov   edx,[ecx*4+gst.arb]
 249          mov   ecx,[gdst]
 250          mov   eax,[ecx*4+gst.arb]
 251          add   eax,edx
 252          mov   [ecx*4+gst.arb],eax
 253          mov   ecx,1
 254          jc    addend
 255          mov   ecx,0
 256       addend:
 257          mov   [gc],ecx
 258       };
 259
 260       gz = (gst.arb[gdst] == 0) ? 1 : 0;
 261       gn = (gst.arb[gdst] <  0) ? 1 : 0;
 262
 263       #ifdef DEBUG_GPU
 264          fprintf( oo, "0x%06X ADD R%i,R%i\t\tR%02i = 0x%08X  Z:%i N:%i C:%i\n",
 265                  gpc, gsrc, gdst, gdst, gst.arb[gdst],
 266                  gz, gn, gc );
 267       #endif
 268    }
 269
 270    void G_ADDC( void )
 271    {
 272       __asm {
 273          clc
 274          mov   ecx,[gc]
 275          jcxz  addc
 276          stc
 277       addc:
 278          mov   ecx,[gsrc]
 279          mov   edx,[ecx*4+gst.arb]
 280          mov   ecx,[gdst]
 281          mov   eax,[ecx*4+gst.arb]
 282          adc   eax,edx
 283          mov   [ecx*4+gst.arb],eax
 284          mov   ecx,1
 285          jc    addcend
 286          mov   ecx,0
 287       addcend:
 288          mov   [gc],ecx
 289       };
 290
 291       gz = (gst.arb[gdst] == 0) ? 1 : 0;
 292       gn = (gst.arb[gdst] <  0) ? 1 : 0;
 293
 294       #ifdef DEBUG_GPU
 295          fprintf( oo, "0x%06X ADDC R%i,R%i\t\tR%02i = 0x%08X  "
 296                  "Z:%i N:%i C:%i\n", gpc, gsrc, gdst, gdst,
 297                  gst.arb[gdst], gz, gn, gc );
 298       #endif
 299    }
 300
 301    void G_ADDQ( void )
 302    {
 303       __asm {
 304          mov   ecx,[gdst]
 305          mov   eax,[ecx*4+gst.arb]
 306          mov   edx,[gsrc]
 307          add   eax,edx
 308          mov   [ecx*4+gst.arb],eax
 309          mov   ecx,1
 310          jc    addqend
 311          mov   ecx,0
 312       addqend:
 313          mov   [gc],ecx
 314       };
 315
 316       gz = (gst.arb[gdst] == 0) ? 1 : 0;
 317       gn = (gst.arb[gdst] <  0) ? 1 : 0;
 318
 319       #ifdef DEBUG_GPU
 320          fprintf( oo, "0x%06X ADDQ 0x%02X,R%i\t\tR%02i = 0x%08X  "
 321                  "Z:%i N:%i C:%i\n", gpc, gsrc, gdst, gdst,
 322                  gst.arb[gdst], gz, gn, gc );
 323       #endif
 324    }
 325
 326    void G_ADDQT( void )
 327    {
 328       __asm {
 329          mov   ecx,[gdst]
 330          mov   eax,[ecx*4+gst.arb]
 331          mov   edx,[gsrc]
 332          add   eax,edx
 333          mov   [ecx*4+gst.arb],eax
 334       };
 335
 336       #ifdef DEBUG_GPU
 337          fprintf( oo, "0x%06X ADDQT 0x%02X,R%i\t\tR%02i = 0x%08X\n",
 338                  gpc, gsrc, gdst, gdst, gst.arb[gdst] );
 339       #endif
 340    }
 341
 342    void G_AND( void )
 343    {
 344       gst.arb[gdst] &= gst.arb[gsrc];
 345       gz = (gst.arb[gdst] == 0) ? 1 : 0;
 346       gn = (gst.arb[gdst] <  0) ? 1 : 0;
 347
 348       #ifdef DEBUG_GPU
 349          fprintf( oo, "0x%06X AND R%i,R%i\t\tR%02i = 0x%08X  Z:%i N:%i C:%i\n",
 350                  gpc, gsrc, gdst, gdst, gst.arb[gdst],
 351                  gz, gn, gc );
 352       #endif
 353    }
 354
 355    void G_BCLR( void )
 356    {
 357       __asm {
 358          mov   ecx,[gdst]
 359          mov   eax,[ecx*4+gst.arb]
 360          mov   edx,[gsrc]
 361          btr   eax,edx
 362          mov   [ecx*4+gst.arb],eax
 363       };
 364
 365       gz = (gst.arb[gdst] == 0) ? 1 : 0;
 366       gn = (gst.arb[gdst] <  0) ? 1 : 0;
 367
 368       #ifdef DEBUG_GPU
 369          fprintf( oo, "0x%06X BCLR 0x%04X,R%i\t\t\t                  "
 370                  "Z:%i N:%i C:%i\n",
 371                  gpc, gsrc, gdst, gz, gn, gc );
 372       #endif
 373    }
 374
 375    void G_BSET( void )
 376    {
 377       __asm {
 378          mov   ecx,[gdst]
 379          mov   eax,[ecx*4+gst.arb]
 380          mov   edx,[gsrc]
 381          bts   eax,edx
 382          mov   [ecx*4+gst.arb],eax
 383       };
 384
 385       gz = (gst.arb[gdst] == 0) ? 1 : 0;
 386       gn = (gst.arb[gdst] <  0) ? 1 : 0;
 387
 388       #ifdef DEBUG_GPU
 389          fprintf( oo, "0x%06X BSET 0x%04X,R%i\t\t\t                  "
 390                  "Z:%i N:%i C:%i\n",
 391                  gpc, gsrc, gdst, gz, gn, gc );
 392       #endif
 393    }
 394
 395    void G_BTST( void )
 396    {
 397       __asm {
 398          mov   ecx,[gdst]
 399          mov   eax,[ecx*4+gst.arb]
 400          mov   ecx,[gsrc]
 401          bt    eax,ecx
 402          mov   ecx,1
 403          jc    btstend
 404          mov   ecx,0
 405       btstend:
 406          mov   [gz],ecx
 407       };
 408
 409       #ifdef DEBUG_GPU
 410          fprintf( oo, "0x%06X BTST 0x%04X,R%i\t\t\t                  "
 411                  "Z:%i N:%i C:%i\n",
 412                  gpc, gsrc, gdst, gz, gn, gc );
 413       #endif
 414    }
 415
 416    void G_CMP( void )
 417    {
 418       sdword tmpW;
 419
 420       __asm {
 421          mov   ecx,[gsrc]
 422          mov   edx,[ecx*4+gst.arb]
 423          mov   ecx,[gdst]
 424          mov   eax,[ecx*4+gst.arb]
 425          sub   eax,edx
 426          lahf
 427          mov   [tmpW],eax
 428       };
 429
 430       gc = (tmpW & 0x0100) ? 1 : 0;
 431       gz = (tmpW & 0x4000) ? 1 : 0;
 432       gn = (tmpW & 0x8000) ? 1 : 0;
 433
 434       #ifdef DEBUG_GPU
 435          fprintf( oo, "0x%06X CMP R%i,R%i\t\t                  "
 436                  "Z:%i N:%i C:%i\n",
 437                  gpc, gsrc, gdst, gz, gn, gc );
 438       #endif
 439    }
 440
 441    void G_CMPQ( void )
 442    {
 443       sdword tmpW;
 444
 445       __asm {
 446          mov   edx,[gsrc]
 447          bt    edx,4
 448          jnc   cmpq
 449          bts   edx,31
 450       cmpq:
 451          mov   ecx,[gdst]
 452          mov   eax,[ecx*4+gst.arb]
 453          sub   eax,edx
 454          lahf
 455          mov   [tmpW],eax
 456       };
 457
 458       gc = (tmpW & 0x0100) ? 1 : 0;
 459       gz = (tmpW & 0x4000) ? 1 : 0;
 460       gn = (tmpW & 0x8000) ? 1 : 0;
 461
 462       #ifdef DEBUG_GPU
 463          fprintf( oo, "0x%06X CMPQ 0x%02X,R%i\t\t                  "
 464                  "Z:%i N:%i C:%i\n",
 465                  gpc, gsrc, gdst, gz, gn, gc );
 466       #endif*/
 467    }
 468
 469    void G_DIV( void )
 470    {
 471       if( gst.div16 )
 472          printf( "GPU DIVIDE 16.16 REQUIRED !!!!\n" );
 473       else
 474       {
 475          (dword)gst.arb[gdst] = (dword)gst.arb[gdst] /
 476                                    (dword)gst.arb[gsrc];
 477
 478          gst.divrem = (dword)gst.arb[gdst] % (dword)gst.arb[gsrc];
 479       }
 480
 481       #ifdef DEBUG_GPU
 482          fprintf( oo, "0x%06X DIV R%i,R%i\t\tR%02i = 0x%08X  ",
 483                   gpc, gsrc, gdst, gdst, gst.arb[gdst] );
 484       #endif
 485    }
 486
 487    void G_IMACN( void )
 488    {
 489       // Like IMULT but product is added to the previous arithmetic operation.
 490       // Intended to be used after IMULTN.
 491
 492       gst.acc += (sdword)((sword)gst.arb[gsrc] *
 493                           (sword)gst.arb[gdst] );
 494
 495       #ifdef DEBUG_GPU
 496          fprintf( oo, "0x%06X IMACN R%i,R%i\t\tACC = 0x%08X\n",
 497                  gpc, gsrc, gdst, gst.acc );
 498       #endif
 499    }
 500
 501    void G_IMULT( void )
 502    {
 503       gst.arb[gdst] = (sdword)((sword)gst.arb[gsrc] *
 504                                   (sword)gst.arb[gdst] );
 505
 506       gz = (gst.arb[gdst] == 0) ? 1 : 0;
 507       gn = (gst.arb[gdst] <  0) ? 1 : 0;
 508
 509       #ifdef DEBUG_GPU
 510          fprintf( oo, "0x%06X IMULT R%i,R%i\t\tR%02i = 0x%08X  "
 511                  "Z:%i N:%i C:%i\n", gpc, gsrc, gdst, gdst,
 512                  gst.arb[gdst], gz, gn, gc );
 513       #endif
 514    }
 515
 516    void G_IMULTN( void )
 517    {
 518       // Like IMULT but result not written back to gst.arb[gdst]
 519       // but to an accumulator. Used as first part of multiply/accumulate group.
 520
 521       gst.acc = (sdword)((sword)gst.arb[gsrc] *
 522                          (sword)gst.arb[gdst] );
 523
 524       gz = (gst.arb[gdst] == 0) ? 1 : 0;
 525       gn = (gst.arb[gdst] <  0) ? 1 : 0;
 526
 527       #ifdef DEBUG_GPU
 528          fprintf( oo, "0x%06X IMULTN R%i,R%i\t\tACC = 0x%08X  "
 529                  "Z:%i N:%i C:%i\n", gpc, gsrc, gdst, gst.acc,
 530                   gz, gn, gc );
 531       #endif
 532    }
 533
 534    void G_JR( void )
 535    {
 536       if( gsrc >= 16 )         // Set Jump Direction
 537          gsrc -= 32;
 538
 539       GjmpPC = (gpc + 2) + (gsrc * 2);
 540
 541       switch( gdst )
 542       {
 543          case 0x00:           // No Conditions
 544             Gbranch = 1;
 545             #ifdef DEBUG_GPU
 546                fprintf( oo, "0x%06X JR 0x%08X\n", gpc, GjmpPC );
 547             #endif
 548             break;
 549
 550          case 0x01:           // NE - Not Equal
 551             if( !gz )  // Zero Flag Unset
 552                Gbranch = 1;
 553             #ifdef DEBUG_GPU
 554                fprintf( oo, "0x%06X JR NE,0x%08X\n",gpc, GjmpPC );
 555             #endif
 556             break;
 557
 558          case 0x02:           // EQ - Equal
 559             if( gz)    // Zero Flag Set
 560                Gbranch = 1;
 561             #ifdef DEBUG_GPU
 562                fprintf( oo, "0x%06X JR EQ,0x%08X\n", gpc, GjmpPC );
 563             #endif
 564             break;
 565
 566          case 0x04:           // Flag Selected Cleared to Jump
 567             if( !gc ) Gbranch = 1; else Gbranch = 0;
 568             #ifdef DEBUG_GPU
 569                fprintf( oo, "0x%06X JR CC,0x%08X\n", gpc, GjmpPC );
 570             #endif
 571             break;
 572
 573          case 0x08:           // Flag Selected Set to Jump
 574             if( gc ) Gbranch = 1; else Gbranch = 0;
 575             #ifdef DEBUG_GPU
 576                fprintf( oo, "0x%06X JR CS,0x%08X\n", gpc, GjmpPC );
 577             #endif
 578             break;
 579
 580          case 0x14:
 581             if( !gn ) Gbranch = 1; else Gbranch = 0;
 582             #ifdef DEBUG_GPU
 583                fprintf( oo, "0x%06X JR NN,0x%08X\n", gpc, GjmpPC );
 584             #endif
 585             break;
 586
 587          case 0x18:
 588             if( gn ) Gbranch = 1; else Gbranch = 0;
 589             #ifdef DEBUG_GPU
 590                fprintf( oo, "0x%06X JR N,0x%08X\n", gpc, GjmpPC );
 591             #endif
 592             break;
 593
 594          default:
 595             #ifdef DEBUG_GPU
 596                fprintf( oo, "Unknown JR Condition at 0x%08X\n", gpc );
 597             #endif
 598             break;
 599
 600       }
 601    }
 602
 603    void G_JUMP( void )
 604    {
 605       GjmpPC = gst.arb[gsrc];
 606
 607       switch( gdst )
 608       {
 609          case J_ALWAYS:
 610             Gbranch = 1;
 611             #ifdef DEBUG_GPU
 612                fprintf( oo, "0x%06X JUMP (R%02i)                    DEST = 0x%08X\n",
 613                        gpc, gsrc, GjmpPC );
 614             #endif
 615             break;
 616
 617          case J_NZ:
 618             if( !gz ) Gbranch = 1;
 619             else         Gbranch = 0;
 620             #ifdef DEBUG_GPU
 621                fprintf( oo, "0x%06X JUMP NZ,(R%02i)                 DEST = 0x%08X\n",
 622                         gpc, gsrc, GjmpPC );
 623             #endif
 624             break;
 625
 626          case J_Z:
 627             if( gz) Gbranch = 1;
 628             else       Gbranch = 0;
 629             #ifdef DEBUG_GPU
 630                fprintf( oo, "0x%06X JUMP Z,(R%02i)                  DEST = 0x%08X\n",
 631                         gpc, gsrc, GjmpPC );
 632             #endif
 633             break;
 634
 635          case J_NC:
 636                if( !gc ) Gbranch = 1;
 637                else         Gbranch = 0;
 638             #ifdef DEBUG_GPU
 639                fprintf( oo, "0x%06X JUMP NC,(R%02i)                 DEST = 0x%08X\n",
 640                         gpc, gsrc, GjmpPC );
 641             #endif
 642             break;
 643
 644          case J_NC_NZ:
 645                if( !gc && !gz ) Gbranch = 1;
 646                else                   Gbranch = 0;
 647             #ifdef DEBUG_GPU
 648                fprintf( oo, "0x%06X JUMP NC_NZ,(R%02i)              DEST = 0x%08X\n",
 649                         gpc, gsrc, GjmpPC );
 650             #endif
 651             break;
 652
 653          case J_NC_Z:
 654                if( !gc && gz ) Gbranch = 1;
 655                else                  Gbranch = 0;
 656             #ifdef DEBUG_GPU
 657                fprintf( oo, "0x%06X JUMP NC_Z,(R%02i)               DEST = 0x%08X\n",
 658                         gpc, gsrc, GjmpPC );
 659             #endif
 660             break;
 661
 662          case J_C:
 663                if( gc ) Gbranch = 1;
 664                else        Gbranch = 0;
 665             #ifdef DEBUG_GPU
 666                fprintf( oo, "0x%06X JUMP C,(R%02i)                  DEST = 0x%08X\n",
 667                         gpc, gsrc, GjmpPC );
 668             #endif
 669             break;
 670
 671          case J_C_NZ:
 672                if( gc && !gz ) Gbranch = 1;
 673                else                  Gbranch = 0;
 674             #ifdef DEBUG_GPU
 675                fprintf( oo, "0x%06X JUMP C_NZ,(R%02i)               DEST = 0x%08X\n",
 676                         gpc, gsrc, GjmpPC );
 677             #endif
 678             break;
 679
 680          case J_C_Z:
 681                if( gc && gz ) Gbranch = 1;
 682                else                 Gbranch = 0;
 683             #ifdef DEBUG_GPU
 684                fprintf( oo, "0x%06X JUMP C_Z,(R%02i)                DEST = 0x%08X\n",
 685                         gpc, gsrc, GjmpPC );
 686             #endif
 687             break;
 688
 689          case J_NN:
 690             if( !gn ) Gbranch = 1;
 691             else         Gbranch = 0;
 692             #ifdef DEBUG_GPU
 693                fprintf( oo, "0x%06X JUMP NN,(R%02i)                 DEST = 0x%08X\n",
 694                         gpc, gsrc, GjmpPC );
 695             #endif
 696             break;
 697
 698          case J_NN_NZ:
 699             if( !gn && !gz ) Gbranch = 1;
 700             else                   Gbranch = 0;
 701             #ifdef DEBUG_GPU
 702                fprintf( oo, "0x%06X JUMP NN_NZ,(R%02i)              DEST = 0x%08X\n",
 703                         gpc, gsrc, GjmpPC );
 704             #endif
 705             break;
 706
 707          case J_NN_Z:
 708             if( !gn && gz ) Gbranch = 1;
 709             else                  Gbranch = 0;
 710             #ifdef DEBUG_GPU
 711                fprintf( oo, "0x%06X JUMP NN_Z,(R%02i)               DEST = 0x%08X\n",
 712                         gpc, gsrc, GjmpPC );
 713             #endif
 714             break;
 715
 716          case J_N:
 717             if( gn ) Gbranch = 1;
 718             else        Gbranch = 0;
 719             #ifdef DEBUG_GPU
 720                fprintf( oo, "0x%06X JUMP N,(R%02i)                  DEST = 0x%08X\n",
 721                         gpc, gsrc, GjmpPC );
 722             #endif
 723             break;
 724
 725          case J_N_NZ:
 726             if( gn && !gz ) Gbranch = 1;
 727             else                  Gbranch = 0;
 728             #ifdef DEBUG_GPU
 729                fprintf( oo, "0x%06X JUMP N_NZ,(R%02i)               DEST = 0x%08X\n",
 730                         gpc, gsrc, GjmpPC );
 731             #endif
 732             break;
 733
 734          case J_N_Z:
 735             if( gn && gz ) Gbranch = 1;
 736             else                 Gbranch = 0;
 737             #ifdef DEBUG_GPU
 738                fprintf( oo, "0x%06X JUMP N_Z,(R%02i)                DEST = 0x%08X\n",
 739                         gpc, gsrc, GjmpPC );
 740             #endif
 741             break;
 742
 743          case J_NEVER:
 744             Gbranch = 0;
 745             #ifdef DEBUG_GPU
 746                fprintf( oo, "0x%06X JUMP NEVER (R%02i)              DEST = 0x%08X\n",
 747                        gpc, gsrc, GjmpPC );
 748             #endif
 749             break;
 750
 751          default:
 752             #ifdef DEBUG_GPU
 753                fprintf( oo, "Unknown JUMP Condition\n" );
 754             #endif
 755             break;
 756       }
 757    }
 758
 759    void G_LOAD( void )
 760    {
 761       gst.arb[gdst]  = mem_readword( gst.arb[gsrc] ) << 16;
 762       gst.arb[gdst] |= mem_readword( gst.arb[gsrc] + 2 );
 763
 764       #ifdef DEBUG_GPU
 765          fprintf( oo, "0x%06X LOAD (R%i),R%i\t\tR%02i = 0x%08X\n",
 766                  gpc, gsrc, gdst, gdst, gst.arb[gdst] );
 767       #endif
 768    }
 769
 770    void G_LOAD_14I( void )
 771    {
 772       sdword tmpW;
 773
 774       tmpW = gst.arb[0x0E] + (gsrc * 4);
 775       gst.arb[gdst]  = mem_readword( tmpW ) << 16;
 776       gst.arb[gdst] |= mem_readword( tmpW + 2 );
 777
 778       #ifdef DEBUG_GPU
 779          fprintf( oo, "0x%06X LOAD (R14+%02i),R%i\t\tR%02i = 0x%08X\n",
 780                  gpc, gsrc, gdst, gdst, gst.arb[gdst] );
 781       #endif
 782    }
 783
 784    void G_LOAD_15I( void )
 785    {
 786       sdword tmpW;
 787
 788       tmpW = gst.arb[0x0F] + (gsrc * 4);
 789       gst.arb[gdst]  = mem_readword( tmpW ) << 16;
 790       gst.arb[gdst] |= mem_readword( tmpW + 2 );
 791
 792       #ifdef DEBUG_GPU
 793          fprintf( oo, "0x%06X LOAD (R15+%02i),R%i\t\tR%02i = 0x%08X\n",
 794                  gpc, gsrc, gdst, gdst, gst.arb[gdst] );
 795       #endif
 796    }
 797
 798    void G_LOAD_14R( void )
 799    {
 800       sdword tmpW;
 801
 802       tmpW = gst.arb[0x0E] + gst.arb[gsrc];
 803       gst.arb[gdst]  = mem_readword( tmpW ) << 16;
 804       gst.arb[gdst] |= mem_readword( tmpW + 2 );
 805
 806       #ifdef DEBUG_GPU
 807          fprintf( oo, "0x%06X LOAD (R14+R%i),R%i\tR%02i = 0x%08X\n",
 808                  gpc, gsrc, gdst, gdst, gst.arb[gdst] );
 809       #endif
 810    }
 811
 812    void G_LOAD_15R( void )
 813    {
 814       sdword tmpW;
 815
 816       // NOTE: Manual seems to indicate that this opcode
 817       // uses Register 14 as the base offset address.
 818
 819       tmpW = gst.arb[0x0E] + gst.arb[gsrc];
 820       gst.arb[gdst]  = mem_readword( tmpW ) << 16;
 821       gst.arb[gdst] |= mem_readword( tmpW + 2 );
 822
 823       #ifdef DEBUG_GPU
 824          fprintf( oo, "0x%06X LOAD (R15+R%i),R%i\tR%02i = 0x%08X\n",
 825                  gpc, gsrc, gdst, gdst, gst.arb[gdst] );
 826       #endif
 827    }
 828
 829    void G_LOADB( void )
 830    {
 831       if( gst.arb[gsrc] >= 0xF03000 && gst.arb[gsrc] < 0xF04000 )
 832       {
 833          gst.arb[gdst]  = mem_readword( gst.arb[gsrc] ) << 16;
 834          gst.arb[gdst] |= mem_readword( gst.arb[gsrc] + 2 );
 835       }
 836       else
 837          gst.arb[gdst] = mem_readbyte( gst.arb[gsrc] );
 838
 839       #ifdef DEBUG_GPU
 840          fprintf( oo, "0x%06X LOADB (R%i),R%i\t\tR%02i = 0x%08X\n",
 841                  gpc, gsrc, gdst, gdst, gst.arb[gdst] );
 842       #endif
 843    }
 844
 845    void G_LOADW( void )
 846    {
 847       if( gst.arb[gsrc] >= 0xF03000 && gst.arb[gsrc] < 0xF04000 )
 848       {
 849          gst.arb[gdst]  = mem_readword( gst.arb[gsrc] ) << 16;
 850          gst.arb[gdst] |= mem_readword( gst.arb[gsrc] + 2 );
 851       }
 852       else
 853          gst.arb[gdst] = mem_readword( gst.arb[gsrc] );
 854
 855       #ifdef DEBUG_GPU
 856          fprintf( oo, "0x%06X LOADW (R%i),R%i\t\tR%02i = 0x%08X\n",
 857                  gpc, gsrc, gdst, gdst, gst.arb[gdst] );
 858       #endif
 859    }
 860
 861    void G_LOADP( void )
 862    {/*
 863          phr.hi  = mem_readword( tolp ) << 16;
 864          phr.hi |= mem_readword( tolp + 0x02 );
 865          phr.lo  = mem_readword( tolp + 0x04 ) << 16;
 866          phr.lo |= mem_readword( tolp + 0x06 );
 867 */
 868       #ifdef DEBUG_GPU
 869          fprintf( oo, "GPU - Unimplemented Opcode (LOADP)\n" );
 870       #endif
 871
 872       gst.gpuActive = FALSE;
 873    }
 874
 875    void G_MMULT( void )
 876    {
 877       #ifdef DEBUG_GPU
 878          fprintf( oo, "GPU - Unimplemented Opcode (MMULT)\n" );
 879       #endif
 880       gst.gpuActive = FALSE;
 881    }
 882
 883    void G_MOVE( void )
 884    {
 885       gst.arb[gdst] = gst.arb[gsrc];
 886
 887       #ifdef DEBUG_GPU
 888          fprintf( oo, "0x%06X MOVE R%i,R%i\t\tR%02i = 0x%08X\n",
 889                  gpc, gsrc, gdst, gdst, gst.arb[gdst] );
 890       #endif
 891    }
 892
 893    void G_MOVE_PC( void )
 894    {
 895       gst.arb[gdst] = gpc;
 896
 897       #ifdef DEBUG_GPU
 898          fprintf( oo, "0x%06X MOVE PC,R%i\t\tR%02i = 0x%08X\n",
 899                   gpc, gdst, gdst, gst.arb[gdst] );
 900       #endif
 901    }
 902
 903    void G_MOVEFA( void )
 904    {
 905       gst.arb[gdst] = gst.srb[gsrc];
 906
 907       #ifdef DEBUG_GPU
 908          fprintf( oo, "0x%06X MOVEFA R%i,R%i\t\tR%02i = 0x%08X\n",
 909                  gpc, gsrc, gdst, gdst, gst.arb[gdst] );
 910       #endif
 911    }
 912
 913    void G_MOVEI( void )
 914    {
 915       gst.arb[gdst]  = mem_readword(gpc + 2);
 916       gst.arb[gdst] |= mem_readword(gpc + 4) << 16;
 917
 918       GincPC = 1;
 919
 920       #ifdef DEBUG_GPU
 921          fprintf( oo, "0x%06X MOVEI 0x%08X,R%i\tR%02i = 0x%08X\n",
 922                  gpc, gst.arb[gdst], gdst, gdst, gst.arb[gdst] );
 923       #endif
 924    }
 925
 926    void G_MOVEQ( void )
 927    {
 928       gst.arb[gdst] = gsrc;
 929
 930       #ifdef DEBUG_GPU
 931          fprintf( oo, "0x%06X MOVEQ 0x%02X,R%i\t\tR%02i = 0x%08X\n",
 932                  gpc, gsrc, gdst, gdst, gst.arb[gdst] );
 933       #endif
 934    }
 935
 936    void G_MOVETA( void )
 937    {
 938       gst.srb[gdst] = gst.arb[gsrc];
 939
 940       #ifdef DEBUG_GPU
 941          fprintf( oo, "0x%06X MOVETA R%i,R%i\t\tR%02i = 0x%08X(0)\n",
 942                  gpc, gsrc, gdst, gdst, gst.srb[gdst] );
 943       #endif
 944    }
 945
 946    void G_MTOI( void )
 947    {
 948       #ifdef DEBUG_GPU
 949          fprintf( oo, "GPU - Unimplemented Opcode (MTOI)\n" );
 950       #endif
 951       gst.gpuActive = FALSE;
 952    }
 953
 954    void G_MULT( void )
 955    {
 956       gst.arb[gdst] = (sdword)((word)gst.arb[gsrc] *
 957                                   (word)gst.arb[gdst] );
 958
 959       gz = (gst.arb[gdst] == 0) ? 1 : 0;
 960       gn = (gst.arb[gdst] <  0) ? 1 : 0;
 961
 962       #ifdef DEBUG_GPU
 963          fprintf( oo, "0x%06X MULT R%i,R%i\t\tR%02i = 0x%08X  "
 964                  "Z:%i N:%i C:%i\n", gpc, gsrc, gdst, gdst,
 965                  gst.arb[gdst], gz, gn, gc );
 966       #endif
 967    }
 968
 969    void G_NEG( void )
 970    {
 971       __asm {
 972          mov   ecx,[gdst]
 973          mov   eax,[ecx*4+gst.arb]
 974          neg   eax
 975          mov   [ecx*4+gst.arb],eax
 976          mov   ecx,1
 977          jc    negend
 978          mov   ecx,0
 979       negend:
 980          mov   [gc],ecx
 981       };
 982
 983       gz = (gst.arb[gdst] == 0) ? 1 : 0;
 984       gn = (gst.arb[gdst] <  0) ? 1 : 0;
 985
 986       #ifdef DEBUG_GPU
 987          fprintf( oo, "0x%06X NEG R%i\t\t\tR%02i = 0x%08X  Z:%i N:%i C:%i\n",
 988                  gpc, gdst, gdst, gst.arb[gdst],
 989                  gz, gn, gc );
 990       #endif
 991    }
 992
 993    void G_NOP( void )
 994    {
 995       #ifdef DEBUG_GPU
 996          fprintf( oo, "0x%06X NOP\n", gpc );
 997       #endif
 998    }
 999
1000    void G_NORMI( void )
1001    {
1002       #ifdef DEBUG_GPU
1003          fprintf( oo, "GPU - Unimplemented Opcode (NORMI)\n" );
1004       #endif
1005       gst.gpuActive = FALSE;
1006    }
1007
1008    void G_NOT( void )                  // Fix donated by YaK
1009    {
1010       gst.arb[gdst] = gst.arb[gdst] ^ 0xFFFFFFFF;
1011       gz = (gst.arb[gdst] == 0) ? 1 : 0;
1012       gn = (gst.arb[gdst] <  0) ? 1 : 0;
1013
1014       #ifdef DEBUG_GPU
1015          fprintf( oo, "0x%06X NOT R%i\t\t\tR%02i = 0x%08X  Z:%i N:%i C:%i\n",
1016                  gpc, gdst, gdst, gst.arb[gdst],
1017                  gz, gn, gc );
1018       #endif
1019    }
1020
1021    void G_OR( void )
1022    {
1023       gst.arb[gdst] |= gst.arb[gsrc];
1024       gz = (gst.arb[gdst] == 0) ? 1 : 0;
1025       gn = (gst.arb[gdst] <  0) ? 1 : 0;
1026
1027       #ifdef DEBUG_GPU
1028          fprintf( oo, "0x%06X OR R%i,R%i\t\tR%02i = 0x%08X  Z:%i N:%i C:%i\n",
1029                  gpc, gsrc, gdst, gdst, gst.arb[gdst],
1030                  gz, gn, gc );
1031       #endif
1032    }
1033
1034    void G_PACK_UNPACK( void )
1035    {
1036       dword tmpW;
1037
1038       tmpW = gst.arb[gdst];
1039
1040       if( gsrc )                    // UNPACK
1041       {
1042          gst.arb[gdst]  = (tmpW & 0x000000FF);
1043          gst.arb[gdst] |= (tmpW & 0x00000F00) << 5;
1044          gst.arb[gdst] |= (tmpW & 0x0000F000) << 10;
1045
1046          #ifdef DEBUG_GPU
1047             fprintf( oo, "0x%06X UNPACK R%i\t\t\tR%02i = 0x%08X\n",
1048                     gpc, gdst, gdst, gst.arb[gdst] );
1049          #endif
1050       }
1051       else                             // PACK
1052       {
1053          gst.arb[gdst]  = (tmpW & 0x000000FF);
1054          gst.arb[gdst] |= (tmpW & 0x0001E000) >> 5;
1055          gst.arb[gdst] |= (tmpW & 0x03C00000) >> 10;
1056
1057          #ifdef DEBUG_GPU
1058             fprintf( oo, "0x%06X PACK R%i\t\t\tR%02i = 0x%08X\n",
1059                     gpc, gdst, gdst, gst.arb[gdst] );
1060          #endif
1061       }
1062    }
1063
1064    void G_RESMAC( void )
1065    {
1066       // Write result register to Register Rn
1067       // Used as last part of multiply/accumulate group.
1068
1069       gst.arb[gdst] = gst.acc;
1070
1071       #ifdef DEBUG_GPU
1072          fprintf( oo, "0x%06X RESMAC R%i\t\tR%02X = 0x%08X\n",
1073                   gpc, gdst, gdst, gst.arb[gdst] );
1074       #endif
1075    }
1076
1077    void G_ROR( void )
1078    {
1079       gc = (gst.arb[gdst] >> 31) & 0x01;
1080
1081       __asm {
1082          mov   ecx,[gdst]
1083          mov   eax,[ecx*4+gst.arb]
1084          mov   edx,[gsrc]
1085          mov   ecx,[edx*4+gst.arb]
1086          and   ecx,0x1F
1087          ror   eax,cl
1088          mov   ecx,[gdst]
1089          mov   [ecx*4+gst.arb],eax
1090       };
1091
1092       gz = (gst.arb[gdst] == 0) ? 1 : 0;
1093       gn = (gst.arb[gdst] <  0) ? 1 : 0;
1094
1095       #ifdef DEBUG_GPU
1096          fprintf( oo, "0x%06X ROR R%i,R%i\t\tR%02i = 0x%08X  Z:%i N:%i C:%i\n",
1097                  gpc, gsrc, gdst, gdst, gst.arb[gdst],
1098                  gz, gn, gc );
1099       #endif
1100    }
1101
1102    void G_RORQ( void )
1103    {
1104       sdword tmpW;
1105
1106       gc = (gst.arb[gdst] >> 31) & 0x01;
1107       tmpW = gst.arb[gdst];
1108
1109       __asm {
1110          mov   eax,[tmpW]
1111          mov   ecx,[gsrc]
1112          ror   eax,cl
1113          mov   [tmpW],eax
1114       };
1115
1116       gst.arb[gdst] = tmpW;
1117
1118       gz = (gst.arb[gdst] == 0) ? 1 : 0;
1119       gn = (gst.arb[gdst] <  0) ? 1 : 0;
1120
1121       #ifdef DEBUG_GPU
1122          fprintf( oo, "0x%06X RORQ 0x%02X,R%i\t\tR%02i = 0x%08X  "
1123                  "Z:%i N:%i C:%i\n",
1124                  gpc, gsrc, gdst, gdst, gst.arb[gdst],
1125                  gz, gn, gc );
1126       #endif
1127    }
1128
1129    void G_SAT8( void )
1130    {
1131       if( gst.arb[gdst] < 0   ) gst.arb[gdst] =0x00000000;
1132       if( gst.arb[gdst] > 255 ) gst.arb[gdst] =0x000000FF;
1133
1134       gn = 0;
1135       gz = (gst.arb[gdst] == 0) ? 1 : 0;
1136
1137       #ifdef DEBUG_GPU
1138          fprintf( oo, "0x%06X SAT8 R%02i\t\t\tR%02i = 0x%08X  "
1139                  "Z:%i N:%i C:%i\n",
1140                  gpc, gdst, gdst, gst.arb[gdst],
1141                  gz, gn, gc );
1142       #endif
1143    }
1144
1145    void G_SAT16( void )
1146    {
1147       if( gst.arb[gdst] < 0     ) gst.arb[gdst] =0x00000000;
1148       if( gst.arb[gdst] > 65535 ) gst.arb[gdst] =0x0000FFFF;
1149
1150       gn = 0;
1151       gz = (gst.arb[gdst] == 0) ? 1 : 0;
1152
1153       #ifdef DEBUG_GPU
1154          fprintf( oo, "0x%06X SAT16 R%02i\t\t\tR%02i = 0x%08X  "
1155                  "Z:%i N:%i C:%i\n",
1156                  gpc, gdst, gdst, gst.arb[gdst],
1157                  gz, gn, gc );
1158       #endif
1159    }
1160
1161    void G_SAT24( void )
1162    {
1163       if( gst.arb[gdst] < 0        ) gst.arb[gdst] =0x00000000;
1164       if( gst.arb[gdst] > 16777215 ) gst.arb[gdst] =0x00FFFFFF;
1165
1166       gn = 0;
1167       gz = (gst.arb[gdst] == 0) ? 1 : 0;
1168
1169       #ifdef DEBUG_GPU
1170          fprintf( oo, "0x%06X SAT24 R%02i\t\t\tR%02i = 0x%08X  "
1171                  "Z:%i N:%i C:%i\n",
1172                  gpc, gdst, gdst, gst.arb[gdst],
1173                  gz, gn, gc );
1174       #endif
1175    }
1176
1177    void G_SH( void )
1178    {
1179       sdword tmpW;
1180
1181       // NOTE: Watch the values here carefully
1182
1183       if( gst.arb[gsrc] >= 0 )    // Shift Right
1184       {
1185          gc = gst.arb[gdst] & 0x01;
1186          tmpW = gst.arb[gsrc];
1187          __asm {
1188             mov   edx,[gdst]
1189             mov   eax,[edx*4+gst.arb]
1190             mov   ecx,[tmpW]
1191             shr   eax,cl
1192             mov   [edx*4+gst.arb],eax
1193          };
1194       }
1195       else                    // Shift Left
1196       {
1197          gc = (gst.arb[gdst] >> 31) & 0x01;
1198          // Fix donated by YaK
1199          tmpW = (0xFFFFFFFF - gst.arb[gsrc]) + 1;
1200          __asm {
1201             mov   edx,[gdst]
1202             mov   eax,[edx*4+gst.arb]
1203             mov   ecx,[tmpW]
1204             shl   eax,cl
1205             mov   [edx*4+gst.arb],eax
1206          };
1207       }
1208
1209       gz = (gst.arb[gdst] == 0) ? 1 : 0;
1210       gn = (gst.arb[gdst] <  0) ? 1 : 0;
1211
1212       #ifdef DEBUG_GPU
1213          fprintf( oo, "0x%06X SH R%i,R%i\t\tR%02i = 0x%08X  "
1214                  "Z:%i N:%i C:%i\n",
1215                  gpc, gsrc, gdst, gdst, gst.arb[gdst],
1216                  gz, gn, gc );
1217       #endif*/
1218    }
1219
1220    void G_SHA( void )
1221    {
1222       sdword tmpW;
1223
1224       // NOTE: Watch the values here carefully
1225
1226       if( gst.arb[gsrc] >= 0 )    // Shift Right
1227       {
1228          gc = gst.arb[gdst] & 0x01;
1229          tmpW = gst.arb[gsrc];
1230          __asm {
1231             mov   edx,[gdst]
1232             mov   eax,[edx*4+gst.arb]
1233             mov   ecx,[tmpW]
1234             sar   eax,cl
1235             mov   [edx*4+gst.arb],eax
1236          };
1237       }
1238       else                    // Shift Left
1239       {
1240          gc = (gst.arb[gdst] >> 31) & 0x01;
1241          // Fix donated by YaK
1242          tmpW = (0xFFFFFFFF - gst.arb[gsrc]) + 1;
1243          __asm {
1244             mov   edx,[gdst]
1245             mov   eax,[edx*4+gst.arb]
1246             mov   ecx,[tmpW]
1247             shl   eax,cl
1248             mov   [edx*4+gst.arb],eax
1249          };
1250       }
1251
1252       gz = (gst.arb[gdst] == 0) ? 1 : 0;
1253       gn = (gst.arb[gdst] <  0) ? 1 : 0;
1254
1255       #ifdef DEBUG_GPU
1256          fprintf( oo, "0x%06X SHA R%i,R%i\t\tR%02i = 0x%08X  "
1257                  "Z:%i N:%i C:%i\n",
1258                  gpc, gsrc, gdst, gdst, gst.arb[gdst],
1259                  gz, gn, gc );
1260       #endif*/
1261    }
1262
1263    void G_SHARQ( void )
1264    {
1265       sdword tmpW;
1266
1267       gc = (gst.arb[gdst] & 0x01);
1268       tmpW = gst.arb[gdst];
1269
1270       __asm {
1271          mov   eax,[tmpW]
1272          mov   ecx,[gsrc]
1273          sar   eax,cl
1274          mov   [tmpW],eax
1275       };
1276
1277       gst.arb[gdst] = tmpW;
1278
1279       gz = (gst.arb[gdst] == 0) ? 1 : 0;
1280       gn = (gst.arb[gdst] <  0) ? 1 : 0;
1281
1282       #ifdef DEBUG_GPU
1283          fprintf( oo, "0x%06X SHARQ 0x%02X,R%i\t\tR%02i = 0x%08X  "
1284                  "Z:%i N:%i C:%i\n", gpc, gsrc, gdst, gdst,
1285                  gst.arb[gdst], gz, gn, gc );
1286       #endif
1287    }
1288
1289    void G_SHLQ( void )
1290    {
1291       gc = (gst.arb[gdst] >> 31) & 0x01;
1292       gst.arb[gdst] <<= (32 - gsrc);
1293
1294       gz = (gst.arb[gdst] == 0) ? 1 : 0;
1295       gn = (gst.arb[gdst] <  0) ? 1 : 0;
1296
1297       #ifdef DEBUG_GPU
1298          fprintf( oo, "0x%06X SHLQ 0x%02X,R%i\t\tR%02i = 0x%08X  "
1299                  "Z:%i N:%i C:%i\n", gpc, gsrc, gdst, gdst,
1300                  gst.arb[gdst], gz, gn, gc );
1301       #endif
1302    }
1303
1304    void G_SHRQ( void )
1305    {
1306       gc = gst.arb[gdst] & 0x01;
1307       gst.arb[gdst] >>= (32 - gsrc);
1308
1309       gz = (gst.arb[gdst] == 0) ? 1 : 0;
1310       gn = (gst.arb[gdst] <  0) ? 1 : 0;
1311
1312       #ifdef DEBUG_GPU
1313          fprintf( oo, "0x%06X SHRQ 0x%02X,R%i\t\tR%02i = 0x%08X  "
1314                  "Z:%i N:%i C:%i\n", gpc, gsrc, gdst, gdst,
1315                  gst.arb[gdst], gz, gn, gc );
1316       #endif
1317    }
1318
1319    void G_STORE( void )
1320    {
1321       mem_writeword( gst.arb[gsrc],     (gst.arb[gdst] >> 16)    );
1322       mem_writeword( gst.arb[gsrc] + 2, (gst.arb[gdst] & 0xFFFF) );
1323
1324       #ifdef DEBUG_GPU
1325          fprintf( oo, "0x%06X STORE R%i,(R%i)\t\tgdst = 0x%08X\n",
1326                  gpc, gdst, gsrc, gst.arb[gsrc] );
1327       #endif
1328    }
1329
1330    void G_STORE_14I( void )
1331    {
1332       sdword tmpW;
1333
1334       tmpW = gst.arb[0x0E] + (gsrc * 4);
1335
1336       mem_writeword( tmpW,     (gst.arb[gdst] >> 16)    );
1337       mem_writeword( tmpW + 2, (gst.arb[gdst] & 0xFFFF) );
1338
1339       #ifdef DEBUG_GPU
1340          fprintf( oo, "0x%06X STORE R%i,(R14+%02i)\t\tgdst = 0x%08X\n",
1341                  gpc, gsrc, gdst, tmpW );
1342       #endif
1343    }
1344
1345    void G_STORE_15I( void )
1346    {
1347       sdword tmpW;
1348
1349       tmpW = gst.arb[0x0F] + (gsrc * 4);
1350
1351       mem_writeword( tmpW,     (gst.arb[gdst] >> 16)    );
1352       mem_writeword( tmpW + 2, (gst.arb[gdst] & 0xFFFF) );
1353
1354       #ifdef DEBUG_GPU
1355          fprintf( oo, "0x%06X STORE R%i,(R15+%02i)\t\tgdst = 0x%08X\n",
1356                  gpc, gsrc, gdst, tmpW );
1357       #endif
1358    }
1359
1360    void G_STORE_14R( void )
1361    {
1362       sdword tmpW;
1363
1364       tmpW = gst.arb[0x0E] + gst.arb[gsrc];
1365       mem_writeword( tmpW,     (gst.arb[gdst] >> 16)    );
1366       mem_writeword( tmpW + 2, (gst.arb[gdst] & 0xFFFF) );
1367
1368       #ifdef DEBUG_GPU
1369          fprintf( oo, "0x%06X STORE R%i,(R14+R%i)\tgdst = 0x%08X\n",
1370                   gpc, gdst, gsrc, tmpW );
1371       #endif
1372    }
1373
1374    void G_STORE_15R( void )
1375    {
1376       sdword tmpW;
1377
1378       // NOTE: Manual seems to indicate that this opcode
1379       // uses Register 14 as the base offset address.
1380
1381       tmpW = gst.arb[0x0E] + gst.arb[gsrc];
1382       mem_writeword( tmpW,     (gst.arb[gdst] >> 16)    );
1383       mem_writeword( tmpW + 2, (gst.arb[gdst] & 0xFFFF) );
1384
1385       #ifdef DEBUG_GPU
1386          fprintf( oo, "0x%06X STORE R%i,(R14+R%i)\tgdst = 0x%08X\n",
1387                  gpc, gdst, gsrc, tmpW );
1388       #endif
1389    }
1390
1391    void G_STOREB( void )
1392    {
1393       if( gst.arb[gsrc] >= 0xF03000 && gst.arb[gsrc] < 0xF04000 )
1394       {
1395          mem_writeword( gst.arb[gsrc],     (gst.arb[gdst] >> 16)     );
1396          mem_writeword( gst.arb[gsrc] + 2, (gst.arb[gdst] & 0xFFFF) );
1397       }
1398       else
1399          mem_writebyte( gst.arb[gsrc], (gst.arb[gdst] & 0xFF) );
1400
1401       #ifdef DEBUG_GPU
1402          fprintf( oo, "0x%06X STOREB R%i,(R%i)\tgdst = 0x%08X\n",
1403                  gpc, gdst, gsrc, gsrc );
1404       #endif
1405    }
1406
1407    void G_STOREW( void )
1408    {
1409       if( gst.arb[gsrc] >= 0xF03000 && gst.arb[gsrc] < 0xF04000 )
1410       {
1411          mem_writeword( gst.arb[gsrc],     (gst.arb[gdst] >> 16)     );
1412          mem_writeword( gst.arb[gsrc] + 2, (gst.arb[gdst] & 0xFFFF) );
1413       }
1414       else
1415          mem_writeword( gst.arb[gsrc], (gst.arb[gdst] & 0xFFFF) );
1416
1417       #ifdef DEBUG_GPU
1418          fprintf( oo, "0x%06X STOREW R%i,(R%i)\tgdst = 0x%08X\n",
1419                  gpc, gdst, gsrc, gsrc );
1420       #endif
1421    }
1422
1423    void G_STOREP( void )
1424    {
1425       #ifdef DEBUG_GPU
1426          fprintf( oo, "GPU - Unimplemented Opcode (STOREP)\n" );
1427       #endif
1428       gst.gpuActive = FALSE;
1429    }
1430
1431    void G_SUB( void )
1432    {
1433       __asm {
1434          mov   ecx,[gsrc]
1435          mov   edx,[ecx*4+gst.arb]
1436          mov   ecx,[gdst]
1437          mov   eax,[ecx*4+gst.arb]
1438          sub   eax,edx
1439          mov   [ecx*4+gst.arb],eax
1440          mov   ecx,1
1441          jc    subend
1442          mov   ecx,0
1443       subend:
1444          mov   [gc],ecx
1445       };
1446
1447       gz = (gst.arb[gdst] == 0) ? 1 : 0;
1448       gn = (gst.arb[gdst] <  0) ? 1 : 0;
1449
1450       #ifdef DEBUG_GPU
1451          fprintf( oo, "0x%06X SUB R%i,R%i\t\tR%02i = 0x%08X  Z:%i N:%i C:%i\n",
1452                  gpc, gsrc, gdst, gdst, gst.arb[gdst],
1453                  gz, gn, gc );
1454       #endif
1455    }
1456
1457    void G_SUBC( void )
1458    {
1459       __asm {
1460          clc
1461          mov   ecx,[gc]
1462          jcxz  subc
1463          stc
1464       subc:
1465          mov   ecx,[gsrc]
1466          mov   edx,[ecx*4+gst.arb]
1467          mov   ecx,[gdst]
1468          mov   eax,[ecx*4+gst.arb]
1469          sbb   eax,edx
1470          mov   [ecx*4+gst.arb],eax
1471          mov   ecx,1
1472          jc    subcend
1473          mov   ecx,0
1474       subcend:
1475          mov   [gc],ecx
1476       };
1477
1478       gz = (gst.arb[gdst] == 0) ? 1 : 0;
1479       gn = (gst.arb[gdst] <  0) ? 1 : 0;
1480
1481       #ifdef DEBUG_GPU
1482           fprintf( oo, "0x%06X SUBC R%i,R%i\t\tR%02i = 0x%08X  "
1483                   "Z:%i N:%i C:%i\n", gpc, gsrc, gdst, gdst,
1484                   gst.arb[gdst], gz, gn, gc );
1485       #endif
1486    }
1487
1488    void G_SUBQ( void )
1489    {
1490       __asm {
1491          mov   ecx,[gdst]
1492          mov   eax,[ecx*4+gst.arb]
1493          mov   edx,[gsrc]
1494          sub   eax,edx
1495          mov   [ecx*4+gst.arb],eax
1496          mov   ecx,1
1497          jc    subqend
1498          mov   ecx,0
1499       subqend:
1500          mov   [gc],ecx
1501       };
1502
1503       gz = (gst.arb[gdst] == 0) ? 1 : 0;
1504       gn = (gst.arb[gdst] <  0) ? 1 : 0;
1505
1506       #ifdef DEBUG_GPU
1507          fprintf( oo, "0x%06X SUBQ 0x%02X,R%i\t\tR%02i = 0x%08X  "
1508                  "Z:%i N:%i C:%i\n", gpc, gsrc, gdst, gdst,
1509                  gst.arb[gdst], gz, gn, gc );
1510       #endif
1511    }
1512
1513    void G_SUBQT( void )
1514    {
1515       __asm {
1516          mov   ecx,[gdst]
1517          mov   eax,[ecx*4+gst.arb]
1518          mov   edx,[gsrc]
1519          sub   eax,edx
1520          mov   [ecx*4+gst.arb],eax
1521       };
1522
1523       #ifdef DEBUG_GPU
1524          fprintf( oo, "0x%06X SUBQT 0x%02X,R%i\t\tR%02i = 0x%08X\n",
1525                  gpc, gsrc, gdst, gdst, gst.arb[gdst] );
1526       #endif
1527    }
1528
1529    void G_XOR( void )
1530    {
1531       gst.arb[gdst] ^= gst.arb[gsrc];
1532       gz = (gst.arb[gdst] == 0) ? 1 : 0;
1533       gn = (gst.arb[gdst] <  0) ? 1 : 0;
1534
1535       #ifdef DEBUG_GPU
1536          fprintf( oo, "0x%06X XOR R%i,R%i\t\tR%02i = 0x%08X  Z:%i N:%i C:%i\n",
1537                  gpc, gsrc, gdst, gdst, gst.arb[gdst],
1538                  gz, gn, gc );
1539       #endif
1540    }