summaryrefslogtreecommitdiff
path: root/utils/2c/txt.c
diff options
context:
space:
mode:
Diffstat (limited to 'utils/2c/txt.c')
-rw-r--r--utils/2c/txt.c940
1 files changed, 940 insertions, 0 deletions
diff --git a/utils/2c/txt.c b/utils/2c/txt.c
new file mode 100644
index 00000000..2723c6d6
--- /dev/null
+++ b/utils/2c/txt.c
@@ -0,0 +1,940 @@
+#include "gc.h"
+
+void
+tindex(Type *tf, Type *tt)
+{
+ int i, j;
+
+ j = 0;
+ if(tt != T) {
+ j = tt->etype;
+ if(j >= NTYPE)
+ j = 0;
+ }
+ i = 0;
+ if(tf != T) {
+ i = tf->etype;
+ if(i >= NTYPE)
+ if(typesu[i])
+ i = j;
+ else
+ i = 0;
+ }
+ txtp = &txt[i][j];
+}
+
+void
+ginit(void)
+{
+ int i, j, si, sj;
+
+ thestring = "68020";
+ thechar = '2';
+ exregoffset = 7;
+ exaregoffset = 5;
+ exfregoffset = 7;
+ listinit();
+ for(i=0; i<NREG; i++) {
+ regused[i] = 0;
+ fregused[i] = 0;
+ aregused[i] = 0;
+ }
+ regaddr(D_A0+6);
+ regaddr(D_A0+7);
+ for(i=0; i<sizeof(regbase); i++)
+ regbase[i] = D_NONE;
+ for(i=0; i<NREG; i++) {
+ regbase[D_R0+i] = D_R0+i;
+ regbase[D_A0+i] = D_A0+i;
+ regbase[D_F0+i] = D_F0+i;
+ }
+ regbase[D_TOS] = D_TOS;
+
+ for(i=0; i<NTYPE; i++)
+ for(j=0; j<NTYPE; j++) {
+ txtp = &txt[i][j];
+ txtp->movas = AGOK;
+ txtp->preclr = 0;
+ txtp->postext = AGOK;
+ if(!(typechlp[i] && typechlp[j]))
+ continue;
+ si = types[i]->width;
+ sj = types[j]->width;
+ if(sj < si)
+ txtp->preclr = -1;
+ if(sj > si) {
+ if(typeu[i]) {
+ txtp->preclr = 1;
+ } else {
+ if(sj == 2)
+ txtp->postext = AEXTBW;
+ if(sj == 4)
+ if(si == 1)
+ txtp->postext = AEXTBL;
+ else
+ txtp->postext = AEXTWL;
+ }
+ sj = si;
+ }
+ if(sj == 1)
+ txtp->movas = AMOVB;
+ if(sj == 2)
+ txtp->movas = AMOVW;
+ if(sj == 4)
+ txtp->movas = AMOVL;
+ }
+
+ for(i=0; i<ALLOP; i++)
+ for(j=0; j<NTYPE; j++)
+ opxt[i][j] = AGOK;
+ oinit(OFUNC, ABSR, ATRAP, AGOK, AGOK, AGOK);
+
+ oinit(OAS, AMOVB, AMOVW, AMOVL, AFMOVEF, AFMOVED);
+ oinit(OFAS, AFMOVEB, AFMOVEW, AFMOVEL, AFMOVEF, AFMOVED);
+ oinit(OADDR, AGOK, APEA, ALEA, AGOK, AGOK);
+ oinit(OPREINC, AADDB, AADDW, AADDL, AFADDF, AFADDD);
+ oinit(OPOSTINC, AADDB, AADDW, AADDL, AFADDF, AFADDD);
+ oinit(OPREDEC, ASUBB, ASUBW, ASUBL, AFSUBF, AFSUBD);
+ oinit(OPOSTDEC, ASUBB, ASUBW, ASUBL, AFSUBF, AFSUBD);
+ oinit(OADD, AADDB, AADDW, AADDL, AFADDF, AFADDD);
+ oinit(OASADD, AADDB, AADDW, AADDL, AFADDF, AFADDD);
+ oinit(OSUB, ASUBB, ASUBW, ASUBL, AFSUBF, AFSUBD);
+ oinit(OASSUB, ASUBB, ASUBW, ASUBL, AFSUBF, AFSUBD);
+ oinit(OMUL, AGOK, AMULSW, AMULSL, AFMULF, AFMULD);
+ oinit(OLMUL, AGOK, AMULSW, AMULSL, AFMULF, AFMULD);
+ oinit(OASMUL, AGOK, AMULSW, AMULSL, AFMULF, AFMULD);
+ oinit(OASLMUL, AGOK, AMULSW, AMULSL, AFMULF, AFMULD);
+ oinit(ODIV, AGOK, ADIVSW, ADIVSL, AFDIVF, AFDIVD);
+ oinit(OLDIV, AGOK, ADIVUW, ADIVUL, AFDIVF, AFDIVD);
+ oinit(OASDIV, AGOK, ADIVSW, ADIVSL, AFDIVF, AFDIVD);
+ oinit(OASLDIV, AGOK, ADIVUW, ADIVUL, AFDIVF, AFDIVD);
+ oinit(OMOD, AGOK, ADIVSW, ADIVSL, AFMODF, AFMODD);
+ oinit(OASMOD, AGOK, ADIVSW, ADIVSL, AGOK, AGOK);
+ oinit(OLMOD, AGOK, ADIVUW, ADIVUL, AGOK, AGOK);
+ oinit(OASLMOD, AGOK, ADIVUW, ADIVUL, AGOK, AGOK);
+ oinit(OAND, AANDB, AANDW, AANDL, AGOK, AGOK);
+ oinit(OASAND, AANDB, AANDW, AANDL, AGOK, AGOK);
+ oinit(OOR, AORB, AORW, AORL, AGOK, AGOK);
+ oinit(OASOR, AORB, AORW, AORL, AGOK, AGOK);
+ oinit(OXOR, AEORB, AEORW, AEORL, AGOK, AGOK);
+ oinit(OASXOR, AEORB, AEORW, AEORL, AGOK, AGOK);
+ oinit(ONEG, ANEGB, ANEGW, ANEGL, AFNEGF, AFNEGD);
+ oinit(OCOM, ANOTB, ANOTW, ANOTL, AGOK, AGOK);
+ oinit(OTST, ATSTB, ATSTW, ATSTL, AFTSTF, AFTSTD);
+ oinit(OEQ, ACMPB, ACMPW, ACMPL, AFCMPF, AFCMPD);
+ oinit(ONE, ACMPB, ACMPW, ACMPL, AFCMPF, AFCMPD);
+ oinit(OGE, ACMPB, ACMPW, ACMPL, AFCMPF, AFCMPD);
+ oinit(OGT, ACMPB, ACMPW, ACMPL, AFCMPF, AFCMPD);
+ oinit(OLT, ACMPB, ACMPW, ACMPL, AFCMPF, AFCMPD);
+ oinit(OLE, ACMPB, ACMPW, ACMPL, AFCMPF, AFCMPD);
+ oinit(OLS, ACMPB, ACMPW, ACMPL, AFCMPF, AFCMPD);
+ oinit(OLO, ACMPB, ACMPW, ACMPL, AFCMPF, AFCMPD);
+ oinit(OHS, ACMPB, ACMPW, ACMPL, AFCMPF, AFCMPD);
+ oinit(OHI, ACMPB, ACMPW, ACMPL, AFCMPF, AFCMPD);
+ oinit(OASHR, AASRB, AASRW, AASRL, AGOK, AGOK);
+ oinit(OASASHR, AASRB, AASRW, AASRL, AGOK, AGOK);
+ oinit(OLSHR, ALSRB, ALSRW, ALSRL, AGOK, AGOK);
+ oinit(OASLSHR, ALSRB, ALSRW, ALSRL, AGOK, AGOK);
+ oinit(OASHL, AASLB, AASLW, AASLL, AGOK, AGOK);
+ oinit(OASASHL, AASLB, AASLW, AASLL, AGOK, AGOK);
+ oinit(OBIT, ABFEXTU, AGOK, AGOK, AGOK, AGOK);
+
+ nstring = 0;
+ mnstring = 0;
+ nrathole = 0;
+ nstatic = 0;
+ pc = 0;
+ breakpc = -1;
+ continpc = -1;
+ cases = C;
+ firstp = P;
+ lastp = P;
+ tfield = types[TLONG];
+
+ zprog.link = P;
+ zprog.as = AGOK;
+ zprog.from.type = D_NONE;
+ zprog.from.index = D_NONE;
+ zprog.to = zprog.from;
+
+ nodret = new(ONAME, Z, Z);
+ nodret->sym = slookup(".ret");
+ nodret->type = types[TIND];
+ nodret->etype = types[TIND]->etype;
+ nodret->class = CPARAM;
+ nodret = new(OIND, nodret, Z);
+ complex(nodret);
+
+ symrathole = slookup(".rathole");
+ symrathole->class = CGLOBL;
+ symrathole->type = typ(TARRAY, types[TCHAR]);
+ nodrat = new(ONAME, Z, Z);
+ nodrat->sym = symrathole;
+ nodrat->type = types[TIND];
+ nodrat->etype = TVOID;
+ nodrat->class = CGLOBL;
+ complex(nodrat);
+ nodrat->type = symrathole->type;
+
+ com64init();
+
+ symstatic = slookup(".static");
+ symstatic->class = CSTATIC;
+ symstatic->type = typ(TARRAY, types[TLONG]);
+}
+
+void
+gclean(void)
+{
+ int i;
+ Sym *s;
+
+ regfree(D_A0+6);
+ regfree(D_A0+7);
+ for(i=0; i<NREG; i++) {
+ if(regused[i])
+ diag(Z, "missing R%d", i);
+ if(aregused[i])
+ diag(Z, "missing A%d", i);
+ if(fregused[i])
+ diag(Z, "missing F%d", i);
+ }
+
+ while(mnstring)
+ outstring("", 1L);
+ symstring->type->width = nstring;
+ symstatic->type->width = nstatic;
+ symrathole->type->width = nrathole;
+ for(i=0; i<NHASH; i++)
+ for(s = hash[i]; s != S; s = s->link) {
+ if(s->type == T)
+ continue;
+ if(s->type->width == 0)
+ continue;
+ if(s->class != CGLOBL && s->class != CSTATIC)
+ continue;
+ if(s->type == types[TENUM])
+ continue;
+ gpseudo(AGLOBL, s, D_CONST, s->type->width);
+ pc--;
+ }
+ nextpc();
+ p->as = AEND;
+ outcode();
+}
+
+void
+oinit(int o, int ab, int aw, int al, int af, int ad)
+{
+ int i;
+
+ i = o;
+ if(i >= ALLOP) {
+ diag(Z, "op(%d) >= ALLOP(%d)", i, ALLOP);
+ errorexit();
+ }
+ opxt[i][TCHAR] = ab;
+ opxt[i][TUCHAR] = ab;
+ opxt[i][TSHORT] = aw;
+ opxt[i][TUSHORT] = aw;
+ opxt[i][TINT] = al;
+ opxt[i][TUINT] = al;
+ opxt[i][TLONG] = al;
+ opxt[i][TULONG] = al;
+ opxt[i][TIND] = al;
+ opxt[i][TFLOAT] = af;
+ opxt[i][TDOUBLE] = ad;
+}
+
+Prog*
+prg(void)
+{
+ Prog *p;
+
+ p = alloc(sizeof(*p));
+ *p = zprog;
+ return p;
+}
+
+void
+nextpc(void)
+{
+
+ p = prg();
+ pc++;
+ p->lineno = nearln;
+ if(firstp == P) {
+ firstp = p;
+ lastp = p;
+ return;
+ }
+ lastp->link = p;
+ lastp = p;
+}
+
+void
+gargs(Node *n)
+{
+ long s;
+
+loop:
+ if(n == Z)
+ return;
+ if(n->op == OLIST) {
+ gargs(n->right);
+ n = n->left;
+ goto loop;
+ }
+ s = argoff;
+ cgen(n, D_TOS, n);
+ argoff = s + n->type->width;
+}
+
+void
+naddr(Node *n, Adr *a, int x)
+{
+ Node *l;
+ long v;
+
+ switch(n->op) {
+ default:
+ bad:
+ diag(n, "bad in naddr: %O", n->op);
+ break;
+
+ case OADDR:
+ case OIND:
+ naddr(n->left, a, x);
+ goto noadd;
+
+ case OREGISTER:
+ a->sym = S;
+ a->type = n->reg;
+ a->offset = n->xoffset;
+ a->displace = 0;
+ break;
+
+ case ONAME:
+ a->etype = n->etype;
+ a->displace = 0;
+ a->sym = n->sym;
+ a->offset = n->xoffset;
+ a->type = D_STATIC;
+ if(n->class == CSTATIC)
+ break;
+ if(n->class == CEXTERN || n->class == CGLOBL) {
+ a->type = D_EXTERN;
+ break;
+ }
+ if(n->class == CAUTO) {
+ a->type = D_AUTO;
+ break;
+ }
+ if(n->class == CPARAM) {
+ a->type = D_PARAM;
+ break;
+ }
+ goto bad;
+
+ case OINDEX:
+ naddr(n->left, a, x);
+ switch(n->left->addable) {
+ default:
+ goto bad;
+ case 1:
+ case 12:
+ a->index = x | I_INDEX1;
+ a->type &= D_MASK;
+ break;
+ case 2:
+ case 10:
+ case 11:
+ a->index = x | I_INDEX2;
+ break;
+ }
+ a->scale = n->scale;
+ break;
+
+ case OCONST:
+ a->displace = 0;
+ if(typefd[n->type->etype]) {
+ a->type = D_FCONST;
+ a->dval = n->fconst;
+ break;
+ }
+ a->type = D_CONST;
+ a->offset = n->vconst;
+ break;
+
+ case OADD:
+ l = n->left;
+ if(l->addable == 20) {
+ v = l->vconst;
+ naddr(n->right, a, x);
+ goto add;
+ }
+ l = n->right;
+ if(l->addable == 20) {
+ v = l->vconst;
+ naddr(n->left, a, x);
+ goto add;
+ }
+ goto bad;
+ noadd:
+ v = 0;
+ add:
+ switch(n->addable) {
+ default:
+ goto bad;
+ case 2:
+ a->displace += v;
+ break;
+ case 21:
+ a->type &= D_MASK;
+ a->type |= I_INDIR;
+ break;
+ case 1:
+ case 12:
+ a->offset += v;
+ a->type &= D_MASK;
+ a->type |= I_ADDR;
+ break;
+ case 13:
+ a->index = D_NONE|I_INDEX3;
+ case 10:
+ case 11:
+ case 20:
+ a->type &= D_MASK;
+ a->type |= I_DIR;
+ break;
+ }
+ break;
+
+ case OPREINC:
+ case OPREDEC:
+ case OPOSTINC:
+ case OPOSTDEC:
+
+ case OAS:
+ case OASLMUL:
+ case OASLDIV:
+ case OASLMOD:
+ case OASMUL:
+ case OASDIV:
+ case OASMOD:
+ case OASXOR:
+ case OASOR:
+ case OASADD:
+ case OASSUB:
+ case OASLSHR:
+ case OASASHR:
+ case OASASHL:
+ case OASAND:
+ naddr(n->left, a, x);
+ break;
+ }
+}
+
+int
+regalloc(Type *t, int g)
+{
+
+ if(t == T)
+ return D_NONE;
+ g &= D_MASK;
+ if(typefd[t->etype]) {
+ if(g >= D_F0 && g < D_F0+NREG) {
+ fregused[g-D_F0]++;
+ return g;
+ }
+ for(g=0; g<NREG; g++)
+ if(fregused[g] == 0) {
+ fregused[g]++;
+ return g + D_F0;
+ }
+ } else {
+ if(g >= D_R0 && g < D_R0+NREG) {
+ regused[g-D_R0]++;
+ return g;
+ }
+ for(g=0; g<NREG; g++)
+ if(regused[g] == 0) {
+ regused[g]++;
+ return g + D_R0;
+ }
+ }
+ diag(Z, "out of registers");
+ return D_TOS;
+}
+
+int
+regaddr(int g)
+{
+
+ if(g >= D_A0 && g < D_A0+NREG) {
+ aregused[g-D_A0]++;
+ return g;
+ }
+ for(g=0; g<NREG; g++)
+ if(aregused[g] == 0) {
+ aregused[g]++;
+ return g + D_A0;
+ }
+ diag(Z, "out of addr registers");
+ return D_TOS;
+}
+
+int
+regpair(int g)
+{
+
+ if(g >= D_R0+1 && g < D_R0+NREG)
+ if(!regused[g-D_R0-1]) {
+ regused[g-D_R0-1]++;
+ regused[g-D_R0]++;
+ return g-1;
+ }
+ if(g >= D_R0 && g < D_R0+NREG-1)
+ if(!regused[g-D_R0+1]) {
+ regused[g-D_R0+1]++;
+ regused[g-D_R0]++;
+ return g;
+ }
+ for(g = 0; g < NREG-1; g++)
+ if(!regused[g])
+ if(!regused[g+1]) {
+ regused[g]++;
+ regused[g+1]++;
+ return g + D_R0;
+ }
+ diag(Z, "out of register pairs");
+ return D_TOS;
+}
+
+int
+regret(Type *t)
+{
+
+ if(t == T)
+ return D_NONE;
+ if(typefd[t->etype])
+ return D_F0;
+ return D_R0;
+}
+
+void
+regfree(int g)
+{
+
+ g &= D_MASK;
+ if(g == D_TOS || g == D_TREE || g == D_NONE)
+ return;
+ if(g >= D_R0 && g < D_R0+NREG) {
+ regused[g-D_R0]--;
+ return;
+ }
+ if(g >= D_A0 && g < D_A0+NREG) {
+ aregused[g-D_A0]--;
+ return;
+ }
+ if(g >= D_F0 && g < D_F0+NREG) {
+ fregused[g-D_F0]--;
+ return;
+ }
+ diag(Z, "bad in regfree: %d", g);
+}
+
+void
+gmove(Type *tf, Type *tt, int gf, Node *f, int gt, Node *t)
+{
+ int g, a, b;
+ Prog *p1;
+
+ tindex(tf, tt);
+ if(txtp->preclr) {
+ if(gf >= D_R0 && gf < D_R0+NREG)
+ if(txtp->preclr < 0) {
+ gmove(tt, tt, gf, f, gt, t);
+ return;
+ }
+ g = regalloc(types[TLONG], gt);
+ if(g == gf) {
+ g = regalloc(types[TLONG], D_NONE);
+ regfree(gf);
+ }
+ if(txtp->preclr > 0)
+ gopcode(OAS, types[TLONG], D_CONST, nodconst(0), g, Z);
+ gopcode(OAS, tf, gf, f, g, Z);
+ if(g != gt)
+ gopcode(OAS, tt, g, Z, gt, t);
+ regfree(g);
+ return;
+ }
+ a = txtp->postext;
+ if(a != AGOK) {
+ if(gf >= D_R0 && gf < D_R0+NREG)
+ g = regalloc(types[TLONG], gf);
+ else
+ g = regalloc(types[TLONG], gt);
+ if(g != gf)
+ gopcode(OAS, tf, gf, f, g, Z);
+ nextpc();
+ p->as = a;
+ p->to.type = g;
+ if(debug['g'])
+ print("%P\n", p);
+ if(g != gt)
+ gopcode(OAS, tt, g, Z, gt, t);
+ regfree(g);
+ return;
+ }
+ if((regbase[gf] != D_NONE && regbase[gf] == regbase[gt]) ||
+ (gf == D_TREE && gt == D_TREE && f == t))
+ return;
+ if(typefd[tf->etype] || typefd[tt->etype]) {
+ if(typeu[tf->etype] && typefd[tt->etype]) { /* unsign->float */
+ a = regalloc(types[TLONG], D_NONE);
+ gmove(tf, types[TLONG], gf, f, a, t);
+ if(tf->etype == TULONG) {
+ b = regalloc(types[TDOUBLE], D_NONE);
+ gmove(types[TLONG], tt, a, t, b, t);
+ gopcode(OTST, types[TLONG], D_NONE, Z, a, t);
+ gbranch(OGE);
+ p1 = p;
+ gopcode(OASADD, types[TDOUBLE],
+ D_CONST, nodconst(100), b, t);
+ p->from.dval = 4294967296.;
+ patch(p1, pc);
+ gmove(types[TDOUBLE], tt, b, t, gt, t);
+ regfree(b);
+ } else
+ gmove(types[TLONG], tt, a, t, gt, t);
+ regfree(a);
+ return;
+ }
+ if(typefd[tf->etype] && !typefd[tt->etype]) { /* float->fix */
+ a = regalloc(types[TLONG], D_NONE);
+ gopcode(OAS, types[TLONG], D_FPCR, t, a, t);
+ gopcode(OAS, types[TLONG], D_CONST, nodconst(16), D_FPCR, t);
+ }
+ if(gf < D_F0 || gf >= D_F0+NREG) {
+ g = regalloc(types[TDOUBLE], gt);
+ gopcode(OFAS, tf, gf, f, g, t);
+ if(g != gt)
+ gopcode(OFAS, tt, g, t, gt, t);
+ regfree(g);
+ } else
+ gopcode(OFAS, tt, gf, f, gt, t);
+ if(typefd[tf->etype] && !typefd[tt->etype]) { /* float->fix */
+ gopcode(OAS, types[TLONG], a, t, D_FPCR, t);
+ regfree(a);
+ }
+ return;
+ }
+ gopcode(OAS, tt, gf, f, gt, t);
+}
+
+void
+gopcode(int o, Type *ty, int gf, Node *f, int gt, Node *t)
+{
+ int i, fidx, tidx;
+ long v;
+
+ if(o == OAS)
+ if(gf == gt)
+ if(gf != D_TREE || f == t)
+ return;
+
+ fidx = D_NONE;
+ if(gf == D_TREE) {
+ if(f->op == OINDEX) {
+ fidx = regalloc(types[TIND], fidx);
+ cgen(f->right, fidx, f->right);
+ }
+ }
+ tidx = D_NONE;
+ if(gt == D_TREE) {
+ if(t->op == OINDEX) {
+ v = argoff;
+ tidx = regalloc(types[TIND], tidx);
+ cgen(t->right, tidx, t->right);
+ if(gf == D_TOS)
+ adjsp(v - argoff);
+ }
+ }
+ i = 0;
+ if(ty != T) {
+ i = ty->etype;
+ if(i >= NTYPE)
+ i = 0;
+ }
+ nextpc();
+ if(gf == D_TREE) {
+ naddr(f, &p->from, fidx);
+ } else {
+ p->from.type = gf;
+ if(gf == D_CONST) {
+ p->from.offset = (long)(uintptr)f;
+ if(typefd[i]) {
+ p->from.type = D_FCONST;
+ p->from.dval = (long)(uintptr)f;
+ }
+ }
+ }
+ p->as = opxt[o][i];
+ if(gt == D_TREE) {
+ naddr(t, &p->to, tidx);
+ } else {
+ p->to.type = gt;
+ if(gt == D_CONST)
+ p->to.offset = (long)(uintptr)t;
+ }
+ if(o == OBIT) {
+ p->from.field = f->type->nbits;
+ p->to.field = f->type->shift;
+ if(p->from.field == 0)
+ diag(Z, "BIT zero width bit field");
+ }
+ if(p->as == AMOVL || p->as == AMOVW || p->as == AMOVB)
+ asopt();
+ if(debug['g'])
+ print("%P\n", p);
+ if(p->as == AGOK)
+ diag(Z, "GOK in gopcode: %s", onames[o]);
+ if(fidx != D_NONE)
+ regfree(fidx);
+ if(tidx != D_NONE)
+ regfree(tidx);
+}
+
+void
+asopt(void)
+{
+ long v;
+ int g;
+ Prog *q;
+
+ /*
+ * mov $0, ...
+ * ==>
+ * clr , ...
+ */
+ v = 0;
+ if(p->from.type == D_CONST) {
+ v = p->from.offset;
+ if(v == 0) {
+ p->from.type = D_NONE;
+ if(p->as == AMOVL)
+ p->as = ACLRL;
+ if(p->as == AMOVW)
+ p->as = ACLRW;
+ if(p->as == AMOVB)
+ p->as = ACLRB;
+ return;
+ }
+ }
+ /*
+ * mov ..., TOS
+ * ==>
+ * pea (...)
+ */
+ if(p->as == AMOVL && p->to.type == D_TOS && p->from.index == D_NONE)
+ switch(p->from.type) {
+ case D_CONST:
+ p->from.type |= I_INDIR;
+ p->to = p->from;
+ p->from = zprog.from;
+ p->as = APEA;
+ return;
+
+ case I_ADDR|D_EXTERN:
+ case I_ADDR|D_STATIC:
+ p->from.type &= ~I_ADDR;
+ p->to = p->from;
+ p->from = zprog.from;
+ p->as = APEA;
+ return;
+ }
+ /*
+ * movL $Qx, ...
+ * ==>
+ * movL $Qx,R
+ * movL R, ...
+ */
+ if(p->as == AMOVL && p->from.type == D_CONST)
+ if(v >= -128 && v < 128)
+ if(p->to.type < D_R0 || p->to.type >= D_R0+NREG) {
+ g = regalloc(types[TLONG], D_NONE);
+ q = p;
+ nextpc();
+ p->as = AMOVL;
+ p->from.type = g;
+ p->to = q->to;
+ q->to = p->from;
+ regfree(g);
+ if(debug['g'])
+ print("%P\n", q);
+ return;
+ }
+}
+
+void
+gbranch(int o)
+{
+ int a;
+
+ a = ABNE;
+ switch(o) {
+ case ORETURN: a = ARTS; break;
+ case OGOTO: a = ABRA; break;
+ case OEQ: a = ABEQ; break;
+ case ONE: a = ABNE; break;
+ case OLE: a = ABLE; break;
+ case OLS: a = ABLS; break;
+ case OLT: a = ABLT; break;
+ case OLO: a = ABCS; break;
+ case OGE: a = ABGE; break;
+ case OHS: a = ABCC; break;
+ case OGT: a = ABGT; break;
+ case OHI: a = ABHI; break;
+ case OBIT: a = ABCS; break;
+ case OCASE: a = ABCASE; break;
+ }
+ nextpc();
+ p->from.type = D_NONE;
+ p->to.type = D_NONE;
+ p->as = a;
+}
+
+void
+fpbranch(void)
+{
+ int a;
+
+ a = p->as;
+ switch(a) {
+ case ABEQ: a = AFBEQ; break;
+ case ABNE: a = AFBNE; break;
+ case ABLE: a = AFBLE; break;
+ case ABLT: a = AFBLT; break;
+ case ABGE: a = AFBGE; break;
+ case ABGT: a = AFBGT; break;
+ }
+ p->as = a;
+}
+
+void
+patch(Prog *op, long pc)
+{
+
+ op->to.offset = pc;
+ op->to.type = D_BRANCH;
+}
+
+void
+gpseudo(int a, Sym *s, int g, long v)
+{
+
+ nextpc();
+ if(a == ADATA)
+ pc--;
+ p->as = a;
+ if(g == D_TREE)
+ abort(); /* obsolete */
+ p->to.type = g;
+ p->to.offset = v;
+ p->from.sym = s;
+ p->from.type = D_EXTERN;
+ if(s->class == CSTATIC)
+ p->from.type = D_STATIC;
+}
+
+void
+gpseudotree(int a, Sym *s, Node *n)
+{
+ nextpc();
+ if(a == ADATA)
+ pc--;
+ p->as = a;
+ naddr(n, &p->to, D_NONE);
+ p->from.sym = s;
+ p->from.type = D_EXTERN;
+ if(s->class == CSTATIC)
+ p->from.type = D_STATIC;
+}
+
+long
+exreg(Type *t)
+{
+ long o;
+
+ if(typechl[t->etype]) {
+ if(exregoffset <= 5)
+ return 0;
+ o = exregoffset + D_R0;
+ exregoffset--;
+ return o;
+ }
+ if(t->etype == TIND) {
+ if(exaregoffset <= 3)
+ return 0;
+ o = exaregoffset + D_A0;
+ exaregoffset--;
+ return o;
+ }
+ if(typefd[t->etype]) {
+ if(exfregoffset <= 5)
+ return 0;
+ o = exfregoffset + D_F0;
+ exfregoffset--;
+ return o;
+ }
+ return 0;
+}
+
+schar ewidth[NTYPE] =
+{
+ -1, /* [TXXX] */
+ SZ_CHAR, /* [TCHAR] */
+ SZ_CHAR, /* [TUCHAR] */
+ SZ_SHORT, /* [TSHORT] */
+ SZ_SHORT, /* [TUSHORT] */
+ SZ_INT, /* [TINT] */
+ SZ_INT, /* [TUINT] */
+ SZ_LONG, /* [TLONG] */
+ SZ_LONG, /* [TULONG] */
+ SZ_VLONG, /* [TVLONG] */
+ SZ_VLONG, /* [TUVLONG] */
+ SZ_FLOAT, /* [TFLOAT] */
+ SZ_DOUBLE, /* [TDOUBLE] */
+ SZ_IND, /* [TIND] */
+ 0, /* [TFUNC] */
+ -1, /* [TARRAY] */
+ 0, /* [TVOID] */
+ -1, /* [TSTRUCT] */
+ -1, /* [TUNION] */
+ SZ_INT, /* [TENUM] */
+};
+long ncast[NTYPE] =
+{
+ 0, /* [TXXX] */
+ BCHAR|BUCHAR, /* [TCHAR] */
+ BCHAR|BUCHAR, /* [TUCHAR] */
+ BSHORT|BUSHORT, /* [TSHORT] */
+ BSHORT|BUSHORT, /* [TUSHORT] */
+ BINT|BUINT|BLONG|BULONG|BIND, /* [TINT] */
+ BINT|BUINT|BLONG|BULONG|BIND, /* [TUINT] */
+ BINT|BUINT|BLONG|BULONG|BIND, /* [TLONG] */
+ BINT|BUINT|BLONG|BULONG|BIND, /* [TULONG] */
+ BVLONG|BUVLONG, /* [TVLONG] */
+ BVLONG|BUVLONG, /* [TUVLONG] */
+ BFLOAT, /* [TFLOAT] */
+ BDOUBLE, /* [TDOUBLE] */
+ BLONG|BULONG|BIND, /* [TIND] */
+ 0, /* [TFUNC] */
+ 0, /* [TARRAY] */
+ 0, /* [TVOID] */
+ BSTRUCT, /* [TSTRUCT] */
+ BUNION, /* [TUNION] */
+ 0, /* [TENUM] */
+};
generated by cgit v1.2.3 (git 2.46.0) at 2025-12-10 23:14:30 +0000