home *** CD-ROM | disk | FTP | other *** search
/ Programmer 7500 / MAX_PROGRAMMERS.iso / INFO / CROSSASM / 68ASMSIM.ZIP / simsrc / code4.c < prev    next >
Encoding:
C/C++ Source or Header  |  1989-04-09  |  7.3 KB  |  430 lines
  1.  
  2. /***************************** 68000 SIMULATOR ****************************
  3.  
  4. File Name: CODE4.C
  5. Version: 1.0
  6.  
  7. The instructions implemented in this file are the integer arithmetic
  8.     operations:
  9.  
  10.         DIVS, DIVU, MULS, MULU, NEG, NEGX, CMP, CMPA, CMPI, CMPM,
  11.         TST, CLR, EXT
  12.  
  13.  
  14. ***************************************************************************/
  15.  
  16.  
  17. #include <stdio.h>
  18. #include "extern.h"         /* contains global "extern" declarations */
  19.  
  20.  
  21.  
  22.  
  23.  
  24. int    DIVS()
  25. {
  26. int    reg, overflow;
  27. long    remainder;
  28.  
  29. if (eff_addr ((long) WORD, DATA_ADDR, TRUE))
  30.     return (BAD_INST);            /* bad instruction format */
  31.  
  32. reg = (inst >> 9) & 0x0007;
  33.  
  34. from_2s_comp (EV1 & WORD, (long) WORD, &source);
  35. from_2s_comp (D[reg], LONG, &dest);
  36.  
  37. if (source == 0)
  38.     return (DIV_BY_ZERO);        /* initiate exception processing */
  39.  
  40. /* check for overflow */
  41. if ( ( (source < 0) && (dest >= 0) ) || ( (source >= 0) && (dest < 0) ) )
  42.     {
  43.     if ((dest / -source) > WORD)
  44.         overflow = TRUE;
  45.     else
  46.         overflow = FALSE;
  47.     }
  48. else
  49.     {
  50.     if ((dest / source) > WORD)
  51.         overflow = TRUE;
  52.     else
  53.         overflow = FALSE;
  54.     }
  55.  
  56. if (overflow)
  57.     SR |= vbit;            /* if overflow then quit */
  58. else
  59.     {
  60.     SR &= ~vbit;
  61.     result = (dest / source) & 0xffff;
  62.     remainder = (dest % source) & 0xffff;
  63.     D[reg] = result = result | (remainder * 0x10000);
  64.     cc_update (N_A, GEN, GEN, N_A, ZER, source, dest, result, (long) WORD, 0);
  65.     if ( ( (source < 0) && (dest >= 0) ) || ( (source >= 0) && (dest < 0) ) )
  66.         SR |= nbit;
  67.     else
  68.         SR &= ~nbit;
  69.     }
  70.  
  71. inc_cyc (158);
  72.  
  73. return SUCCESS;
  74.  
  75. }
  76.  
  77.  
  78.  
  79. int    DIVU()
  80. {
  81. int    reg;
  82.  
  83. if (eff_addr ((long) WORD, DATA_ADDR, TRUE))
  84.     return (BAD_INST);            /* bad instruction format */
  85.  
  86. reg = (inst >> 9) & 0x0007;
  87.  
  88. source = EV1 & WORD;
  89. dest = D[reg];
  90.  
  91. if (source == 0)
  92.     return (DIV_BY_ZERO);        /* initiate exception processing */
  93.  
  94. if ( (dest / source) > WORD)
  95.     SR |= vbit;         /* check for overflow */
  96. else
  97.     {
  98.     SR &= ~vbit;
  99.     D[reg] = result =((dest / source) & 0xffff) | ((dest % source) * 0x10000);
  100.  
  101.     cc_update (N_A, GEN, GEN, N_A, ZER, source, dest, result, (long) WORD, 0);
  102.     }
  103.  
  104. inc_cyc (140);
  105.  
  106. return SUCCESS;
  107.  
  108. }
  109.  
  110.  
  111.  
  112. int    MULS()
  113. {
  114. int    reg;
  115.  
  116. if (eff_addr ((long) WORD, DATA_ADDR, TRUE))
  117.     return (BAD_INST);            /* bad instruction format */
  118.  
  119. reg = (inst >> 9) & 0x0007;
  120.  
  121. from_2s_comp (EV1 & WORD, (long) WORD, &source);
  122. from_2s_comp (D[reg] & WORD, (long) WORD, &dest);
  123.  
  124. D[reg] = result = source * dest;
  125.  
  126. cc_update (N_A, GEN, GEN, CASE_9, ZER, source, dest, result, (long) WORD, 0);
  127.  
  128. inc_cyc (70);
  129.  
  130. return SUCCESS;
  131.  
  132. }
  133.  
  134.  
  135.  
  136. int    MULU()
  137. {
  138. int    reg;
  139.  
  140. if (eff_addr ((long) WORD, DATA_ADDR, TRUE))
  141.     return (BAD_INST);            /* bad instruction format */
  142.  
  143. reg = (inst >> 9) & 0x0007;
  144.  
  145. source = EV1 & WORD;
  146. dest = D[reg] & WORD;
  147.  
  148. D[reg] = result = source * dest;
  149.  
  150. cc_update (N_A, GEN, GEN, ZER, ZER, source, dest, result, LONG, 0);
  151.  
  152. inc_cyc (70);
  153.  
  154. return SUCCESS;
  155.  
  156. }
  157.  
  158.  
  159.  
  160. int    NEG()
  161. {
  162. long    size;
  163.  
  164. if ((decode_size(&size)) ||
  165.     (eff_addr (size, DATA_ALT_ADDR, TRUE)))
  166.     return (BAD_INST);        /* bad instruction format */
  167.  
  168. source = dest = EV1 & size;
  169.  
  170. /* perform the NEG operation */
  171. put (EA1, -dest, size);
  172. value_of (EA1, &result, size);
  173.  
  174. cc_update (GEN, GEN, GEN, CASE_3, CASE_4, source, dest, result, size, 0);
  175.  
  176. if (inst & 0x0030) 
  177.     inc_cyc ( (size == LONG) ? 12 : 8);
  178. else 
  179.     inc_cyc ( (size == LONG) ? 6 : 4);
  180.  
  181. return SUCCESS;
  182.  
  183. }
  184.  
  185.  
  186.  
  187. int    NEGX()
  188. {
  189. long    size;
  190.  
  191. if ((decode_size(&size)) ||
  192.     (eff_addr (size, DATA_ALT_ADDR, TRUE)))
  193.     return (BAD_INST);        /* bad instruction format */
  194.  
  195. dest = dest = EV1 & size;
  196.  
  197. /* perform the NEGX operation */
  198. put (EA1, -dest - ((SR & xbit) >> 4), size);
  199. value_of (EA1, &result, size);
  200.  
  201. cc_update (GEN, GEN, CASE_1, CASE_3, CASE_4, source, dest, result, size, 0);
  202.  
  203. if (inst & 0x0030) {
  204.     inc_cyc ( (size == LONG) ? 12 : 8);
  205.     }
  206. else {
  207.     inc_cyc ( (size == LONG) ? 6 : 4);
  208.     }
  209.  
  210. return SUCCESS;
  211.  
  212. }
  213.  
  214.  
  215.  
  216. int    CMP()
  217. {
  218. long    size;
  219. int    reg;
  220.  
  221. if ((decode_size(&size)) || 
  222.     (eff_addr (size, ALL_ADDR, TRUE)))
  223.     return (BAD_INST);            /* bad instruction format */
  224.  
  225. reg = (inst >> 9) & 0x0007;
  226.  
  227. source = EV1 & size;
  228. dest = D[reg] & size;
  229.  
  230. put (&result, dest - source, size);
  231.  
  232. /* now set the condition codes */
  233. cc_update (N_A, GEN, GEN, CASE_2, CASE_6, source, dest, result, size, 0);
  234.  
  235. inc_cyc ( (size == LONG) ? 6 : 4);
  236.  
  237. return SUCCESS;
  238.  
  239. }
  240.  
  241.  
  242. int    CMPA()
  243. {
  244. long    size;
  245. int    reg;
  246.  
  247. if (inst & 0x0100)
  248.     size = LONG;
  249. else
  250.     size = WORD;
  251.  
  252. if (eff_addr (size, ALL_ADDR, TRUE))
  253.     return (BAD_INST);            /* bad instruction format */
  254.  
  255. reg = a_reg((inst >> 9) & 0x0007);
  256.  
  257. if (size == WORD)
  258.     sign_extend ((int)EV1, WORD, &EV1);
  259.  
  260. source = EV1 & size;
  261. dest = A[reg] & size;
  262.  
  263. put (&result, dest - source, size);
  264.  
  265. /* now set the condition codes according to the result */
  266. cc_update (N_A, GEN, GEN, GEN, GEN, source, dest, result, size, 0);
  267.  
  268. inc_cyc (6);
  269.  
  270. return SUCCESS;
  271.  
  272. }
  273.  
  274.  
  275. int    CMPI()
  276. {
  277. long    size;
  278.  
  279. if (decode_size(&size))
  280.     return (BAD_INST);            /* bad instruction format */
  281.  
  282. mem_request (&PC, size, &source);
  283.  
  284. if (eff_addr (size, DATA_ALT_ADDR, TRUE))
  285.     return (BAD_INST);            /* bad instruction format */
  286.  
  287. dest = EV1 & size;
  288.  
  289. put (&result, dest - source, size);
  290.  
  291. cc_update (N_A, GEN, GEN, CASE_2, CASE_6, source, dest, result, size, 0);
  292.  
  293. if (inst & 0x0038) {
  294.     inc_cyc ( (size == LONG) ? 12 : 8);
  295.     }
  296. else {
  297.     inc_cyc ( (size == LONG) ? 14 : 8);
  298.     }
  299.  
  300. return SUCCESS;
  301.  
  302. }
  303.  
  304.  
  305.  
  306. int    CMPM()
  307. {
  308. long    size;
  309. int    Rx, Ry;
  310.  
  311. if (decode_size(&size)) 
  312.     return (BAD_INST);
  313.  
  314. Rx = a_reg((inst >> 9) & 0x07);
  315. Ry = a_reg(inst & 0x07);
  316.  
  317. mem_req ( (int) A[Ry], size, &source);
  318. mem_req ( (int) A[Rx], size, &dest);
  319.  
  320. put (&result, dest - source, size);
  321.  
  322. if (size == BYTE)  {
  323.     A[Rx]++;
  324.     A[Ry]++;
  325.     };
  326. if (size == WORD)  {
  327.     A[Rx] += 2;
  328.     A[Ry] += 2;
  329.     };
  330. if (size == LONG)  {
  331.     A[Rx] += 4;
  332.     A[Ry] += 4;
  333.     };
  334.  
  335. /* now set the condition codes according to the result */
  336. cc_update (N_A, GEN, GEN, CASE_2, CASE_6, source, dest, result, size, 0);
  337.  
  338. inc_cyc ( (size == LONG) ? 20 : 12);
  339.  
  340. return SUCCESS;
  341.  
  342. }
  343.  
  344.  
  345.  
  346.  
  347. int    TST()
  348. {
  349. long    size;
  350.  
  351. if ((decode_size(&size)) ||
  352.     (eff_addr (size, DATA_ALT_ADDR, TRUE)))
  353.     return (BAD_INST);        /* bad instruction format */
  354.  
  355. value_of (EA1, &dest, size);
  356.  
  357. /* test the dest operand and set the condition codes accordingly */
  358. cc_update (N_A, GEN, GEN, ZER, ZER, source, dest, dest, size, 0);
  359.  
  360. if (inst & 0x0030) {
  361.     inc_cyc ( (size == LONG) ? 4 : 4);
  362.     }
  363. else {
  364.     inc_cyc ( (size == LONG) ? 4 : 4);
  365.     }
  366.  
  367. return SUCCESS;
  368.  
  369. }
  370.  
  371.  
  372.  
  373. int    CLR()
  374. {
  375. long    size;
  376.  
  377. if ((decode_size(&size)) ||
  378.     (eff_addr (size, DATA_ALT_ADDR, TRUE)))
  379.     return (BAD_INST);        /* bad instruction format */
  380.  
  381. source = dest = EV1 & size;
  382.  
  383. /* perform the CLR operation */
  384. put (EA1, (long) 0, size);
  385. value_of (EA1, &result, size);
  386.  
  387. cc_update (N_A, ZER, GEN, ZER, ZER, source, dest, result, size, 0);
  388.  
  389. if (inst & 0x0030) {
  390.     inc_cyc ( (size == LONG) ? 12 : 8);
  391.     }
  392. else {
  393.     inc_cyc ( (size == LONG) ? 6 : 4);
  394.     }
  395.  
  396. return SUCCESS;
  397.  
  398. }
  399.  
  400.  
  401.  
  402.  
  403. int    EXT()
  404. {
  405. long    size;
  406. int    reg;
  407.  
  408. reg = inst & 0x07;
  409.  
  410. if (inst & 0x0040)
  411.     size = LONG;
  412. else
  413.     size = WORD;
  414.  
  415. source = dest = D[reg] & size;
  416.  
  417. if (size == WORD)
  418.  D[reg] = (D[reg]&~WORD) | (D[reg] & BYTE) | (0xff00 * ((D[reg]>>7) & 0x01));
  419. else
  420.  D[reg] = (D[reg] & WORD) | (0xffff0000 * ((D[reg] >> 15) & 0x01));
  421.  
  422. cc_update (N_A, GEN, GEN, ZER, ZER, source, dest, D[reg], size, 0);
  423.  
  424. inc_cyc (4);
  425.  
  426. return SUCCESS;
  427.  
  428. }
  429.  
  430.