home *** CD-ROM | disk | FTP | other *** search
/ Programmer 7500 / MAX_PROGRAMMERS.iso / INFO / CROSSASM / AS68K.ZIP / AS3.C < prev    next >
Encoding:
C/C++ Source or Header  |  1987-01-10  |  15.2 KB  |  580 lines
  1. #include "a:printf.h"
  2. #include "a:stdio.h"
  3. #include "as.h"
  4.  
  5.  
  6. nop(opskel)
  7. unsigned    opskel;
  8. {
  9.     /* Process NOP */
  10.  
  11.         objbuf[1] = opskel;
  12.         return 1;
  13. }
  14.  
  15.  
  16. move()
  17. {
  18.  
  19. /*
  20.        Process MOVE
  21.        <EA>,<EA> SR,<EA> <EA>,CCR <EA>,SR USP,An An,USP
  22. */
  23.         long    ltemp;
  24.  
  25.         /* look for obvious mistakes */
  26.  
  27.         if (op2ea == 6 || op1ea == 8 || (op1ea == 9 && op2ea != 2) ||
  28.             (op1ea != 2 && op2ea == 9) || opnptr == 0 || opnpt2 == 0)
  29.                 return 3;
  30.  
  31.     /* USP,An */
  32.  
  33.         if (op1ea == 9) {
  34.                 objbuf[1] = 0x4e68 | op2da;
  35.                 return 1;
  36.         }
  37.  
  38.     /* SR,<EA> */
  39.  
  40.     else
  41.     if (op1ea == 7) {
  42.                 if (op2ea == 2)
  43.                         return 3;
  44.  
  45.                 if (op2ea != 0) {
  46.                         objbuf[1] = 0x40C0 | op2da | ((op2ea - 1) * 8);
  47.                         return 1;
  48.                 }
  49.  
  50.                 procop(&opnpt2);
  51.                 objbuf[2] = opnwrd[2];
  52.  
  53.                 if (opnwc == 2) {
  54.                         objbuf[2] = opnwrd[3];
  55.                         objbuf[3] = opnwrd[2];
  56.                 }
  57.  
  58.                 objwc += opnwc;
  59.                 objbuf[1] = 0x4600 | opnwrd[1];
  60.                 return 1;
  61.         }
  62.  
  63.         /* op1ea = 1 thru 5 */
  64.  
  65.         else
  66.     if (op1ea >= 1 && op1ea <= 5) {
  67.  
  68.                 /* Process EA types 0-5 for first operand */
  69.  
  70.                 objbuf[1] = (((op1ea - 1) * 8) | op1da);
  71.                 return secop();
  72.         }
  73.  
  74.         /* Process first operand here if complex */
  75.  
  76.         procop(&opnptr);
  77.  
  78.         /* check for EA types 7-9 */
  79.  
  80.         if (op2ea > 6) {
  81.                 if (op2ea == 7)
  82.                         objbuf[1] = 0x46c0;
  83.                 else
  84.         if (op2ea == 8)
  85.                         objbuf[1] = 0x44c0;
  86.                 else
  87.         if (op2ea == 9) {
  88.                         objbuf[1] = 0x4e60 | op1da;
  89.                         return 1;
  90.                 }
  91.  
  92.                 if (op1ea == 0 || op1ea == 6) {
  93.                         objbuf[1] |= opnwrd[1];
  94.                         objbuf[2] = opnwrd[2];
  95.  
  96.                         if (imode == 3) {
  97.                                 objbuf[2] = opnwrd[3];
  98.                                 objbuf[3] = opnwrd[2];
  99.                         }
  100.  
  101.                         objwc += opnwc;
  102.                         return 1;
  103.                 }
  104.                 else
  105.                         return 3;
  106.         }
  107.  
  108.         /* Check for first operand immediate mode addressing */
  109.  
  110.         if ((op1ea == 6 && opnflg != 1 && imode == 3) &&
  111.             (opnwrd[3] == 0 || opnwrd[3] == 0xffff)) {
  112.  
  113.                 /* Check if value is within range for MOVEQ (+/- 128)    */
  114.                 /* also check if destination is a data register        */
  115.  
  116.                 ltemp = asn(opnwrd[2],opnwrd[3]);
  117.                 if ((ltemp >= -128l && ltemp <= 127l) && (op2ea == 1)) {
  118.                         objbuf[1] = (opnwrd[2] & 0xff) | 0x7000 | (op2da * 0x200);
  119.                         return 1;
  120.                 }
  121.         }
  122.  
  123.         /* add in opcode size bits */
  124.  
  125.         objbuf[1] |= 0x3000;
  126.  
  127.         if (imode == 1)
  128.                 objbuf[1] &= 0x1FFF;
  129.  
  130.         if (imode == 3)
  131.                 objbuf[1] &= 0x2FFF;
  132.  
  133.         /* move in numbers for 1st and 2nd ext words */
  134.  
  135.         objwc += opnwc;
  136.         objbuf[2] = opnwrd[2];
  137.         objbuf[1] = opnwrd[1];
  138.  
  139.         if (opnwc == 2) {
  140.                 objbuf[2] = opnwrd[3];
  141.                 objbuf[3] = opnwrd[2];
  142.         }
  143.  
  144.         return secop();
  145. }
  146.  
  147.  
  148. secop()
  149. {
  150.     int    i, j;
  151.  
  152.         /* check for simple second operands */
  153.  
  154.         if (op2ea == 0) {
  155.  
  156.                 /* calculate complex second operand */
  157.  
  158.                 procop(&opnpt2);
  159.                 objbuf[objwc + 1] = opnwrd[2];
  160.  
  161.                 if (opnwc == 2) {
  162.                         objbuf[objwc + 2] = opnwrd[2];
  163.                         objbuf[objwc + 1] = opnwrd[3];
  164.                 }
  165.  
  166.                 objwc += opnwc;
  167.                 i = (opnwrd[1] & 7) * 8;
  168.                 j = (opnwrd[1] & 0x38) / 8;
  169.                 objbuf[1] = objbuf[1] | ((i + j) * 0x40) | 0x3000;
  170.  
  171.                 /* add in the size bits */
  172.  
  173.                 if (imode == 1)
  174.                         objbuf[1] &= 0x1FFF;
  175.  
  176.                 if (imode == 3)
  177.                         objbuf[1] &= 0x2FFF;
  178.  
  179.                 return 1;
  180.         }
  181.  
  182.         /* check for SR,CCR,USP */
  183.  
  184.         else
  185.     if (op2ea > 6) {
  186.                 if (op2ea == 7)
  187.                         objbuf[1] = 0x46C0;
  188.  
  189.         if (op2ea == 8)
  190.                         objbuf[1] = 0x44C0;
  191.  
  192.         if (op2ea == 9) {
  193.                         objbuf[1] = 0x4E60 | op1da;
  194.                         return 1;
  195.                 }
  196.  
  197.                 /* get non-register EA'S if 0 or 6 */
  198.  
  199.                 if (op1ea == 0 || op1ea == 6) {
  200.  
  201.                         /* handle stuff for EA'S 0 and 6 */
  202.  
  203.                         objbuf[1] |= opnwrd[1];
  204.                         objbuf[2] = opnwrd[2];
  205.  
  206.                         if (opnwc == 2) {
  207.                                 objbuf[2] = opnwrd[3];
  208.                                 objbuf[3] = opnwrd[2];
  209.                         }
  210.  
  211.                         objwc += opnwc;
  212.  
  213.                         return 1;
  214.                 }
  215.                 else {
  216.                         objbuf[1] = objbuf[1] | op1da | ((op1ea - 1) * 8);
  217.                         return 1;
  218.                 }
  219.         }
  220.  
  221.         /* process EA types 0-5 for second operand */
  222.  
  223.         else {
  224.                 objbuf[1] = objbuf[1] + (((op2ea - 1) | (op2da * 8)) * 0x40) | 0x3000;
  225.  
  226.                 /* add in size bits */
  227.  
  228.                 if (imode == 1)
  229.                         objbuf[1] &= 0x1FFF;
  230.  
  231.                 if (imode == 3)
  232.                         objbuf[1] &= 0x2FFF;
  233.  
  234.                 return 1;
  235.         }
  236. }
  237.  
  238.  
  239. cmp(opskel,opsk2)
  240. unsigned    opskel,opsk2;
  241. {
  242.  
  243. /*
  244.        process CMP
  245.        <EA>,DN <EA>,AN DATA,<EA> (AY)+,(AX)+
  246. */
  247.  
  248.         if ((op1ea == 6) && (op2ea != 2)) {
  249.  
  250.                 /* CMPI instruction */
  251.                 /* evaluate the immediate part */
  252.  
  253.                 procop(&opnptr);
  254.                 objwc += opnwc;
  255.                 objbuf[2] = opnwrd[2];
  256.  
  257.                 if (opnwc == 2) {
  258.                         objbuf[2] = opnwrd[3];
  259.                         objbuf[3] = opnwrd[2];
  260.                 }
  261.  
  262.                 /* check for simple destination EA */
  263.  
  264.                 if ((op2ea > 0) && (op2ea < 6)) {
  265.  
  266.                         /* second EA is not complex */
  267.  
  268.                         objbuf[1] = opsk2 | op2da | ((op2ea - 1) * 8);
  269.                         return 0;
  270.                 }
  271.  
  272.                 if (op2ea > 6)
  273.                         return 3;
  274.  
  275.                 procop(&opnpt2);
  276.                 objbuf[1] = opsk2 | (opnwrd[1] & 0x3F);
  277.                 objbuf[objwc + 1] = opnwrd[2];
  278.  
  279.                 if (opnwc == 2) {
  280.                         objbuf[objwc + 1] = opnwrd[3];
  281.                         objbuf[objwc + 2] = opnwrd[2];
  282.                 }
  283.  
  284.                 objwc += opnwc;
  285.  
  286.                 return 0;
  287.         }
  288.  
  289.         if ((op1ea == 5) && (op2ea == 5)) {
  290.  
  291.                 /* CMPM (AY)+,(AX)+ */
  292.  
  293.                 objbuf[1] = opskel + ((op2da * 0x200) + op1da);
  294.                 return 0;
  295.         }
  296.  
  297.         if ((op2ea == 1) || (op2ea == 2)) {
  298.  
  299.                 /* process <EA>,DN <EA>,AN */
  300.  
  301.                 if (op2ea == 2 && imode == 1)
  302.                         return 3;
  303.  
  304.                 if (op2ea == 2)
  305.                         if (imode == 3)
  306.                                 opskel |= 0x140;
  307.                         else
  308.                                 opskel |= 0x80;
  309.  
  310.                 if ((op1ea != 0) && (op1ea != 6)) {
  311.  
  312.                         /* process for REG operands */
  313.  
  314.                         objbuf[1] = opskel | (op2da * 0x200) |
  315.                                         ((op1ea - 1) * 8) | op1da;
  316.  
  317.                         return 0;
  318.                 }
  319.  
  320.                 /* process for complex 1st operands */
  321.  
  322.                 procop(&opnptr);
  323.                 objbuf[1] = opskel | (op2da * 0x200) | (opnwrd[1] & 0x3F);
  324.                 objbuf[2] = opnwrd[2];
  325.  
  326.                 if (opnwc == 2) {
  327.                         objbuf[2] = opnwrd[3];
  328.                         objbuf[3] = opnwrd[2];
  329.                 }
  330.  
  331.                 objwc += opnwc;
  332.  
  333.                 return 0;
  334.         }
  335.  
  336.         return 3;
  337. }
  338.  
  339.  
  340. add(opskel,opsk2)
  341. unsigned    opskel,opsk2;
  342. {
  343.  
  344. /*
  345.        process ADD,SUB
  346.        <EA>,DN <EA>,AN DN,<EA> DATA,<EA>
  347. */
  348.  
  349.         if (op2ea == 2) {
  350.  
  351.                 /* generate <EA>,AN */
  352.  
  353.                 if (imode == 1)
  354.             return 3;
  355.  
  356.                 if (imode == 3)
  357.             opskel |= 0x1c0;
  358.  
  359.                 if ((imode == 2) || (imode == 0))
  360.             opskel |= 0xc0;
  361.  
  362.                 opskel |= (op2da * 0x200);
  363.  
  364.                 if (op1ea == 6) {
  365.                         procop(&opnptr);
  366.                         if (opnflg == 1) {
  367.                                 objbuf[2] = opnwrd[2];
  368.  
  369.                                 if (opnwc == 2) {
  370.                                         objbuf[2] = opnwrd[3];
  371.                                         objbuf[3] = opnwrd[2];
  372.                                 }
  373.  
  374.                                 objwc += opnwc;
  375.                                 objbuf[1] = opskel | opnwrd[1];
  376.  
  377.                                 return 0;
  378.                         }
  379.  
  380.                         if (opnwrd[3] == 0 && opnwrd[2] >= 1 && opnwrd[2] <= 8) {
  381.                                 if (opnwrd[2] == 8)
  382.                     opnwrd[2] = 0;
  383.  
  384.                                 if (opsk2 == 0x400)
  385.                     opsk2 = 0x5100;
  386.  
  387.                                 if (opsk2 == 0x600)
  388.                     opsk2 = 0x5000;
  389.  
  390.                                 opsk2 |= opnwrd[2] * 0x200;
  391.                                 objbuf[1] = opsk2 | ((op2ea - 1) * 8) | op2da;
  392.  
  393.                                 return 0;
  394.                         }
  395.  
  396.                         objbuf[2] = opnwrd[2];
  397.  
  398.                         if (opnwc == 2) {
  399.                                 objbuf[2] = opnwrd[3];
  400.                                 objbuf[3] = opnwrd[2];
  401.                         }
  402.  
  403.                         objwc += opnwc;
  404.                         objbuf[1] = opskel | opnwrd[1];
  405.  
  406.                         return 0;
  407.                 }
  408.  
  409.                 if (op1ea == 0) {
  410.                         procop(&opnptr);
  411.                         objbuf[2] = opnwrd[2];
  412.  
  413.                         if (opnwc == 2) {
  414.                                 objbuf[2] = opnwrd[3];
  415.                                 objbuf[3] = opnwrd[2];
  416.                         }
  417.  
  418.                         objwc += opnwc;
  419.                         objbuf[1] = opskel | opnwrd[1];
  420.  
  421.                         return 0;
  422.                 }
  423.  
  424.                 objbuf[1] = opskel | ((op1ea - 1) * 8) | op1da;
  425.  
  426.                 return 0;
  427.         }
  428.  
  429.         if (op1ea == 6) {
  430.  
  431.                 /* generate xxxI */
  432.  
  433.                 if (op2ea > 6)
  434.                         return 3;
  435.  
  436.                 /* evaluate immediate expression */
  437.  
  438.                 procop(&opnptr);
  439.  
  440.                 /* try to generate the short form of instruction */
  441.                 /* after checking to see if operand was fwd ref  */
  442.  
  443.                 if (opnflg == 1) {
  444.  
  445.                         /* generate extension words    */
  446.                         /* length of operand depends   */
  447.                         /* on the imode of instruction */
  448.  
  449.                         objbuf[2] = opnwrd[2];
  450.  
  451.                         if (opnwc == 2) {
  452.                                 objbuf[2] = opnwrd[3];
  453.                                 objbuf[3] = opnwrd[2];
  454.                         }
  455.  
  456.                         objwc += opnwc;
  457.  
  458.                         /* if destination thru REG evaluate it here */
  459.  
  460.                         if (op2ea != 0) {
  461.                                 objbuf[1] = opsk2 | ((op2ea - 1) * 8) | op2da;
  462.                                 return 0;
  463.                         }
  464.  
  465.                         /* evaluate non-REG destination */
  466.  
  467.                         procop(&opnpt2);
  468.                         objbuf[1] = opsk2 | opnwrd[1];
  469.                         objbuf[objwc + 1] = opnwrd[2];
  470.  
  471.                         if (opnwc == 2) {
  472.                                 objbuf[objwc + 1] = opnwrd[3];
  473.                                 objbuf[objwc + 2] = opnwrd[2];
  474.                         }
  475.  
  476.                         objwc += opnwc;
  477.  
  478.                         return 0;
  479.                 }
  480.  
  481.                 if (opnwrd[3] == 0 && opnwrd[2] >= 1 && opnwrd[2] <= 8) {
  482.  
  483.                         /* generate xxxQ */
  484.  
  485.                         if (opnwrd[2] == 8)
  486.                 opnwrd[2] = 0;
  487.  
  488.                         if (opsk2 == 0x400)
  489.                 opsk2 = 0x5100;
  490.  
  491.                         if (opsk2 == 0x600)
  492.                 opsk2 = 0x5000;
  493.  
  494.                         opsk2 |= (opnwrd[2]*0x200);
  495.                 }
  496.                 else {
  497.                         objbuf[2] = opnwrd[2];
  498.  
  499.                         if (opnwc == 2) {
  500.                                 objbuf[2] = opnwrd[3];
  501.                                 objbuf[3] = opnwrd[2];
  502.                         }
  503.  
  504.                         objwc += opnwc;
  505.                 }
  506.  
  507.                 if (op2ea != 0) {
  508.                         objbuf[1] = opsk2 | ((op2ea - 1) * 8) | op2da;
  509.                         return 0;
  510.                 }
  511.  
  512.                 /* evaluate non-REG destination */
  513.  
  514.                 procop(&opnpt2);
  515.                 objbuf[1] = opsk2 | opnwrd[1];
  516.                 objbuf[objwc + 1] = opnwrd[2];
  517.  
  518.                 if (opnwc == 2) {
  519.                         objbuf[objwc + 1] = opnwrd[3];
  520.                         objbuf[objwc + 2] = opnwrd[2];
  521.                 }
  522.  
  523.                 objwc += opnwc;
  524.  
  525.                 return 0;
  526.         }
  527.  
  528.         if (op1ea == 1 || op2ea == 1) {
  529.                 if (op2ea != 1) {
  530.                         opskel |= 0x100;
  531.  
  532.                         /* generate DN,<EA> */
  533.  
  534.                         opskel |= (op1da * 0x200);
  535.  
  536.                         if (op2ea != 0) {
  537.                                 objbuf[1] = opskel | ((op2ea - 1) * 8) | op2da;
  538.                                 return 0;
  539.                         }
  540.  
  541.                         procop(&opnpt2);
  542.                         objbuf[2] = opnwrd[2];
  543.  
  544.                         if (opnwc == 2) {
  545.                                 objbuf[2] = opnwrd[3];
  546.                                 objbuf[3] = opnwrd[2];
  547.                         }
  548.  
  549.                         objwc += opnwc;
  550.                         objbuf[1] = opskel | opnwrd[1];
  551.  
  552.                         return 0;
  553.                 }
  554.  
  555.                 /* generate <EA>,DN */
  556.  
  557.                 opskel |= (op2da * 0x200);
  558.  
  559.                 if (op1ea == 0) {
  560.                         procop(&opnptr);
  561.                         objbuf[2] = opnwrd[2];
  562.  
  563.                         if (opnwc == 2) {
  564.                                 objbuf[2] = opnwrd[3];
  565.                                 objbuf[3] = opnwrd[2];
  566.                         }
  567.  
  568.                         objwc += opnwc;
  569.                         objbuf[1] = opskel | opnwrd[1];
  570.                         return 0;
  571.                 }
  572.  
  573.                 objbuf[1] = opskel | ((op1ea - 1) * 8) | op1da;
  574.  
  575.                 return 0;
  576.         }
  577.  
  578.         return 3;
  579. }
  580.