home *** CD-ROM | disk | FTP | other *** search
/ Celestin Apprentice 4 / Apprentice-Release4.iso / Source Code / Libraries / Z80 emulator / PPC version / CodesXX.c < prev    next >
Encoding:
Text File  |  1995-11-01  |  7.2 KB  |  222 lines  |  [TEXT/CWIE]
  1. /*    Z80 Emulator: ix/iy instruction handlers
  2.     Copyright (C) 1995 G.Woigk
  3.     
  4.     This file is part of Mac Spectacle and it is free software
  5.     See application.c for details
  6.             
  7.     This program is distributed in the hope that it will be useful,
  8.     but WITHOUT ANY WARRANTY; without even the implied warranty of
  9.     MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  
  10.  
  11.     based on fMSX; Copyright (C) Marat Fayzullin 1994,1995
  12.     
  13.     Handler for ix/iy prefixed instructions
  14.     All opcodes covered, no unsupported opcodes!
  15. */
  16.  
  17.  
  18. increment_r;        // prefixed instructions increment r by 2
  19. COUNT_XY_INSTR;        // profiling
  20.  
  21.  
  22. switch(n)
  23. {
  24.  
  25. case LD_H_B:    time(8);  rzh=RB;                     loop_ill2;
  26. case LD_L_B:       time(8);  rzl=RB;                    loop_ill2;
  27. case LD_X_B:    time(19); w=iz+dis; rompoke(w,RB);    loop;
  28.  
  29. case LD_H_C:    time(8);  rzh=RC;                    loop_ill2;
  30. case LD_L_C:    time(8);  rzl=RC;                    loop_ill2;
  31. case LD_X_C:    time(19); w=iz+dis; rompoke(w,RC);    loop;
  32.  
  33. case LD_H_D:    time(8);  rzh=RD;                    loop_ill2;
  34. case LD_L_D:    time(8);  rzl=RD;                    loop_ill2;
  35. case LD_X_D:    time(19); w=iz+dis; rompoke(w,RD);    loop;
  36.  
  37. case LD_H_E:    time(8);  rzh=RE;                    loop_ill2;
  38. case LD_L_E:    time(8);  rzl=RE;                    loop_ill2;
  39. case LD_X_E:    time(19); w=iz+dis; rompoke(w,RE);    loop;
  40.  
  41. case LD_B_H:    time(8);  RB=rzh;                    loop_ill2;
  42. case LD_C_H:    time(8);  RC=rzh;                    loop_ill2;
  43. case LD_D_H:    time(8);  RD=rzh;                    loop_ill2;
  44. case LD_E_H:    time(8);  RE=rzh;                    loop_ill2;
  45. case LD_H_H:    time(8);  rzh=rzh;                    loop_weird2;
  46. case LD_L_H:    time(8);  rzl=rzh;                    loop_weird2;
  47. case LD_A_H:    time(8);  ra=rzh;                    loop_ill2;
  48. case LD_X_H:    time(19); w=iz+dis; rompoke(w,RH);    loop;
  49.  
  50. case LD_B_L:    time(8);  RB=rzl;                    loop_ill2;
  51. case LD_C_L:    time(8);  RC=rzl;                    loop_ill2;
  52. case LD_D_L:    time(8);  RD=rzl;                    loop_ill2;
  53. case LD_E_L:    time(8);  RE=rzl;                    loop_ill2;
  54. case LD_H_L:    time(8);  rzh=rzl;                    loop_weird2;
  55. case LD_L_L:    time(8);  rzl=rzl;                    loop_weird2;
  56. case LD_A_L:    time(8);  ra=rzl;                    loop_ill2;
  57. case LD_X_L:    time(19); w=iz+dis; rompoke(w,RL);    loop;
  58.  
  59. case LD_H_A:    time(8);  rzh=ra;                    loop_ill2;
  60. case LD_L_A:    time(8);  rzl=ra;                    loop_ill2;
  61. case LD_X_A:    time(19); w=iz+dis; rompoke(w,ra);    loop;
  62.  
  63. case LD_B_X:    time(19); RB=peek(iz+dis);             loop;
  64. case LD_C_X:    time(19); RC=peek(iz+dis);             loop;
  65. case LD_D_X:    time(19); RD=peek(iz+dis);             loop;
  66. case LD_E_X:    time(19); RE=peek(iz+dis);             loop;
  67. case LD_H_X:    time(19); RH=peek(iz+dis);             loop;
  68. case LD_L_X:    time(19); RL=peek(iz+dis);             loop;
  69. case LD_A_X:    time(19); ra=peek(iz+dis);             loop;
  70.  
  71. case LD_H_N:    time(11); rzh=n;                     loop_ill3;
  72. case LD_L_N:    time(11); rzl=n;                     loop_ill3;
  73. case LD_X_N:    time(19); w=iz+dis;c=n;rompoke(w,c);loop;
  74.  
  75. case LD_xNN_HL:    time(20); w=nn; rompoke2(w,iz);        loop;
  76. case LD_HL_xNN:    time(20); w=nn; rzl=peek(w); rzh=peek(w+1);    loop;
  77. case EX_HL_xSP:    time(23); w=pop(); push(iz); iz=w;    loop;
  78.  
  79. case PUSH_HL:    time(15); push(iz);                    loop;
  80. case POP_HL:    time(14); iz=pop();                    loop;
  81. case LD_HL_WORD:time(14); iz=nn;                    loop;
  82. case LD_PC_HL:    time(8);  pc=iz;                    loop;
  83. case LD_SP_HL:    time(10); sp=iz;                    loop;
  84.  
  85. case ADD_HL_BC:    time(15); M_ADDW(iz,BC);            loop;
  86. case ADD_HL_DE:    time(15); M_ADDW(iz,DE);            loop;
  87. case ADD_HL_HL:    time(15); M_ADDW(iz,iz);            loop;
  88. case ADD_HL_SP:    time(15); M_ADDW(iz,sp);            loop;
  89. case DEC_HL:       time(10); iz--;                        loop;
  90. case INC_HL:    time(10); iz++;                        loop;
  91.  
  92. case DEC_H:    time(8);  M_DEC(rzh);                    loop_ill2;
  93. case DEC_L:    time(8);  M_DEC(rzl);                    loop_ill2;
  94. case DEC_X:    time(23); w=iz+dis;c=peek(w);M_DEC(c);rompoke(w,c); loop;
  95.  
  96. case INC_H:    time(8);  M_INC(rzh);                    loop_ill2;
  97. case INC_L:    time(8);  M_INC(rzl);                    loop_ill2;
  98. case INC_X:    time(23); w=iz+dis;c=peek(w);M_INC(c);rompoke(w,c); loop;
  99.  
  100. case ADD_H:    time(8);  M_ADD(rzh);                    loop_ill2;
  101. case ADD_L:    time(8);  M_ADD(rzl);                    loop_ill2;
  102. case ADD_X:    time(19); c=peek(iz+dis); M_ADD(c);        loop;
  103.  
  104. case SUB_H:    time(8);  M_SUB(rzh);                    loop_ill2;
  105. case SUB_L:    time(8);  M_SUB(rzl);                    loop_ill2;
  106. case SUB_X:    time(19); c=peek(iz+dis); M_SUB(c);        loop;
  107.  
  108. case ADC_H:    time(8);  M_ADC(rzh);                    loop_ill2;
  109. case ADC_L:    time(8);  M_ADC(rzl);                    loop_ill2;
  110. case ADC_X:    time(19); c=peek(iz+dis); M_ADC(c);        loop;
  111.  
  112. case SBC_H:    time(8);  M_SBC(rzh);                    loop_ill2;
  113. case SBC_L:    time(8);  M_SBC(rzl);                    loop_ill2;
  114. case SBC_X:    time(19); c=peek(iz+dis); M_SBC(c);        loop;
  115.  
  116. case CP_H:    time(8);  M_CP(rzh);                    loop_ill2;
  117. case CP_L:    time(8);  M_CP(rzl);                    loop_ill2;
  118. case CP_X:    time(19); c=peek(iz+dis); M_CP(c);        loop;
  119.                
  120. case AND_H:    time(8);  M_AND(rzh);                    loop_ill2;
  121. case AND_L:    time(8);  M_AND(rzl);                    loop_ill2;
  122. case AND_X:    time(19); c=peek(iz+dis); M_AND(c);        loop;
  123.  
  124. case OR_H:    time(8);  M_OR(rzh);                    loop_ill2;
  125. case OR_L:    time(8);  M_OR(rzl);                    loop_ill2;
  126. case OR_X:    time(19); c=peek(iz+dis); M_OR(c);        loop;
  127.  
  128. case XOR_H:    time(8);  M_XOR(rzh);                    loop_ill2;
  129. case XOR_L:    time(8);  M_XOR(rzl);                    loop_ill2;
  130. case XOR_X:    time(19); c=peek(iz+dis); M_XOR(c);        loop;
  131.  
  132.  
  133. case PFX_CB:
  134. //    Within an 8-instruction block, every illegal DD CB instruction works as
  135. //    the official one, but also copies the result to the specified register.    
  136. //    ((The information about the inofficial CB instructions was given to   ))
  137. //    ((Gerton Lunter by Arnt Gulbrandsen, and originated from David Librik.))
  138.     {    int o;
  139.  
  140.     COUNT_XYCB_INSTR;    // profiling
  141.     time(20);            // SHIFT, SET, and RES: 23 T cycles; BIT: 20 T cycles
  142.     
  143.     w = iz + dis;        // target address
  144.     c = peek(w);        // target
  145.     o = n;                // opcode
  146.     
  147.     switch (o>>3)        // instruction
  148.     {
  149.     case RLC_X>>3:    M_RLC(c); break;
  150.     case RRC_X>>3:    M_RRC(c); break;
  151.     case RL_X>>3:    M_RL(c);  break;
  152.     case RR_X>>3:    M_RR(c);  break;
  153.     case SLA_X>>3:  M_SLA(c); break;
  154.     case SRA_X>>3:  M_SRA(c); break;
  155.     case SLL_X>>3:  M_SLL(c); break;
  156.     case SRL_X>>3:    M_SRL(c); break;
  157.  
  158.     case BIT0_X>>3: M_BIT(0x01,c); break;
  159.     case BIT1_X>>3: M_BIT(0x02,c); break;
  160.     case BIT2_X>>3: M_BIT(0x04,c); break;
  161.     case BIT3_X>>3: M_BIT(0x08,c); break;
  162.     case BIT4_X>>3: M_BIT(0x10,c); break;
  163.     case BIT5_X>>3: M_BIT(0x20,c); break;
  164.     case BIT6_X>>3: M_BIT(0x40,c); break;
  165.     case BIT7_X>>3: M_BIT(0x80,c); break;
  166.     
  167.     case RES0_X>>3:    c &= ~0x01; break;
  168.     case RES1_X>>3: c &= ~0x02; break;
  169.     case RES2_X>>3: c &= ~0x04; break;
  170.     case RES3_X>>3: c &= ~0x08; break;
  171.     case RES4_X>>3: c &= ~0x10; break;
  172.     case RES5_X>>3: c &= ~0x20; break;
  173.     case RES6_X>>3: c &= ~0x40; break;
  174.     case RES7_X>>3: c &= ~0x80; break;
  175.  
  176.     case SET0_X>>3: c |= 0x01;  break;
  177.     case SET1_X>>3: c |= 0x02;  break;
  178.     case SET2_X>>3: c |= 0x04;  break; 
  179.     case SET3_X>>3: c |= 0x08;  break; 
  180.     case SET4_X>>3: c |= 0x10;  break; 
  181.     case SET5_X>>3: c |= 0x20;  break; 
  182.     case SET6_X>>3: c |= 0x40;  break; 
  183.     case SET7_X>>3: c |= 0x80;  break; 
  184.     };
  185.  
  186.     switch(o&0x07)    // copy result to register (illegal opcodes only)
  187.     {
  188.     case 0:    RB=c; break;
  189.     case 1:    RC=c; break;
  190.     case 2:    RD=c; break;
  191.     case 3:    RE=c; break;
  192.     case 4:    RH=c; break;
  193.     case 5:    RL=c; break;
  194.     case 6:    
  195.         if ( (o&0xc0)==0x40 ) loop;   // quick exit: legal bit test
  196.         more(3);rompoke(w,c);
  197. #if INFO_ILLEGALS
  198.         if ((o>>3)!=(SLL_X>>3)) loop; // quick exit: legal shift, set, res
  199.         loop_ill4;                      // SLL
  200. #else
  201.         loop;
  202. #endif
  203.     case 7:    ra=c; break;
  204.     };
  205.  
  206.     if ((o&0xc0)==0x40) loop_weird4;        // illegal bit test
  207.     more(3);rompoke(w,c);
  208.     loop_weird4;                            // illegal shift, set, res
  209.     };
  210.  
  211.  
  212. default:            // ix/iy prefix has no effect on operation:
  213.     time(4);        // T cycles for useless ix/iy prefix
  214.     decrement_r;    // r register only incremented by 1
  215.     --pc;            // execute instruction without prefix
  216.     loop_weird2;        // weird illegal
  217.  
  218. };
  219. loop;    // never used
  220.  
  221.  
  222.