Reaching *reaching(Cfg *cfg)
{
Bitset **in, **out;
Bitset **gen, **kill;
Bitset *bbin, *bbout;
Reaching *reaching;
size_t **defs; /* mapping from did => [def,list] */
size_t *ndefs;
size_t i, j;
int changed;
in = zalloc(cfg->nbb * sizeof(Bb*));
out = zalloc(cfg->nbb * sizeof(Bb*));
gen = zalloc(cfg->nbb * sizeof(Bb*));
kill = zalloc(cfg->nbb * sizeof(Bb*));
defs = zalloc(ndecls * sizeof(size_t*));
ndefs = zalloc(ndecls * sizeof(size_t));
collectdefs(cfg, defs, ndefs);
for (i = 0; i < cfg->nbb; i++) {
in[i] = mkbs();
out[i] = mkbs();
gen[i] = mkbs();
kill[i] = mkbs();
if (cfg->bb[i])
genkill(cfg->bb[i], defs, ndefs, gen[i], kill[i]);
}
do {
changed = 0;
for (i = 0; i < cfg->nbb; i++) {
if (!cfg->bb[i])
continue;
bbin = mkbs();
for (j = 0; bsiter(cfg->bb[i]->pred, &j); j++)
bsunion(bbin, out[j]);
bbout = bsdup(bbin);
bsdiff(bbout, kill[i]);
bsunion(bbout, gen[i]);
if (!bseq(out[i], bbout) || !bseq(in[i], bbin)) {
changed = 1;
bsfree(in[i]);
bsfree(out[i]);
in[i] = bbin;
out[i] = bbout;
}
}
} while (changed);
reaching = xalloc(sizeof(Reaching));
reaching->in = in;
reaching->out = out;
reaching->defs = defs;
reaching->ndefs = ndefs;
return reaching;
}
static void
doif(ASTNode *n, int ctxt)
{
BitSet *g, *k, *kp;
BitSet *g1, *k1, *k1p;
BitSet *g2, *k2, *k2p, *t;
PipeStage *p;
p = stcur;
t = bsnew(p->nvars);
findstages(n->n1, ctxt);
g = p->gen;
k = p->kill;
kp = p->killp;
p->gen = g1 = bsdup(g);
p->kill = k1 = bsdup(k);
p->killp = k1p = bsdup(kp);
findstages(n->n2, ctxt);
p->gen = g2 = bsdup(g);
p->kill = k2 = bsdup(k);
p->killp = k2p = bsdup(kp);
findstages(n->n3, ctxt);
bsunion(g, g1, g);
bsunion(g, g2, g);
bsunion(k, k1, k);
bsunion(k, k2, k);
bsunion(kp, k1p, kp);
bsunion(kp, k2p, kp);
bsminus(t, k1, k2);
addeq(t, &n->n3, 0);
bsunion(g, t, g);
bsminus(t, k2, k1);
addeq(t, &n->n2, 0);
bsunion(g, t, g);
bsminus(t, k1p, k2p);
addeq(t, &n->n3, 1);
bsunion(g, t, g);
bsminus(t, k2p, k1p);
addeq(t, &n->n2, 1);
bsunion(g, t, g);
p->gen = g;
p->kill = k;
p->killp = kp;
bsfree(g1);
bsfree(g2);
bsfree(k1);
bsfree(k2);
bsfree(k1p);
bsfree(k2p);
bsfree(t);
}
static void
propsets(void)
{
PipeStage *s;
for(s = stlist.next; s != &stlist; s = s->next)
s->live = bsnew(s->nvars);
for(s = stlist.prev; s != &stlist; s = s->prev){
bsunion(s->kill, s->kill, s->killp);
if(s->next != &stlist)
bsminus(s->live, s->next->live, s->kill);
bsunion(s->live, s->live, s->gen);
}
}
/* liveness analysis
* requires rpo computation
*/
void
filllive(Fn *f)
{
Blk *b;
Ins *i;
int k, t, m[2], n, chg, nlv[2];
BSet u[1], v[1];
Mem *ma;
bsinit(u, f->ntmp);
bsinit(v, f->ntmp);
for (b=f->start; b; b=b->link) {
bsinit(b->in, f->ntmp);
bsinit(b->out, f->ntmp);
bsinit(b->gen, f->ntmp);
}
chg = 1;
Again:
for (n=f->nblk-1; n>=0; n--) {
b = f->rpo[n];
bscopy(u, b->out);
if (b->s1) {
liveon(v, b, b->s1);
bsunion(b->out, v);
}
if (b->s2) {
liveon(v, b, b->s2);
bsunion(b->out, v);
}
chg |= !bsequal(b->out, u);
memset(nlv, 0, sizeof nlv);
b->out->t[0] |= T.rglob;
bscopy(b->in, b->out);
for (t=0; bsiter(b->in, &t); t++)
nlv[KBASE(f->tmp[t].cls)]++;
if (rtype(b->jmp.arg) == RCall) {
assert((int)bscount(b->in) == T.nrglob &&
nlv[0] == T.nrglob &&
nlv[1] == 0);
b->in->t[0] |= T.retregs(b->jmp.arg, nlv);
} else
bset(b->jmp.arg, b, nlv, f->tmp);
for (k=0; k<2; k++)
b->nlive[k] = nlv[k];
for (i=&b->ins[b->nins]; i!=b->ins;) {
if ((--i)->op == Ocall && rtype(i->arg[1]) == RCall) {
b->in->t[0] &= ~T.retregs(i->arg[1], m);
for (k=0; k<2; k++) {
nlv[k] -= m[k];
/* caller-save registers are used
* by the callee, in that sense,
* right in the middle of the call,
* they are live: */
nlv[k] += T.nrsave[k];
if (nlv[k] > b->nlive[k])
b->nlive[k] = nlv[k];
}
b->in->t[0] |= T.argregs(i->arg[1], m);
for (k=0; k<2; k++) {
nlv[k] -= T.nrsave[k];
nlv[k] += m[k];
}
}
if (!req(i->to, R)) {
assert(rtype(i->to) == RTmp);
t = i->to.val;
if (bshas(b->in, i->to.val))
nlv[KBASE(f->tmp[t].cls)]--;
bsset(b->gen, t);
bsclr(b->in, t);
}
for (k=0; k<2; k++)
switch (rtype(i->arg[k])) {
case RMem:
ma = &f->mem[i->arg[k].val];
bset(ma->base, b, nlv, f->tmp);
bset(ma->index, b, nlv, f->tmp);
break;
default:
bset(i->arg[k], b, nlv, f->tmp);
break;
}
for (k=0; k<2; k++)
if (nlv[k] > b->nlive[k])
b->nlive[k] = nlv[k];
}
}
if (chg) {
chg = 0;
goto Again;
}
if (debug['L']) {
fprintf(stderr, "\n> Liveness analysis:\n");
for (b=f->start; b; b=b->link) {
fprintf(stderr, "\t%-10sin: ", b->name);
dumpts(b->in, f->tmp, stderr);
fprintf(stderr, "\t out: ");
dumpts(b->out, f->tmp, stderr);
fprintf(stderr, "\t gen: ");
dumpts(b->gen, f->tmp, stderr);
fprintf(stderr, "\t live: ");
fprintf(stderr, "%d %d\n", b->nlive[0], b->nlive[1]);
}
}
}
