ref: 7d3cc1c55a435bd9e3d37d9bf8a9299ea9e1f87e
dir: /sys/src/cmd/2c/reg.c/
#include "gc.h"
Reg*
rega(void)
{
Reg *r;
r = freer;
if(r == R) {
r = alloc(sizeof(*r));
} else
freer = r->link;
*r = zreg;
return r;
}
int
rcmp(const void *a1, const void *a2)
{
Rgn *p1, *p2;
int c1, c2;
p1 = (Rgn*)a1;
p2 = (Rgn*)a2;
c1 = p2->costr;
if(p2->costa > c1)
c1 = p2->costa;
c2 = p1->costr;
if(p1->costa > c2)
c2 = p1->costa;
if(c1 -= c2)
return c1;
return p2->varno - p1->varno;
}
void
regopt(Prog *p)
{
Reg *r, *r1, *r2;
Prog *p1;
int i, z;
long val, initpc, npc;
ulong vreg;
Bits bit;
Var *v;
struct {
long m;
long c;
Reg* p;
} log5[6], *lp;
firstr = R;
lastr = R;
nvar = 0;
for(z=0; z<BITS; z++) {
externs.b[z] = 0;
params.b[z] = 0;
addrs.b[z] = 0;
}
regbits = RtoB(0) | /* return reg */
AtoB(6) | AtoB(7) | /* sp and sb */
FtoB(0) | FtoB(1); /* floating return reg */
for(i=0; i<NREG; i++) {
if(regused[i])
regbits |= RtoB(i);
if(fregused[i])
regbits |= FtoB(i);
if(aregused[i])
regbits |= AtoB(i);
}
/*
* pass 1
* build aux data structure
* allocate pcs
* find use and set of variables
*/
val = 5L * 5L * 5L * 5L * 5L;
lp = log5;
for(i=0; i<5; i++) {
lp->m = val;
lp->c = 0;
lp->p = R;
val /= 5L;
lp++;
}
val = 0;
for(; p != P; p = p->link) {
switch(p->as) {
case ADATA:
case AGLOBL:
case ANAME:
case ASIGNAME:
continue;
}
r = rega();
if(firstr == R) {
firstr = r;
lastr = r;
} else {
lastr->link = r;
r->p1 = lastr;
lastr->s1 = r;
lastr = r;
}
r->prog = p;
r->pc = val;
val++;
lp = log5;
for(i=0; i<5; i++) {
lp->c--;
if(lp->c <= 0) {
lp->c = lp->m;
if(lp->p != R)
lp->p->log5 = r;
lp->p = r;
(lp+1)->c = 0;
break;
}
lp++;
}
r1 = r->p1;
if(r1 != R)
switch(r1->prog->as) {
case ABRA:
case ARTS:
case ARTE:
r->p1 = R;
r1->s1 = R;
}
bit = mkvar(&p->from, AGOK);
if(bany(&bit))
switch(p->as) {
case ALEA:
if(!(mvbits & B_INDIR))
for(z=0; z<BITS; z++)
addrs.b[z] |= bit.b[z];
default:
if(mvbits & B_ADDR)
for(z=0; z<BITS; z++)
addrs.b[z] |= bit.b[z];
for(z=0; z<BITS; z++)
r->use1.b[z] |= bit.b[z];
}
bit = mkvar(&p->to, p->as);
if(bany(&bit))
switch(p->as) {
case ABSR: /* funny */
for(z=0; z<BITS; z++)
addrs.b[z] |= bit.b[z];
goto def;
case APEA:
if(!(mvbits & B_INDIR))
for(z=0; z<BITS; z++)
addrs.b[z] |= bit.b[z];
def:
case ACMPB: case ACMPW: case ACMPL:
case AFCMPF: case AFCMPD:
case ATSTB: case ATSTW: case ATSTL:
case AFTSTF: case AFTSTD:
case ABFEXTU: case ABFEXTS:
if(mvbits & B_ADDR)
for(z=0; z<BITS; z++)
addrs.b[z] |= bit.b[z];
for(z=0; z<BITS; z++)
r->use2.b[z] |= bit.b[z];
break;
default:
diag(Z, "reg: unknown asop: %A", p->as);
case AADDB: case AADDW: case AADDL:
case ASUBB: case ASUBW: case ASUBL:
case AANDB: case AANDW: case AANDL:
case AORB: case AORW: case AORL:
case AEORB: case AEORW: case AEORL:
case ABFINS:
for(z=0; z<BITS; z++)
r->use2.b[z] |= bit.b[z];
case ANOP:
case AMOVB: case AMOVW: case AMOVL:
case AFMOVEB: case AFMOVEW: case AFMOVEL:
case ACLRB: case ACLRW: case ACLRL:
case AFMOVEF: case AFMOVED:
if(mvbits & B_INDIR)
for(z=0; z<BITS; z++)
r->use2.b[z] |= bit.b[z];
else
for(z=0; z<BITS; z++)
r->set.b[z] |= bit.b[z];
break;
}
}
if(firstr == R)
return;
initpc = pc - val;
npc = val;
/*
* pass 2
* turn branch references to pointers
* build back pointers
*/
for(r = firstr; r != R; r = r->link) {
p = r->prog;
if(p->to.type == D_BRANCH) {
val = p->to.offset - initpc;
r1 = firstr;
while(r1 != R) {
r2 = r1->log5;
if(r2 != R && val >= r2->pc) {
r1 = r2;
continue;
}
if(r1->pc == val)
break;
r1 = r1->link;
}
if(r1 == R) {
diag(Z, "ref not found\n%L:%P", p->lineno, p);
continue;
}
if(r1 == r) {
diag(Z, "ref to self");
continue;
}
r->s2 = r1;
r->p2link = r1->p2;
r1->p2 = r;
}
}
if(debug['R'])
print("\n%L %D\n", firstr->prog->lineno, &firstr->prog->from);
/*
* pass 2.5
* find looping structure
*/
for(r = firstr; r != R; r = r->link)
r->active = 0;
changer = 0;
loopit(firstr, npc);
if(debug['R'] && debug['v']) {
print("\nlooping structure:\n");
for(r = firstr; r != R; r = r->link) {
print("%ld:%P", r->loop, r->prog);
for(z=0; z<BITS; z++)
bit.b[z] = r->use1.b[z] |
r->use2.b[z] | r->set.b[z];
if(bany(&bit)) {
print("\t");
if(bany(&r->use1))
print(" u1=%B", r->use1);
if(bany(&r->use2))
print(" u2=%B", r->use2);
if(bany(&r->set))
print(" st=%B", r->set);
}
print("\n");
}
}
/*
* pass 3
* iterate propagating usage
* back until flow graph is complete
*/
loop1:
changer = 0;
for(r = firstr; r != R; r = r->link)
r->active = 0;
for(r = firstr; r != R; r = r->link)
if(r->prog->as == ARTS)
prop(r, zbits, zbits);
loop11:
/* pick up unreachable code */
i = 0;
for(r = firstr; r != R; r = r1) {
r1 = r->link;
if(r1 && r1->active && !r->active) {
prop(r, zbits, zbits);
i = 1;
}
}
if(i)
goto loop11;
if(changer)
goto loop1;
/*
* pass 4
* iterate propagating register/variable synchrony
* forward until graph is complete
*/
loop2:
changer = 0;
for(r = firstr; r != R; r = r->link)
r->active = 0;
synch(firstr, zbits);
if(changer)
goto loop2;
/*
* pass 5
* isolate regions
* calculate costs (paint1)
*/
r = firstr;
if(r) {
for(z=0; z<BITS; z++)
bit.b[z] = (r->refahead.b[z] | r->calahead.b[z]) &
~(externs.b[z] | params.b[z] | addrs.b[z]);
if(bany(&bit)) {
nearln = r->prog->lineno;
warn(Z, "used and not set: %B", bit);
if(debug['R'] && !debug['w'])
print("used and not set: %B\n", bit);
/*
* 68040 'feature':
* load of a denormalized fp will trap
*/
while(bany(&bit)) {
i = bnum(bit);
bit.b[i/32] &= ~(1L << (i%32));
v = var + i;
if(v->type == D_AUTO) {
r->set.b[i/32] |= (1L << (i%32));
if(typefd[v->etype])
addmove(r, i, NREG+NREG, 1);
}
}
}
}
if(debug['R'] && debug['v'])
print("\nprop structure:\n");
for(r = firstr; r != R; r = r->link) {
if(debug['R'] && debug['v'])
print("%P\n set = %B; rah = %B; cal = %B\n",
r->prog, r->set, r->refahead, r->calahead);
r->act = zbits;
}
rgp = region;
nregion = 0;
for(r = firstr; r != R; r = r->link) {
for(z=0; z<BITS; z++)
bit.b[z] = r->set.b[z] &
~(r->refahead.b[z] | r->calahead.b[z] | addrs.b[z]);
if(bany(&bit)) {
nearln = r->prog->lineno;
warn(Z, "set and not used: %B", bit);
if(debug['R'])
print("set an not used: %B\n", bit);
excise(r);
}
for(z=0; z<BITS; z++)
bit.b[z] = LOAD(r) & ~(r->act.b[z] | addrs.b[z]);
while(bany(&bit)) {
i = bnum(bit);
rgp->enter = r;
rgp->varno = i;
changer = 0;
changea = 0;
if(debug['R'] && debug['v'])
print("\n");
paint1(r, i);
bit.b[i/32] &= ~(1L<<(i%32));
if(changer <= 0 && changea <= 0) {
if(debug['R'])
print("%L$%d.%d: %B\n",
r->prog->lineno,
changer, changea, blsh(i));
continue;
}
rgp->costr = changer;
rgp->costa = changea;
nregion++;
if(nregion >= NRGN) {
warn(Z, "too many regions");
goto brk;
}
rgp++;
}
}
brk:
qsort(region, nregion, sizeof(region[0]), rcmp);
/*
* pass 6
* determine used registers (paint2)
* replace code (paint3)
*/
rgp = region;
for(i=0; i<nregion; i++) {
bit = blsh(rgp->varno);
vreg = paint2(rgp->enter, rgp->varno);
vreg = allreg(vreg, rgp);
if(debug['R'])
print("%L$%d.%d %R: %B\n",
rgp->enter->prog->lineno,
rgp->costr, rgp->costa,
rgp->regno,
bit);
if(rgp->regno != D_NONE)
paint3(rgp->enter, rgp->varno, vreg, rgp->regno);
rgp++;
}
/*
* pass 7
* peep-hole on basic block
*/
if(!debug['R'] || debug['P'])
peep();
/*
* pass 8
* recalculate pc
*/
val = initpc;
for(r = firstr; r != R; r = r1) {
r->pc = val;
p = r->prog;
p1 = P;
r1 = r->link;
if(r1 != R)
p1 = r1->prog;
for(; p != p1; p = p->link) {
switch(p->as) {
default:
val++;
break;
case ANOP:
case ADATA:
case AGLOBL:
case ANAME:
case ASIGNAME:
break;
}
}
}
pc = val;
/*
* fix up branches
*/
if(debug['R'])
if(bany(&addrs))
print("addrs: %B\n", addrs);
r1 = 0; /* set */
for(r = firstr; r != R; r = r->link) {
p = r->prog;
if(p->to.type == D_BRANCH)
p->to.offset = r->s2->pc;
r1 = r;
}
/*
* last pass
* eliminate nops
* free aux structures
*/
for(p = firstr->prog; p != P; p = p->link){
while(p->link && p->link->as == ANOP)
p->link = p->link->link;
}
if(r1 != R) {
r1->link = freer;
freer = firstr;
}
}
/*
* add mov b,rn
* just after r
*/
void
addmove(Reg *r, int bn, int rn, int f)
{
Prog *p, *p1;
Var *v;
int badccr;
badccr = 0;
p = r->prog;
p1 = p->link;
if(p1)
switch(p1->as) {
case AMOVW:
if(p1->from.type == D_CCR)
p = p1;
break;
case ABEQ:
case ABNE:
case ABLE:
case ABLS:
case ABLT:
case ABMI:
case ABGE:
case ABPL:
case ABGT:
case ABHI:
case ABCC:
case ABCS:
p1 = prg();
p1->link = p->link;
p->link = p1;
p1->lineno = p->lineno;
p1->from.type = D_CCR;
p1->to.type = D_TOS;
p1->as = AMOVW;
p = p1;
badccr = 1;
}
p1 = prg();
p1->link = p->link;
p->link = p1;
p1->lineno = p->lineno;
v = var + bn;
p1->from.sym = v->sym;
p1->from.type = v->type;
p1->from.offset = v->offset;
p1->from.etype = v->etype;
p1->to.type = rn;
if(f) {
p1->to = p1->from;
p1->from = zprog.from;
p1->from.type = rn;
}
p1->as = opxt[OAS][v->etype];
if(badccr) {
p = p1;
p1 = prg();
p1->link = p->link;
p->link = p1;
p1->lineno = p->lineno;
p1->from.type = D_TOS;
p1->to.type = D_CCR;
p1->as = AMOVW;
}
if(debug['R'])
print("%P\t.a%P\n", p, p1);
}
Bits
mkvar(Adr *a, int as)
{
Var *v;
int i, t, z;
long o;
Bits bit;
Sym *s;
mvbits = 0;
t = a->type & D_MASK;
switch(t) {
default:
if(t >= D_R0 && t < D_R0+NREG) {
regbits |= RtoB(t-D_R0);
if(as == ADIVUL || as == ADIVSL)
regbits |= RtoB(t-D_R0+1);
}
if(t >= D_A0 && t < D_A0+NREG)
regbits |= AtoB(t-D_A0);
if(t >= D_F0 && t < D_F0+NREG)
regbits |= FtoB(t-D_F0);
goto none;
case D_EXTERN:
case D_STATIC:
case D_AUTO:
case D_PARAM:
break;
}
s = a->sym;
if(s == S)
goto none;
if((a->type & I_MASK) == I_ADDR)
mvbits |= B_ADDR;
switch(a->index & I_MASK) {
case I_INDEX1:
mvbits |= B_ADDR;
break;
case I_INDEX2:
case I_INDEX3:
mvbits |= B_INDIR;
break;
}
o = a->offset;
v = var;
for(i=0; i<nvar; i++) {
if(s == v->sym)
if(t == v->type)
if(o == v->offset)
goto out;
v++;
}
if(s)
if(s->name[0] == '.')
goto none;
if(nvar >= NVAR) {
if(debug['w'] > 1 && s)
warn(Z, "variable not optimized: %s", s->name);
goto none;
}
i = nvar;
nvar++;
v = &var[i];
v->sym = s;
v->offset = o;
v->etype = a->etype;
v->type = t;
if(debug['R'])
print("bit=%2d et=%2d %s (%p,%d,%ld)\n",
i, a->etype, s->name,
v->sym, v->type, v->offset);
out:
bit = blsh(i);
if(t == D_EXTERN || t == D_STATIC)
for(z=0; z<BITS; z++)
externs.b[z] |= bit.b[z];
if(t == D_PARAM)
for(z=0; z<BITS; z++)
params.b[z] |= bit.b[z];
if(a->etype != v->etype || !typechlpfd[a->etype])
for(z=0; z<BITS; z++)
addrs.b[z] |= bit.b[z]; /* funny punning */
return bit;
none:
return zbits;
}
void
prop(Reg *r, Bits ref, Bits cal)
{
Reg *r1, *r2;
int z;
for(r1 = r; r1 != R; r1 = r1->p1) {
for(z=0; z<BITS; z++) {
ref.b[z] |= r1->refahead.b[z];
if(ref.b[z] != r1->refahead.b[z]) {
r1->refahead.b[z] = ref.b[z];
changer++;
}
cal.b[z] |= r1->calahead.b[z];
if(cal.b[z] != r1->calahead.b[z]) {
r1->calahead.b[z] = cal.b[z];
changer++;
}
}
switch(r1->prog->as) {
case ABSR:
for(z=0; z<BITS; z++) {
cal.b[z] |= ref.b[z] | externs.b[z];
ref.b[z] = 0;
}
break;
case ATEXT:
for(z=0; z<BITS; z++) {
cal.b[z] = 0;
ref.b[z] = 0;
}
break;
case ARTS:
for(z=0; z<BITS; z++) {
cal.b[z] = externs.b[z];
ref.b[z] = 0;
}
}
for(z=0; z<BITS; z++) {
ref.b[z] = (ref.b[z] & ~r1->set.b[z]) |
r1->use1.b[z] | r1->use2.b[z];
cal.b[z] &= ~(r1->set.b[z] | r1->use1.b[z] | r1->use2.b[z]);
r1->refbehind.b[z] = ref.b[z];
r1->calbehind.b[z] = cal.b[z];
}
if(r1->active)
break;
r1->active = 1;
}
for(; r != r1; r = r->p1)
for(r2 = r->p2; r2 != R; r2 = r2->p2link)
prop(r2, r->refbehind, r->calbehind);
}
/*
* find looping structure
*
* 1) find reverse postordering
* 2) find approximate dominators,
* the actual dominators if the flow graph is reducible
* otherwise, dominators plus some other non-dominators.
* See Matthew S. Hecht and Jeffrey D. Ullman,
* "Analysis of a Simple Algorithm for Global Data Flow Problems",
* Conf. Record of ACM Symp. on Principles of Prog. Langs, Boston, Massachusetts,
* Oct. 1-3, 1973, pp. 207-217.
* 3) find all nodes with a predecessor dominated by the current node.
* such a node is a loop head.
* recursively, all preds with a greater rpo number are in the loop
*/
long
postorder(Reg *r, Reg **rpo2r, long n)
{
Reg *r1;
r->rpo = 1;
r1 = r->s1;
if(r1 && !r1->rpo)
n = postorder(r1, rpo2r, n);
r1 = r->s2;
if(r1 && !r1->rpo)
n = postorder(r1, rpo2r, n);
rpo2r[n] = r;
n++;
return n;
}
long
rpolca(long *idom, long rpo1, long rpo2)
{
long t;
if(rpo1 == -1)
return rpo2;
while(rpo1 != rpo2){
if(rpo1 > rpo2){
t = rpo2;
rpo2 = rpo1;
rpo1 = t;
}
while(rpo1 < rpo2){
t = idom[rpo2];
if(t >= rpo2)
fatal(Z, "bad idom");
rpo2 = t;
}
}
return rpo1;
}
int
doms(long *idom, long r, long s)
{
while(s > r)
s = idom[s];
return s == r;
}
int
loophead(long *idom, Reg *r)
{
long src;
src = r->rpo;
if(r->p1 != R && doms(idom, src, r->p1->rpo))
return 1;
for(r = r->p2; r != R; r = r->p2link)
if(doms(idom, src, r->rpo))
return 1;
return 0;
}
void
loopmark(Reg **rpo2r, long head, Reg *r)
{
if(r->rpo < head || r->active == head)
return;
r->active = head;
r->loop += LOOP;
if(r->p1 != R)
loopmark(rpo2r, head, r->p1);
for(r = r->p2; r != R; r = r->p2link)
loopmark(rpo2r, head, r);
}
void
loopit(Reg *r, long nr)
{
Reg *r1;
long i, d, me;
if(nr > maxnr) {
rpo2r = alloc(nr * sizeof(Reg*));
idom = alloc(nr * sizeof(long));
maxnr = nr;
}
d = postorder(r, rpo2r, 0);
if(d > nr)
fatal(Z, "too many reg nodes");
nr = d;
for(i = 0; i < nr / 2; i++){
r1 = rpo2r[i];
rpo2r[i] = rpo2r[nr - 1 - i];
rpo2r[nr - 1 - i] = r1;
}
for(i = 0; i < nr; i++)
rpo2r[i]->rpo = i;
idom[0] = 0;
for(i = 0; i < nr; i++){
r1 = rpo2r[i];
me = r1->rpo;
d = -1;
if(r1->p1 != R && r1->p1->rpo < me)
d = r1->p1->rpo;
for(r1 = r1->p2; r1 != nil; r1 = r1->p2link)
if(r1->rpo < me)
d = rpolca(idom, d, r1->rpo);
idom[i] = d;
}
for(i = 0; i < nr; i++){
r1 = rpo2r[i];
r1->loop++;
if(r1->p2 != R && loophead(idom, r1))
loopmark(rpo2r, i, r1);
}
}
void
synch(Reg *r, Bits dif)
{
Reg *r1;
int z;
for(r1 = r; r1 != R; r1 = r1->s1) {
for(z=0; z<BITS; z++) {
dif.b[z] = (dif.b[z] &
~(~r1->refbehind.b[z] & r1->refahead.b[z])) |
r1->set.b[z] | r1->regdiff.b[z];
if(dif.b[z] != r1->regdiff.b[z]) {
r1->regdiff.b[z] = dif.b[z];
changer++;
}
}
if(r1->active)
break;
r1->active = 1;
for(z=0; z<BITS; z++)
dif.b[z] &= ~(~r1->calbehind.b[z] & r1->calahead.b[z]);
if(r1->s2 != R)
synch(r1->s2, dif);
}
}
ulong
allreg(ulong b, Rgn *r)
{
Var *v;
int i, j;
v = var + r->varno;
r->regno = D_NONE;
switch(v->etype) {
default:
diag(Z, "unknown etype");
break;
case TCHAR:
case TUCHAR:
case TSHORT:
case TUSHORT:
case TINT:
case TUINT:
case TLONG:
case TULONG:
case TIND:
i = BtoR(~b);
j = BtoA(~b);
if(r->costa == r->costr)
if(i > j)
i = NREG;
if(j < NREG && r->costa > 0)
if(r->costa > r->costr || i >= NREG) {
r->regno = D_A0 + j;
return AtoB(j);
}
if(i < NREG && r->costr > 0) {
r->regno = D_R0 + i;
return RtoB(i);
}
break;
case TDOUBLE:
case TFLOAT:
i = BtoF(~b);
if(i < NREG) {
r->regno = D_F0 + i;
return FtoB(i);
}
break;
}
return 0;
}
void
paint1(Reg *r, int bn)
{
Reg *r1;
Prog *p;
int z;
ulong bb;
int x;
z = bn/32;
bb = 1L<<(bn%32);
if(r->act.b[z] & bb)
return;
for(;;) {
if(!(r->refbehind.b[z] & bb))
break;
r1 = r->p1;
if(r1 == R)
break;
if(!(r1->refahead.b[z] & bb))
break;
if(r1->act.b[z] & bb)
break;
r = r1;
}
if(LOAD(r) & ~(r->set.b[z]&~(r->use1.b[z]|r->use2.b[z])) & bb) {
changer -= CLOAD * r->loop;
changea -= CLOAD * r->loop;
if(debug['R'] && debug['v'])
print("%ld%P\tld %B $%d.%d\n", r->loop,
r->prog, blsh(bn), changer, changea);
}
for(;;) {
r->act.b[z] |= bb;
p = r->prog;
if(r->use1.b[z] & bb) {
changer += CREF * r->loop;
changea += CREF * r->loop;
x = p->from.index;
if(x == D_NONE) {
switch(p->as) {
default:
changea = -CINF;
case AADDL:
case ASUBL:
case AMOVL:
case ACMPL:
break;
}
} else {
changer += (CXREF-CREF) * r->loop;
if(x != (I_INDEX3|D_NONE))
changer = -CINF;
if((x&I_MASK) == I_INDEX1)
changea = -CINF;
}
if(p->as == AMOVL) {
x = p->to.type;
if(x >= D_R0 && x < D_R0+NREG)
changer += r->loop;
if(x >= D_A0 && x < D_A0+NREG)
changea += r->loop;
}
if(debug['R'] && debug['v'])
print("%ld%P\tu1 %B $%d.%d\n", r->loop,
p, blsh(bn), changer, changea);
}
if((r->use2.b[z]|r->set.b[z]) & bb) {
changer += CREF * r->loop;
changea += CREF * r->loop;
x = p->to.index;
if(x == D_NONE)
switch(p->as) {
default:
changea = -CINF;
break;
case AMOVL:
case AADDL:
case ACMPL:
case ASUBL:
case ACLRL: /* can be faked */
case ATSTL: /* can be faked */
break;
}
else {
changer += (CXREF-CREF) * r->loop;
if(x != (I_INDEX3|D_NONE))
changer = -CINF;
if((x&I_MASK) == I_INDEX1)
changea = -CINF;
}
if(p->as == AMOVL) {
x = p->from.type;
if(x >= D_R0 && x < D_R0+NREG)
changer += r->loop;
if(x >= D_A0 && x < D_A0+NREG)
changea += r->loop;
}
if(debug['R'] && debug['v'])
print("%ld%P\tu2 %B $%d.%d\n", r->loop,
p, blsh(bn), changer, changea);
}
if(STORE(r) & r->regdiff.b[z] & bb) {
changer -= CLOAD * r->loop;
changea -= CLOAD * r->loop;
if(debug['R'] && debug['v'])
print("%ld%P\tst %B $%d.%d\n", r->loop,
p, blsh(bn), changer, changea);
}
if(r->refbehind.b[z] & bb)
for(r1 = r->p2; r1 != R; r1 = r1->p2link)
if(r1->refahead.b[z] & bb)
paint1(r1, bn);
if(!(r->refahead.b[z] & bb))
break;
r1 = r->s2;
if(r1 != R)
if(r1->refbehind.b[z] & bb)
paint1(r1, bn);
r = r->s1;
if(r == R)
break;
if(r->act.b[z] & bb)
break;
if(!(r->refbehind.b[z] & bb))
break;
}
}
ulong
paint2(Reg *r, int bn)
{
Reg *r1;
int z;
ulong bb, vreg;
z = bn/32;
bb = 1L << (bn%32);
vreg = regbits;
if(!(r->act.b[z] & bb))
return vreg;
for(;;) {
if(!(r->refbehind.b[z] & bb))
break;
r1 = r->p1;
if(r1 == R)
break;
if(!(r1->refahead.b[z] & bb))
break;
if(!(r1->act.b[z] & bb))
break;
r = r1;
}
for(;;) {
r->act.b[z] &= ~bb;
vreg |= r->regu;
if(r->refbehind.b[z] & bb)
for(r1 = r->p2; r1 != R; r1 = r1->p2link)
if(r1->refahead.b[z] & bb)
vreg |= paint2(r1, bn);
if(!(r->refahead.b[z] & bb))
break;
r1 = r->s2;
if(r1 != R)
if(r1->refbehind.b[z] & bb)
vreg |= paint2(r1, bn);
r = r->s1;
if(r == R)
break;
if(!(r->act.b[z] & bb))
break;
if(!(r->refbehind.b[z] & bb))
break;
}
return vreg;
}
void
paint3(Reg *r, int bn, ulong rb, int rn)
{
Reg *r1;
Prog *p;
int z;
ulong bb;
z = bn/32;
bb = 1L << (bn%32);
if(r->act.b[z] & bb)
return;
for(;;) {
if(!(r->refbehind.b[z] & bb))
break;
r1 = r->p1;
if(r1 == R)
break;
if(!(r1->refahead.b[z] & bb))
break;
if(r1->act.b[z] & bb)
break;
r = r1;
}
if(LOAD(r) & ~(r->set.b[z] & ~(r->use1.b[z]|r->use2.b[z])) & bb)
addmove(r, bn, rn, 0);
for(;;) {
r->act.b[z] |= bb;
p = r->prog;
if(r->use1.b[z] & bb) {
if(debug['R'])
print("%P", p);
addreg(&p->from, rn);
if(debug['R'])
print("\t.c%P\n", p);
}
if((r->use2.b[z]|r->set.b[z]) & bb) {
if(debug['R'])
print("%P", p);
addreg(&p->to, rn);
if(debug['R'])
print("\t.c%P\n", p);
}
if(STORE(r) & r->regdiff.b[z] & bb)
addmove(r, bn, rn, 1);
r->regu |= rb;
if(r->refbehind.b[z] & bb)
for(r1 = r->p2; r1 != R; r1 = r1->p2link)
if(r1->refahead.b[z] & bb)
paint3(r1, bn, rb, rn);
if(!(r->refahead.b[z] & bb))
break;
r1 = r->s2;
if(r1 != R)
if(r1->refbehind.b[z] & bb)
paint3(r1, bn, rb, rn);
r = r->s1;
if(r == R)
break;
if(r->act.b[z] & bb)
break;
if(!(r->refbehind.b[z] & bb))
break;
}
}
void
addreg(Adr *a, int rn)
{
int x;
a->sym = 0;
x = a->index;
if(rn >= D_R0 && rn < D_R0+NREG)
goto addr;
if(x == (I_INDEX3|D_NONE)) {
a->type = rn | I_INDIR;
a->index = D_NONE;
a->offset = a->displace;
a->displace = 0;
return;
}
if(x != D_NONE) {
a->type = rn | I_INDIR;
a->index += I_INDEX1 - I_INDEX2;
a->offset = a->displace;
a->displace = 0;
return;
}
a->type = rn | (a->type & I_INDIR);
return;
addr:
if(x == (I_INDEX3|D_NONE)) {
a->type = D_NONE|I_INDIR;
a->index += I_INDEX1 + rn - D_NONE - I_INDEX3;
a->scale = 4; /* .L*1 */
a->offset = a->displace;
a->displace = 0;
return;
}
a->type = rn | (a->type & I_INDIR);
}
/*
* bit reg
* 0-7 R0-R7
* 8-15 A0-A7
* 16-23 F0-F7
*/
ulong
RtoB(int r)
{
if(r < 0 || r >= NREG)
return 0;
return 1L << (r + 0);
}
int
BtoR(ulong b)
{
b &= 0x0000ffL;
if(b == 0)
return NREG;
return bitno(b) - 0;
}
ulong
AtoB(int a)
{
if(a < 0 || a >= NREG)
return 0;
return 1L << (a + NREG);
}
int
BtoA(ulong b)
{
b &= 0x00ff00L;
if(b == 0)
return NREG;
return bitno(b) - NREG;
}
ulong
FtoB(int f)
{
if(f < 0 || f >= NREG)
return 0;
return 1L << (f + NREG+NREG);
}
int
BtoF(ulong b)
{
b &= 0xff0000L;
if(b == 0)
return NREG;
return bitno(b) - NREG-NREG;
}