568 lines
8.8 KiB
C
568 lines
8.8 KiB
C
#include "all.h"
|
|
|
|
Blk *
|
|
newblk()
|
|
{
|
|
static Blk z;
|
|
Blk *b;
|
|
|
|
b = alloc(sizeof *b);
|
|
*b = z;
|
|
b->ins = vnew(0, sizeof b->ins[0], PFn);
|
|
b->pred = vnew(0, sizeof b->pred[0], PFn);
|
|
return b;
|
|
}
|
|
|
|
static void
|
|
fixphis(Fn *f)
|
|
{
|
|
Blk *b, *bp;
|
|
Phi *p;
|
|
uint n, n0;
|
|
|
|
for (b=f->start; b; b=b->link) {
|
|
assert(b->id < f->nblk);
|
|
for (p=b->phi; p; p=p->link) {
|
|
for (n=n0=0; n<p->narg; n++) {
|
|
bp = p->blk[n];
|
|
if (bp->id != -1u)
|
|
if (bp->s1 == b || bp->s2 == b) {
|
|
p->blk[n0] = bp;
|
|
p->arg[n0] = p->arg[n];
|
|
n0++;
|
|
}
|
|
}
|
|
assert(n0 > 0);
|
|
p->narg = n0;
|
|
}
|
|
}
|
|
}
|
|
|
|
static void
|
|
addpred(Blk *bp, Blk *b)
|
|
{
|
|
vgrow(&b->pred, ++b->npred);
|
|
b->pred[b->npred-1] = bp;
|
|
}
|
|
|
|
void
|
|
fillpreds(Fn *f)
|
|
{
|
|
Blk *b;
|
|
|
|
for (b=f->start; b; b=b->link)
|
|
b->npred = 0;
|
|
for (b=f->start; b; b=b->link) {
|
|
if (b->s1)
|
|
addpred(b, b->s1);
|
|
if (b->s2 && b->s2 != b->s1)
|
|
addpred(b, b->s2);
|
|
}
|
|
}
|
|
|
|
static void
|
|
porec(Blk *b, uint *npo)
|
|
{
|
|
Blk *s1, *s2;
|
|
|
|
if (!b || b->id != -1u)
|
|
return;
|
|
b->id = 0; /* marker */
|
|
s1 = b->s1;
|
|
s2 = b->s2;
|
|
if (s1 && s2 && s1->loop > s2->loop) {
|
|
s1 = b->s2;
|
|
s2 = b->s1;
|
|
}
|
|
porec(s1, npo);
|
|
porec(s2, npo);
|
|
b->id = (*npo)++;
|
|
}
|
|
|
|
static void
|
|
fillrpo(Fn *f)
|
|
{
|
|
Blk *b, **p;
|
|
|
|
for (b=f->start; b; b=b->link)
|
|
b->id = -1u;
|
|
f->nblk = 0;
|
|
porec(f->start, &f->nblk);
|
|
vgrow(&f->rpo, f->nblk);
|
|
for (p=&f->start; (b=*p);) {
|
|
if (b->id == -1u) {
|
|
*p = b->link;
|
|
} else {
|
|
b->id = f->nblk-b->id-1;
|
|
f->rpo[b->id] = b;
|
|
p = &b->link;
|
|
}
|
|
}
|
|
}
|
|
|
|
/* fill rpo, preds; prune dead blks */
|
|
void
|
|
fillcfg(Fn *f)
|
|
{
|
|
fillrpo(f);
|
|
fillpreds(f);
|
|
fixphis(f);
|
|
}
|
|
|
|
/* for dominators computation, read
|
|
* "A Simple, Fast Dominance Algorithm"
|
|
* by K. Cooper, T. Harvey, and K. Kennedy.
|
|
*/
|
|
|
|
static Blk *
|
|
inter(Blk *b1, Blk *b2)
|
|
{
|
|
Blk *bt;
|
|
|
|
if (b1 == 0)
|
|
return b2;
|
|
while (b1 != b2) {
|
|
if (b1->id < b2->id) {
|
|
bt = b1;
|
|
b1 = b2;
|
|
b2 = bt;
|
|
}
|
|
while (b1->id > b2->id) {
|
|
b1 = b1->idom;
|
|
assert(b1);
|
|
}
|
|
}
|
|
return b1;
|
|
}
|
|
|
|
void
|
|
filldom(Fn *fn)
|
|
{
|
|
Blk *b, *d;
|
|
int ch;
|
|
uint n, p;
|
|
|
|
for (b=fn->start; b; b=b->link) {
|
|
b->idom = 0;
|
|
b->dom = 0;
|
|
b->dlink = 0;
|
|
}
|
|
do {
|
|
ch = 0;
|
|
for (n=1; n<fn->nblk; n++) {
|
|
b = fn->rpo[n];
|
|
d = 0;
|
|
for (p=0; p<b->npred; p++)
|
|
if (b->pred[p]->idom
|
|
|| b->pred[p] == fn->start)
|
|
d = inter(d, b->pred[p]);
|
|
if (d != b->idom) {
|
|
ch++;
|
|
b->idom = d;
|
|
}
|
|
}
|
|
} while (ch);
|
|
for (b=fn->start; b; b=b->link)
|
|
if ((d=b->idom)) {
|
|
assert(d != b);
|
|
b->dlink = d->dom;
|
|
d->dom = b;
|
|
}
|
|
}
|
|
|
|
int
|
|
sdom(Blk *b1, Blk *b2)
|
|
{
|
|
assert(b1 && b2);
|
|
if (b1 == b2)
|
|
return 0;
|
|
while (b2->id > b1->id)
|
|
b2 = b2->idom;
|
|
return b1 == b2;
|
|
}
|
|
|
|
int
|
|
dom(Blk *b1, Blk *b2)
|
|
{
|
|
return b1 == b2 || sdom(b1, b2);
|
|
}
|
|
|
|
static void
|
|
addfron(Blk *a, Blk *b)
|
|
{
|
|
uint n;
|
|
|
|
for (n=0; n<a->nfron; n++)
|
|
if (a->fron[n] == b)
|
|
return;
|
|
if (!a->nfron)
|
|
a->fron = vnew(++a->nfron, sizeof a->fron[0], PFn);
|
|
else
|
|
vgrow(&a->fron, ++a->nfron);
|
|
a->fron[a->nfron-1] = b;
|
|
}
|
|
|
|
/* fill the dominance frontier */
|
|
void
|
|
fillfron(Fn *fn)
|
|
{
|
|
Blk *a, *b;
|
|
|
|
for (b=fn->start; b; b=b->link)
|
|
b->nfron = 0;
|
|
for (b=fn->start; b; b=b->link) {
|
|
if (b->s1)
|
|
for (a=b; !sdom(a, b->s1); a=a->idom)
|
|
addfron(a, b->s1);
|
|
if (b->s2)
|
|
for (a=b; !sdom(a, b->s2); a=a->idom)
|
|
addfron(a, b->s2);
|
|
}
|
|
}
|
|
|
|
static void
|
|
loopmark(Blk *hd, Blk *b, void f(Blk *, Blk *))
|
|
{
|
|
uint p;
|
|
|
|
if (b->id < hd->id || b->visit == hd->id)
|
|
return;
|
|
b->visit = hd->id;
|
|
f(hd, b);
|
|
for (p=0; p<b->npred; ++p)
|
|
loopmark(hd, b->pred[p], f);
|
|
}
|
|
|
|
void
|
|
loopiter(Fn *fn, void f(Blk *, Blk *))
|
|
{
|
|
uint n, p;
|
|
Blk *b;
|
|
|
|
for (b=fn->start; b; b=b->link)
|
|
b->visit = -1u;
|
|
for (n=0; n<fn->nblk; ++n) {
|
|
b = fn->rpo[n];
|
|
for (p=0; p<b->npred; ++p)
|
|
if (b->pred[p]->id >= n)
|
|
loopmark(b, b->pred[p], f);
|
|
}
|
|
}
|
|
|
|
/* dominator tree depth */
|
|
void
|
|
filldepth(Fn *fn)
|
|
{
|
|
Blk *b, *d;
|
|
int depth;
|
|
|
|
for (b=fn->start; b; b=b->link)
|
|
b->depth = -1;
|
|
|
|
fn->start->depth = 0;
|
|
|
|
for (b=fn->start; b; b=b->link) {
|
|
if (b->depth != -1)
|
|
continue;
|
|
depth = 1;
|
|
for (d=b->idom; d->depth==-1; d=d->idom)
|
|
depth++;
|
|
depth += d->depth;
|
|
b->depth = depth;
|
|
for (d=b->idom; d->depth==-1; d=d->idom)
|
|
d->depth = --depth;
|
|
}
|
|
}
|
|
|
|
/* least common ancestor in dom tree */
|
|
Blk *
|
|
lca(Blk *b1, Blk *b2)
|
|
{
|
|
if (!b1)
|
|
return b2;
|
|
if (!b2)
|
|
return b1;
|
|
while (b1->depth > b2->depth)
|
|
b1 = b1->idom;
|
|
while (b2->depth > b1->depth)
|
|
b2 = b2->idom;
|
|
while (b1 != b2) {
|
|
b1 = b1->idom;
|
|
b2 = b2->idom;
|
|
}
|
|
return b1;
|
|
}
|
|
|
|
void
|
|
multloop(Blk *hd, Blk *b)
|
|
{
|
|
(void)hd;
|
|
b->loop *= 10;
|
|
}
|
|
|
|
void
|
|
fillloop(Fn *fn)
|
|
{
|
|
Blk *b;
|
|
|
|
for (b=fn->start; b; b=b->link)
|
|
b->loop = 1;
|
|
loopiter(fn, multloop);
|
|
}
|
|
|
|
static void
|
|
uffind(Blk **pb, Blk **uf)
|
|
{
|
|
Blk **pb1;
|
|
|
|
pb1 = &uf[(*pb)->id];
|
|
if (*pb1) {
|
|
uffind(pb1, uf);
|
|
*pb = *pb1;
|
|
}
|
|
}
|
|
|
|
/* requires rpo and no phis, breaks cfg */
|
|
void
|
|
simpljmp(Fn *fn)
|
|
{
|
|
|
|
Blk **uf; /* union-find */
|
|
Blk **p, *b, *ret;
|
|
|
|
ret = newblk();
|
|
ret->id = fn->nblk++;
|
|
ret->jmp.type = Jret0;
|
|
uf = emalloc(fn->nblk * sizeof uf[0]);
|
|
for (b=fn->start; b; b=b->link) {
|
|
assert(!b->phi);
|
|
if (b->jmp.type == Jret0) {
|
|
b->jmp.type = Jjmp;
|
|
b->s1 = ret;
|
|
}
|
|
if (b->nins == 0)
|
|
if (b->jmp.type == Jjmp) {
|
|
uffind(&b->s1, uf);
|
|
if (b->s1 != b)
|
|
uf[b->id] = b->s1;
|
|
}
|
|
}
|
|
for (p=&fn->start; (b=*p); p=&b->link) {
|
|
if (b->s1)
|
|
uffind(&b->s1, uf);
|
|
if (b->s2)
|
|
uffind(&b->s2, uf);
|
|
if (b->s1 && b->s1 == b->s2) {
|
|
b->jmp.type = Jjmp;
|
|
b->s2 = 0;
|
|
}
|
|
}
|
|
*p = ret;
|
|
free(uf);
|
|
}
|
|
|
|
static int
|
|
reachrec(Blk *b, Blk *to)
|
|
{
|
|
if (b == to)
|
|
return 1;
|
|
if (!b || b->visit)
|
|
return 0;
|
|
|
|
b->visit = 1;
|
|
if (reachrec(b->s1, to))
|
|
return 1;
|
|
if (reachrec(b->s2, to))
|
|
return 1;
|
|
|
|
return 0;
|
|
}
|
|
|
|
/* Blk.visit needs to be clear at entry */
|
|
int
|
|
reaches(Fn *fn, Blk *b, Blk *to)
|
|
{
|
|
int r;
|
|
|
|
assert(to);
|
|
r = reachrec(b, to);
|
|
for (b=fn->start; b; b=b->link)
|
|
b->visit = 0;
|
|
return r;
|
|
}
|
|
|
|
/* can b reach 'to' not through excl
|
|
* Blk.visit needs to be clear at entry */
|
|
int
|
|
reachesnotvia(Fn *fn, Blk *b, Blk *to, Blk *excl)
|
|
{
|
|
excl->visit = 1;
|
|
return reaches(fn, b, to);
|
|
}
|
|
|
|
int
|
|
ifgraph(Blk *ifb, Blk **pthenb, Blk **pelseb, Blk **pjoinb)
|
|
{
|
|
Blk *s1, *s2, **t;
|
|
|
|
if (ifb->jmp.type != Jjnz)
|
|
return 0;
|
|
|
|
s1 = ifb->s1;
|
|
s2 = ifb->s2;
|
|
if (s1->id > s2->id) {
|
|
s1 = ifb->s2;
|
|
s2 = ifb->s1;
|
|
t = pthenb;
|
|
pthenb = pelseb;
|
|
pelseb = t;
|
|
}
|
|
if (s1 == s2)
|
|
return 0;
|
|
|
|
if (s1->jmp.type != Jjmp || s1->npred != 1)
|
|
return 0;
|
|
|
|
if (s1->s1 == s2) {
|
|
/* if-then / if-else */
|
|
if (s2->npred != 2)
|
|
return 0;
|
|
*pthenb = s1;
|
|
*pelseb = ifb;
|
|
*pjoinb = s2;
|
|
return 1;
|
|
}
|
|
|
|
if (s2->jmp.type != Jjmp || s2->npred != 1)
|
|
return 0;
|
|
if (s1->s1 != s2->s1 || s1->s1->npred != 2)
|
|
return 0;
|
|
|
|
assert(s1->s1 != ifb);
|
|
*pthenb = s1;
|
|
*pelseb = s2;
|
|
*pjoinb = s1->s1;
|
|
return 1;
|
|
}
|
|
|
|
typedef struct Jmp Jmp;
|
|
|
|
struct Jmp {
|
|
int type;
|
|
Ref arg;
|
|
Blk *s1, *s2;
|
|
};
|
|
|
|
static int
|
|
jmpeq(Jmp *a, Jmp *b)
|
|
{
|
|
return a->type == b->type && req(a->arg, b->arg)
|
|
&& a->s1 == b->s1 && a->s2 == b->s2;
|
|
}
|
|
|
|
static int
|
|
jmpnophi(Jmp *j)
|
|
{
|
|
if (j->s1 && j->s1->phi)
|
|
return 0;
|
|
if (j->s2 && j->s2->phi)
|
|
return 0;
|
|
return 1;
|
|
}
|
|
|
|
/* require cfg rpo, breaks use */
|
|
void
|
|
simplcfg(Fn *fn)
|
|
{
|
|
Ins cpy, *i;
|
|
Blk *b, *bb, **pb;
|
|
Jmp *jmp, *j, *jj;
|
|
Phi *p;
|
|
int *empty, done;
|
|
uint n;
|
|
|
|
if (debug['C']) {
|
|
fprintf(stderr, "\n> Before CFG simplification:\n");
|
|
printfn(fn, stderr);
|
|
}
|
|
|
|
cpy = (Ins){.op = Ocopy};
|
|
for (b=fn->start; b; b=b->link)
|
|
if (b->npred == 1) {
|
|
bb = b->pred[0];
|
|
for (p=b->phi; p; p=p->link) {
|
|
cpy.cls = p->cls;
|
|
cpy.to = p->to;
|
|
cpy.arg[0] = phiarg(p, bb);
|
|
addins(&bb->ins, &bb->nins, &cpy);
|
|
}
|
|
b->phi = 0;
|
|
}
|
|
|
|
jmp = emalloc(fn->nblk * sizeof jmp[0]);
|
|
empty = emalloc(fn->nblk * sizeof empty[0]);
|
|
for (b=fn->start; b; b=b->link) {
|
|
jmp[b->id].type = b->jmp.type;
|
|
jmp[b->id].arg = b->jmp.arg;
|
|
jmp[b->id].s1 = b->s1;
|
|
jmp[b->id].s2 = b->s2;
|
|
empty[b->id] = !b->phi;
|
|
for (i=b->ins; i<&b->ins[b->nins]; i++)
|
|
if (i->op != Onop && i->op != Odbgloc) {
|
|
empty[b->id] = 0;
|
|
break;
|
|
}
|
|
}
|
|
|
|
do {
|
|
done = 1;
|
|
for (b=fn->start; b; b=b->link) {
|
|
if (b->id == -1u)
|
|
continue;
|
|
j = &jmp[b->id];
|
|
if (j->type == Jjmp && j->s1->npred == 1) {
|
|
assert(!j->s1->phi);
|
|
addbins(&b->ins, &b->nins, j->s1);
|
|
empty[b->id] &= empty[j->s1->id];
|
|
jj = &jmp[j->s1->id];
|
|
pb = (Blk*[]){jj->s1, jj->s2, 0};
|
|
for (; (bb=*pb); pb++)
|
|
for (p=bb->phi; p; p=p->link) {
|
|
n = phiargn(p, j->s1);
|
|
p->blk[n] = b;
|
|
}
|
|
j->s1->id = -1u;
|
|
*j = *jj;
|
|
done = 0;
|
|
}
|
|
else if (j->type == Jjnz
|
|
&& empty[j->s1->id] && empty[j->s2->id]
|
|
&& jmpeq(&jmp[j->s1->id], &jmp[j->s2->id])
|
|
&& jmpnophi(&jmp[j->s1->id])) {
|
|
*j = jmp[j->s1->id];
|
|
done = 0;
|
|
}
|
|
}
|
|
} while (!done);
|
|
|
|
for (b=fn->start; b; b=b->link)
|
|
if (b->id != -1u) {
|
|
j = &jmp[b->id];
|
|
b->jmp.type = j->type;
|
|
b->jmp.arg = j->arg;
|
|
b->s1 = j->s1;
|
|
b->s2 = j->s2;
|
|
assert(!j->s1 || j->s1->id != -1u);
|
|
assert(!j->s2 || j->s2->id != -1u);
|
|
}
|
|
|
|
fillcfg(fn);
|
|
free(empty);
|
|
free(jmp);
|
|
|
|
if (debug['C']) {
|
|
fprintf(stderr, "\n> After CFG simplification:\n");
|
|
printfn(fn, stderr);
|
|
}
|
|
}
|