home *** CD-ROM | disk | FTP | other *** search
/ Programmer 7500 / MAX_PROGRAMMERS.iso / INFO / CROSSASM / 68ASMSIM.ZIP / simsrc / code2.c < prev    next >
Encoding:
C/C++ Source or Header  |  1989-04-09  |  2.9 KB  |  170 lines
  1.  
  2. /***************************** 68000 SIMULATOR ****************************
  3.  
  4. File Name: CODE2.C
  5. Version: 1.0
  6.  
  7. The instructions implemented in this file are the data movement instructions
  8.    other than the MOVE instructions:
  9.  
  10.         EXG, LEA, PEA, LINK, UNLK
  11.  
  12.  
  13. ***************************************************************************/
  14.  
  15.  
  16. #include <stdio.h>
  17. #include "extern.h"         /* contains global "extern" declarations */
  18.  
  19.  
  20.  
  21.  
  22. int    EXG()
  23. {
  24. long    temp_reg;
  25. int    Rx, Ry;
  26.  
  27. Rx = (inst >> 9) & 0x07;
  28. Ry = inst & 0x07;
  29. switch ((inst >> 3) & 0x1f)
  30.     {
  31.     case 0x08: temp_reg = D[Rx];
  32.         D[Rx] = D[Ry];
  33.         D[Ry] = temp_reg;
  34.         break;
  35.     case 0x09:    temp_reg = A[a_reg(Rx)];
  36.         A[a_reg(Rx)] = A[a_reg(Ry)];
  37.         A[a_reg(Ry)] = temp_reg;
  38.         break;
  39.     case 0x11: temp_reg = D[Rx];
  40.         D[Rx] = A[a_reg(Ry)];
  41.         A[a_reg(Ry)] = temp_reg;
  42.         break;
  43.     default  : return (BAD_INST);    /* bad op_mode field */
  44.               break;
  45.     }
  46.  
  47. inc_cyc (6);
  48.  
  49. return SUCCESS;
  50.  
  51. }
  52.  
  53.  
  54.  
  55.  
  56. int    LEA()
  57. {
  58. int    reg;
  59.  
  60. reg = (inst >> 9) & 0x07;
  61.  
  62. if (eff_addr (LONG, CONTROL_ADDR, FALSE))
  63.     return (BAD_INST);        /* bad instruction format */
  64.  
  65. /* perform the LEA operation */
  66. A[a_reg(reg)] = (long) ((long)EA1 - (long)&memory[0]);
  67.  
  68. switch (eff_addr_code (inst, 0)) {
  69.     case 0x02 : inc_cyc (4);
  70.                 break;
  71.     case 0x05 : inc_cyc (8);
  72.                 break;
  73.     case 0x06 : inc_cyc (12);
  74.                 break;
  75.     case 0x07 : inc_cyc (8);
  76.                 break;
  77.     case 0x08 : inc_cyc (12);
  78.                 break;
  79.     case 0x09 : inc_cyc (8);
  80.                 break;
  81.     case 0x0a : inc_cyc (12);
  82.                 break;
  83.     default   : break;
  84.     }
  85.  
  86. return SUCCESS;
  87.  
  88. }
  89.  
  90.  
  91.  
  92.  
  93. int    PEA()
  94. {
  95.  
  96. if (eff_addr (LONG, CONTROL_ADDR, FALSE))
  97.     return (BAD_INST);        /* bad instruction format */
  98.  
  99. /* push the longword address computed by the */
  100. /* effective address routine onto the stack */
  101.  
  102. A[a_reg(7)] -= 4;
  103. put (&memory[A[a_reg(7)]], (long) ((long)EA1 - (long)&memory[0]), LONG);
  104.  
  105. switch (eff_addr_code (inst, 0)) {
  106.     case 0x02 : inc_cyc (12);
  107.                 break;
  108.     case 0x05 : inc_cyc (16);
  109.                 break;
  110.     case 0x06 : inc_cyc (20);
  111.                 break;
  112.     case 0x07 : inc_cyc (16);
  113.                 break;
  114.     case 0x08 : inc_cyc (20);
  115.                 break;
  116.     case 0x09 : inc_cyc (16);
  117.                 break;
  118.     case 0x0a : inc_cyc (20);
  119.                 break;
  120.     default   : break;
  121.     }
  122.  
  123. return SUCCESS;
  124.  
  125. }
  126.  
  127.  
  128.  
  129.  
  130. int    LINK()
  131. {
  132. int    reg;
  133. long    temp, displacement;
  134.  
  135. reg = inst & 0x07;
  136.  
  137. mem_request (&PC, (long) WORD, &temp);
  138. from_2s_comp(temp, (long) WORD, &displacement);
  139.  
  140. /* perform the LINK operation */
  141. A[a_reg(7)] -= 4;
  142. put (&memory[A[a_reg(7)]], A[reg], LONG);
  143. A[reg] = A[a_reg(7)];
  144. A[a_reg(7)] = A[a_reg(7)] + displacement;
  145.  
  146. inc_cyc (16);
  147.  
  148. return SUCCESS;
  149.  
  150. }
  151.  
  152.  
  153.  
  154. int    UNLK()
  155. {
  156. int    reg;
  157.  
  158. reg = inst & 0x07;
  159.  
  160. A[a_reg(7)] = A[reg];
  161. mem_req ( (int) A[a_reg(7)], LONG, &A[reg]);
  162. A[a_reg(7)] += 4;
  163.  
  164. inc_cyc (12);
  165.  
  166. return SUCCESS;
  167.  
  168. }
  169.  
  170.