ref: c1d40df49550393f3afe53fb6e6d500dfa8eb7a8
dir: /sys/src/cmd/qc/txt.c/
#include "gc.h"
static int resvreg[nelem(reg)];
static void gopcode64(int, Node*, Node*, Node*);
static void gori64(int, Node*, Node*, Node*);
static void gandi64(int, Node*, Node*, Node*);
void
ginit(void)
{
Type *t;
thechar = 'q';
thestring = "power";
exregoffset = REGEXT;
exfregoffset = FREGEXT;
newvlongcode = 1;
listinit();
nstring = 0;
mnstring = 0;
nrathole = 0;
pc = 0;
breakpc = -1;
continpc = -1;
cases = C;
firstp = P;
lastp = P;
tfield = types[TLONG];
typeswitch = typechlv;
zprog.link = P;
zprog.as = AGOK;
zprog.reg = NREG;
zprog.from.type = D_NONE;
zprog.from.name = D_NONE;
zprog.from.reg = NREG;
zprog.from3 = zprog.from;
zprog.to = zprog.from;
regnode.op = OREGISTER;
regnode.class = CEXREG;
regnode.reg = 0;
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;
com64init();
memset(reg, 0, sizeof(reg));
reg[REGZERO] = 1; /* don't use */
reg[REGTMP] = 1;
reg[FREGCVI+NREG] = 1;
reg[FREGZERO+NREG] = 1;
reg[FREGHALF+NREG] = 1;
reg[FREGONE+NREG] = 1;
reg[FREGTWO+NREG] = 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+NREG; 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) {
cgen(*fnxp, tn2);
(*fnxp)++;
} else
cgen(n, tn2);
return;
}
if(REGARG && curarg == 0 && typechlp[n->type->etype]) {
regaalloc1(tn1, n);
if(n->complex >= FNX) {
cgen(*fnxp, tn1);
(*fnxp)++;
} else
cgen(n, tn1);
return;
}
if(vconst(n) == 0) {
regaalloc(tn2, n);
gopcode(OAS, n, Z, tn2);
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*
nod32const(vlong v)
{
constnode.vconst = v & MASK(32);
return &constnode;
}
Node*
nodconst(long v)
{
constnode.vconst = v;
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]++;
}
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) {
i = j;
goto out;
}
j++;
}
diag(tn, "out of fixed registers");
goto err;
case TFLOAT:
case TDOUBLE:
if(o != Z && o->op == OREGISTER) {
i = o->reg;
if(i >= NREG && i < NREG+NREG)
goto out;
}
j = lasti + NREG;
for(i=NREG; i<NREG+NREG; i++) {
if(j >= NREG+NREG)
j = NREG;
if(reg[j] == 0) {
i = j;
goto out;
}
j++;
}
diag(tn, "out of float registers");
goto err;
case TVLONG:
case TUVLONG:
n->op = OREGPAIR;
n->complex = 0; /* already in registers */
n->addable = 11;
n->type = tn->type;
n->lineno = nearln;
n->left = alloc(sizeof(Node));
n->right = alloc(sizeof(Node));
if(o != Z && o->op == OREGPAIR) {
regalloc(n->left, ®node, o->left);
regalloc(n->right, ®node, o->right);
} else {
regalloc(n->left, ®node, Z);
regalloc(n->right, ®node, Z);
}
n->right->type = types[TULONG];
if(tn->type->etype == TUVLONG)
n->left->type = types[TULONG]; /* TO DO: is this a bad idea? */
return;
}
diag(tn, "unknown type in regalloc: %T", tn->type);
err:
i = 0;
out:
if(i)
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;
if(n->op == OREGPAIR) {
regfree(n->left);
regfree(n->right);
return;
}
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 [%d]", i, reg[i]);
prtree(n, "regfree");
}
void
regsalloc(Node *n, Node *nn)
{
cursafe = align(cursafe+stkoff, nn->type, Aaut3)-stkoff;
maxargsafe = maxround(maxargsafe, cursafe+curarg);
// if(nn->type->etype == TDOUBLE || nn->type->etype == TVLONG){
// extern int hasdoubled;
// fprint(2, "stkoff=%ld cursafe=%ld curarg=%ld %d\n", stkoff, cursafe, curarg, hasdoubled);
// }
*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 = REGZERO;
}
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);
a->offset += n->xoffset; /* little hack for reglcgenv */
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
gloadhi(Node *f, Node *t, int c)
{
Type *ot;
if(f->op == OCONST){
f = nodconst((long)(f->vconst>>32));
if(c==1 && sconst(f) || c==2 && uconst(f)){
if(t->op == OREGISTER)
regfree(t);
*t = *f;
return;
}
}
if(f->op == OREGPAIR) {
gmove(f->left, t);
return;
}
ot = f->type;
f->type = types[TLONG];
gmove(f, t);
f->type = ot;
}
void
gloadlo(Node *f, Node *t, int c)
{
Type *ot;
if(f->op == OCONST){
f = nodconst((long)f->vconst);
if(c && uconst(f)){
if(t->op == OREGISTER)
regfree(t);
*t = *f;
return;
}
}
if(f->op == OREGPAIR) {
gmove(f->right, t);
return;
}
ot = f->type;
f->type = types[TLONG];
f->xoffset += SZ_LONG;
if(0){
prtree(f, "gloadlo f"); prtree(t, "gloadlo t");
}
gmove(f, t);
f->xoffset -= SZ_LONG;
f->type = ot;
}
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);
}
static void
floattofix(Node *f, Node *t)
{
Node nod, fxrat;
regalloc(&nod, f, Z);
regsalloc(&fxrat, &fconstnode);
gins(AFCTIWZ, f, &nod);
gins(AFMOVD, &nod, &fxrat);
regfree(&nod);
fxrat.type = nodrat->type;
fxrat.etype = nodrat->etype;
fxrat.xoffset += 4;
gins(AMOVW, &fxrat, t);
gmove(t, t);
}
static void
fixtofloat(Node *f, Node *t)
{
int a, ft, tt;
Prog *p1;
Node nod, fxc0, fxc1, fxc2, fxrat;
ft = f->type->etype;
tt = t->type->etype;
/*
* rat[0] = 0x43300000; rat[1] = f^0x80000000;
* t = *(double*)rat - FREGCVI;
* is-unsigned(t) => if(t<0) t += 2^32;
* could be streamlined for int-to-float
*/
regalloc(&fxc0, f, Z);
regalloc(&fxc2, f, Z);
regsalloc(&fxrat, &fconstnode); /* should be type float */
gins(AMOVW, nodconst(0x43300000L), &fxc0);
gins(AMOVW, f, &fxc2);
gins(AMOVW, &fxc0, &fxrat);
gins(AXOR, nodconst(0x80000000L), &fxc2);
fxc1 = fxrat;
fxc1.type = nodrat->type;
fxc1.etype = nodrat->etype;
fxc1.xoffset += SZ_LONG;
gins(AMOVW, &fxc2, &fxc1);
regfree(&fxc2);
regfree(&fxc0);
regalloc(&nod, t, t); /* should be type float */
gins(AFMOVD, &fxrat, &nod);
nodreg(&fxc1, t, NREG+FREGCVI);
gins(AFSUB, &fxc1, &nod);
a = AFMOVD;
if(tt == TFLOAT)
a = AFRSP;
gins(a, &nod, t);
regfree(&nod);
if(ft == TULONG) {
regalloc(&nod, t, Z);
gins(AFCMPU, t, Z);
p->to.type = D_FREG;
p->to.reg = FREGZERO;
gins(ABGE, Z, Z);
p1 = p;
if(tt == TFLOAT) {
gins(AFMOVS, nodfconst(4294967296.), &nod);
gins(AFADDS, &nod, t);
} else {
gins(AFMOVD, nodfconst(4294967296.), &nod);
gins(AFADD, &nod, t);
}
patch(p1, pc);
regfree(&nod);
}
}
void
gmove(Node *f, Node *t)
{
int ft, tt, a;
Node nod;
double d;
ft = f->type->etype;
tt = t->type->etype;
if(ft == TDOUBLE && f->op == OCONST) {
d = f->fconst;
if(d == 0.0) {
a = FREGZERO;
goto ffreg;
}
if(d == 0.5) {
a = FREGHALF;
goto ffreg;
}
if(d == 1.0) {
a = FREGONE;
goto ffreg;
}
if(d == 2.0) {
a = FREGTWO;
goto ffreg;
}
if(d == -.5) {
fop(OSUB, FREGHALF, FREGZERO, t);
return;
}
if(d == -1.0) {
fop(OSUB, FREGONE, FREGZERO, t);
return;
}
if(d == -2.0) {
fop(OSUB, FREGTWO, FREGZERO, t);
return;
}
if(d == 1.5) {
fop(OADD, FREGONE, FREGHALF, t);
return;
}
if(d == 2.5) {
fop(OADD, FREGTWO, FREGHALF, t);
return;
}
if(d == 3.0) {
fop(OADD, FREGTWO, FREGONE, t);
return;
}
}
if(ft == TFLOAT && f->op == OCONST) {
d = f->fconst;
if(d == 0) {
a = FREGZERO;
ffreg:
nodreg(&nod, f, NREG+a);
gmove(&nod, t);
return;
}
}
if((ft == TVLONG || ft == TUVLONG) && f->op == OCONST && t->op == OREGPAIR) {
if(align(0, types[TCHAR], Aarg1)) /* isbigendian */
gmove(nod32const(f->vconst>>32), t->left);
else
gmove(nod32const(f->vconst), t->left);
if(align(0, types[TCHAR], Aarg1)) /* isbigendian */
gmove(nod32const(f->vconst), t->right);
else
gmove(nod32const(f->vconst>>32), t->right);
return;
}
/*
* 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 = AFMOVS;
break;
case TDOUBLE:
a = AFMOVD;
break;
case TCHAR:
a = AMOVB;
break;
case TUCHAR:
a = AMOVBZ;
break;
case TSHORT:
a = AMOVH;
break;
case TUSHORT:
a = AMOVHZ;
break;
}
if(typev[ft]) {
if(typev[tt] || typefd[tt]) {
regalloc(&nod, f, t);
/* low order first, because its value will be used first */
f->xoffset += SZ_LONG;
gins(AMOVW, f, nod.right);
f->xoffset -= SZ_LONG;
gins(AMOVW, f, nod.left);
} else {
/* assumed not float or double */
regalloc(&nod, ®node, t);
f->xoffset += SZ_LONG;
gins(AMOVW, f, &nod);
f->xoffset -= SZ_LONG;
}
} 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 = AMOVBZ;
break;
case TCHAR:
a = AMOVB;
break;
case TUSHORT:
a = AMOVHZ;
break;
case TSHORT:
a = AMOVH;
break;
case TFLOAT:
a = AFMOVS;
break;
case TDOUBLE:
a = AFMOVD;
break;
}
if(R0ISZERO && !typefd[ft] && vconst(f) == 0) {
gins(a, f, t);
if(typev[tt]) {
t->xoffset += SZ_LONG;
gins(a, f, t);
t->xoffset -= SZ_LONG;
}
return;
}
if(ft == tt)
regalloc(&nod, t, f);
else
regalloc(&nod, t, Z);
gmove(f, &nod);
if(typev[tt]) {
t->xoffset += SZ_LONG;
gins(a, nod.right, t);
t->xoffset -= SZ_LONG;
gins(a, nod.left, t);
} else
gins(a, &nod, t);
regfree(&nod);
return;
}
/*
* type x type cross table
*/
a = AGOK;
switch(ft) {
case TDOUBLE:
case TFLOAT:
switch(tt) {
case TDOUBLE:
a = AFMOVD;
if(ft == TFLOAT)
a = AFMOVS; /* AFMOVSD */
break;
case TFLOAT:
a = AFRSP;
if(ft == TFLOAT)
a = AFMOVS;
break;
case TINT:
case TUINT:
case TLONG:
case TULONG:
case TIND:
case TSHORT:
case TUSHORT:
case TCHAR:
case TUCHAR:
/* BUG: not right for unsigned long */
floattofix(f, t);
return;
case TVLONG:
case TUVLONG:
diag(f, "unimplemented double->vlong");
return;
}
break;
case TINT:
case TUINT:
case TLONG:
case TULONG:
case TIND:
switch(tt) {
case TDOUBLE:
case TFLOAT:
fixtofloat(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:
case TFLOAT:
fixtofloat(f, t);
return;
case TINT:
case TUINT:
case TLONG:
case TULONG:
case TIND:
a = AMOVH;
break;
case TSHORT:
case TUSHORT:
case TCHAR:
case TUCHAR:
a = AMOVW;
break;
}
break;
case TUSHORT:
switch(tt) {
case TDOUBLE:
case TFLOAT:
fixtofloat(f, t);
return;
case TINT:
case TUINT:
case TLONG:
case TULONG:
case TIND:
a = AMOVHZ;
break;
case TSHORT:
case TUSHORT:
case TCHAR:
case TUCHAR:
a = AMOVW;
break;
}
break;
case TCHAR:
switch(tt) {
case TDOUBLE:
case TFLOAT:
fixtofloat(f, t);
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:
case TFLOAT:
fixtofloat(f, t);
return;
case TINT:
case TUINT:
case TLONG:
case TULONG:
case TIND:
case TSHORT:
case TUSHORT:
a = AMOVBZ;
break;
case TCHAR:
case TUCHAR:
a = AMOVW;
break;
}
break;
case TVLONG:
case TUVLONG:
switch(tt) {
case TVLONG:
case TUVLONG:
a = AMOVW;
break;
}
break;
}
if(a == AGOK)
diag(Z, "bad opcode in gmove %T -> %T", f->type, t->type);
if(a == AMOVW || a == AFMOVS || a == AFMOVD)
if(samaddr(f, t))
return;
if(typev[ft]) {
if(f->op != OREGPAIR || t->op != OREGPAIR)
diag(Z, "bad vlong in gmove (%O->%O)", f->op, t->op);
gins(a, f->left, t->left);
gins(a, f->right, t->right);
} 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
gins3(int a, Node *f1, Node *f2, Node *t)
{
Adr ta;
nextpc();
p->as = a;
if(f1 != Z)
naddr(f1, &p->from);
if(f2 != Z && (f2->op != OREGISTER || !samaddr(f2, t))) {
ta = zprog.from; /* TO DO */
naddr(f2, &ta);
p->reg = ta.reg;
if(ta.type == D_CONST && ta.offset == 0) {
if(R0ISZERO)
p->reg = REGZERO;
else
diag(Z, "REGZERO in gins3 %A", a);
}else if(ta.type == D_CONST)
p->from3 = ta;
}
if(t != Z)
naddr(t, &p->to);
if(debug['g'])
print("%P\n", p);
}
void
gins4(int a, Node *f1, Node *f2, Node *f3, Node *t)
{
Adr ta;
nextpc();
p->as = a;
naddr(f1, &p->from);
if(f2->op != OREGISTER && (f2->op != OCONST || vconst(f2) != 0))
diag(f2, "invalid gins4");
naddr(f2, &ta);
p->reg = ta.reg;
if(ta.type == D_CONST && ta.offset == 0)
p->reg = REGZERO;
naddr(f3, &p->from3);
naddr(t, &p->to);
if(debug['g'])
print("%P\n", p);
}
void
gopcode(int o, Node *f1, Node *f2, Node *t)
{
int a, et, uns;
if(o == OAS) {
gmove(f1, t);
return;
}
et = TLONG;
if(f1 != Z && f1->type != T) {
if(f1->op == OCONST && t != Z && t->type != T)
et = t->type->etype;
else
et = f1->type->etype;
}
if((typev[et] || t->type != T && typev[t->type->etype]) && o != OFUNC) {
gopcode64(o, f1, f2, t);
return;
}
uns = 0;
a = AGOK;
switch(o) {
case OASADD:
case OADD:
a = AADD;
if(et == TFLOAT)
a = AFADDS;
else
if(et == TDOUBLE)
a = AFADD;
break;
case OASSUB:
case OSUB:
a = ASUB;
if(et == TFLOAT)
a = AFSUBS;
else
if(et == TDOUBLE)
a = AFSUB;
break;
case OASOR:
case OOR:
a = AOR;
break;
case OASAND:
case OAND:
a = AAND;
if(f1->op == OCONST)
a = AANDCC;
break;
case OASXOR:
case OXOR:
a = AXOR;
break;
case OASLSHR:
case OLSHR:
a = ASRW;
break;
case OASASHR:
case OASHR:
a = ASRAW;
break;
case OASASHL:
case OASHL:
a = ASLW;
break;
case OFUNC:
a = ABL;
break;
case OASLMUL:
case OLMUL:
case OASMUL:
case OMUL:
if(et == TFLOAT) {
a = AFMULS;
break;
} else
if(et == TDOUBLE) {
a = AFMUL;
break;
}
a = AMULLW;
break;
case OASDIV:
case ODIV:
if(et == TFLOAT) {
a = AFDIVS;
break;
} else
if(et == TDOUBLE) {
a = AFDIV;
break;
}
a = ADIVW;
break;
case OASMOD:
case OMOD:
a = AREM;
break;
case OASLMOD:
case OLMOD:
a = AREMU;
break;
case OASLDIV:
case OLDIV:
a = ADIVWU;
break;
case OCOM:
a = ANOR;
break;
case ONEG:
a = ANEG;
if(et == TFLOAT || et == TDOUBLE)
a = AFNEG;
break;
case OEQ:
a = ABEQ;
if(t->op == OCONST && t->vconst >= (1<<15))
goto cmpu;
goto cmp;
case ONE:
a = ABNE;
if(t->op == OCONST && t->vconst >= (1<<15))
goto cmpu;
goto cmp;
case OLT:
a = ABLT;
goto cmp;
case OLE:
a = ABLE;
goto cmp;
case OGE:
a = ABGE;
goto cmp;
case OGT:
a = ABGT;
goto cmp;
case OLO:
a = ABLT;
goto cmpu;
case OLS:
a = ABLE;
goto cmpu;
case OHS:
a = ABGE;
goto cmpu;
case OHI:
a = ABGT;
goto cmpu;
cmpu:
uns = 1;
cmp:
nextpc();
p->as = uns? ACMPU: ACMP;
if(et == TFLOAT)
p->as = AFCMPU;
else
if(et == TDOUBLE)
p->as = AFCMPU;
if(f1 != Z)
naddr(f1, &p->from);
if(t != Z)
naddr(t, &p->to);
if(f1 == Z || t == Z || f2 != Z)
diag(Z, "bad cmp in gopcode %O", o);
if(debug['g'])
print("%P\n", p);
f1 = Z;
f2 = Z;
t = Z;
break;
}
if(a == AGOK)
diag(Z, "bad in gopcode %O", o);
gins3(a, f1, f2, t);
}
static void
gopcode64(int o, Node *f1, Node *f2, Node *t)
{
int a1, a2;
Node nod, nod1, nod2, sh;
ulong m;
Prog *p1;
if(t->op != OREGPAIR || f2 != Z && f2->op != OREGPAIR) {
diag(Z, "bad f2/dest in gopcode64 %O", o);
return;
}
if(f1->op != OCONST &&
(typev[f1->type->etype] && f1->op != OREGPAIR || !typev[f1->type->etype] && f1->op != OREGISTER)) {
diag(Z, "bad f1[%O] in gopcode64 %O", f1->op, o);
return;
}
/* a1 for low-order, a2 for high-order */
a1 = AGOK;
a2 = AGOK;
switch(o) {
case OASADD:
case OADD:
if(f1->op == OCONST && sconst(f1)) {
if(f2 == Z)
f2 = t;
gins3(AADDC, f1, f2->right, t->right);
if((f1->vconst>>32) == 0)
gins(AADDZE, f2->left, t->left);
else if((f1->vconst>>32) == -1)
gins(AADDME, f2->left, t->left);
else
diag(t, "odd vlong ADD: %lld", f1->vconst);
return;
}
a1 = AADDC;
a2 = AADDE;
break;
case OASSUB:
case OSUB:
a1 = ASUBC;
a2 = ASUBE;
break;
case OASOR:
case OOR:
if(f1->op == OCONST) {
gori64(AOR, f1, f2, t);
return;
}
a1 = a2 = AOR;
break;
case OASAND:
case OAND:
if(f1->op == OCONST) {
gandi64(AANDCC, f1, f2, t);
return;
}
a1 = a2 = AAND;
break;
case OASXOR:
case OXOR:
if(f1->op == OCONST) {
gori64(AXOR, f1, f2, t);
return;
}
a1 = a2 = AXOR;
break;
case OASLSHR:
case OLSHR:
if(f2 == Z)
f2 = t;
if(f1->op == OCONST) {
if(f1->vconst >= 32) {
if(f1->vconst == 32)
gmove(f2->left, t->right);
else if(f1->vconst < 64)
gins3(ASRW, nodconst(f1->vconst-32), f2->left, t->right);
else
gmove(nodconst(0), t->right);
gmove(nodconst(0), t->left);
return;
}
if(f1->vconst <= 0) {
if(f2 != t)
gmove(f2, t);
return;
}
sh = *nodconst(32 - f1->vconst);
m = 0xFFFFFFFFUL >> f1->vconst;
gins4(ARLWNM, &sh, f2->right, nodconst(m), t->right);
gins4(ARLWMI, &sh, f2->left, nodconst(~m), t->right);
gins4(ARLWNM, &sh, f2->left, nodconst(m), t->left);
return;
}
regalloc(&nod, ®node, Z);
gins3(ASUBC, f1, nodconst(32), &nod);
gins3(ASRW, f1, f2->right, t->right);
regalloc(&nod1, ®node, Z);
gins3(ASLW, &nod, f2->left, &nod1);
gins(AOR, &nod1, t->right);
gins3(AADD, nodconst(-32), f1, &nod);
gins3(ASRW, &nod, f2->left, &nod1);
gins(AOR, &nod1, t->right);
gins3(ASRW, f1, f2->left, t->left);
regfree(&nod);
regfree(&nod1);
return;
case OASASHR:
case OASHR:
if(f2 == Z)
f2 = t;
if(f1->op == OCONST) {
if(f1->vconst >= 32) {
if(f1->vconst == 32)
gmove(f2->left, t->right);
else if(f1->vconst < 64)
gins3(ASRAW, nodconst(f1->vconst-32), f2->left, t->right);
gins3(ASRAW, nodconst(31), f2->left, t->left);
if(f1->vconst >= 64) {
gmove(t->left, t->right);
return;
}
return;
}
if(f1->vconst <= 0) {
if(f2 != t)
gmove(f2, t);
return;
}
sh = *nodconst(32 - f1->vconst);
m = 0xFFFFFFFFUL >> f1->vconst;
gins4(ARLWNM, &sh, f2->right, nodconst(m), t->right);
gins4(ARLWMI, &sh, f2->left, nodconst(~m), t->right);
gins3(ASRAW, &sh, f2->left, t->left);
return;
}
regalloc(&nod, ®node, Z);
gins3(ASUBC, f1, nodconst(32), &nod);
gins3(ASRW, f1, f2->right, t->right);
regalloc(&nod1, ®node, Z);
gins3(ASLW, &nod, f2->left, &nod1);
gins(AOR, &nod1, t->right);
gins3(AADDCCC, nodconst(-32), f1, &nod);
gins3(ASRAW, &nod, f2->left, &nod1);
gins(ABLE, Z, Z);
p1 = p;
gins(AMOVW, &nod1, t->right);
patch(p1, pc);
gins3(ASRAW, f1, f2->left, t->left);
regfree(&nod);
regfree(&nod1);
return;
case OASASHL:
case OASHL:
if(f2 == Z)
f2 = t;
if(f1->op == OCONST) {
if(f1->vconst >= 32) {
if(f1->vconst == 32)
gmove(f2->right, t->left);
else if(f1->vconst >= 64)
gmove(nodconst(0), t->left);
else
gins3(ASLW, nodconst(f1->vconst-32), f2->right, t->left);
gmove(nodconst(0), t->right);
return;
}
if(f1->vconst <= 0) {
if(f2 != t)
gmove(f2, t);
return;
}
m = 0xFFFFFFFFUL << f1->vconst;
gins4(ARLWNM, f1, f2->left, nodconst(m), t->left);
gins4(ARLWMI, f1, f2->right, nodconst(~m), t->left);
gins4(ARLWNM, f1, f2->right, nodconst(m), t->right);
return;
}
regalloc(&nod, ®node, Z);
gins3(ASUBC, f1, nodconst(32), &nod);
gins3(ASLW, f1, f2->left, t->left);
regalloc(&nod1, ®node, Z);
gins3(ASRW, &nod, f2->right, &nod1);
gins(AOR, &nod1, t->left);
gins3(AADD, nodconst(-32), f1, &nod);
gins3(ASLW, &nod, f2->right, &nod1);
gins(AOR, &nod1, t->left);
gins3(ASLW, f1, f2->right, t->right);
regfree(&nod);
regfree(&nod1);
return;
case OASLMUL:
case OLMUL:
case OASMUL:
case OMUL:
if(f2 == Z)
f2 = t;
regalloc(&nod, ®node, Z);
gins3(AMULLW, f1->right, f2->right, &nod); /* lo(f2.low*f1.low) */
regalloc(&nod1, ®node, Z);
gins3(AMULHWU, f1->right, f2->right, &nod1); /* hi(f2.low*f1.low) */
regalloc(&nod2, ®node, Z);
gins3(AMULLW, f2->right, f1->left, &nod2); /* lo(f2.low*f1.high) */
gins(AADD, &nod2, &nod1);
gins3(AMULLW, f1->right, f2->left, &nod2); /* lo(f2.high*f1.low) */
gins(AADD, &nod2, &nod1);
regfree(&nod2);
gmove(&nod, t->right);
gmove(&nod1, t->left);
regfree(&nod);
regfree(&nod1);
return;
case OCOM:
a1 = a2 = ANOR;
break;
case ONEG:
gins3(ASUBC, t->right, nodconst(0), t->right);
gins(ASUBZE, t->left, t->left);
return;
}
if(a1 == AGOK || a2 == AGOK)
diag(Z, "bad in gopcode64 %O", o);
if(f1->op == OCONST) {
if(f2 != Z & f2 != t)
diag(Z, "bad const in gopcode64 %O", o);
gins(a1, nod32const(f1->vconst), t->right);
gins(a2, nod32const(f1->vconst>>32), t->left);
} else {
if(f2 != Z && f2 != t) {
gins3(a1, f1->right, f2->right, t->right);
gins3(a2, f1->left, f2->left, t->left);
} else {
gins(a1, f1->right, t->right);
gins(a2, f1->left, t->left);
}
}
}
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;
case OREGPAIR:
return samaddr(f->left, t->left) && samaddr(f->right, t->right);
}
return 0;
}
static void
gori64(int a, Node *f1, Node *f2, Node *t)
{
ulong lo, hi;
if(f2 == Z)
f2 = t;
lo = f1->vconst & MASK(32);
hi = (f1->vconst >> 32) & MASK(32);
if(lo & 0xFFFF)
gins3(a, nodconst(lo & 0xFFFF), f2->right, t->right);
if((lo >> 16) != 0)
gins3(a, nodconst(lo & 0xFFFF0000UL), f2->right, t->right);
if(hi & 0xFFFF)
gins3(a, nodconst(hi & 0xFFFF), f2->left, t->left);
if((hi >> 16) != 0)
gins3(a, nodconst(hi & 0xFFFF0000UL), f2->left, t->left);
}
static void
gandi64(int a, Node *f1, Node *f2, Node *t)
{
ulong lo, hi;
if(f2 == Z)
f2 = t;
lo = f1->vconst & MASK(32);
hi = (f1->vconst >> 32) & MASK(32);
if(lo == 0)
gins(AMOVW, nodconst(0), t->right);
else
gins3(a, nodconst(lo), f2->right, t->right);
if(hi == 0)
gins(AMOVW, nodconst(0), t->left);
else
gins3(a, nodconst(hi), f2->left, t->left);
}
void
gbranch(int o)
{
int a;
a = AGOK;
switch(o) {
case ORETURN:
a = ARETURN;
break;
case OGOTO:
a = ABR;
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;
if(a == ATEXT)
p->reg = (profileflg ? 0 : NOPROF);
p->from.name = D_EXTERN;
if(s->class == CSTATIC)
p->from.name = D_STATIC;
naddr(n, &p->to);
if(a == ADATA || a == AGLOBL)
pc--;
}
int
sval(long v)
{
if(v >= -(1<<15) && v < (1<<15))
return 1;
return 0;
}
int
sconst(Node *n)
{
vlong vv;
if(n->op == OCONST) {
if(!typefd[n->type->etype]) {
vv = n->vconst;
if(vv >= -(((vlong)1)<<15) && vv < (((vlong)1)<<15))
return 1;
}
}
return 0;
}
int
uconst(Node *n)
{
vlong vv;
if(n->op == OCONST) {
if(!typefd[n->type->etype]) {
vv = n->vconst;
if(vv >= 0 && vv < (((vlong)1)<<16))
return 1;
}
}
return 0;
}
long
exreg(Type *t)
{
long o;
if(typechlp[t->etype]) {
if(exregoffset <= 3)
return 0;
o = exregoffset;
exregoffset--;
return o;
}
if(typefd[t->etype]) {
if(exfregoffset <= 16)
return 0;
o = exfregoffset + NREG;
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] */
};