ref: de1a460fa13ed2bffbdc3cb046cc8831c1d22008
dir: /sys/src/cmd/2c/sgen.c/
#include "gc.h"
void
codgen(Node *n, Node *nn)
{
Prog *sp;
argoff = 0;
inargs = 0;
for(;; nn = nn->left) {
if(nn == Z) {
diag(Z, "cant find function name");
return;
}
if(nn->op == ONAME)
break;
}
nearln = nn->lineno;
gpseudo(ATEXT, nn->sym, D_CONST, stkoff);
sp = p;
retok = 0;
gen(n);
if(!retok)
if(thisfn->link->etype != TVOID)
warn(Z, "no return at end of function: %s", nn->sym->name);
noretval(3);
gbranch(ORETURN);
if(!debug['N'] || debug['R'] || debug['P'])
regopt(sp);
}
void
gen(Node *n)
{
Node *l;
Prog *sp, *spc, *spb;
Case *cn;
long sbc, scc;
int snbreak;
int g, o;
loop:
if(n == Z)
return;
nearln = n->lineno;
o = n->op;
if(debug['G'])
if(o != OLIST)
print("%L %O\n", nearln, o);
retok = 0;
switch(o) {
default:
complex(n);
doinc(n, PRE);
cgen(n, D_NONE, n);
doinc(n, POST);
break;
case OLIST:
gen(n->left);
rloop:
n = n->right;
goto loop;
case ORETURN:
retok = 1;
complex(n);
if(n->type == T)
break;
l = n->left;
if(l == Z) {
noretval(3);
gbranch(ORETURN);
break;
}
doinc(l, PRE);
if(typesuv[n->type->etype]) {
sugen(l, D_TREE, nodret, n->type->width);
doinc(l, POST);
noretval(3);
gbranch(ORETURN);
break;
}
g = regalloc(n->type, regret(n->type));
cgen(l, g, n);
doinc(l, POST);
if(typefd[n->type->etype])
noretval(1);
else
noretval(2);
gbranch(ORETURN);
regfree(g);
break;
case OLABEL:
l = n->left;
if(l) {
l->xoffset = pc;
if(l->label)
patch(l->label, pc);
}
gbranch(OGOTO); /* prevent self reference in reg */
patch(p, pc);
goto rloop;
case OGOTO:
retok = 1;
n = n->left;
if(n == Z)
return;
if(n->complex == 0) {
diag(Z, "label undefined: %s", n->sym->name);
return;
}
gbranch(OGOTO);
if(n->xoffset) {
patch(p, n->xoffset);
return;
}
if(n->label)
patch(n->label, pc-1);
n->label = p;
return;
case OCASE:
l = n->left;
if(cases == C)
diag(n, "case/default outside a switch");
if(l == Z) {
casf();
cases->val = 0;
cases->def = 1;
cases->label = pc;
setsp();;
goto rloop;
}
complex(l);
if(l->type == T)
goto rloop;
if(l->op == OCONST)
if(typechl[l->type->etype]) {
casf();
cases->val = l->vconst;
cases->def = 0;
cases->label = pc;
setsp();
goto rloop;
}
diag(n, "case expression must be integer constant");
goto rloop;
case OSWITCH:
l = n->left;
complex(l);
doinc(l, PRE);
if(l->type == T)
break;
if(!typechl[l->type->etype]) {
diag(n, "switch expression must be integer");
break;
}
g = regalloc(types[TLONG], D_NONE);
n->type = types[TLONG];
cgen(l, g, n);
regfree(g);
doinc(l, POST);
setsp();
gbranch(OGOTO); /* entry */
sp = p;
cn = cases;
cases = C;
casf();
sbc = breakpc;
breakpc = pc;
snbreak = nbreak;
nbreak = 0;
gbranch(OGOTO);
spb = p;
gen(n->right);
gbranch(OGOTO);
patch(p, breakpc);
nbreak++;
patch(sp, pc);
doswit(g, l);
patch(spb, pc);
cases = cn;
breakpc = sbc;
nbreak = snbreak;
setsp();
break;
case OWHILE:
case ODWHILE:
l = n->left;
gbranch(OGOTO); /* entry */
sp = p;
scc = continpc;
continpc = pc;
gbranch(OGOTO);
spc = p;
sbc = breakpc;
breakpc = pc;
snbreak = nbreak;
nbreak = 0;
gbranch(OGOTO);
spb = p;
patch(spc, pc);
if(n->op == OWHILE)
patch(sp, pc);
bcomplex(l); /* test */
patch(p, breakpc);
if(l->op != OCONST || vconst(l) == 0)
nbreak++;
if(n->op == ODWHILE)
patch(sp, pc);
gen(n->right); /* body */
gbranch(OGOTO);
patch(p, continpc);
patch(spb, pc);
continpc = scc;
breakpc = sbc;
if(nbreak == 0)
retok = 1;
nbreak = snbreak;
break;
case OFOR:
l = n->left;
gen(l->right->left); /* init */
gbranch(OGOTO); /* entry */
sp = p;
scc = continpc;
continpc = pc;
gbranch(OGOTO);
spc = p;
sbc = breakpc;
breakpc = pc;
snbreak = nbreak;
nbreak = 0;
gbranch(OGOTO);
spb = p;
patch(spc, pc);
gen(l->right->right); /* inc */
patch(sp, pc);
if(l->left != Z) { /* test */
bcomplex(l->left);
patch(p, breakpc);
if(l->left->op != OCONST || vconst(l->left) == 0)
nbreak++;
}
gen(n->right); /* body */
gbranch(OGOTO);
patch(p, continpc);
patch(spb, pc);
continpc = scc;
breakpc = sbc;
if(nbreak == 0)
retok = 1;
nbreak = snbreak;
break;
case OCONTINUE:
if(continpc < 0) {
diag(n, "continue not in a loop");
break;
}
gbranch(OGOTO);
patch(p, continpc);
break;
case OBREAK:
if(breakpc < 0) {
diag(n, "break not in a loop");
break;
}
gbranch(OGOTO);
patch(p, breakpc);
nbreak++;
break;
case OIF:
l = n->left;
bcomplex(l);
sp = p;
if(n->right->left != Z)
gen(n->right->left);
if(n->right->right != Z) {
gbranch(OGOTO);
patch(sp, pc);
sp = p;
gen(n->right->right);
}
patch(sp, pc);
break;
case OSET:
case OUSED:
usedset(n->left, o);
break;
}
}
void
usedset(Node *n, int o)
{
if(n->op == OLIST) {
usedset(n->left, o);
usedset(n->right, o);
return;
}
complex(n);
switch(n->op) {
case OADDR: /* volatile */
gopcode(OTST, types[TINT], D_TREE, n, D_NONE, Z);
p->as = ANOP;
break;
case ONAME:
if(o == OSET)
gopcode(OTST, types[TINT], D_NONE, Z, D_TREE, n);
else
gopcode(OTST, types[TINT], D_TREE, n, D_NONE, Z);
p->as = ANOP;
break;
}
}
void
noretval(int n)
{
if(n & 1) {
gopcode(OTST, types[TINT], D_NONE, Z, regret(types[TLONG]), Z);
p->as = ANOP;
}
if(n & 2) {
gopcode(OTST, types[TINT], D_NONE, Z, regret(types[TDOUBLE]), Z);
p->as = ANOP;
}
}
/*
* calculate addressability as follows
* REGISTER ==> 12 register
* NAME ==> 10/11 name+value(SB/SP)
* CONST ==> 20 $value
* *(20) ==> 21 value
* &(10) ==> 12 $name+value(SB)
* &(11) ==> 1 $name+value(SP)
* (12) + (20) ==> 12 fold constants
* (1) + (20) ==> 1 fold constants
* *(12) ==> 10 back to name
* *(1) ==> 11 back to name
*
* (2,10,11) + (20) ==> 2 indirect w offset
* (2) ==> &13
* *(10,11) ==> 13 indirect, no index
*
* (20) * (X) ==> 7 multiplier in indexing
* (X,7) + (12,1) ==> 8 adder in indexing (addresses)
* (X,7) + (10,11,2) ==> 8 adder in indexing (names)
* (8) ==> &9 index, almost addressable
*
* (X)++ ==> X fake addressability
*
* calculate complexity (number of registers)
*/
void
xcom(Node *n)
{
Node *l, *r;
int g;
if(n == Z)
return;
l = n->left;
r = n->right;
n->complex = 0;
n->addable = 0;
switch(n->op) {
case OCONST:
n->addable = 20;
break;
case ONAME:
n->addable = 10;
if(n->class == CPARAM || n->class == CAUTO)
n->addable = 11;
break;
case OREGISTER:
n->addable = 12;
break;
case OADDR:
xcom(l);
if(l->addable == 10)
n->addable = 12;
else
if(l->addable == 11)
n->addable = 1;
break;
case OADD:
xcom(l);
xcom(r);
if(n->type->etype != TIND)
break;
if(l->addable == 20)
switch(r->addable) {
case 12:
case 1:
n->addable = r->addable;
goto brk;
case 10:
case 11:
case 2:
goto addr13;
}
if(r->addable == 20)
switch(l->addable) {
case 12:
case 1:
n->addable = l->addable;
goto brk;
case 10:
case 11:
case 2:
addr13:
n->addable = 2;
l = new1(OXXX, Z, Z);
*l = *n;
n->op = OIND;
n->left = l;
n->right = Z;
n->addable = 13;
l = new1(OXXX, Z, Z);
*l = *n;
n->op = OADDR;
n->left = l;
n->right = Z;
n->addable = 2;
goto brk;
}
switch(r->addable) {
case 10:
case 11:
case 12:
case 1:
n->addable = 8;
}
switch(l->addable) {
case 10:
case 11:
case 12:
case 1:
n->addable = 8;
}
if(n->addable == 8) {
indx(n);
l = new1(OINDEX, idx.basetree, idx.regtree);
l->scale = idx.scale;
l->addable = 9;
l->complex = l->right->complex;
l->type = l->left->type;
n->op = OADDR;
n->left = l;
n->right = Z;
n->addable = 0;
break;
}
break;
case OIND:
xcom(l);
if(l->op == OADDR) {
l = l->left;
l->type = n->type;
*n = *l;
return;
}
switch(l->addable) {
case 20:
n->addable = 21;
break;
case 1:
n->addable = 11;
break;
case 12:
n->addable = 10;
break;
case 10:
case 11:
case 2:
n->addable = 13;
break;
}
break;
case OASHL:
xcom(l);
xcom(r);
if(typev[n->type->etype])
break;
g = vconst(r);
if(g >= 0 && g < 4)
n->addable = 7;
break;
case OMUL:
case OLMUL:
xcom(l);
xcom(r);
if(typev[n->type->etype])
break;
g = vlog(r);
if(g >= 0) {
n->op = OASHL;
r->vconst = g;
if(g < 4)
n->addable = 7;
break;
}
g = vlog(l);
if(g >= 0) {
n->left = r;
n->right = l;
l = r;
r = n->right;
n->op = OASHL;
r->vconst = g;
if(g < 4)
n->addable = 7;
break;
}
break;
case ODIV:
case OLDIV:
xcom(l);
xcom(r);
if(typev[n->type->etype])
break;
g = vlog(r);
if(g >= 0) {
if(n->op == ODIV)
n->op = OASHR;
else
n->op = OLSHR;
r->vconst = g;
}
break;
case OSUB:
xcom(l);
xcom(r);
if(typev[n->type->etype])
break;
if(vconst(l) == 0) {
n->op = ONEG;
n->left = r;
n->right = Z;
}
break;
case OXOR:
xcom(l);
xcom(r);
if(typev[n->type->etype])
break;
if(vconst(l) == -1) {
n->op = OCOM;
n->left = r;
n->right = Z;
}
break;
case OASMUL:
case OASLMUL:
xcom(l);
xcom(r);
if(typev[n->type->etype])
break;
g = vlog(r);
if(g >= 0) {
n->op = OASASHL;
r->vconst = g;
}
goto aseae;
case OASDIV:
case OASLDIV:
xcom(l);
xcom(r);
if(typev[n->type->etype])
break;
g = vlog(r);
if(g >= 0) {
if(n->op == OASDIV)
n->op = OASASHR;
else
n->op = OASLSHR;
r->vconst = g;
}
goto aseae;
case OASLMOD:
case OASMOD:
xcom(l);
xcom(r);
if(typev[n->type->etype])
break;
aseae: /* hack that there are no byte/short mul/div operators */
if(n->type->etype == TCHAR || n->type->etype == TSHORT) {
n->right = new1(OCAST, n->right, Z);
n->right->type = types[TLONG];
n->type = types[TLONG];
}
if(n->type->etype == TUCHAR || n->type->etype == TUSHORT) {
n->right = new1(OCAST, n->right, Z);
n->right->type = types[TULONG];
n->type = types[TULONG];
}
goto asop;
case OASXOR:
case OASOR:
case OASADD:
case OASSUB:
case OASLSHR:
case OASASHR:
case OASASHL:
case OASAND:
case OAS:
xcom(l);
xcom(r);
if(typev[n->type->etype])
break;
asop:
if(l->addable > INDEXED &&
l->complex < FNX &&
r && r->complex < FNX)
n->addable = l->addable;
break;
case OPOSTINC:
case OPREINC:
case OPOSTDEC:
case OPREDEC:
xcom(l);
if(typev[n->type->etype])
break;
if(l->addable > INDEXED &&
l->complex < FNX)
n->addable = l->addable;
break;
default:
if(l != Z)
xcom(l);
if(r != Z)
xcom(r);
break;
}
brk:
n->complex = 0;
if(n->addable >= 10)
return;
if(l != Z)
n->complex = l->complex;
if(r != Z) {
if(r->complex == n->complex)
n->complex = r->complex+1;
else
if(r->complex > n->complex)
n->complex = r->complex;
}
if(n->complex == 0)
n->complex++;
if(com64(n))
return;
switch(n->op) {
case OFUNC:
n->complex = FNX;
break;
case OADD:
case OMUL:
case OLMUL:
case OXOR:
case OAND:
case OOR:
/*
* symmetric operators, make right side simple
* if same, put constant on left to get movq
*/
if(r->complex > l->complex ||
(r->complex == l->complex && r->addable == 20)) {
n->left = r;
n->right = l;
}
break;
case OLE:
case OLT:
case OGE:
case OGT:
case OEQ:
case ONE:
/*
* relational operators, make right side simple
* if same, put constant on left to get movq
*/
if(r->complex > l->complex || r->addable == 20) {
n->left = r;
n->right = l;
n->op = invrel[relindex(n->op)];
}
break;
}
}
void
indx(Node *n)
{
Node *l, *r;
int t;
if(debug['x'])
prtree(n, "indx");
t = 0;
loop:
l = n->left;
r = n->right;
switch(r->addable) {
default:
if(t) {
diag(n, "bad indx");
break;
}
n->right = l;
n->left = r;
t++;
goto loop;
case 10:
case 11:
if(l->op == ONAME && r->op == ONAME)
if(l->etype == TIND)
if(r->etype != TIND) {
n->right = l;
n->left = r;
goto loop;
}
if(l->addable == 1 || l->addable == 12) {
n->right = l;
n->left = r;
goto loop;
}
case 1:
case 12:
break;
}
if(l->addable != 7) {
idx.regtree = l;
idx.scale = 0;
} else
if(l->right->addable == 20) {
idx.regtree = l->left;
idx.scale = l->right->vconst;
} else {
idx.regtree = l->right;
idx.scale = l->left->vconst;
}
t = ewidth[idx.regtree->type->etype];
if(t == SZ_LONG)
idx.scale += 4;
else
if(t != SZ_SHORT)
diag(n, "index not W or L");
idx.basetree = r;
if(debug['x']) {
print("scale = %d\n", idx.scale);
prtree(idx.regtree, "index");
prtree(idx.basetree, "base");
}
}
void
bcomplex(Node *n)
{
complex(n);
if(n->type != T)
if(tcompat(n, T, n->type, tnot))
n->type = T;
if(n->type != T) {
bool64(n);
doinc(n, PRE);
boolgen(n, 1, D_NONE, Z, n);
} else
gbranch(OGOTO);
}
Node*
nodconst(long v)
{
return (Node*)v;
}