Post-ansification changes for lib/c2

diff --git a/bin/as/instrs b/bin/as/instrs
index 2b26555..089eba8 100644 (file)
--- a/bin/as/instrs
+++ b/bin/as/instrs
@@ -154,43 +154,43 @@ BEGIN{
                if (flavor == "C2"){
                        if ($5 == "C2X")
                                next;
-                       printf("\"%s\",", $3);
+                       printf("{\"%s\",", $3);
                        if ($4 == "CBR" && $5 != "JBR"){
-                               printf("T(CBR,%s),\n", $5);
+                               printf("T(CBR,%s)},\n", $5);
                        } else {
-                               printf("%s,\n", $5);
+                               printf("%s},\n", $5);
                        }
                        next;
                }
        }
 
        if (flavor == "C2"){
-               printf("\"%s\",", $3);
+               printf("{\"%s\",", $3);
                if ($4 == "HARD"){              # 0 value
-                       printf("0,\n");
+                       printf("0},\n");
                        next;
                }
                if ($5 == "S"){                 # single value
-                       printf("%s,\n", $4);
+                       printf("%s},\n", $4);
                        next;
                }
                if ($5 == "TN1"){               # use type of 1st operand
-                       printf("T(%s,TYP%s),\n", $4, $10);
+                       printf("T(%s,TYP%s)},\n", $4, $10);
                        next;
                }
                if ($5 == "TN3"){               # use type of 3rd operand
-                       printf("T(%s,TYP%s),\n", $4, $14);
+                       printf("T(%s,TYP%s)},\n", $4, $14);
                        next;
                }
                if ($5 == "TNX2"){              # cross product of 1st and 2nd operand
-                       printf("T(%s,U(TYP%s,TYP%s)),\n", $4, $10, $12);
+                       printf("T(%s,U(TYP%s,TYP%s))},\n", $4, $10, $12);
                        next;
                }
                if ($5 == "OP"){                # arithmetic operator
-                       printf("T(%s,U(TYP%s,OP%d)),\n", $4, $10, $8);
+                       printf("T(%s,U(TYP%s,OP%d))},\n", $4, $10, $8);
                        next;
                }
-               printf("T(%s,%s),\n", $4, $5);  # special value
+               printf("T(%s,%s)},\n", $4, $5); # special value
                next;
        }
        if (flavor == "AS"){

diff --git a/lib/c2/c2.h b/lib/c2/c2.h
index dfe9c0b..e0aac61 100644 (file)
--- a/lib/c2/c2.h
+++ b/lib/c2/c2.h
@@ -228,54 +228,54 @@ struct optab *getline __P((void));
 long getnum __P((register char *p));
 int locuse __P((register char *p));
 int locdef __P((register char *p));
-int output __P((void));
+void output __P((void));
 char *copy __P((char *ap));
-int opsetup __P((void));
+void opsetup __P((void));
 struct optab *oplook __P((void));
-int refcount __P((void));
-int iterate __P((void));
-int xjump __P((register struct node *p1));
+void refcount __P((void));
+void iterate __P((void));
+void xjump __P((register struct node *p1));
 struct node *insertl __P((register struct node *np));
 struct node *codemove __P((struct node *ap));
-int comjump __P((void));
-int backjmp __P((struct node *ap1, struct node *ap2));
+void comjump __P((void));
+void backjmp __P((struct node *ap1, struct node *ap2));
 
 /* c21.c */
 int redun3 __P((register struct node *p, int split));
-int bmove __P((void));
-int rmove __P((void));
+void bmove __P((void));
+void rmove __P((void));
 char *byondrd __P((register struct node *p));
 struct node *bflow __P((register struct node *p));
 int ispow2 __P((register long n));
-int bitopt __P((register struct node *p));
+void bitopt __P((register struct node *p));
 int isfield __P((register long n));
 int bixprep __P((register struct node *p, int bix));
 struct node *bicopt __P((register struct node *p));
 int jumpsw __P((void));
-int addsob __P((void));
+void addsob __P((void));
 int equop __P((register struct node *p1, struct node *p2));
-int XXXdelnode __P((register struct node *p));
-int XXXdecref __P((register struct node *p));
+void delnode __P((register struct node *p));
+void decref __P((register struct node *p));
 struct node *nonlab __P((struct node *ap));
-int clearuse __P((void));
-int clearreg __P((void));
-int savereg __P((int ai, register char *s, int type));
-int dest __P((register char *s, int type));
-int splitrand __P((struct node *p));
+void clearuse __P((void));
+void clearreg __P((void));
+void savereg __P((int ai, register char *s, int type));
+void dest __P((register char *s, int type));
+void splitrand __P((struct node *p));
 int compat __P((int have, int want));
 int equtype __P((int t1, int t2));
 int findrand __P((char *as, int type));
 int isreg __P((register char *s));
-int check __P((void));
+void check __P((void));
 int source __P((char *ap));
-int newcode __P((struct node *p));
-int repladdr __P((struct node *p));
-int redunbr __P((register struct node *p));
+void newcode __P((struct node *p));
+void repladdr __P((struct node *p));
+void redunbr __P((register struct node *p));
 char *findcon __P((int i, int type));
 int compare __P((int opc, char *acp1, char *acp2));
-int setcon __P((register char *cv, register char *cl, int type));
+void setcon __P((register char *cv, register char *cl, int type));
 int equstr __P((register char *p1, register char *p2));
-int setcc __P((char *ap, int type));
+void setcc __P((char *ap, int type));
 int okio __P((register char *p));
 int indexa __P((register char *p));
 int natural __P((register char *p));

diff --git a/lib/c2/c20.c b/lib/c2/c20.c
index 4ceff0a..19356b1 100644 (file)
--- a/lib/c2/c20.c
+++ b/lib/c2/c20.c
@@ -331,7 +331,7 @@ int locdef(p) register char *p; {
        return (lgensym[p[0] - '0']++);
 }
 
-int output() {
+void output() {
        register struct node *t;
        int casebas;
 
@@ -441,7 +441,7 @@ char *copy(ap) char *ap; {
 #define        OPHS    560
 struct optab *ophash[OPHS];
 
-int opsetup() {
+void opsetup() {
        register struct optab *optp, **ophp;
        register int i,t;
 
@@ -478,7 +478,7 @@ struct optab *oplook() {
        return(&OPNULL);
 }
 
-int refcount() {
+void refcount() {
        register struct node *p, *lp, *tp;
        struct node *labhash[LABHS];
        register struct node **hp;
@@ -518,7 +518,7 @@ int refcount() {
                        decref(p);
 }
 
-int iterate() {
+void iterate() {
        register struct node *p, *rp, *p1;
 
        nchange = 0;
@@ -591,7 +591,7 @@ int iterate() {
        }
 }
 
-int xjump(p1) register struct node *p1; {
+void xjump(p1) register struct node *p1; {
        register struct node *p2, *p3;
 
        if ((p2 = p1->ref)==0)
@@ -721,7 +721,7 @@ ivloop:
        return(p3);
 }
 
-int comjump() {
+void comjump() {
        register struct node *p1, *p2, *p3;
 
        for (p1 = first.forw; p1!=0; p1 = p1->forw)
@@ -732,7 +732,7 @@ int comjump() {
                                        backjmp(p1, p3);
 }
 
-int backjmp(ap1, ap2) struct node *ap1; struct node *ap2; {
+void backjmp(ap1, ap2) struct node *ap1; struct node *ap2; {
        register struct node *p1, *p2, *p3;
 
        p1 = ap1;

diff --git a/lib/c2/c21.c b/lib/c2/c21.c
index 2df7ec1..b6bcd37 100644 (file)
--- a/lib/c2/c21.c
+++ b/lib/c2/c21.c
@@ -4,6 +4,12 @@
 /*#include <strings.h> gen.h*/
 #include "c2.h"
 
+#ifdef __STDC__
+#include <stdint.h>
+#else
+typedef int intptr_t;
+#endif
+
 #if defined(DOSCCS) && !defined(lint)
 static char sccsid[] = "@(#)c21.c 4.19 4/27/86";
 #endif
@@ -59,7 +65,7 @@ int redun3(p, split) register struct node *p; int split; {
        } return(0);
 }
 
-int bmove() {
+void bmove() {
        register struct node *p, *lastp; register char *cp1,*cp2; register int r;
        refcount();
        for (p=lastp= &first; 0!=(p=p->forw); lastp=p);
@@ -82,7 +88,7 @@ int bmove() {
        switch (p->op) {
        case LABEL: case DLABEL:
                for (r=NUSE; --r>=0;)
-                       if (uses[r]) p->ref=(struct node *) (((int)p->ref)|biti[r]);
+                       if (uses[r]) p->ref=(struct node *) (((intptr_t)p->ref)|biti[r]);
                break;
        case CALLS:
                clearuse(); goto std;
@@ -383,7 +389,7 @@ ashadd:
                /* fall through */
        case CBR:
                if (p->ref->ref!=0) for (r=NUSE;--r>=0;)
-                       if (biti[r] & (int)p->ref->ref) {uses[r]=p; regs[r][0]= -1;}
+                       if (biti[r] & (intptr_t)p->ref->ref) {uses[r]=p; regs[r][0]= -1;}
        case EROU: case JSW:
        case TEXT: case DATA: case BSS: case ALIGN: case WGEN: case END: ;
        }
@@ -392,7 +398,7 @@ ashadd:
                if (p->op==LABEL || p->op==DLABEL) p->ref=0;    /* erase our tracks */
 }
 
-int rmove() {
+void rmove() {
        register struct node *p;
        register int r;
        int r1;
@@ -714,7 +720,7 @@ int ispow2(n) register long n; {/* -1 -> no; else -> log to base 2 */
        for (;;) {n >>= 1; if (n==0) return(log); ++log; if (n== -1) return(log);}
 }
 
-int bitopt(p) register struct node *p; {
+void bitopt(p) register struct node *p; {
        /* change "bitx $<power_of_2>,a" followed by JEQ or JNE
        /* into JBC or JBS.  watch out for I/O registers. (?)
        /* assumes that 'splitrand' has already been called.
@@ -899,7 +905,7 @@ int jumpsw() {
        return(nj);
 }
 
-int addsob() {
+void addsob() {
        register struct node *p, *p1, *p2, *p3;
 
        for (p = &first; (p1 = p->forw)!=0; p = p1) {
@@ -978,14 +984,14 @@ int equop(p1, p2) register struct node *p1; struct node *p2; {
 }
 
 #ifndef delnode
-int XXXdelnode(p) register struct node *p; {
+void delnode(p) register struct node *p; {
        p->back->forw = p->forw;
        p->forw->back = p->back;
 }
 #endif
 
 #ifndef decref
-int XXXdecref(p) register struct node *p; {
+void decref(p) register struct node *p; {
        if (p && --p->refc <= 0) {
                nrlab++;
                delnode(p);
@@ -1002,12 +1008,12 @@ struct node *nonlab(ap) struct node *ap; {
        return(p);
 }
 
-int clearuse() {
+void clearuse() {
        register struct node **i;
        for (i=uses+NUSE; i>uses;) *--i=0;
 }
 
-int clearreg() {
+void clearreg() {
        register char **i;
        for (i=regs; i<regs+NREG; ++i) {
                **i = 0;
@@ -1017,7 +1023,7 @@ int clearreg() {
        ccloc[0] = 0;
 }
 
-int savereg(ai, s, type) int ai; register char *s; int type; {
+void savereg(ai, s, type) int ai; register char *s; int type; {
        register char *p, *sp;
 
        sp = p = regs[ai];
@@ -1030,7 +1036,7 @@ int savereg(ai, s, type) int ai; register char *s; int type; {
                if (*s=='[' || *s++=='(' && *s!='a' && *s!='f') {*sp = 0; return;}
 }
 
-int dest(s, type) register char *s; int type; {
+void dest(s, type) register char *s; int type; {
        register int i;
 
        (void) source(s); /* handle addressing side effects */
@@ -1081,7 +1087,7 @@ int dest(s, type) register char *s; int type; {
 }
 
 /* separate operands at commas, set up 'regs' and 'lastrand' */
-int splitrand(p) struct node *p; {
+void splitrand(p) struct node *p; {
        register char *p1, *p2;
        register char **preg;
 
@@ -1128,7 +1134,7 @@ int isreg(s) register char *s; {
        return(-1);
 }
 
-int check() {
+void check() {
        register struct node *p, *lp;
 
        lp = &first;
@@ -1165,7 +1171,7 @@ int source(ap) char *ap; {
        return(0);
 }
 
-int newcode(p) struct node *p; {
+void newcode(p) struct node *p; {
        register char *p1,*p2,**preg;
        preg=regs+RT1; p2=line;
        while (*(p1= *preg++)) {while (*p2++= *p1++); *(p2-1)=',';}
@@ -1173,7 +1179,7 @@ int newcode(p) struct node *p; {
        p->code=copy(line);
 }
 
-int repladdr(p) struct node *p; {
+void repladdr(p) struct node *p; {
        register r;
        register char *p1;
        char **preg; int nrepl;
@@ -1236,7 +1242,7 @@ int repladdr(p) struct node *p; {
 /* }
 */
 
-int redunbr(p) register struct node *p; {
+void redunbr(p) register struct node *p; {
        register struct node *p1;
        register char *ap1;
        char *ap2;
@@ -1337,7 +1343,7 @@ int compare(opc, acp1, acp2) int opc; char *acp1; char *acp2; {
        return(0);
 }
 
-int setcon(cv, cl, type) register char *cv; register char *cl; int type; {
+void setcon(cv, cl, type) register char *cv; register char *cl; int type; {
        register char *p;
 
        if (*cv != '$')
@@ -1359,7 +1365,7 @@ int equstr(p1, p2) register char *p1; register char *p2; {
        return(1);
 }
 
-int setcc(ap, type) char *ap; int type; {
+void setcc(ap, type) char *ap; int type; {
        register char *p, *p1;
 
        p = ap;

diff --git a/lib/c2/c22.c b/lib/c2/c22.c
index f4bf834..da5f1ba 100644 (file)
--- a/lib/c2/c22.c
+++ b/lib/c2/c22.c
@@ -25,4 +25,5 @@ struct optab optab[] = {
 
 #include "./instrs.c2"
 
-0,     0};
+{"", 0}
+};

diff --git a/lib/c2/instrs.c2 b/lib/c2/instrs.c2
index 911d9d5..963c42c 100644 (file)
--- a/lib/c2/instrs.c2
+++ b/lib/c2/instrs.c2
@@ -3,369 +3,369 @@
 
 
 
-".word",WGEN,
-".int",LGEN,
-".long",LGEN,
+{".word",WGEN},
+{".int",LGEN},
+{".long",LGEN},
 
-".data",DATA,
-".text",TEXT,
-".align",ALIGN,
+{".data",DATA},
+{".text",TEXT},
+{".align",ALIGN},
 
 
-".globl",EROU,
-".comm",COMM,
-".lcomm",LCOMM,
-".set",SET,
+{".globl",EROU},
+{".comm",COMM},
+{".lcomm",LCOMM},
+{".set",SET},
 
 
 
 
-"jbc",T(CBR,JBC),
-"jlbc",T(CBR,JLBC),
-"jbs",T(CBR,JBS),
-"jlbs",T(CBR,JLBS),
-"jbcc",T(CBR,JBCC),
-"jbsc",T(CBR,JBSC),
-"jbcs",T(CBR,JBCS),
-"jbss",T(CBR,JBSS),
+{"jbc",T(CBR,JBC)},
+{"jlbc",T(CBR,JLBC)},
+{"jbs",T(CBR,JBS)},
+{"jlbs",T(CBR,JLBS)},
+{"jbcc",T(CBR,JBCC)},
+{"jbsc",T(CBR,JBSC)},
+{"jbcs",T(CBR,JBCS)},
+{"jbss",T(CBR,JBSS)},
 
-"jbr",JBR,
-"jlss",T(CBR,JLT),
-"jlssu",T(CBR,JLO),
-"jleq",T(CBR,JLE),
-"jlequ",T(CBR,JLOS),
-"jeql",T(CBR,JEQ),
-"jeqlu",T(CBR,JEQ),
-"jneq",T(CBR,JNE),
-"jnequ",T(CBR,JNE),
-"jgeq",T(CBR,JGE),
-"jgequ",T(CBR,JHIS),
-"jgtr",T(CBR,JGT),
-"jgtru",T(CBR,JHI),
+{"jbr",JBR},
+{"jlss",T(CBR,JLT)},
+{"jlssu",T(CBR,JLO)},
+{"jleq",T(CBR,JLE)},
+{"jlequ",T(CBR,JLOS)},
+{"jeql",T(CBR,JEQ)},
+{"jeqlu",T(CBR,JEQ)},
+{"jneq",T(CBR,JNE)},
+{"jnequ",T(CBR,JNE)},
+{"jgeq",T(CBR,JGE)},
+{"jgequ",T(CBR,JHIS)},
+{"jgtr",T(CBR,JGT)},
+{"jgtru",T(CBR,JHI)},
 
 
-"chmk",0,
-"chme",0,
-"chms",0,
-"chmu",0,
-"prober",T(PROBER,TYPB),
-"probew",T(PROBEW,TYPB),
-"rei",0,
-"ldpctx",0,
-"svpctx",0,
-"mtpr",T(MTPR,TYPL),
-"mfpr",T(MFPR,TYPL),
-"xfc",0,
-"bpt",0,
-"bugw",0,
-"bugl",0,
-"halt",0,
-"movb",T(MOV,TYPB),
-"movw",T(MOV,TYPW),
-"movl",T(MOV,TYPL),
-"movq",T(MOV,TYPQ),
-"movo",T(MOV,TYPO),
-"movf",T(MOV,TYPF),
-"movd",T(MOV,TYPD),
-"movg",T(MOV,TYPG),
-"movh",T(MOV,TYPH),
-"pushl",T(PUSH,TYPL),
-"clrb",T(CLR,TYPB),
-"clrw",T(CLR,TYPW),
-"clrf",T(CLR,TYPF),
-"clrl",T(CLR,TYPL),
-"clrd",T(CLR,TYPD),
-"clrg",T(CLR,TYPG),
-"clrq",T(CLR,TYPQ),
-"clrh",T(CLR,TYPH),
-"clro",T(CLR,TYPO),
-"mnegb",T(NEG,TYPB),
-"mnegw",T(NEG,TYPW),
-"mnegl",T(NEG,TYPL),
-"mnegf",T(NEG,TYPF),
-"mnegg",T(NEG,TYPG),
-"mnegd",T(NEG,TYPD),
-"mnegh",T(NEG,TYPH),
-"mcomb",T(COM,TYPB),
-"mcomw",T(COM,TYPW),
-"mcoml",T(COM,TYPL),
-"cvtbw",T(CVT,U(TYPB,TYPW)),
-"cvtbl",T(CVT,U(TYPB,TYPL)),
-"cvtwb",T(CVT,U(TYPW,TYPB)),
-"cvtwl",T(CVT,U(TYPW,TYPL)),
-"cvtlb",T(CVT,U(TYPL,TYPB)),
-"cvtlw",T(CVT,U(TYPL,TYPW)),
-"cvtbf",T(CVT,U(TYPB,TYPF)),
-"cvtbd",T(CVT,U(TYPB,TYPD)),
-"cvtbg",T(CVT,U(TYPB,TYPG)),
-"cvtbh",T(CVT,U(TYPB,TYPH)),
-"cvtwf",T(CVT,U(TYPW,TYPF)),
-"cvtwd",T(CVT,U(TYPW,TYPD)),
-"cvtwg",T(CVT,U(TYPW,TYPG)),
-"cvtwh",T(CVT,U(TYPW,TYPH)),
-"cvtlf",T(CVT,U(TYPL,TYPF)),
-"cvtld",T(CVT,U(TYPL,TYPD)),
-"cvtlg",T(CVT,U(TYPL,TYPG)),
-"cvtlh",T(CVT,U(TYPL,TYPH)),
-"cvtfb",T(CVT,U(TYPF,TYPB)),
-"cvtdb",T(CVT,U(TYPD,TYPB)),
-"cvtgb",T(CVT,U(TYPG,TYPB)),
-"cvthb",T(CVT,U(TYPH,TYPB)),
-"cvtfw",T(CVT,U(TYPF,TYPW)),
-"cvtdw",T(CVT,U(TYPD,TYPW)),
-"cvtgw",T(CVT,U(TYPG,TYPW)),
-"cvthw",T(CVT,U(TYPH,TYPW)),
-"cvtfl",T(CVT,U(TYPF,TYPL)),
-"cvtrfl",T(CVT,U(TYPF,TYPL)),
-"cvtdl",T(CVT,U(TYPD,TYPL)),
-"cvtrdl",T(CVT,U(TYPD,TYPL)),
-"cvtgl",T(CVT,U(TYPG,TYPL)),
-"cvtrgl",T(CVT,U(TYPG,TYPL)),
-"cvthl",T(CVT,U(TYPH,TYPL)),
-"cvtrhl",T(CVT,U(TYPH,TYPL)),
-"cvtfd",T(CVT,U(TYPF,TYPD)),
-"cvtfg",T(CVT,U(TYPF,TYPG)),
-"cvtfh",T(CVT,U(TYPF,TYPH)),
-"cvtdf",T(CVT,U(TYPD,TYPF)),
-"cvtdh",T(CVT,U(TYPD,TYPH)),
-"cvtgf",T(CVT,U(TYPG,TYPF)),
-"cvtgh",T(CVT,U(TYPG,TYPH)),
-"cvthf",T(CVT,U(TYPH,TYPF)),
-"cvthd",T(CVT,U(TYPH,TYPD)),
-"cvthg",T(CVT,U(TYPH,TYPG)),
-"movzbw",T(MOVZ,U(TYPB,TYPW)),
-"movzbl",T(MOVZ,U(TYPB,TYPL)),
-"movzwl",T(MOVZ,U(TYPW,TYPL)),
-"cmpb",T(CMP,TYPB),
-"cmpw",T(CMP,TYPW),
-"cmpl",T(CMP,TYPL),
-"cmpf",T(CMP,TYPF),
-"cmpd",T(CMP,TYPD),
-"cmpg",T(CMP,TYPG),
-"cmph",T(CMP,TYPH),
-"incb",T(INC,TYPB),
-"incw",T(INC,TYPW),
-"incl",T(INC,TYPL),
-"tstb",T(TST,TYPB),
-"tstw",T(TST,TYPW),
-"tstl",T(TST,TYPL),
-"tstf",T(TST,TYPF),
-"tstd",T(TST,TYPD),
-"tstg",T(TST,TYPG),
-"tsth",T(TST,TYPH),
-"addb2",T(ADD,U(TYPB,OP2)),
-"addh2",T(ADD,U(TYPH,OP2)),
-"addb3",T(ADD,U(TYPB,OP3)),
-"addh3",T(ADD,U(TYPH,OP3)),
-"addw2",T(ADD,U(TYPW,OP2)),
-"addw3",T(ADD,U(TYPW,OP3)),
-"addl2",T(ADD,U(TYPL,OP2)),
-"addl3",T(ADD,U(TYPL,OP3)),
-"addf2",T(ADD,U(TYPF,OP2)),
-"addf3",T(ADD,U(TYPF,OP3)),
-"addd2",T(ADD,U(TYPD,OP2)),
-"addd3",T(ADD,U(TYPD,OP3)),
-"addg2",T(ADD,U(TYPG,OP2)),
-"addg3",T(ADD,U(TYPG,OP3)),
-"adwc",0,
-"adawi",0,
-"subb2",T(SUB,U(TYPB,OP2)),
-"subb3",T(SUB,U(TYPB,OP3)),
-"subw2",T(SUB,U(TYPW,OP2)),
-"subw3",T(SUB,U(TYPW,OP3)),
-"subl2",T(SUB,U(TYPL,OP2)),
-"subl3",T(SUB,U(TYPL,OP3)),
-"subf2",T(SUB,U(TYPF,OP2)),
-"subf3",T(SUB,U(TYPF,OP3)),
-"subd2",T(SUB,U(TYPD,OP2)),
-"subd3",T(SUB,U(TYPD,OP3)),
-"subg2",T(SUB,U(TYPG,OP2)),
-"subg3",T(SUB,U(TYPG,OP3)),
-"subh2",T(SUB,U(TYPH,OP2)),
-"subh3",T(SUB,U(TYPH,OP3)),
-"decb",T(DEC,TYPB),
-"decw",T(DEC,TYPW),
-"decl",T(DEC,TYPL),
-"sbwc",0,
-"mulb2",T(MUL,U(TYPB,OP2)),
-"mulb3",T(MUL,U(TYPB,OP3)),
-"mulw2",T(MUL,U(TYPW,OP2)),
-"mulw3",T(MUL,U(TYPW,OP3)),
-"mull2",T(MUL,U(TYPL,OP2)),
-"mull3",T(MUL,U(TYPL,OP3)),
-"mulf2",T(MUL,U(TYPF,OP2)),
-"mulf3",T(MUL,U(TYPF,OP3)),
-"muld2",T(MUL,U(TYPD,OP2)),
-"muld3",T(MUL,U(TYPD,OP3)),
-"mulg2",T(MUL,U(TYPG,OP2)),
-"mulg3",T(MUL,U(TYPG,OP3)),
-"mulh2",T(MUL,U(TYPH,OP2)),
-"mulh3",T(MUL,U(TYPH,OP3)),
-"emodf",0,
-"emul",0,
-"emodd",0,
-"emodg",0,
-"emodh",0,
-"divb2",T(DIV,U(TYPB,OP2)),
-"divb3",T(DIV,U(TYPB,OP3)),
-"divw2",T(DIV,U(TYPW,OP2)),
-"divw3",T(DIV,U(TYPW,OP3)),
-"divl2",T(DIV,U(TYPL,OP2)),
-"divl3",T(DIV,U(TYPL,OP3)),
-"divf2",T(DIV,U(TYPF,OP2)),
-"divf3",T(DIV,U(TYPF,OP3)),
-"divd2",T(DIV,U(TYPD,OP2)),
-"divd3",T(DIV,U(TYPD,OP3)),
-"divg2",T(DIV,U(TYPG,OP2)),
-"divg3",T(DIV,U(TYPG,OP3)),
-"divh2",T(DIV,U(TYPH,OP2)),
-"divh3",T(DIV,U(TYPH,OP3)),
-"ediv",0,
-"bitb",T(BIT,TYPB),
-"bitl",T(BIT,TYPL),
-"bitw",T(BIT,TYPW),
-"bisb2",T(BIS,U(TYPB,OP2)),
-"bisb3",T(BIS,U(TYPB,OP3)),
-"bisw2",T(BIS,U(TYPW,OP2)),
-"bisw3",T(BIS,U(TYPW,OP3)),
-"bisl2",T(BIS,U(TYPL,OP2)),
-"bisl3",T(BIS,U(TYPL,OP3)),
-"bicb2",T(BIC,U(TYPB,OP2)),
-"bicb3",T(BIC,U(TYPB,OP3)),
-"bicw2",T(BIC,U(TYPW,OP2)),
-"bicw3",T(BIC,U(TYPW,OP3)),
-"bicl2",T(BIC,U(TYPL,OP2)),
-"bicl3",T(BIC,U(TYPL,OP3)),
-"xorb2",T(XOR,U(TYPB,OP2)),
-"xorb3",T(XOR,U(TYPB,OP3)),
-"xorw2",T(XOR,U(TYPW,OP2)),
-"xorw3",T(XOR,U(TYPW,OP3)),
-"xorl2",T(XOR,U(TYPL,OP2)),
-"xorl3",T(XOR,U(TYPL,OP3)),
-"ashl",T(ASH,TYPL),
-"ashq",T(ASH,TYPQ),
-"rotl",0,
-"polyf",0,
-"polyd",0,
-"polyg",0,
-"polyh",0,
-"pushr",0,
-"popr",0,
-"movpsl",0,
-"bispsw",0,
-"bicpsw",0,
-"movab",T(MOVA,TYPB),
-"pushab",T(PUSHA,TYPB),
-"movaw",T(MOVA,TYPW),
-"pushaw",T(PUSHA,TYPW),
-"movaf",T(MOVA,TYPF),
-"moval",T(MOVA,TYPL),
-"pushaf",T(PUSHA,TYPF),
-"pushal",T(PUSHA,TYPL),
-"pushad",T(PUSHA,TYPD),
-"pushag",T(PUSHA,TYPG),
-"pushaq",T(PUSHA,TYPQ),
-"pushah",T(PUSHA,TYPH),
-"pushao",T(PUSHA,TYPO),
-"movad",T(MOVA,TYPD),
-"movag",T(MOVA,TYPG),
-"movaq",T(MOVA,TYPQ),
-"movah",T(MOVA,TYPH),
-"movao",T(MOVA,TYPO),
-"index",0,
-"insque",0,
-"remque",0,
-"insqhi",0,
-"insqti",0,
-"remqhi",0,
-"remqti",0,
-"ffc",0,
-"ffs",0,
-"extv",T(EXTV,TYPL),
-"extzv",T(EXTZV,TYPL),
-"cmpv",0,
-"cmpzv",0,
-"insv",T(INSV,-1),
-"bneq",T(CBR,JNE),
-"bnequ",T(CBR,JNE),
-"beql",T(CBR,JEQ),
-"beqlu",T(CBR,JEQ),
-"bgtr",T(CBR,JGT),
-"bleq",T(CBR,JLE),
-"bgeq",T(CBR,JGE),
-"blss",T(CBR,JLT),
-"bgtru",T(CBR,JHI),
-"blequ",T(CBR,JLOS),
-"bvc",T(CBR,0),
-"bvs",T(CBR,0),
-"bgequ",T(CBR,JHIS),
-"bcc",T(CBR,JHIS),
-"blssu",T(CBR,JLO),
-"bcs",T(CBR,JLO),
-"brb",JBR,
-"brw",JBR,
-"jmp",JMP,
-"bbs",T(CBR,JBS),
-"bbc",T(CBR,JBC),
-"bbss",T(CBR,JBSS),
-"bbcs",T(CBR,JBCS),
-"bbsc",T(CBR,JBSC),
-"bbcc",T(CBR,JBCC),
-"bbssi",T(CBR,JBSS),
-"bbcci",T(CBR,JBCC),
-"blbs",T(CBR,JLBS),
-"blbc",T(CBR,JLBC),
-"acbb",T(ACB,TYPB),
-"acbw",T(ACB,TYPW),
-"acbl",T(ACB,TYPL),
-"acbf",T(ACB,TYPF),
-"acbd",T(ACB,TYPD),
-"acbg",T(ACB,TYPG),
-"acbh",T(ACB,TYPH),
-"aoblss",AOBLSS,
-"aobleq",AOBLEQ,
-"sobgeq",SOBGEQ,
-"sobgtr",SOBGTR,
-"caseb",T(CASE,TYPB),
-"casew",T(CASE,TYPW),
-"casel",T(CASE,TYPL),
-"bsbb",0,
-"bsbw",0,
-"jsb",JSB,
-"rsb",T(JBR,RSB),
-"callg",CALLS,
-"calls",CALLS,
-"ret",T(JBR,RET),
-"movc3",MOVC3,
-"movc5",0,
-"movtc",0,
-"movtuc",0,
-"cmpc3",0,
-"cmpc5",0,
-"scanc",0,
-"spanc",0,
-"locc",0,
-"skpc",0,
-"matchc",0,
-"crc",0,
-"movp",0,
-"cmpp3",0,
-"cmpp4",0,
-"addp4",0,
-"addp6",0,
-"subp4",0,
-"subp6",0,
-"mulp",0,
-"divp",0,
-"cvtlp",0,
-"cvtpl",0,
-"cvtpt",0,
-"cvttp",0,
-"cvtps",0,
-"cvtsp",0,
-"ashp",0,
-"editpc",0,
-"nop",0,
-"escd",0,
-"esce",0,
-"escf",0,
+{"chmk",0},
+{"chme",0},
+{"chms",0},
+{"chmu",0},
+{"prober",T(PROBER,TYPB)},
+{"probew",T(PROBEW,TYPB)},
+{"rei",0},
+{"ldpctx",0},
+{"svpctx",0},
+{"mtpr",T(MTPR,TYPL)},
+{"mfpr",T(MFPR,TYPL)},
+{"xfc",0},
+{"bpt",0},
+{"bugw",0},
+{"bugl",0},
+{"halt",0},
+{"movb",T(MOV,TYPB)},
+{"movw",T(MOV,TYPW)},
+{"movl",T(MOV,TYPL)},
+{"movq",T(MOV,TYPQ)},
+{"movo",T(MOV,TYPO)},
+{"movf",T(MOV,TYPF)},
+{"movd",T(MOV,TYPD)},
+{"movg",T(MOV,TYPG)},
+{"movh",T(MOV,TYPH)},
+{"pushl",T(PUSH,TYPL)},
+{"clrb",T(CLR,TYPB)},
+{"clrw",T(CLR,TYPW)},
+{"clrf",T(CLR,TYPF)},
+{"clrl",T(CLR,TYPL)},
+{"clrd",T(CLR,TYPD)},
+{"clrg",T(CLR,TYPG)},
+{"clrq",T(CLR,TYPQ)},
+{"clrh",T(CLR,TYPH)},
+{"clro",T(CLR,TYPO)},
+{"mnegb",T(NEG,TYPB)},
+{"mnegw",T(NEG,TYPW)},
+{"mnegl",T(NEG,TYPL)},
+{"mnegf",T(NEG,TYPF)},
+{"mnegg",T(NEG,TYPG)},
+{"mnegd",T(NEG,TYPD)},
+{"mnegh",T(NEG,TYPH)},
+{"mcomb",T(COM,TYPB)},
+{"mcomw",T(COM,TYPW)},
+{"mcoml",T(COM,TYPL)},
+{"cvtbw",T(CVT,U(TYPB,TYPW))},
+{"cvtbl",T(CVT,U(TYPB,TYPL))},
+{"cvtwb",T(CVT,U(TYPW,TYPB))},
+{"cvtwl",T(CVT,U(TYPW,TYPL))},
+{"cvtlb",T(CVT,U(TYPL,TYPB))},
+{"cvtlw",T(CVT,U(TYPL,TYPW))},
+{"cvtbf",T(CVT,U(TYPB,TYPF))},
+{"cvtbd",T(CVT,U(TYPB,TYPD))},
+{"cvtbg",T(CVT,U(TYPB,TYPG))},
+{"cvtbh",T(CVT,U(TYPB,TYPH))},
+{"cvtwf",T(CVT,U(TYPW,TYPF))},
+{"cvtwd",T(CVT,U(TYPW,TYPD))},
+{"cvtwg",T(CVT,U(TYPW,TYPG))},
+{"cvtwh",T(CVT,U(TYPW,TYPH))},
+{"cvtlf",T(CVT,U(TYPL,TYPF))},
+{"cvtld",T(CVT,U(TYPL,TYPD))},
+{"cvtlg",T(CVT,U(TYPL,TYPG))},
+{"cvtlh",T(CVT,U(TYPL,TYPH))},
+{"cvtfb",T(CVT,U(TYPF,TYPB))},
+{"cvtdb",T(CVT,U(TYPD,TYPB))},
+{"cvtgb",T(CVT,U(TYPG,TYPB))},
+{"cvthb",T(CVT,U(TYPH,TYPB))},
+{"cvtfw",T(CVT,U(TYPF,TYPW))},
+{"cvtdw",T(CVT,U(TYPD,TYPW))},
+{"cvtgw",T(CVT,U(TYPG,TYPW))},
+{"cvthw",T(CVT,U(TYPH,TYPW))},
+{"cvtfl",T(CVT,U(TYPF,TYPL))},
+{"cvtrfl",T(CVT,U(TYPF,TYPL))},
+{"cvtdl",T(CVT,U(TYPD,TYPL))},
+{"cvtrdl",T(CVT,U(TYPD,TYPL))},
+{"cvtgl",T(CVT,U(TYPG,TYPL))},
+{"cvtrgl",T(CVT,U(TYPG,TYPL))},
+{"cvthl",T(CVT,U(TYPH,TYPL))},
+{"cvtrhl",T(CVT,U(TYPH,TYPL))},
+{"cvtfd",T(CVT,U(TYPF,TYPD))},
+{"cvtfg",T(CVT,U(TYPF,TYPG))},
+{"cvtfh",T(CVT,U(TYPF,TYPH))},
+{"cvtdf",T(CVT,U(TYPD,TYPF))},
+{"cvtdh",T(CVT,U(TYPD,TYPH))},
+{"cvtgf",T(CVT,U(TYPG,TYPF))},
+{"cvtgh",T(CVT,U(TYPG,TYPH))},
+{"cvthf",T(CVT,U(TYPH,TYPF))},
+{"cvthd",T(CVT,U(TYPH,TYPD))},
+{"cvthg",T(CVT,U(TYPH,TYPG))},
+{"movzbw",T(MOVZ,U(TYPB,TYPW))},
+{"movzbl",T(MOVZ,U(TYPB,TYPL))},
+{"movzwl",T(MOVZ,U(TYPW,TYPL))},
+{"cmpb",T(CMP,TYPB)},
+{"cmpw",T(CMP,TYPW)},
+{"cmpl",T(CMP,TYPL)},
+{"cmpf",T(CMP,TYPF)},
+{"cmpd",T(CMP,TYPD)},
+{"cmpg",T(CMP,TYPG)},
+{"cmph",T(CMP,TYPH)},
+{"incb",T(INC,TYPB)},
+{"incw",T(INC,TYPW)},
+{"incl",T(INC,TYPL)},
+{"tstb",T(TST,TYPB)},
+{"tstw",T(TST,TYPW)},
+{"tstl",T(TST,TYPL)},
+{"tstf",T(TST,TYPF)},
+{"tstd",T(TST,TYPD)},
+{"tstg",T(TST,TYPG)},
+{"tsth",T(TST,TYPH)},
+{"addb2",T(ADD,U(TYPB,OP2))},
+{"addh2",T(ADD,U(TYPH,OP2))},
+{"addb3",T(ADD,U(TYPB,OP3))},
+{"addh3",T(ADD,U(TYPH,OP3))},
+{"addw2",T(ADD,U(TYPW,OP2))},
+{"addw3",T(ADD,U(TYPW,OP3))},
+{"addl2",T(ADD,U(TYPL,OP2))},
+{"addl3",T(ADD,U(TYPL,OP3))},
+{"addf2",T(ADD,U(TYPF,OP2))},
+{"addf3",T(ADD,U(TYPF,OP3))},
+{"addd2",T(ADD,U(TYPD,OP2))},
+{"addd3",T(ADD,U(TYPD,OP3))},
+{"addg2",T(ADD,U(TYPG,OP2))},
+{"addg3",T(ADD,U(TYPG,OP3))},
+{"adwc",0},
+{"adawi",0},
+{"subb2",T(SUB,U(TYPB,OP2))},
+{"subb3",T(SUB,U(TYPB,OP3))},
+{"subw2",T(SUB,U(TYPW,OP2))},
+{"subw3",T(SUB,U(TYPW,OP3))},
+{"subl2",T(SUB,U(TYPL,OP2))},
+{"subl3",T(SUB,U(TYPL,OP3))},
+{"subf2",T(SUB,U(TYPF,OP2))},
+{"subf3",T(SUB,U(TYPF,OP3))},
+{"subd2",T(SUB,U(TYPD,OP2))},
+{"subd3",T(SUB,U(TYPD,OP3))},
+{"subg2",T(SUB,U(TYPG,OP2))},
+{"subg3",T(SUB,U(TYPG,OP3))},
+{"subh2",T(SUB,U(TYPH,OP2))},
+{"subh3",T(SUB,U(TYPH,OP3))},
+{"decb",T(DEC,TYPB)},
+{"decw",T(DEC,TYPW)},
+{"decl",T(DEC,TYPL)},
+{"sbwc",0},
+{"mulb2",T(MUL,U(TYPB,OP2))},
+{"mulb3",T(MUL,U(TYPB,OP3))},
+{"mulw2",T(MUL,U(TYPW,OP2))},
+{"mulw3",T(MUL,U(TYPW,OP3))},
+{"mull2",T(MUL,U(TYPL,OP2))},
+{"mull3",T(MUL,U(TYPL,OP3))},
+{"mulf2",T(MUL,U(TYPF,OP2))},
+{"mulf3",T(MUL,U(TYPF,OP3))},
+{"muld2",T(MUL,U(TYPD,OP2))},
+{"muld3",T(MUL,U(TYPD,OP3))},
+{"mulg2",T(MUL,U(TYPG,OP2))},
+{"mulg3",T(MUL,U(TYPG,OP3))},
+{"mulh2",T(MUL,U(TYPH,OP2))},
+{"mulh3",T(MUL,U(TYPH,OP3))},
+{"emodf",0},
+{"emul",0},
+{"emodd",0},
+{"emodg",0},
+{"emodh",0},
+{"divb2",T(DIV,U(TYPB,OP2))},
+{"divb3",T(DIV,U(TYPB,OP3))},
+{"divw2",T(DIV,U(TYPW,OP2))},
+{"divw3",T(DIV,U(TYPW,OP3))},
+{"divl2",T(DIV,U(TYPL,OP2))},
+{"divl3",T(DIV,U(TYPL,OP3))},
+{"divf2",T(DIV,U(TYPF,OP2))},
+{"divf3",T(DIV,U(TYPF,OP3))},
+{"divd2",T(DIV,U(TYPD,OP2))},
+{"divd3",T(DIV,U(TYPD,OP3))},
+{"divg2",T(DIV,U(TYPG,OP2))},
+{"divg3",T(DIV,U(TYPG,OP3))},
+{"divh2",T(DIV,U(TYPH,OP2))},
+{"divh3",T(DIV,U(TYPH,OP3))},
+{"ediv",0},
+{"bitb",T(BIT,TYPB)},
+{"bitl",T(BIT,TYPL)},
+{"bitw",T(BIT,TYPW)},
+{"bisb2",T(BIS,U(TYPB,OP2))},
+{"bisb3",T(BIS,U(TYPB,OP3))},
+{"bisw2",T(BIS,U(TYPW,OP2))},
+{"bisw3",T(BIS,U(TYPW,OP3))},
+{"bisl2",T(BIS,U(TYPL,OP2))},
+{"bisl3",T(BIS,U(TYPL,OP3))},
+{"bicb2",T(BIC,U(TYPB,OP2))},
+{"bicb3",T(BIC,U(TYPB,OP3))},
+{"bicw2",T(BIC,U(TYPW,OP2))},
+{"bicw3",T(BIC,U(TYPW,OP3))},
+{"bicl2",T(BIC,U(TYPL,OP2))},
+{"bicl3",T(BIC,U(TYPL,OP3))},
+{"xorb2",T(XOR,U(TYPB,OP2))},
+{"xorb3",T(XOR,U(TYPB,OP3))},
+{"xorw2",T(XOR,U(TYPW,OP2))},
+{"xorw3",T(XOR,U(TYPW,OP3))},
+{"xorl2",T(XOR,U(TYPL,OP2))},
+{"xorl3",T(XOR,U(TYPL,OP3))},
+{"ashl",T(ASH,TYPL)},
+{"ashq",T(ASH,TYPQ)},
+{"rotl",0},
+{"polyf",0},
+{"polyd",0},
+{"polyg",0},
+{"polyh",0},
+{"pushr",0},
+{"popr",0},
+{"movpsl",0},
+{"bispsw",0},
+{"bicpsw",0},
+{"movab",T(MOVA,TYPB)},
+{"pushab",T(PUSHA,TYPB)},
+{"movaw",T(MOVA,TYPW)},
+{"pushaw",T(PUSHA,TYPW)},
+{"movaf",T(MOVA,TYPF)},
+{"moval",T(MOVA,TYPL)},
+{"pushaf",T(PUSHA,TYPF)},
+{"pushal",T(PUSHA,TYPL)},
+{"pushad",T(PUSHA,TYPD)},
+{"pushag",T(PUSHA,TYPG)},
+{"pushaq",T(PUSHA,TYPQ)},
+{"pushah",T(PUSHA,TYPH)},
+{"pushao",T(PUSHA,TYPO)},
+{"movad",T(MOVA,TYPD)},
+{"movag",T(MOVA,TYPG)},
+{"movaq",T(MOVA,TYPQ)},
+{"movah",T(MOVA,TYPH)},
+{"movao",T(MOVA,TYPO)},
+{"index",0},
+{"insque",0},
+{"remque",0},
+{"insqhi",0},
+{"insqti",0},
+{"remqhi",0},
+{"remqti",0},
+{"ffc",0},
+{"ffs",0},
+{"extv",T(EXTV,TYPL)},
+{"extzv",T(EXTZV,TYPL)},
+{"cmpv",0},
+{"cmpzv",0},
+{"insv",T(INSV,-1)},
+{"bneq",T(CBR,JNE)},
+{"bnequ",T(CBR,JNE)},
+{"beql",T(CBR,JEQ)},
+{"beqlu",T(CBR,JEQ)},
+{"bgtr",T(CBR,JGT)},
+{"bleq",T(CBR,JLE)},
+{"bgeq",T(CBR,JGE)},
+{"blss",T(CBR,JLT)},
+{"bgtru",T(CBR,JHI)},
+{"blequ",T(CBR,JLOS)},
+{"bvc",T(CBR,0)},
+{"bvs",T(CBR,0)},
+{"bgequ",T(CBR,JHIS)},
+{"bcc",T(CBR,JHIS)},
+{"blssu",T(CBR,JLO)},
+{"bcs",T(CBR,JLO)},
+{"brb",JBR},
+{"brw",JBR},
+{"jmp",JMP},
+{"bbs",T(CBR,JBS)},
+{"bbc",T(CBR,JBC)},
+{"bbss",T(CBR,JBSS)},
+{"bbcs",T(CBR,JBCS)},
+{"bbsc",T(CBR,JBSC)},
+{"bbcc",T(CBR,JBCC)},
+{"bbssi",T(CBR,JBSS)},
+{"bbcci",T(CBR,JBCC)},
+{"blbs",T(CBR,JLBS)},
+{"blbc",T(CBR,JLBC)},
+{"acbb",T(ACB,TYPB)},
+{"acbw",T(ACB,TYPW)},
+{"acbl",T(ACB,TYPL)},
+{"acbf",T(ACB,TYPF)},
+{"acbd",T(ACB,TYPD)},
+{"acbg",T(ACB,TYPG)},
+{"acbh",T(ACB,TYPH)},
+{"aoblss",AOBLSS},
+{"aobleq",AOBLEQ},
+{"sobgeq",SOBGEQ},
+{"sobgtr",SOBGTR},
+{"caseb",T(CASE,TYPB)},
+{"casew",T(CASE,TYPW)},
+{"casel",T(CASE,TYPL)},
+{"bsbb",0},
+{"bsbw",0},
+{"jsb",JSB},
+{"rsb",T(JBR,RSB)},
+{"callg",CALLS},
+{"calls",CALLS},
+{"ret",T(JBR,RET)},
+{"movc3",MOVC3},
+{"movc5",0},
+{"movtc",0},
+{"movtuc",0},
+{"cmpc3",0},
+{"cmpc5",0},
+{"scanc",0},
+{"spanc",0},
+{"locc",0},
+{"skpc",0},
+{"matchc",0},
+{"crc",0},
+{"movp",0},
+{"cmpp3",0},
+{"cmpp4",0},
+{"addp4",0},
+{"addp6",0},
+{"subp4",0},
+{"subp6",0},
+{"mulp",0},
+{"divp",0},
+{"cvtlp",0},
+{"cvtpl",0},
+{"cvtpt",0},
+{"cvttp",0},
+{"cvtps",0},
+{"cvtsp",0},
+{"ashp",0},
+{"editpc",0},
+{"nop",0},
+{"escd",0},
+{"esce",0},
+{"escf",0},