From 31e13b09cca8a1d3e0a4c4ca061abdcb7d30b669 Mon Sep 17 00:00:00 2001 From: Dennis Ritchie Date: Tue, 26 Nov 1974 18:13:21 -0500 Subject: [PATCH] Research V5 development Work on file usr/c/c21.c Work on file usr/c/regtab.s Work on file usr/c/cvopt.c Synthesized-from: v5 --- usr/c/c21.c | 657 +++++++++++++++++++++++++++++++++++++ usr/c/cvopt.c | 350 ++++++++++++++++++++ usr/c/regtab.s | 858 +++++++++++++++++++++++++++++++++++++++++++++++++ 3 files changed, 1865 insertions(+) create mode 100644 usr/c/c21.c create mode 100644 usr/c/cvopt.c create mode 100644 usr/c/regtab.s diff --git a/usr/c/c21.c b/usr/c/c21.c new file mode 100644 index 0000000000..624cb4171c --- /dev/null +++ b/usr/c/c21.c @@ -0,0 +1,657 @@ +# +/* + * C object code improver-- second part + * Copyright 1974 Bell Telephone Laboratories, Incorporated + */ + +#include "c2h.c" + +rmove() +{ + register struct node *p; + register char *cp; + register int r; + int r1, flt; + + for (p=first.forw; p!=0; p = p->forw) { + if (debug) { + for (r=0; r<2*NREG; r++) + if (regs[r][0]) + printf("%d: %s\n", r, regs[r]); + printf("-\n"); + } + flt = 0; + switch (p->op) { + + case MOVF: + case MOVFO: + case MOVOF: + flt = NREG; + + case MOV: + dualop(p); + if ((r = findrand(regs[RT1], flt)) >= 0) { + if (r == flt+isreg(regs[RT2]) && p->forw->op!=CBR) { + p->forw->back = p->back; + p->back->forw = p->forw; + redunm++; + continue; + } + } + repladdr(p, 0, flt); + r = isreg(regs[RT1]); + r1 = isreg(regs[RT2]); + dest(regs[RT2], flt); + if (r >= 0) + if (r1 >= 0) + savereg(r1+flt, regs[r+flt]); + else + savereg(r+flt, regs[RT2]); + else + if (r1 >= 0) + savereg(r1+flt, regs[RT1]); + else + setcon(regs[RT1], regs[RT2]); + source(regs[RT1]); + setcc(regs[RT2]); + continue; + + case ADDF: + case SUBF: + case DIVF: + case MULF: + flt = NREG; + + case ADD: + case SUB: + case BIC: + case BIS: + case MUL: + case DIV: + case ASH: + dualop(p); + repladdr(p, 0, flt); + source(regs[RT1]); + dest(regs[RT2], flt); + if (p->op==DIV && (r = isreg(regs[RT2])>=0)) + regs[r+1][0] = 0; + ccloc[0] = 0; + continue; + + case CLRF: + case NEGF: + flt = NREG; + + case CLR: + case COM: + case INC: + case DEC: + case NEG: + case ASR: + case ASL: + case SXT: + singop(p); + dest(regs[RT1], flt); + if (p->op==CLR && flt==0) + if ((r = isreg(regs[RT1])) >= 0) + savereg(r, "$0"); + else + setcon("$0", regs[RT1]); + setcc(regs[RT1]); + continue; + + case TSTF: + flt = NREG; + + case TST: + singop(p); + repladdr(p, 0, flt); + source(regs[RT1]); + if (equstr(regs[RT1], ccloc)) { + p->back->forw = p->forw; + p->forw->back = p->back; + p = p->back; + nrtst++; + nchange++; + } + continue; + + case CMPF: + flt = NREG; + + case CMP: + case BIT: + dualop(p); + source(regs[RT1]); + source(regs[RT2]); + repladdr(p, 1, flt); + ccloc[0] = 0; + continue; + + case CBR: + case CFCC: + ccloc[0] = 0; + continue; + + case JBR: + redunbr(p); + + default: + clearreg(); + } + } +} + +jumpsw() +{ + register struct node *p, *p1; + register t; + int nj; + + t = 0; + nj = 0; + for (p=first.forw; p!=0; p = p->forw) + p->refc = ++t; + for (p=first.forw; p!=0; p = p1) { + p1 = p->forw; + if (p->op == CBR && p1->op==JBR && p->ref && p1->ref + && abs(p->refc - p->ref->refc) > abs(p1->refc - p1->ref->refc)) { + p->subop = revbr[p->subop]; + t = p1->ref; + p1->ref = p->ref; + p->ref = t; + t = p1->labno; + p1->labno = p->labno; + p->labno = t; + nrevbr++; + nj++; + } + } + return(nj); +} + +addsob() +{ + register struct node *p, *p1; + + for (p = &first; (p1 = p->forw)!=0; p = p1) { + if (p->op==DEC && isreg(p->code)>=0 + && p1->combop==(CBR|JNE<<8)) { + if (p->refc < p1->ref->refc) + continue; + if (p->refc - p1->ref->refc > 50) + continue; + p->labno = p1->labno; + p->combop = SOB; + p1->forw->back = p; + p->forw = p1->forw; + nsob++; + } + } +} + +abs(x) +{ + return(x<0? -x: x); +} + +equop(ap1, p2) +struct node *ap1, *p2; +{ + register char *cp1, *cp2; + register struct node *p1; + + p1 = ap1; + if (p1->combop != p2->combop) + return(0); + if (p1->op>0 && p1->opcode; + cp2 = p2->code; + if (cp1==0 && cp2==0) + return(1); + if (cp1==0 || cp2==0) + return(0); + while (*cp1 == *cp2++) + if (*cp1++ == 0) + return(1); + return(0); +} + +decref(ap) +{ + register struct node *p; + + p = ap; + if (--p->refc <= 0) { + nrlab++; + p->back->forw = p->forw; + p->forw->back = p->back; + } +} + +nonlab(ap) +struct node *ap; +{ + register struct node *p; + + p = ap; + while (p && p->op==LABEL) + p = p->forw; + return(p); +} + +alloc(an) +{ + register int n; + register char *p; + + n = an; + n++; + n =& ~01; + if (lasta+n >= lastr) { + if (sbrk(2000) == -1) { + write(2, "Out of space\n", 14); + exit(1); + } + lastr =+ 2000; + } + p = lasta; + lasta =+ n; + return(p); +} + +clearreg() +{ + register int i; + + for (i=0; i<2*NREG; i++) + regs[i][0] = '\0'; + conloc[0] = 0; + ccloc[0] = 0; +} + +savereg(ai, as) +char *as; +{ + register char *p, *s, *sp; + + sp = p = regs[ai]; + s = as; + if (source(s)) + return; + while (*p++ = *s) { + if (s[0]=='(' && s[1]=='r' && s[2]<'5') { + *sp = 0; + return; + } + if (*s++ == ',') + break; + } + *--p = '\0'; +} + +dest(as, flt) +char *as; +{ + register char *s; + register int i; + + s = as; + if ((i = isreg(s)) >= 0) + regs[i+flt][0] = 0; + while ((i = findrand(s, flt)) >= 0) + regs[i][0] = 0; + while (*s) { + if ((*s=='(' && (*(s+1)!='r' || *(s+2)!='5')) || *s++=='*') { + for (i=flt; icode; + p2 = regs[RT1]; + while (*p2++ = *p1++); + regs[RT2][0] = 0; +} + + +dualop(ap) +struct node *ap; +{ + register char *p1, *p2; + register struct node *p; + + p = ap; + p1 = p->code; + p2 = regs[RT1]; + while (*p1 && *p1!=',') + *p2++ = *p1++; + *p2++ = 0; + p2 = regs[RT2]; + *p2 = 0; + if (*p1++ !=',') + return; + while (*p2++ = *p1++); +} + +findrand(as, flt) +char *as; +{ + register int i; + for (i = flt; i='0' && s[1]<='4' && s[2]==0) + return(s[1]-'0'); + return(-1); +} + +check() +{ + register struct node *p, *lp; + + lp = &first; + for (p=first.forw; p!=0; p = p->forw) { + if (p->back != lp) + abort(); + lp = p; + } +} + +source(ap) +char *ap; +{ + register char *p1, *p2; + + p1 = ap; + p2 = p1; + if (*p1==0) + return(0); + while (*p2++); + if (*p1=='-' && *(p1+1)=='(' + || *p1=='*' && *(p1+1)=='-' && *(p1+2)=='(' + || *(p2-2)=='+') { + while (*p1 && *p1++!='r'); + if (*p1>='0' && *p1<='4') + regs[*p1 - '0'][0] = 0; + return(1); + } + return(0); +} + +repladdr(p, f, flt) +struct node *p; +{ + register r; + int r1; + register char *p1, *p2; + static char rt1[50], rt2[50]; + + if (f) + r1 = findrand(regs[RT2], flt); + else + r1 = -1; + r = findrand(regs[RT1], flt); + if (r1 >= NREG) + r1 =- NREG; + if (r >= NREG) + r =- NREG; + if (r>=0 || r1>=0) { + p2 = regs[RT1]; + for (p1 = rt1; *p1++ = *p2++;); + if (regs[RT2][0]) { + p1 = rt2; + *p1++ = ','; + for (p2 = regs[RT2]; *p1++ = *p2++;); + } else + rt2[0] = 0; + if (r>=0) { + rt1[0] = 'r'; + rt1[1] = r + '0'; + rt1[2] = 0; + nsaddr++; + } + if (r1>=0) { + rt2[1] = 'r'; + rt2[2] = r1 + '0'; + rt2[3] = 0; + nsaddr++; + } + p->code = copy(rt1, rt2); + } +} + +movedat() +{ + register struct node *p1, *p2; + struct node *p3; + register seg; + struct node data; + struct node *datp; + + if (first.forw == 0) + return; + datp = &data; + for (p1 = first.forw; p1!=0; p1 = p1->forw) { + if (p1->op == DATA) { + p2 = p1->forw; + while (p2 && p2->op!=TEXT) + p2 = p2->forw; + if (p2==0) + break; + p3 = p1->back; + p1->back->forw = p2->forw; + p2->forw->back = p3; + p2->forw = 0; + datp->forw = p1; + p1->back = datp; + p1 = p3; + datp = p2; + } + } + if (data.forw) { + datp->forw = first.forw; + first.forw->back = datp; + data.forw->back = &first; + first.forw = data.forw; + } + seg = -1; + for (p1 = first.forw; p1!=0; p1 = p1->forw) { + if (p1->op==TEXT||p1->op==DATA||p1->op==BSS) { + if (p1->op == seg || p1->forw&&p1->forw->op==seg) { + p1->back->forw = p1->forw; + p1->forw->back = p1->back; + p1 = p1->back; + continue; + } + seg = p1->op; + } + } +} + +redunbr(ap) +struct node *ap; +{ + register struct node *p, *p1; + register char *ap1; + char *ap2; + + if ((p1 = p->ref) == 0) + return; + p1 = nonlab(p1); + if (p1->op==TST) { + singop(p1); + savereg(RT2, "$0"); + } else if (p1->op==CMP) + dualop(p1); + else + return; + if (p1->forw->op!=CBR) + return; + ap1 = findcon(RT1); + ap2 = findcon(RT2); + p1 = p1->forw; + if (compare(p1->subop, ap1, ap2)) { + nredunj++; + nchange++; + decref(p->ref); + p->ref = p1->ref; + p->labno = p1->labno; + p->ref->refc++; + } +} + +findcon(i) +{ + register char *p; + register r; + + p = regs[i]; + if (*p=='$') + return(p); + if ((r = isreg(p)) >= 0) + return(regs[r]); + if (equstr(p, conloc)) + return(conval); + return(p); +} + +compare(op, acp1, acp2) +char *acp1, *acp2; +{ + register char *cp1, *cp2; + register n1; + int n2; + struct { int i;}; + + cp1 = acp1; + cp2 = acp2; + if (*cp1++ != '$' || *cp2++ != '$') + return(0); + n1 = 0; + while (*cp2 >= '0' && *cp2 <= '7') { + n1 =<< 3; + n1 =+ *cp2++ - '0'; + } + n2 = n1; + n1 = 0; + while (*cp1 >= '0' && *cp1 <= '7') { + n1 =<< 3; + n1 =+ *cp1++ - '0'; + } + if (*cp1=='+') + cp1++; + if (*cp2=='+') + cp2++; + do { + if (*cp1++ != *cp2) + return(0); + } while (*cp2++); + cp1 = n1; + cp2 = n2; + switch(op) { + + case JEQ: + return(cp1 == cp2); + case JNE: + return(cp1 != cp2); + case JLE: + return(cp1.i <= cp2.i); + case JGE: + return(cp1.i >= cp2.i); + case JLT: + return(cp1.i < cp2.i); + case JGT: + return(cp1.i > cp2.i); + case JLO: + return(cp1 < cp2); + case JHI: + return(cp1 > cp2); + case JLOS: + return(cp1 <= cp2); + case JHIS: + return(cp1 >= cp2); + } + return(0); +} + +setcon(ar1, ar2) +char *ar1, *ar2; +{ + register char *cl, *cv, *p; + + cl = ar2; + cv = ar1; + if (*cv != '$') + return; + if (!natural(cl)) + return; + p = conloc; + while (*p++ = *cl++); + p = conval; + while (*p++ = *cv++); +} + +equstr(ap1, ap2) +char *ap1, *ap2; +{ + char *p1, *p2; + + p1 = ap1; + p2 = ap2; + do { + if (*p1++ != *p2) + return(0); + } while (*p2++); + return(1); +} + +setcc(ap) +char *ap; +{ + register char *p, *p1; + + p = ap; + if (!natural(p)) { + ccloc[0] = 0; + return; + } + p1 = ccloc; + while (*p1++ = *p++); +} + +natural(ap) +char *ap; +{ + register char *p; + + p = ap; + if (*p=='*' || *p=='(' || *p=='-'&&*(p+1)=='(') + return(0); + while (*p++); + p--; + if (*--p == '+' || *p ==')' && *--p != '5') + return(0); + return(1); +} diff --git a/usr/c/cvopt.c b/usr/c/cvopt.c new file mode 100644 index 0000000000..9fcf415b6c --- /dev/null +++ b/usr/c/cvopt.c @@ -0,0 +1,350 @@ +int nofloat; +int peekc; +int obuf[259]; +int tabflg; +int labno 1; + +main(argc, argv) +char **argv; +{ +/* + A1 -> A + A2 B + A O + B1 C + B2 D + BE L + BF P + C1 E + C2 F + F G + H H + R I + R1 J + S K + I M + M N + + * +1 + S +2 + C +4 + 1 +8 + + z -> 4 + c 10 + a 14 + e 20 + n 63 + * +0100 +*/ + + auto c,snlflg,nlflg,t,smode,m,ssmode; + extern fin; + + smode = nlflg = snlflg = ssmode = 0; + if (argc>1) + if ((fin = open(argv[1], 0)) < 0) { + putchar('?\n'); + return; + } + obuf[0] = 1; + if (argc>2) + if ((obuf[0] = creat(argv[2], 0666)) < 0) { + putchar('?\n'); + return; + } +loop: + c = getc(); + if (c!='\n' && c!='\t') nlflg = 0; + if (ssmode!=0 && c!='%') { + ssmode = 0; + printf(".data\nL%d:<", labno++); + } + switch(c) { + + case '\0': + printf(".text; 0\n"); + fflush(obuf); + return; + + case ':': + if (!smode) + printf("=.+2; 0"); else + putchar(':'); + goto loop; + + case 'A': + if ((c=getc())=='1' || c=='2') { + putchar(c+'A'-'1'); + goto loop; + } + putchar('O'); + peekc = c; + goto loop; + + case 'B': + switch (getc()) { + + case '1': + putchar('C'); + goto loop; + + case '2': + putchar('D'); + goto loop; + + case 'E': + putchar('L'); + goto loop; + + case 'F': + putchar('P'); + goto loop; + } + putchar('?'); + goto loop; + + case 'C': + putchar(getc()+'E'-'1'); + goto loop; + + case 'F': + putchar('G'); + goto subtre; + + case 'R': + if ((c=getc()) == '1') + putchar('J'); else { + putchar('I'); + peekc = c; + } + goto loop; + + case 'H': + putchar('H'); + goto subtre; + + case 'I': + putchar('M'); + goto loop; + + case 'V': + putchar('V'); + snlflg++; + goto loop; + + case 'S': + putchar('K'); +subtre: + snlflg = 1; + t = 'A'; +l1: + switch (c=getc()) { + + case '*': + t++; + goto l1; + + case 'S': + t =+ 2; + goto l1; + + case 'C': + t =+ 4; + goto l1; + + case '1': + t =+ 8; + goto l1; + + case '2': + t =+ 16; + goto l1; + } + peekc = c; + putchar(t); + goto loop; + + case '#': + if(getc()=='1') + putchar('#'); else + putchar('"'); + goto loop; + + case '%': + if (smode) + printf(".text;"); +loop1: + switch (c=getc()) { + + case 'a': + m = 16; + t = flag(); + goto pf; + + case ',': + putchar(';'); + goto loop1; + + case 'i': + m = 12; + t = flag(); + goto pf; + case 'z': + m = 4; + t = flag(); + goto pf; + + case 'r': + m = 9; + t = flag(); + goto pf; + + case '1': + m = 5; + t = flag(); + goto pf; + + case 'c': + t = 0; + m = 8; + goto pf; + + case 'e': + t = flag(); + m = 20; + goto pf; + + case 'n': + t = flag(); + m = 63; +pf: + if ((c=getc())=='*') + m =+ 0100; else + peekc = c; + printf(".byte %o,%o", m, t); + goto loop1; + + case '\n': + printf("\nL%d\n", labno); + ssmode = 1; + nlflg = 1; + smode = 1; + goto loop; + } + putchar(c); + goto loop1; + + case '\t': + if (nlflg) { + nlflg = 0; + goto loop; + } + if (smode) { + tabflg++; + goto loop; + } + putchar('\t'); + goto loop; + + case '\n': + if (!smode) { + putchar('\n'); + goto loop; + } + if (nlflg) { + nlflg = 0; + printf("\\0>\n.text\n"); + smode = 0; + goto loop; + } + if (!snlflg) + printf("\\n"); + snlflg = 0; + printf(">\n<"); + nlflg = 1; + goto loop; + + case 'X': + case 'Y': + case 'T': + snlflg++; + } + putchar(c); + goto loop; +} + +getc() { + auto t, ifcnt; + + ifcnt = 0; +gc: + if (peekc) { + t = peekc; + peekc = 0; + } else + t = getchar(); + if (t==0) + return(0); + if (t=='{') { + ifcnt++; + t = getchar(); + } + if (t=='}') { + t = getc(); + if (--ifcnt==0) + if (t=='\n') + t = getc(); + } + if (ifcnt && nofloat) + goto gc; + return(t); +} + +flag() { + register c, f; + + f = 0; +l1: + switch(c=getc()) { + + case 'w': + f = 1; + goto l1; + + case 'i': + f = 2; + goto l1; + + case 'b': + f = 3; + goto l1; + + case 'f': + f = 4; + goto l1; + + case 'd': + f = 5; + goto l1; + + case 's': + f = 6; + goto l1; + + case 'p': + f =+ 16; + goto l1; + } + peekc = c; + return(f); +} + +putchar(c) +{ + if (tabflg) { + tabflg = 0; + printf(">;.byte %o;<", c+0200); + } else + putc(c, obuf); +} diff --git a/usr/c/regtab.s b/usr/c/regtab.s new file mode 100644 index 0000000000..fb37658aee --- /dev/null +++ b/usr/c/regtab.s @@ -0,0 +1,858 @@ +/ c code tables-- compile to register + +.globl _regtab + +.data +_regtab=. + 106.; cr106 + 30.; cr30 + 31.; cr30 + 32.; cr32 + 33.; cr32 + 37.; cr37 + 38.; cr38 + 98.; cr100 + 99.; cr100 + 80.; cr80 + 40.; cr40 + 41.; cr40 / - like + + 42.; cr42 + 43.; cr43 + 44.; cr43 + 45.; cr45 + 46.; cr46 + 47.; cr47 + 48.; cr48 + 49.; cr49 + 70.; cr70 + 71.; cr70 + 72.; cr72 + 73.; cr73 + 74.; cr74 + 75.; cr75 + 76.; cr76 + 77.; cr77 + 78.; cr78 + 81.; cr78 + 79.; cr79 + 102.; cr102 + 51.; cr51 + 52.; cr52 + 104.; cr104 + 0 +.text + +/ init expression +cr104: +%c,n +C1 + +%a,n +%af,n +A1 + +/ goto +cr102: +%i,n + jmp A1 + +%n*,n + F* + jmp #1(R) + +/ call +cr100: +%a,n +%a,nf + jsr pc,IA1 + +%n*,n +%n*,nf + F* + jsr pc,#1(R) + +%n,n +%n,nf + F + jsr pc,(R) + +/ addressible +cr106: +%z,n + clr R + +%zf,n + clrf R + +%a,n +%ad,n + movB1 A1,R + +%af,n + movof A1,R + +%n*,n +%nd*,n + F* + movB1 #1(R),R + +%nf*,n + F* + movof #1(R),R + +/++,-- prefix +cr30: +%ai,n +%abp,n +%ab,n + IB1 A1' + movB1 A1,R + +%adp,n +%afp,n +%a,n + I' $^,A1' + mov A1,R + +%nbp*,n +%ni*,n +%nb*,n + F* + IB1 #1(R) + movB1 #1(R),R + +%ndp*,n +%nfp*,n +%n*,n + F* + I' $^,#1(R) + mov #1(R),R + +/ ++,-- postfix +cr32: +%ai,n +%abp,n +%ab,n + movB1 A1',R + IB1 A1 + +%adp,n +%afp,n +%a,n + mov A1',R + I' $^,A1 + +%ebp*,n +%eb*,n +%ei*,n + F1* + movB1 #1(R1),R + IB1 #1(R1) + +%nbp*,n +%nb*,n +%ni*,n + F* + movB1 #1(R),-(sp) + IB1 #1(R) + movB1 (sp)+,R + +%edp*,n +%efp*,n +%e*,n + F1* + mov #1(R1),R + I' $^,#1(R1) + +%ndp*,n +%nfp*,n +%n*,n + F* + mov #1(R),-(sp) + I' $^,#1(R) + mov (sp)+,R + +/ - unary +cr37: +%n,n +%nf,n + F + negBF R + +/ ~ +cr38: +%n,n + F + com R + +/ = +cr80: +%a,n +%ad,nf + S + movB1 R,A1 + +%af,nf + S + movfo R,A1 + +%nd*,af + F* + S + movf R,#1(R) + +%n*,a + F* + movB1 A2,#1(R) + movB1 #1(R),R + +%nf*,af + F* + S + movfo R,#1(R) + +%n*,e + F* + S1 + movB1 R1,#1(R) + movB1 R1,R + +%ed*,nf + S + F1* + movf R,#1(R1) + +%ef*,nf + S + F1* + movfo R,#1(R1) + +%n*,n +%nd*,nf + FS* + S + movB1 R,*(sp)+ + +%nf*,nf + FS* + S + movfo R,*(sp)+ + +%a,nf + S + movfi R,R + movB1 R,A1 + +%e*,nf + S + F1* + movfi R,R + movB1 R,#1(R1) + +%n*,nf + FS* + S + movfi R,R + movB1 R,*(sp)+ + +/ ^ -- xor +cr49: +%n,e + F + S1 + xor R1,R + +%n,n + FS + S + xor R,(sp) + mov (sp)+,R + +/ | +cr48: +%n,a + F + bisB2 A2,R + +%n,e* + F + S1* + bisB2 #2(R1),R + +%n,e + F + S1 + bis R1,R + +%n,n + FS + S + bis (sp)+,R + +/ & +cr47: +%n,c + F + bic $!C2,R + +%n,e + F + S1 + com R1 + bic R1,R + +%n,n + FS + S + com (sp) + bic (sp)+,R + +/ >> +cr45: +%n,1 + F + asr R + +%n,c + F + ash $-C2,R + +%n,e + F + S1 + neg R1 + ash R1,R + +%n,n + SS + neg (sp) + F + ash (sp)+,R + +/ << +cr46: +%n,1 + F + asl R + +%n,aw + F + ash A2,R + +%n,ew* + F + S1* + ash #1(R1),R + +%n,e + F + S1 + ash R1,R + +%n,n + SS + F + ash (sp)+,R + +/ +, - +cr40: +%n,z + F + +%n,1 + F + I' R + +%n,aw +%nf,ad + F + IBF A2,R + +%n,ew* +%nf,ed* + F + S1* + IBF #2(R1),R + +%n,e +%nf,ef + F + S1 + IBF R1,R + +%n,nw* +%nf,nd* + SS* + F + IBF *(sp)+,R + +%n,n +%nf,nf + SS + F + IBF (sp)+,R + +/ * -- R must be odd on integers +cr42: +%n,aw +%nf,ad + F + mulBF A2,R + +%n,ew* +%nf,ed* + F + S1* + mulBF #2(R1),R + +%n,e +%nf,ef + F + S1 + mulBF R1,R + +%n,n +%nf,nf + SS + F + mulBF (sp)+,R + +/ / R must be odd on integers +cr43: +%n,aw + F + T + sxt R- + div A2,R- + +%n,ew* + F + T + sxt R- + S1* + div #2(R1),R- + +%n,e + F + T + sxt R- + S1 + div R1,R- + +%n,n + SS + F + T + sxt R- + div (sp)+,R- + +%nf,ad + F + divf A2,R + +%nf,ed* + F + S1* + divf #2(R1),R + +%nf,ef + F + S1 + divf R1,R + +%nf,nf + SS + F + divf (sp)+,R + +/ =* +cr72: +%a,aw +%ad,ad + movB1 A1',R + mulBF A2,R + movB1 R,A1 + +%af,nf + SS + movof A1',R + mulf (sp)+,R + movfo R,A1 + +%a,ew* +%ad,ed* + movB1 A1',R + S1* + mulBF #2(R1),R + movB1 R,A1 + +%aw,n +%ad,n + S + mulBF A1',R + movBF R,A1 + +%a,n + SS + movB1 A1',R + mulBF (sp)+,R + movB1 R,A1 + +%nw*,n +%nd*,nf + FS* + S + mulBF *(sp),R + movB1 R,*(sp)+ + +%n*,n + FS* + SS + movB1 *2(sp),R + mul (sp)+,R + movB1 R,*(sp)+ + +%nf*,nf + FS* + movof *(sp),R + movf R,-(sp) + S + mulf (sp)+,R + movfo R,*(sp)+ + +/ =/ ; R must be odd on integers +cr73: +%a,aw + movB1 A1',R + sxt R- + divBF A2,R- + movB1 R-,A1 + +%a,n + SS + movB1 A1',R + sxt R- + div (sp)+,R- + movB1 R-,A1 + +%e*,n + SS + F1* + movB1 #1(R1),R + sxt R- + div (sp)+,R- + movB1 R-,#1(R1) + +%n*,n + FS* + SS + movB1 *2(sp),R + sxt R- + div (sp)+,R- + movB1 R-,*(sp)+ + +%ad,ad + movf A1',R + divf A2,R + movf R,A1 + +%ad,ef + movf A1',R + S1 + divf R1,R + movf R,A1 + +%ad,nf + SS + movf A1',R + divf (sp)+,R + movf R,A1 + +%af,nf + SS + movof A1',R + divf (sp)+,R + movfo R,A1 + +%nd*,nf + FS* + SS + movf *8(sp),R + divf (sp)+,R + movf R,*(sp)+ + +%nf*,nf + FS* + SS + movof *8(sp),R + divf (sp)+,R + movfo R,*(sp)+ + +/ =mod; R must be odd on integers +cr74: +%a,aw + movB1 A1',R + sxt R- + div A2,R- + movB1 R,A1 + +%a,n + SS + movB1 A1',R + sxt R- + div (sp)+,R- + movB1 R,A1 + +%e*,n + SS + F1* + movB1 #1(R1),R + sxt R- + div (sp)+,R- + movB1 R,#1(R1) + +%n*,n + FS* + SS + movB1 *2(sp),R + sxt R- + div (sp)+,R- + mov R,*(sp)+ + +/ =| and =& ~ +cr78: +%a,a + IBE A2,A1' + movB1 A1,R + +%a,n + S + IB1 R,A1' + movB1 A1,R + +%n*,a + F* + IBE A2,#1(R) + movB1 #1(R),R + +%e*,n* + S* + F1* + IBE #2(R),#1(R1) + movB1 #2(R1),R + +%e*,n + S + F1* + IBE R,#1(R1) + movB1 #1(R1),R + +%n*,e* + F* + S1* + IBE #2(R1),#1(R) + movB1 #1(R),R + +%n*,e + F* + S1 + IBE R1,#1(R) + movB2 #1(R),R + +%n*,n* + FS* + S* + IBE #2(R),*(sp) + movB2 *(sp)+,R + +%n*,n + FS* + S + IBE R,*(sp) + mov *(sp)+,R + +/ =^ -- =xor +cr79: +%aw,n + S + xor R,A1' + mov A1,R + +%ab,n + SS + movb A1',R + xor R,(sp) + mov (sp)+,R + movb R,A1 + +%n*,n + FS* + movB1 *(sp),-(sp) + S + xor R,(sp) + movB1 (sp)+,R + movB1 R,*(sp)+ + +/ =& +cr77: +%a,c + bicB1 $!C2,A1' + movB2 A1,R + +%a,n + S + com R + bicB1 R,A1' + movB1 A1,R + +%e*,n + S + F1* + com R + bicB1 R,#1(R1) + movB1 #1(R1),R + +%n*,e + F* + S1 + com R1 + bicB1 R1,#1(R) + movB1 #1(R),R + +%n*,n + FS* + S + com R + bicB1 R,*(sp) + movB1 *(sp)+,R + +/ =>> +cr75: +%a,c + movB1 A1',R + ash $-C2,R + movB1 R,A1 + +%a,n + SS + movB1 A1',R + neg (sp) + ash (sp)+,R + movB1 R,A1 + +%n*,n + SS + F1* + movB1 #1(R1),R + neg (sp) + ash (sp)+,R + movB1 R,#1(R1) + +/ =<< +cr76: +%a,aw + movB1 A1',R + ash A2,R + movB1 R,A1 + +%a,n + SS + movB1 A1',R + ash (sp)+,R + movB1 R,A1 + +%n*,n + SS + F1* + movB1 #1(R1),R + ash (sp)+,R + movB1 R,#1(R1) + +/ =+ +cr70: +%aw,aw + I A2,A1' + mov A1,R + +%aw,nw* + S* + I #2(R),A1' + mov A1,R + +%aw,n + S + I R,A1' + mov A1,R + +%ew*,nw* + S* + F1* + I #2(R),#1(R1) + mov #1(R1),R + + +%a,n +%ad,nf + SS + movB1 A1',R + IBF (sp)+,R + movB1 R,A1 + +%af,nf + SS + movof A1,R + IBF (sp)+,R + movfo R,A1 + +%ew*,n + S + F1* + I R,#1(R1) + mov #1(R1),R + +%nw*,n + SS + F* + I (sp)+,#1(R) + mov #1(R),R + +%n*,n +%nd*,nf + SS + F* + movB1 #1(R),R1 + IBF (sp)+,R1 + movB1 R1,#1(R) + movBF R1,R + +%nf*,nf + SS + F* + movof #1(R),R1 + IBF (sp)+,R1 + movfo R1,#1(R) + movf R1,R + +/ int -> float +cr51: +%aw,n + movif A1,R + +%nw*,n + F* + movif #1(R),R + +%n,n + F + movif R,R + +/ float, double -> int +cr52: +%nf,n + F + movfi R,R + +.data +.even +.text + -- 2.20.1