ref: 12e226ac6798412271020d42645f69138715c519
dir: /utils/5c/txt.c/
#include "gc.h" static char resvreg[nelem(reg)]; void ginit(void) { Type *t; thechar = '5'; thestring = "arm"; exregoffset = REGEXT; exfregoffset = FREGEXT; listinit(); nstring = 0; mnstring = 0; nrathole = 0; pc = 0; breakpc = -1; continpc = -1; cases = C; firstp = P; lastp = P; tfield = types[TLONG]; zprog.link = P; zprog.as = AGOK; zprog.reg = NREG; zprog.from.type = D_NONE; zprog.from.name = D_NONE; zprog.from.reg = NREG; zprog.to = zprog.from; zprog.scond = 0xE; regnode.op = OREGISTER; regnode.class = CEXREG; regnode.reg = REGTMP; regnode.complex = 0; regnode.addable = 11; regnode.type = types[TLONG]; constnode.op = OCONST; constnode.class = CXXX; constnode.complex = 0; constnode.addable = 20; constnode.type = types[TLONG]; fconstnode.op = OCONST; fconstnode.class = CXXX; fconstnode.complex = 0; fconstnode.addable = 20; fconstnode.type = types[TDOUBLE]; nodsafe = new(ONAME, Z, Z); nodsafe->sym = slookup(".safe"); nodsafe->type = types[TINT]; nodsafe->etype = types[TINT]->etype; nodsafe->class = CAUTO; complex(nodsafe); t = typ(TARRAY, types[TCHAR]); symrathole = slookup(".rathole"); symrathole->class = CGLOBL; symrathole->type = t; nodrat = new(ONAME, Z, Z); nodrat->sym = symrathole; nodrat->type = types[TIND]; nodrat->etype = TVOID; nodrat->class = CGLOBL; complex(nodrat); nodrat->type = t; nodret = new(ONAME, Z, Z); nodret->sym = slookup(".ret"); nodret->type = types[TIND]; nodret->etype = TIND; nodret->class = CPARAM; nodret = new(OIND, nodret, Z); complex(nodret); com64init(); memset(reg, 0, sizeof(reg)); /* don't allocate */ reg[REGTMP] = 1; reg[REGSB] = 1; reg[REGSP] = 1; reg[REGLINK] = 1; reg[REGPC] = 1; /* keep two external registers */ reg[REGEXT] = 1; reg[REGEXT-1] = 1; memmove(resvreg, reg, sizeof(reg)); } void gclean(void) { int i; Sym *s; for(i=0; i<NREG; i++) if(reg[i] && !resvreg[i]) diag(Z, "reg %d left allocated", i); for(i=NREG; i<NREG+NFREG; i++) if(reg[i] && !resvreg[i]) diag(Z, "freg %d left allocated", i-NREG); while(mnstring) outstring("", 1L); symstring->type->width = nstring; 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, nodconst(s->type->width)); } nextpc(); p->as = AEND; outcode(); } void nextpc(void) { p = alloc(sizeof(*p)); *p = zprog; p->lineno = nearln; pc++; if(firstp == P) { firstp = p; lastp = p; return; } lastp->link = p; lastp = p; } void gargs(Node *n, Node *tn1, Node *tn2) { long regs; Node fnxargs[20], *fnxp; regs = cursafe; fnxp = fnxargs; garg1(n, tn1, tn2, 0, &fnxp); /* compile fns to temps */ curarg = 0; fnxp = fnxargs; garg1(n, tn1, tn2, 1, &fnxp); /* compile normal args and temps */ cursafe = regs; } void garg1(Node *n, Node *tn1, Node *tn2, int f, Node **fnxp) { Node nod; if(n == Z) return; if(n->op == OLIST) { garg1(n->left, tn1, tn2, f, fnxp); garg1(n->right, tn1, tn2, f, fnxp); return; } if(f == 0) { if(n->complex >= FNX) { regsalloc(*fnxp, n); nod = znode; nod.op = OAS; nod.left = *fnxp; nod.right = n; nod.type = n->type; cgen(&nod, Z); (*fnxp)++; } return; } if(typesuv[n->type->etype]) { regaalloc(tn2, n); if(n->complex >= FNX) { sugen(*fnxp, tn2, n->type->width); (*fnxp)++; } else sugen(n, tn2, n->type->width); return; } if(REGARG >= 0 && curarg == 0 && typechlp[n->type->etype]) { regaalloc1(tn1, n); if(n->complex >= FNX) { cgen(*fnxp, tn1); (*fnxp)++; } else cgen(n, tn1); return; } regalloc(tn1, n, Z); if(n->complex >= FNX) { cgen(*fnxp, tn1); (*fnxp)++; } else cgen(n, tn1); regaalloc(tn2, n); gopcode(OAS, tn1, Z, tn2); regfree(tn1); } Node* nodconst(long v) { constnode.vconst = v; return &constnode; } Node* nod32const(vlong v) { constnode.vconst = v & MASK(32); return &constnode; } Node* nodfconst(double d) { fconstnode.fconst = d; return &fconstnode; } void nodreg(Node *n, Node *nn, int reg) { *n = regnode; n->reg = reg; n->type = nn->type; n->lineno = nn->lineno; } void regret(Node *n, Node *nn) { int r; r = REGRET; if(typefd[nn->type->etype]) r = FREGRET+NREG; nodreg(n, nn, r); reg[r]++; } int tmpreg(void) { int i; for(i=REGRET+1; i<NREG; i++) if(reg[i] == 0) return i; diag(Z, "out of fixed registers"); return 0; } void regalloc(Node *n, Node *tn, Node *o) { int i, j; static int lasti; switch(tn->type->etype) { case TCHAR: case TUCHAR: case TSHORT: case TUSHORT: case TINT: case TUINT: case TLONG: case TULONG: case TIND: if(o != Z && o->op == OREGISTER) { i = o->reg; if(i >= 0 && i < NREG) goto out; } j = lasti + REGRET+1; for(i=REGRET+1; i<NREG; i++) { if(j >= NREG) j = REGRET+1; if(reg[j] == 0 && resvreg[j] == 0) { i = j; goto out; } j++; } diag(tn, "out of fixed registers"); goto err; case TFLOAT: case TDOUBLE: case TVLONG: if(o != Z && o->op == OREGISTER) { i = o->reg; if(i >= NREG && i < NREG+NFREG) goto out; } j = 0*2 + NREG; for(i=NREG; i<NREG+NFREG; i++) { if(j >= NREG+NFREG) j = NREG; if(reg[j] == 0) { i = j; goto out; } j++; } diag(tn, "out of float registers"); goto err; } diag(tn, "unknown type in regalloc: %T", tn->type); err: nodreg(n, tn, 0); return; out: reg[i]++; lasti++; if(lasti >= 5) lasti = 0; nodreg(n, tn, i); } void regialloc(Node *n, Node *tn, Node *o) { Node nod; nod = *tn; nod.type = types[TIND]; regalloc(n, &nod, o); } void regfree(Node *n) { int i; i = 0; if(n->op != OREGISTER && n->op != OINDREG) goto err; i = n->reg; if(i < 0 || i >= sizeof(reg)) goto err; if(reg[i] <= 0) goto err; reg[i]--; return; err: diag(n, "error in regfree: %d", i); } void regsalloc(Node *n, Node *nn) { cursafe = align(cursafe, nn->type, Aaut3); maxargsafe = maxround(maxargsafe, cursafe+curarg); *n = *nodsafe; n->xoffset = -(stkoff + cursafe); n->type = nn->type; n->etype = nn->type->etype; n->lineno = nn->lineno; } void regaalloc1(Node *n, Node *nn) { nodreg(n, nn, REGARG); reg[REGARG]++; curarg = align(curarg, nn->type, Aarg1); curarg = align(curarg, nn->type, Aarg2); maxargsafe = maxround(maxargsafe, cursafe+curarg); } void regaalloc(Node *n, Node *nn) { curarg = align(curarg, nn->type, Aarg1); *n = *nn; n->op = OINDREG; n->reg = REGSP; n->xoffset = curarg + SZ_LONG; n->complex = 0; n->addable = 20; curarg = align(curarg, nn->type, Aarg2); maxargsafe = maxround(maxargsafe, cursafe+curarg); } void regind(Node *n, Node *nn) { if(n->op != OREGISTER) { diag(n, "regind not OREGISTER"); return; } n->op = OINDREG; n->type = nn->type; } void raddr(Node *n, Prog *p) { Adr a; naddr(n, &a); if(R0ISZERO && a.type == D_CONST && a.offset == 0) { a.type = D_REG; a.reg = 0; } if(a.type != D_REG && a.type != D_FREG) { if(n) diag(n, "bad in raddr: %O", n->op); else diag(n, "bad in raddr: <null>"); p->reg = NREG; } else p->reg = a.reg; } void naddr(Node *n, Adr *a) { long v; a->type = D_NONE; if(n == Z) return; switch(n->op) { default: bad: diag(n, "bad in naddr: %O", n->op); break; case OREGISTER: a->type = D_REG; a->sym = S; a->reg = n->reg; if(a->reg >= NREG) { a->type = D_FREG; a->reg -= NREG; } break; case OIND: naddr(n->left, a); if(a->type == D_REG) { a->type = D_OREG; break; } if(a->type == D_CONST) { a->type = D_OREG; break; } goto bad; case OINDREG: a->type = D_OREG; a->sym = S; a->offset = n->xoffset; a->reg = n->reg; break; case ONAME: a->etype = n->etype; a->type = D_OREG; a->name = D_STATIC; a->sym = n->sym; a->offset = n->xoffset; if(n->class == CSTATIC) break; if(n->class == CEXTERN || n->class == CGLOBL) { a->name = D_EXTERN; break; } if(n->class == CAUTO) { a->name = D_AUTO; break; } if(n->class == CPARAM) { a->name = D_PARAM; break; } goto bad; case OCONST: a->sym = S; a->reg = NREG; if(typefd[n->type->etype]) { a->type = D_FCONST; a->dval = n->fconst; } else { a->type = D_CONST; a->offset = n->vconst; } break; case OADDR: naddr(n->left, a); if(a->type == D_OREG) { a->type = D_CONST; break; } goto bad; case OADD: if(n->left->op == OCONST) { naddr(n->left, a); v = a->offset; naddr(n->right, a); } else { naddr(n->right, a); v = a->offset; naddr(n->left, a); } a->offset += v; break; } } void fop(int as, int f1, int f2, Node *t) { Node nod1, nod2, nod3; nodreg(&nod1, t, NREG+f1); nodreg(&nod2, t, NREG+f2); regalloc(&nod3, t, t); gopcode(as, &nod1, &nod2, &nod3); gmove(&nod3, t); regfree(&nod3); } void gmovm(Node *f, Node *t, int w) { gins(AMOVM, f, t); p->scond |= C_UBIT; if(w) p->scond |= C_WBIT; } void gmove(Node *f, Node *t) { int ft, tt, a; Node nod, nod1; Prog *p1; ft = f->type->etype; tt = t->type->etype; if(ft == TDOUBLE && f->op == OCONST) { } if(ft == TFLOAT && f->op == OCONST) { } /* * a load -- * put it into a register then * worry what to do with it. */ if(f->op == ONAME || f->op == OINDREG || f->op == OIND) { switch(ft) { default: a = AMOVW; break; case TFLOAT: a = AMOVF; break; case TDOUBLE: a = AMOVD; break; case TCHAR: a = AMOVB; break; case TUCHAR: a = AMOVBU; break; case TSHORT: a = AMOVH; break; case TUSHORT: a = AMOVHU; break; } if(typechlp[ft] && typeilp[tt]) regalloc(&nod, t, t); else regalloc(&nod, f, t); gins(a, f, &nod); gmove(&nod, t); regfree(&nod); return; } /* * a store -- * put it into a register then * store it. */ if(t->op == ONAME || t->op == OINDREG || t->op == OIND) { switch(tt) { default: a = AMOVW; break; case TUCHAR: a = AMOVBU; break; case TCHAR: a = AMOVB; break; case TUSHORT: a = AMOVHU; break; case TSHORT: a = AMOVH; break; case TFLOAT: a = AMOVF; break; case TVLONG: case TDOUBLE: a = AMOVD; break; } if(ft == tt) regalloc(&nod, t, f); else regalloc(&nod, t, Z); gmove(f, &nod); gins(a, &nod, t); regfree(&nod); return; } /* * type x type cross table */ a = AGOK; switch(ft) { case TDOUBLE: case TVLONG: case TFLOAT: switch(tt) { case TDOUBLE: case TVLONG: a = AMOVD; if(ft == TFLOAT) a = AMOVFD; break; case TFLOAT: a = AMOVDF; if(ft == TFLOAT) a = AMOVF; break; case TINT: case TUINT: case TLONG: case TULONG: case TIND: a = AMOVDW; if(ft == TFLOAT) a = AMOVFW; break; case TSHORT: case TUSHORT: case TCHAR: case TUCHAR: a = AMOVDW; if(ft == TFLOAT) a = AMOVFW; break; } break; case TUINT: case TULONG: if(tt == TFLOAT || tt == TDOUBLE) { // ugly and probably longer than necessary, // but vfp has a single instruction for this, // so hopefully it won't last long. // // tmp = f // tmp1 = tmp & 0x80000000 // tmp ^= tmp1 // t = float(int32(tmp)) // if(tmp1) // t += 2147483648. // regalloc(&nod, f, Z); regalloc(&nod1, f, Z); gins(AMOVW, f, &nod); gins(AMOVW, &nod, &nod1); gins(AAND, nodconst(0x80000000), &nod1); gins(AEOR, &nod1, &nod); if(tt == TFLOAT) gins(AMOVWF, &nod, t); else gins(AMOVWD, &nod, t); gins(ACMP, nodconst(0), Z); raddr(&nod1, p); gins(ABEQ, Z, Z); regfree(&nod); regfree(&nod1); p1 = p; regalloc(&nod, t, Z); if(tt == TFLOAT) { gins(AMOVF, nodfconst(2147483648.), &nod); gins(AADDF, &nod, t); } else { gins(AMOVD, nodfconst(2147483648.), &nod); gins(AADDD, &nod, t); } regfree(&nod); patch(p1, pc); return; } // fall through case TINT: case TLONG: case TIND: switch(tt) { case TDOUBLE: gins(AMOVWD, f, t); return; case TFLOAT: gins(AMOVWF, f, t); return; case TINT: case TUINT: case TLONG: case TULONG: case TIND: case TSHORT: case TUSHORT: case TCHAR: case TUCHAR: a = AMOVW; break; } break; case TSHORT: switch(tt) { case TDOUBLE: regalloc(&nod, f, Z); gins(AMOVH, f, &nod); gins(AMOVWD, &nod, t); regfree(&nod); return; case TFLOAT: regalloc(&nod, f, Z); gins(AMOVH, f, &nod); gins(AMOVWF, &nod, t); regfree(&nod); return; case TUINT: case TINT: case TULONG: case TLONG: case TIND: a = AMOVH; break; case TSHORT: case TUSHORT: case TCHAR: case TUCHAR: a = AMOVW; break; } break; case TUSHORT: switch(tt) { case TDOUBLE: regalloc(&nod, f, Z); gins(AMOVHU, f, &nod); gins(AMOVWD, &nod, t); regfree(&nod); return; case TFLOAT: regalloc(&nod, f, Z); gins(AMOVHU, f, &nod); gins(AMOVWF, &nod, t); regfree(&nod); return; case TINT: case TUINT: case TLONG: case TULONG: case TIND: a = AMOVHU; break; case TSHORT: case TUSHORT: case TCHAR: case TUCHAR: a = AMOVW; break; } break; case TCHAR: switch(tt) { case TDOUBLE: regalloc(&nod, f, Z); gins(AMOVB, f, &nod); gins(AMOVWD, &nod, t); regfree(&nod); return; case TFLOAT: regalloc(&nod, f, Z); gins(AMOVB, f, &nod); gins(AMOVWF, &nod, t); regfree(&nod); return; case TINT: case TUINT: case TLONG: case TULONG: case TIND: case TSHORT: case TUSHORT: a = AMOVB; break; case TCHAR: case TUCHAR: a = AMOVW; break; } break; case TUCHAR: switch(tt) { case TDOUBLE: regalloc(&nod, f, Z); gins(AMOVBU, f, &nod); gins(AMOVWD, &nod, t); regfree(&nod); return; case TFLOAT: regalloc(&nod, f, Z); gins(AMOVBU, f, &nod); gins(AMOVWF, &nod, t); regfree(&nod); return; case TINT: case TUINT: case TLONG: case TULONG: case TIND: case TSHORT: case TUSHORT: a = AMOVBU; break; case TCHAR: case TUCHAR: a = AMOVW; break; } break; } if(a == AGOK) diag(Z, "bad opcode in gmove %T -> %T", f->type, t->type); if(a == AMOVW || a == AMOVF || a == AMOVD) if(samaddr(f, t)) return; gins(a, f, t); } void gmover(Node *f, Node *t) { int ft, tt, a; ft = f->type->etype; tt = t->type->etype; a = AGOK; if(typechlp[ft] && typechlp[tt] && ewidth[ft] >= ewidth[tt]){ switch(tt){ case TSHORT: a = AMOVH; break; case TUSHORT: a = AMOVHU; break; case TCHAR: a = AMOVB; break; case TUCHAR: a = AMOVBU; break; } } if(a == AGOK) gmove(f, t); else gins(a, f, t); } void gins(int a, Node *f, Node *t) { nextpc(); p->as = a; if(f != Z) naddr(f, &p->from); if(t != Z) naddr(t, &p->to); if(debug['g']) print("%P\n", p); } void gopcode(int o, Node *f1, Node *f2, Node *t) { int a, et; Adr ta; et = TLONG; if(f1 != Z && f1->type != T) et = f1->type->etype; a = AGOK; switch(o) { case OAS: gmove(f1, t); return; case OASADD: case OADD: a = AADD; if(et == TFLOAT) a = AADDF; else if(et == TDOUBLE || et == TVLONG) a = AADDD; break; case OASSUB: case OSUB: if(f2 && f2->op == OCONST) { Node *t = f1; f1 = f2; f2 = t; a = ARSB; } else a = ASUB; if(et == TFLOAT) a = ASUBF; else if(et == TDOUBLE || et == TVLONG) a = ASUBD; break; case OASOR: case OOR: a = AORR; break; case OASAND: case OAND: a = AAND; break; case OASXOR: case OXOR: a = AEOR; break; case OASLSHR: case OLSHR: a = ASRL; break; case OASASHR: case OASHR: a = ASRA; break; case OASASHL: case OASHL: a = ASLL; break; case OFUNC: a = ABL; break; case OASMUL: case OMUL: a = AMUL; if(et == TFLOAT) a = AMULF; else if(et == TDOUBLE || et == TVLONG) a = AMULD; break; case OASDIV: case ODIV: a = ADIV; if(et == TFLOAT) a = ADIVF; else if(et == TDOUBLE || et == TVLONG) a = ADIVD; break; case OASMOD: case OMOD: a = AMOD; break; case OASLMUL: case OLMUL: a = AMULU; break; case OASLMOD: case OLMOD: a = AMODU; break; case OASLDIV: case OLDIV: a = ADIVU; break; case OCASE: case OEQ: case ONE: case OLT: case OLE: case OGE: case OGT: case OLO: case OLS: case OHS: case OHI: a = ACMP; if(et == TFLOAT) a = ACMPF; else if(et == TDOUBLE || et == TVLONG) a = ACMPD; nextpc(); p->as = a; naddr(f1, &p->from); if(a == ACMP && f1->op == OCONST && p->from.offset < 0 && p->from.offset != 0x80000000) { p->as = ACMN; p->from.offset = -p->from.offset; } raddr(f2, p); switch(o) { case OEQ: a = ABEQ; break; case ONE: a = ABNE; break; case OLT: a = ABLT; break; case OLE: a = ABLE; break; case OGE: a = ABGE; break; case OGT: a = ABGT; break; case OLO: a = ABLO; break; case OLS: a = ABLS; break; case OHS: a = ABHS; break; case OHI: a = ABHI; break; case OCASE: nextpc(); p->as = ACASE; p->scond = 0x9; naddr(f2, &p->from); a = ABHI; break; } f1 = Z; f2 = Z; break; } if(a == AGOK) diag(Z, "bad in gopcode %O", o); nextpc(); p->as = a; if(f1 != Z) naddr(f1, &p->from); if(f2 != Z) { naddr(f2, &ta); p->reg = ta.reg; } if(t != Z) naddr(t, &p->to); if(debug['g']) print("%P\n", p); } int samaddr(Node *f, Node *t) { if(f->op != t->op) return 0; switch(f->op) { case OREGISTER: if(f->reg != t->reg) break; return 1; } return 0; } void gbranch(int o) { int a; a = AGOK; switch(o) { case ORETURN: a = ARET; break; case OGOTO: a = AB; break; } nextpc(); if(a == AGOK) { diag(Z, "bad in gbranch %O", o); nextpc(); } p->as = a; } void patch(Prog *op, long pc) { op->to.offset = pc; op->to.type = D_BRANCH; } void gpseudo(int a, Sym *s, Node *n) { nextpc(); p->as = a; p->from.type = D_OREG; p->from.sym = s; p->from.name = D_EXTERN; if(a == ATEXT) p->reg = (profileflg ? 0 : NOPROF); if(s->class == CSTATIC) p->from.name = D_STATIC; naddr(n, &p->to); if(a == ADATA || a == AGLOBL) pc--; } int sconst(Node *n) { vlong vv; if(n->op == OCONST) { if(!typefd[n->type->etype]) { vv = n->vconst; if(vv >= (vlong)(-32766) && vv < (vlong)32766) return 1; /* * should be specialised for constant values which will * fit in different instructionsl; for now, let 5l * sort it out */ return 1; } } return 0; } int sval(long v) { int i; for(i=0; i<16; i++) { if((v & ~0xff) == 0) return 1; if((~v & ~0xff) == 0) return 1; v = (v<<2) | ((ulong)v>>30); } return 0; } long exreg(Type *t) { long o; if(typechlp[t->etype]) { if(exregoffset <= REGEXT-2) return 0; o = exregoffset; if(reg[o] && !resvreg[o]) return 0; resvreg[o] = reg[o] = 1; exregoffset--; return o; } if(typefd[t->etype]) { if(exfregoffset <= NFREG-1) return 0; o = exfregoffset + NREG; if(reg[o] && !resvreg[o]) return 0; resvreg[o] = reg[o] = 1; 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] */ };