home *** CD-ROM | disk | FTP | other *** search
/ Crawly Crypt Collection 1 / crawlyvol1.bin / program / compiler / sozobon / scsrc20 / szadb / dis3.c < prev    next >
Encoding:
C/C++ Source or Header  |  1990-02-24  |  12.2 KB  |  753 lines
  1. /* Copyright (c) 1990 by Sozobon, Limited.  Authors: Johann Ruegg, Don Dugger
  2.  *
  3.  * Permission is granted to anyone to use this software for any purpose
  4.  * on any computer system, and to redistribute it freely, with the
  5.  * following restrictions:
  6.  * 1) No charge may be made other than reasonable charges for reproduction.
  7.  * 2) Modified versions must be clearly marked as such.
  8.  * 3) The authors are not responsible for any harmful consequences
  9.  *    of using this software, even if they result from defects in it.
  10.  *
  11.  *    dis3.c
  12.  */
  13.  
  14. #include "adb.h"
  15.  
  16. extern long dot;
  17. extern int dotoff;
  18. #define DOT    (dot+dotoff)
  19.  
  20. int cursz;
  21.  
  22. nextw()
  23. {
  24.     return getwd();
  25. }
  26.  
  27. long
  28. nextl()
  29. {
  30.     unsigned int i[2];
  31.  
  32.     i[0] = getwd();
  33.     i[1] = getwd();
  34.     return ((long)i[0]) << 16 | i[1];
  35. }
  36.  
  37. int op0(), op1(), op2(), op3(), op4(), op5(), op6(), op7();
  38. int op8(), op9(), opa(), opb(), opc(), opd(), ope(), opf();
  39.  
  40. int (*funhi[])() = {
  41.     op0, op1, op2, op3, op4, op5, op6, op7,
  42.     op8, op9, opa, opb, opc, opd, ope, opf
  43. };
  44.  
  45. puti()
  46. {
  47.     unsigned int op;
  48.  
  49.     align(20);
  50.  
  51.     op = nextw();
  52.  
  53.     if ( (*funhi[op>>12])(op) )
  54.         ;
  55.     else
  56.         prt("???");
  57. }
  58.  
  59.  
  60. #define M_IMM    1
  61. #define M_PX    2
  62. #define M_POFF    4
  63. #define M_ABSL    010
  64. #define M_ABSW    020
  65. #define M_AX    040
  66. #define M_AOFF    0100
  67. #define M_ADEC    0200
  68. #define M_AINC    0400
  69. #define M_ATA    01000
  70. #define M_AREG    02000
  71. #define M_DREG    04000
  72.  
  73. valid(mode,reg,mask)
  74. {
  75.     if (mode == 7)
  76.         switch (reg) {
  77.         case 0:
  78.             return mask & M_ABSW;
  79.         case 1:
  80.             return mask & M_ABSL;
  81.         case 2:
  82.             return mask & M_POFF;
  83.         case 3:
  84.             return mask & M_PX;
  85.         case 4:
  86.             return mask & M_IMM;
  87.         default:
  88.             return 0;
  89.         }
  90.     else
  91.         switch (mode) {
  92.         case 0:
  93.             return mask & M_DREG;
  94.         case 1:
  95.             return mask & M_AREG;
  96.         case 2:
  97.             return mask & M_ATA;
  98.         case 3:
  99.             return mask & M_AINC;
  100.         case 4:
  101.             return mask & M_ADEC;
  102.         case 5:
  103.             return mask & M_AOFF;
  104.         case 6:
  105.             return mask & M_AX;
  106.         }
  107. }
  108.  
  109. ix_str(n)
  110. {
  111.     int op, r;
  112.     char c;
  113.     char *fmt;
  114.  
  115.     op = nextw();
  116.     r = (op>>12) & 7;
  117.     c = (op & 0x800) ? 'l' : 'w';
  118.     if (n >= 8) {
  119.         if (op<0)
  120.             fmt = "%i(pc,%a.%c)";
  121.         else
  122.             fmt = "%i(pc,%d.%c)";
  123.         prtf(fmt, (char)op, r, c);
  124.     } else {
  125.         if (op < 0)
  126.             fmt = "%i(%a,%a.%c)";
  127.         else
  128.             fmt = "%i(%a,%d.%c)";
  129.         prtf(fmt, (char)op, n, r, c);
  130.     }
  131. }
  132.  
  133. modepr(mode,reg)
  134. {
  135.     char *p;
  136.  
  137.     switch (mode) {
  138.     case 0:
  139.         prtf("%d", reg);
  140.         break;
  141.     case 1:
  142.         prtf("%a", reg);
  143.         break;
  144.     case 2:
  145.         prtf("(%a)", reg);
  146.         break;
  147.     case 3:
  148.         prtf("(%a)+", reg);
  149.         break;
  150.     case 4:
  151.         prtf("-(%a)", reg);
  152.         break;
  153.     case 5:
  154.         prtf("%i(%a)", nextw(), reg);
  155.         break;
  156.     case 6:
  157.         ix_str(reg);
  158.         break;
  159.     case 7:
  160.         switch (reg) {
  161.         case 0:
  162.             prtf("%i", nextw());
  163.             break;
  164.         case 1:
  165.             longval();
  166.             break;
  167.         case 2:
  168.             prtf("%i(pc)", nextw());
  169.             break;
  170.         case 3:
  171.             ix_str(8);
  172.             break;
  173.         case 4:
  174.             switch (cursz) {
  175.             case 0:
  176.             case 1:
  177.                 prtf("#%i", nextw());
  178.                 break;
  179.             case 2:
  180.                 putchr('#');
  181.                 longval();
  182.                 break;
  183.             }
  184.             break;
  185.         }
  186.     }
  187. }
  188.  
  189. longval()
  190. {
  191.     long l;
  192.     struct sym *sp;
  193.  
  194.     prtf("%A", nextl());
  195. }
  196.  
  197. char szchr[] = { 'b', 'w', 'l' };
  198.  
  199. struct optbl {
  200.     char sel[6];
  201.     char *name;
  202.     int allow;
  203.     char arg[4];
  204.     char sz;
  205. };
  206.  
  207. struct optbl t0[] = {
  208.     { "0s", "or", 05770, "ie"},
  209.     { "00", "or", 1, "ic"},
  210.     { "01", "or", 1, "is", 1},
  211.     { "*4", "btst", 05777, "De"},
  212.     { "*5", "bchg", 05770, "De"},
  213.     { "*6", "bclr", 05770, "De"},
  214.     { "*7", "bset", 05770, "De"},
  215.     { "*4", "movep.w", 02000, "oD"},
  216.     { "*5", "movep.l", 02000, "oD"},
  217.     { "*6", "movep.w", 02000, "Do"},
  218.     { "*7", "movep.l", 02000, "Do"},
  219.     { "1s", "and", 05770, "ie"},
  220.     { "10", "and", 1, "ic"},
  221.     { "11", "and", 1, "is", 1},
  222.     { "2s", "sub", 05770, "ie"},
  223.     { "3s", "add", 05770, "ie"},
  224.     { "40", "btst", 05776, "ie"},
  225.     { "41", "bchg", 05770, "ie"},
  226.     { "42", "bclr", 05770, "ie"},
  227.     { "43", "bset", 05770, "ie"},
  228.     { "5s", "eor", 05770, "ie"},
  229.     { "50", "eor", 1, "ic"},
  230.     { "51", "eor", 1, "is", 1},
  231.     { "6s", "cmp", 05770, "ie"},
  232.     { 0, 0, 0, 0 }
  233. };
  234.  
  235. op0(op)
  236. {
  237.     return tblop(op, t0);
  238. }
  239.  
  240. match(c, val)
  241. {
  242.     switch (c) {
  243.     case '*':
  244.         return 1;
  245.     case 's':
  246.         return val <= 2;
  247.     case 'S':
  248.         return val >= 4 && val <= 6;
  249.     case 'z':
  250.         return val >= 1 && val <= 2;
  251.     case 'Z':
  252.         return val == 3 || val == 7;
  253.     default:
  254.         return val == (c - '0');
  255.     }
  256. }
  257.  
  258. op1(op)
  259. {
  260.     int sm, sr, dm, dr;
  261.  
  262.     sm = (op>>3) & 7;
  263.     sr = op & 7;
  264.     dm = (op>>6) & 7;
  265.     dr = (op>>9) & 7;
  266.     cursz = 0;
  267.     if (valid(sm,sr,07777) && valid(dm,dr,05770)) {
  268.         prt("move.b\t");
  269.         modepr(sm,sr);
  270.         putchr(',');
  271.         modepr(dm,dr);
  272.         return 1;
  273.     }
  274.     return 0;
  275. }
  276.  
  277. op2(op)
  278. {
  279.     int sm, sr, dm, dr;
  280.  
  281.     sm = (op>>3) & 7;
  282.     sr = op & 7;
  283.     dm = (op>>6) & 7;
  284.     dr = (op>>9) & 7;
  285.     cursz = 2;
  286.     if (valid(sm,sr,07777) && valid(dm,dr,07770)) {
  287.         prt("move.l\t");
  288.         modepr(sm,sr);
  289.         putchr(',');
  290.         modepr(dm,dr);
  291.         return 1;
  292.     }
  293.     return 0;
  294. }
  295.  
  296. op3(op)
  297. {
  298.     int sm, sr, dm, dr;
  299.  
  300.     sm = (op>>3) & 7;
  301.     sr = op & 7;
  302.     dm = (op>>6) & 7;
  303.     dr = (op>>9) & 7;
  304.     cursz = 1;
  305.     if (valid(sm,sr,07777) && valid(dm,dr,07770)) {
  306.         prt("move.w\t");
  307.         modepr(sm,sr);
  308.         putchr(',');
  309.         modepr(dm,dr);
  310.         return 1;
  311.     }
  312.     return 0;
  313. }
  314.  
  315. struct optbl t4[] = {
  316.     { "0s", "negx", 05770, "e"},
  317.     { "03", "move.w", 05770, "se"},
  318.     { "*6", "chk", 05777, "eD"},
  319.     { "*7", "lea", 01176, "eA"},
  320.     { "1s", "clr", 05770, "e"},
  321.     { "2s", "neg", 05770, "e"},
  322.     { "23", "move.b", 05777, "ec"},
  323.     { "3s", "not", 05770, "e"},
  324.     { "33", "move.w", 05777, "es", 1},
  325.     { "40", "nbcd", 05770, "e"},
  326.     { "41", "swap", 04000, "d"},
  327.     { "41", "pea", 01176, "e"},
  328.     { "42", "ext.w", 04000, "d"},
  329.     { "42", "movem.w", 01170, "le"},
  330.     { "42", "movem.w", 00200, "Le"},
  331.     { "43", "movem.l", 01170, "le"},
  332.     { "43", "movem.l", 00200, "Le"},
  333.     { "43", "ext.l", 04000, "d"},
  334.     { "5s", "tst", 05770, "e"},
  335.     { "53", "tas", 05770, "e"},
  336.     { "53", "illegal", 0001, ""},
  337.     { "71", "trap", 06000, "t"},
  338.     { "71", "link", 01000, "ai", 1},
  339.     { "71", "unlk", 00400, "a"},
  340.     { "71", "move", 00200, "au"},
  341.     { "71", "move", 00100, "ua"},
  342.     { "7160", "reset", 0, ""},
  343.     { "7161", "nop", 0, ""},
  344.     { "7162", "stop", 0, ""},
  345.     { "7163", "rte", 0, ""},
  346.     { "7165", "rts", 0, ""},
  347.     { "7166", "trapv", 0, ""},
  348.     { "7167", "rtr", 0, ""},
  349.     { "72", "jsr", 01176, "e"},
  350.     { "73", "jmp", 01176, "e"},
  351.     { 0, 0, 0, 0 }
  352. };
  353.  
  354. op4(op)
  355. {
  356.     int mode, reg, list;
  357.  
  358.     if ((op & 07600) == 06200) {
  359.         reg = op & 7;
  360.         mode = (op>>3) & 7;
  361.         if (valid(mode,reg,01576)) {
  362.             prtf("movem.%c\t", op & 0100 ? 'l' : 'w');
  363.             list = nextw();
  364.             modepr(mode,reg);
  365.             putchr(',');
  366.             rlist(list);
  367.             return 1;
  368.         } else
  369.             return 0;
  370.     }
  371.     return tblop(op, t4);
  372. }
  373.  
  374. tblop(op, tp)
  375. register struct optbl *tp;
  376. {
  377.     int mode, reg;
  378.     int hi,lo;
  379.  
  380.     reg = op & 7;
  381.     mode = (op>>3) & 7;
  382.     lo = (op>>6) & 7;
  383.     hi = (op>>9) & 7;
  384.  
  385.     for (; tp->name; tp++)
  386.         if (match(tp->sel[0], hi) &&
  387.             match(tp->sel[1], lo) &&
  388.             (tp->allow == 0 || valid(mode,reg,tp->allow)) &&
  389.             (tp->sel[2] == 0 || match(tp->sel[2], mode)) &&
  390.             (tp->sel[3] == 0 || match(tp->sel[3], reg)) ) {
  391.  
  392.             prt(tp->name);
  393.  
  394.             switch (tp->sel[1]) {
  395.             case 's':
  396.                 cursz = lo;
  397.                 break;
  398.             case 'S':
  399.                 cursz = lo-4;
  400.                 break;
  401.             case 'z':
  402.                 cursz = (lo==1) ? 1 : 2;
  403.                 break;
  404.             case 'Z':
  405.                 cursz = (lo==3) ? 1 : 2;
  406.                 break;
  407.             default:
  408.                 cursz = tp->sz;
  409.                 goto noszpr;
  410.             }
  411.  
  412.             prtf(".%c", szchr[cursz]);
  413. noszpr:
  414.             putchr('\t');
  415.  
  416.             if (tp->arg[0]) {
  417.                 puta(tp->arg[0],op);
  418.                 if (tp->arg[1]) {
  419.                     putchr(',');
  420.                     puta(tp->arg[1],op);
  421.                 }
  422.             }
  423.             return 1;
  424.         }
  425.     return 0;
  426. }
  427.  
  428. puta(c, op)
  429. {
  430.     int reg,mode,hi;
  431.  
  432.     reg = op & 7;
  433.     mode = (op>>3) & 7;
  434.     hi = (op>>9) & 7;
  435.  
  436.     switch (c) {
  437.     case 'i':
  438.         modepr(7,4);
  439.         break;
  440.     case 'e':
  441.         modepr(mode,reg);
  442.         break;
  443.     case 'c':
  444.         prt("ccr");
  445.         break;
  446.     case 's':
  447.         prt("sr");
  448.         break;
  449.     case 'D':
  450.         modepr(0,hi);
  451.         break;
  452.     case 'd':
  453.         modepr(0,reg);
  454.         break;
  455.     case 'A':
  456.         modepr(1,hi);
  457.         break;
  458.     case 'a':
  459.         modepr(1,reg);
  460.         break;
  461.     case 'o':
  462.         modepr(5,reg);
  463.         break;
  464.     case 'm':
  465.         modepr(4,reg);
  466.         break;
  467.     case 'M':
  468.         modepr(4,hi);
  469.         break;
  470.     case 'p':
  471.         modepr(3,reg);
  472.         break;
  473.     case 'P':
  474.         modepr(3,hi);
  475.         break;
  476.     case 'l':
  477.         rlist(nextw());
  478.         break;
  479.     case 'L':
  480.         blist(nextw());
  481.         break;
  482.     case 'u':
  483.         prt("usp");
  484.         break;
  485.     case 't':
  486.         prtf("#%i", op & 0xf);
  487.         break;
  488.     case 'k':
  489.         prtf("#%i", hi ? hi : 8);
  490.         break;
  491.     }
  492. }
  493.  
  494. rlist(x)
  495. {
  496.     int as, ds;
  497.  
  498.     ds = x & 0xff;
  499.     as = (x>>8) & 0xff;
  500.     putchr('[');
  501.     if (ds) {
  502.         listc('d', ds);
  503.         if (as) {
  504.             putchr(',');
  505.             listc('a', as);
  506.         }
  507.     } else if (as)
  508.         listc('a', as);
  509.     putchr(']');
  510. }
  511.  
  512. listc(c, x)
  513. char c;
  514. {
  515.     int i;
  516.  
  517.     for (i=0; i<8; )
  518.         if (x & (1<<i))
  519.             i += chunk(c, x, i);
  520.         else
  521.             i++;
  522. }
  523.  
  524. chunk(c, x, i)
  525. char c;
  526. {
  527.     int j;
  528.  
  529.     putchr(c);
  530.     j = cnt1s(x>>i);
  531.     if (j == 1) {
  532.         putchr('0'+i);
  533.         return j;
  534.     } else {
  535.         putchr('0'+i);
  536.         putchr('-');
  537.         putchr('0'+i+(j-1));
  538.         return j;
  539.     }
  540. }
  541.  
  542. cnt1s(x)
  543. {
  544.     int i;
  545.  
  546.     for (i=0; i<9; i++)
  547.         if ((x & (1<<i)) == 0)
  548.             return i;
  549. }
  550.  
  551. blist(x)
  552. {
  553.     int y;
  554.     int i;
  555.     unsigned uw = 0x8000;
  556.  
  557.     y = 0;
  558.     for (i=0; i<16; i++)
  559.         if (x & (1<<i))
  560.             y |= (uw>>i);
  561.     rlist(y);
  562. }
  563.  
  564. char *bnm[] = {    "t", "f", "hi", "ls",
  565.         "cc", "cs", "ne", "eq",
  566.         "vc", "vs", "pl", "mi",
  567.         "ge", "lt", "gt", "le" };
  568.  
  569. op5(op)
  570. {
  571.     int cond, mode, reg;
  572.     int sz, k;
  573.     long svdot = DOT;
  574.  
  575.     sz = (op>>6) & 3;
  576.     reg = op & 7;
  577.     mode = (op>>3) & 7;
  578.  
  579.     if (sz == 3) {
  580.         cond = (op>>8) & 0xf;
  581.         if (mode == 1) {
  582.             prtf("db%s\t%d,%A", bnm[cond], reg,
  583.                 svdot+nextw());
  584.             return 1;
  585.         } else if (valid(mode,reg,05770)) {
  586.             prtf("s%s\t", bnm[cond]);
  587.             modepr(mode,reg);
  588.             return 1;
  589.         }
  590.     } else {
  591.         k = (op>>9) & 7;
  592.         if (k == 0) k = 8;
  593.         if (valid(mode,reg, sz ? 07770 : 05770)) {
  594.             prtf((op&0x100) ? "subq.%c\t" : "addq.%c\t",
  595.                 szchr[sz]);
  596.             prtf("#%i,", k);
  597.             modepr(mode,reg);
  598.             return 1;
  599.         }
  600.     }
  601.     return 0;
  602. }
  603.  
  604. op6(op)
  605. {
  606.     int cond, k;
  607.     long svdot = DOT;
  608.  
  609.     cond = (op>>8) & 0xf;
  610.     k = (char)op;
  611.     if (k == 0)
  612.         svdot += nextw();
  613.     else
  614.         svdot += k;
  615.     if (cond < 2)
  616.         prt(cond ? "bsr" : "bra");
  617.     else
  618.         prtf("b%s", bnm[cond]);
  619.     prtf("\t%A", svdot);
  620.     return 1;
  621. }
  622.  
  623. op7(op)
  624. {
  625.     int reg, k;
  626.  
  627.     if (op & 0x100)
  628.         return;
  629.     k = (char)op;
  630.     reg = (op>>9) & 7;
  631.     prtf("moveq\t#%i,%d", k, reg);
  632.     return 1;
  633. }
  634.  
  635. struct optbl t8[] = {
  636.     { "*s", "or", 05777, "eD"},
  637.     { "*S", "or", 01770, "De"},
  638.     { "*3", "divu", 05777, "eD"},
  639.     { "*7", "divs", 05777, "eD"},
  640.     { "*4", "sbcd", 04000, "dD"},
  641.     { "*4", "sbcd", 02000, "mM"},
  642.     { 0, 0, 0, 0}
  643. };
  644.  
  645. op8(op)
  646. {
  647.     return tblop(op, t8);
  648. }
  649.  
  650. struct optbl t9[] = {
  651.     {"*0", "sub.b", 05777, "eD"},
  652.     {"*z", "sub", 07777, "eD"},
  653.     {"*S", "sub", 01770, "De"},
  654.     {"*Z", "sub", 07777, "eA"},
  655.     {"*S", "subx", 04000, "dD"},
  656.     {"*S", "subx", 02000, "mM"},
  657.     { 0, 0, 0, 0}
  658. };
  659.  
  660. op9(op)
  661. {
  662.     return tblop(op, t9);
  663. }
  664.  
  665. opa()
  666. {
  667.     return 0;
  668. }
  669.  
  670. struct optbl tb[] = {
  671.     {"*0", "cmp.b", 05777, "eD"},
  672.     {"*z", "cmp", 07777, "eD"},
  673.     {"*Z", "cmp", 07777, "eA"},
  674.     {"*S", "eor", 05770, "De"},
  675.     {"*S", "cmpm", 02000, "pP"},
  676.     {0, 0, 0, 0}
  677. };
  678.  
  679. opb(op)
  680. {
  681.     return tblop(op, tb);
  682. }
  683.  
  684. struct optbl tc[] = {
  685.     {"*s", "and", 05777, "eD"},
  686.     {"*S", "and", 01770, "De"},
  687.     {"*3", "mulu", 05777, "eD"},
  688.     {"*7", "muls", 05777, "eD"},
  689.     {"*4", "abcd", 04000, "dD"},
  690.     {"*4", "abcd", 02000, "mM"},
  691.     {"*5", "exg", 04000, "dD"},
  692.     {"*5", "exg", 02000, "aA"},
  693.     {"*6", "exg", 02000, "aD"},
  694.     {0, 0, 0, 0}
  695. };
  696.  
  697. opc(op)
  698. {
  699.     return tblop(op, tc);
  700. }
  701.  
  702. struct optbl td[] = {
  703.     {"*0", "add.b", 05777, "eD"},
  704.     {"*z", "add", 07777, "eD"},
  705.     {"*S", "add", 01770, "De"},
  706.     {"*Z", "add", 07777, "eA"},
  707.     {"*S", "addx", 04000, "dD"},
  708.     {"*S", "addx", 02000, "mM"},
  709.     { 0, 0, 0, 0}
  710. };
  711.  
  712. opd(op)
  713. {
  714.     return tblop(op, td);
  715. }
  716.  
  717. char *shiftnm[] = { "as", "ls", "rox", "ro" };
  718.  
  719. ope(op)
  720. {
  721.     int sz, c_r;
  722.     int mode, reg;
  723.  
  724.     sz = (op>>6) & 3;
  725.     if (sz == 3) {
  726.         mode = (op>>3) & 7;
  727.         reg = op & 7;
  728.         if (valid(mode,reg,01770)) {
  729.             prtf("%s%c.w\t #1,", shiftnm[(op>>9)&3],
  730.                 (op&0x100) ? 'l' : 'r');
  731.             modepr(mode,reg);
  732.             return 1;
  733.         }
  734.     } else {
  735.         prtf("%s%c.%c\t", shiftnm[(op>>3)&3],
  736.             (op&0x100) ? 'l' : 'r',
  737.             szchr[sz]);
  738.         c_r = (op>>9) & 7;
  739.         if (op & 040)
  740.             prtf("%d", c_r);
  741.         else
  742.             prtf("#%i", c_r ? c_r : 8);
  743.         prtf(",%d", op & 7);
  744.         return 1;
  745.     }
  746.     return 0;
  747. }
  748.  
  749. opf()
  750. {
  751.     return 0;
  752. }
  753.