regalloc: cleanup. no functional change
This commit is contained in:
Flyinghead
parent
5b2cef3fdd
commit
c6e92028f2
|
|
@ -228,10 +228,10 @@ struct RegAlloc
|
|||
|
||||
bool IsAllocg(Sh4RegType reg)
|
||||
{
|
||||
for (u32 sid=0;sid<all_spans.size();sid++)
|
||||
for (RegSpan *span : all_spans)
|
||||
{
|
||||
if (all_spans[sid]->regstart==(u32)reg && all_spans[sid]->contains(current_opid))
|
||||
return !all_spans[sid]->fpr;
|
||||
if (span->regstart == (u32)reg && span->contains(current_opid))
|
||||
return !span->fpr;
|
||||
}
|
||||
|
||||
return false;
|
||||
|
|
@ -252,10 +252,10 @@ struct RegAlloc
|
|||
|
||||
bool IsAllocf(Sh4RegType reg)
|
||||
{
|
||||
for (u32 sid=0;sid<all_spans.size();sid++)
|
||||
for (RegSpan *span : all_spans)
|
||||
{
|
||||
if (all_spans[sid]->regstart==(u32)reg && all_spans[sid]->contains(current_opid))
|
||||
return all_spans[sid]->fpr;
|
||||
if (span->regstart == (u32)reg && span->contains(current_opid))
|
||||
return span->fpr;
|
||||
}
|
||||
|
||||
return false;
|
||||
|
|
@ -405,11 +405,11 @@ struct RegAlloc
|
|||
|
||||
RegSpan* FindSpan(Sh4RegType reg, u32 opid)
|
||||
{
|
||||
for (u32 sid=0;sid<all_spans.size();sid++)
|
||||
for (RegSpan *span : all_spans)
|
||||
{
|
||||
if (all_spans[sid]->regstart==(u32)reg && all_spans[sid]->contains(opid))
|
||||
if (span->regstart == (u32)reg && span->contains(opid))
|
||||
{
|
||||
return all_spans[sid];
|
||||
return span;
|
||||
}
|
||||
}
|
||||
die("Failed to find span");
|
||||
|
|
@ -432,13 +432,6 @@ struct RegAlloc
|
|||
{
|
||||
op=&block->oplist[opid];
|
||||
|
||||
/*
|
||||
if (op->op!=shop_readm && op->op!=shop_writem && ( op->rd.is_vector() ||op->rs1.is_vector()))
|
||||
{
|
||||
// __asm int 3;
|
||||
}*/
|
||||
|
||||
//if (op->op != shop_readm && op->op != shop_writem && op->op != shop_jcond && op->op != shop_jdyn && op->op != shop_mov32 && op->op != shop_mov64 && (op->op != shop_add || block->addr<=0x8c0DA0BA))
|
||||
if (IsFlushOp(block,opid))
|
||||
{
|
||||
bool fp=false,gpr_b=false,all=false;
|
||||
|
|
@ -564,29 +557,29 @@ struct RegAlloc
|
|||
{
|
||||
reg_rd.erase(*iter);
|
||||
{
|
||||
if ((*iter).is_reg())
|
||||
if (iter->is_reg())
|
||||
{
|
||||
//r~w
|
||||
if ((*iter).is_r32())
|
||||
if (iter->is_r32())
|
||||
{
|
||||
if (spans[(*iter)._reg]==0)
|
||||
if (spans[iter->_reg]==0)
|
||||
{
|
||||
spans[(*iter)._reg] = new RegSpan((*iter),opid,AM_READWRITE);
|
||||
all_spans.push_back(spans[(*iter)._reg]);
|
||||
spans[iter->_reg] = new RegSpan(*iter, opid, AM_READWRITE);
|
||||
all_spans.push_back(spans[iter->_reg]);
|
||||
}
|
||||
else
|
||||
{
|
||||
spans[(*iter)._reg]->Access(opid,AM_READWRITE);
|
||||
spans[iter->_reg]->Access(opid, AM_READWRITE);
|
||||
}
|
||||
}
|
||||
else
|
||||
{
|
||||
for (u32 i=0; i<(*iter).count(); i++)
|
||||
for (u32 i = 0; i < iter->count(); i++)
|
||||
{
|
||||
if (spans[(*iter)._reg+i]!=0)
|
||||
spans[(*iter)._reg+i]->Flush();
|
||||
if (spans[iter->_reg + i] != 0)
|
||||
spans[iter->_reg + i]->Flush();
|
||||
|
||||
spans[(*iter)._reg+i]=0;
|
||||
spans[iter->_reg + i]=0;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
|
@ -594,65 +587,65 @@ struct RegAlloc
|
|||
}
|
||||
else
|
||||
{
|
||||
if ((*iter).is_reg())
|
||||
if (iter->is_reg())
|
||||
{
|
||||
for (u32 i=0; i<(*iter).count(); i++)
|
||||
for (u32 i = 0; i < iter->count(); i++)
|
||||
{
|
||||
if (spans[(*iter)._reg+i]!=0)
|
||||
if (spans[iter->_reg + i] != 0)
|
||||
{
|
||||
//hack//
|
||||
//this is a bug on the current reg alloc code, affects fipr.
|
||||
//generally, vector registers aren't treated correctly
|
||||
//as groups of phy registers. I really need a better model
|
||||
//to accommodate for that on the reg alloc side of things ..
|
||||
if ((*iter).count()==1 && iter->_reg==op->rs1._reg+3)
|
||||
spans[(*iter)._reg+i]->Flush();
|
||||
if (iter->count() == 1 && iter->_reg == op->rs1._reg + 3)
|
||||
spans[iter->_reg + i]->Flush();
|
||||
else
|
||||
spans[(*iter)._reg+i]->Kill();
|
||||
spans[iter->_reg + i]->Kill();
|
||||
}
|
||||
spans[(*iter)._reg+i]=0;
|
||||
spans[iter->_reg + i] = 0;
|
||||
}
|
||||
|
||||
//w
|
||||
if ((*iter).is_r32())
|
||||
if (iter->is_r32())
|
||||
{
|
||||
if (spans[(*iter)._reg]!=0)
|
||||
spans[(*iter)._reg]->Kill();
|
||||
if (spans[iter->_reg] != 0)
|
||||
spans[iter->_reg]->Kill();
|
||||
|
||||
spans[(*iter)._reg]= new RegSpan((*iter),opid,AM_WRITE);
|
||||
all_spans.push_back(spans[(*iter)._reg]);
|
||||
spans[iter->_reg] = new RegSpan(*iter, opid, AM_WRITE);
|
||||
all_spans.push_back(spans[iter->_reg]);
|
||||
}
|
||||
}
|
||||
}
|
||||
++iter;
|
||||
}
|
||||
|
||||
iter=reg_rd.begin();
|
||||
while( iter != reg_rd.end() )
|
||||
iter = reg_rd.begin();
|
||||
while (iter != reg_rd.end())
|
||||
{
|
||||
//r
|
||||
if ((*iter).is_reg())
|
||||
if (iter->is_reg())
|
||||
{
|
||||
if ((*iter).is_r32())
|
||||
if (iter->is_r32())
|
||||
{
|
||||
if (spans[(*iter)._reg]==0)
|
||||
if (spans[iter->_reg] == 0)
|
||||
{
|
||||
spans[(*iter)._reg] = new RegSpan((*iter),opid,AM_READ);
|
||||
all_spans.push_back(spans[(*iter)._reg]);
|
||||
spans[iter->_reg] = new RegSpan((*iter), opid, AM_READ);
|
||||
all_spans.push_back(spans[iter->_reg]);
|
||||
}
|
||||
else
|
||||
{
|
||||
spans[(*iter)._reg]->Access(opid,AM_READ);
|
||||
spans[iter->_reg]->Access(opid, AM_READ);
|
||||
}
|
||||
}
|
||||
else
|
||||
{
|
||||
for (u32 i=0; i<(*iter).count(); i++)
|
||||
for (u32 i = 0; i < iter->count(); i++)
|
||||
{
|
||||
if (spans[(*iter)._reg+i]!=0)
|
||||
spans[(*iter)._reg+i]->Flush();
|
||||
if (spans[iter->_reg + i] != 0)
|
||||
spans[iter->_reg + i]->Flush();
|
||||
|
||||
spans[(*iter)._reg+i]=0;
|
||||
spans[iter->_reg + i] = 0;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
|
@ -698,11 +691,11 @@ struct RegAlloc
|
|||
u32 cc_g=0;
|
||||
u32 cc_f=0;
|
||||
|
||||
for (u32 sid=0;sid<all_spans.size();sid++)
|
||||
for (RegSpan *span : all_spans)
|
||||
{
|
||||
if (all_spans[sid]->contains(opid))
|
||||
if (span->contains(opid))
|
||||
{
|
||||
if (all_spans[sid]->fpr)
|
||||
if (span->fpr)
|
||||
cc_f++;
|
||||
else
|
||||
cc_g++;
|
||||
|
|
@ -768,22 +761,20 @@ struct RegAlloc
|
|||
|
||||
if (!alias_mov)
|
||||
{
|
||||
for (u32 sid=0;sid<all_spans.size();sid++)
|
||||
for (RegSpan *span : all_spans)
|
||||
{
|
||||
RegSpan* spn=all_spans[sid];
|
||||
|
||||
if (spn->begining(opid))
|
||||
if (span->begining(opid))
|
||||
{
|
||||
if (spn->fpr)
|
||||
if (span->fpr)
|
||||
{
|
||||
verify(regsf.size()>0);
|
||||
spn->nregf=regsf.back();
|
||||
span->nregf=regsf.back();
|
||||
regsf.pop_back();
|
||||
}
|
||||
else
|
||||
{
|
||||
verify(regs.size()>0);
|
||||
spn->nreg=regs.back();
|
||||
span->nreg=regs.back();
|
||||
regs.pop_back();
|
||||
|
||||
//printf("rALOC %d from %d\n",spn->regstart,spn->nreg);
|
||||
|
|
@ -791,21 +782,19 @@ struct RegAlloc
|
|||
}
|
||||
}
|
||||
}
|
||||
for (u32 sid=0;sid<all_spans.size();sid++)
|
||||
for (RegSpan *span : all_spans)
|
||||
{
|
||||
RegSpan* spn=all_spans[sid];
|
||||
|
||||
if ( spn->ending(opid) && !spn->aliased)
|
||||
if (span->ending(opid) && !span->aliased)
|
||||
{
|
||||
if (spn->fpr)
|
||||
if (span->fpr)
|
||||
{
|
||||
verify(regsf.size()<reg_cc_max_f);
|
||||
regsf.push_front(spn->nregf);
|
||||
regsf.push_front(span->nregf);
|
||||
}
|
||||
else
|
||||
{
|
||||
verify(regs.size()<reg_cc_max_g);
|
||||
regs.push_front(spn->nreg);
|
||||
regs.push_front(span->nreg);
|
||||
//printf("rFREE %d from %d\n",spn->regstart,spn->nreg);
|
||||
}
|
||||
}
|
||||
|
|
@ -970,41 +959,39 @@ struct RegAlloc
|
|||
RegSpan* last_pacc=0;
|
||||
RegSpan* last_nacc=0;
|
||||
|
||||
for (u32 sid=0;sid<all_spans.size();sid++)
|
||||
for (RegSpan *span : all_spans)
|
||||
{
|
||||
RegSpan* spn=all_spans[sid];
|
||||
|
||||
if (spn->contains(opid) && fpr==spn->fpr)
|
||||
if (span->contains(opid) && fpr==span->fpr)
|
||||
{
|
||||
if (!spn->cacc(opid))
|
||||
if (!span->cacc(opid))
|
||||
{
|
||||
if (!last_nacc || spn->nacc(opid)>last_nacc->nacc(opid))
|
||||
last_nacc=spn;
|
||||
if (!last_nacc || span->nacc(opid)>last_nacc->nacc(opid))
|
||||
last_nacc=span;
|
||||
|
||||
if (!last_pacc || spn->pacc(opid)<last_pacc->pacc(opid))
|
||||
last_pacc=spn;
|
||||
if (!last_pacc || span->pacc(opid)<last_pacc->pacc(opid))
|
||||
last_pacc=span;
|
||||
}
|
||||
if (was_large)
|
||||
printf("\t[%c]span: %d (r%d), [%d:%d],n: %d, p: %d\n",spn->cacc(opid)?'x':' ',sid,all_spans[sid]->regstart,all_spans[sid]->start,all_spans[sid]->end,all_spans[sid]->nacc(opid),all_spans[sid]->pacc(opid));
|
||||
printf("\t[%c]span: r%d, [%d:%d],n: %d, p: %d\n",span->cacc(opid)?'x':' ',span->regstart,span->start,span->end,span->nacc(opid),span->pacc(opid));
|
||||
}
|
||||
}
|
||||
|
||||
//printf("Last pacc: %d, vlen %d | reg r%d\n",last_pacc->nacc(opid)-opid,last_pacc->nacc(opid)-last_pacc->pacc(opid),last_pacc->regstart);
|
||||
//printf("Last nacc: %d, vlen %d | reg r%d\n",last_nacc->nacc(opid)-opid,last_nacc->nacc(opid)-last_nacc->pacc(opid),last_nacc->regstart);
|
||||
|
||||
RegSpan* spn= new RegSpan(*last_nacc);
|
||||
spn->start=last_nacc->nacc(opid);
|
||||
RegSpan* span= new RegSpan(*last_nacc);
|
||||
span->start=last_nacc->nacc(opid);
|
||||
last_nacc->end=last_nacc->pacc(opid);
|
||||
|
||||
//trim the access arrays as required ..
|
||||
spn->trim_access();
|
||||
span->trim_access();
|
||||
last_nacc->trim_access();
|
||||
|
||||
spn->preload=spn->NeedsPL();
|
||||
span->preload=span->NeedsPL();
|
||||
last_nacc->writeback=last_nacc->NeedsWB();
|
||||
|
||||
//add it to the span list !
|
||||
all_spans.push_back(spn);
|
||||
all_spans.push_back(span);
|
||||
spills++;
|
||||
cc--;
|
||||
}
|
||||
|
|
@ -1014,9 +1001,9 @@ struct RegAlloc
|
|||
{
|
||||
verify(reg!=-1);
|
||||
int cc=0;
|
||||
for (u32 sid=0;sid<all_spans.size();sid++)
|
||||
for (RegSpan *span : all_spans)
|
||||
{
|
||||
if (all_spans[sid]->regstart==reg && all_spans[sid]->contains(opid))
|
||||
if (span->regstart == reg && span->contains(opid))
|
||||
cc++;
|
||||
}
|
||||
return cc;
|
||||
|
|
@ -1026,9 +1013,9 @@ struct RegAlloc
|
|||
{
|
||||
verify(nreg!=-1);
|
||||
int cc=0;
|
||||
for (u32 sid=0;sid<all_spans.size();sid++)
|
||||
for (RegSpan *span : all_spans)
|
||||
{
|
||||
if (all_spans[sid]->nreg==nreg && all_spans[sid]->contains(opid))
|
||||
if (span->nreg == nreg && span->contains(opid))
|
||||
cc++;
|
||||
}
|
||||
return cc;
|
||||
|
|
@ -1038,9 +1025,9 @@ struct RegAlloc
|
|||
{
|
||||
verify(nregf!=-1);
|
||||
int cc=0;
|
||||
for (u32 sid=0;sid<all_spans.size();sid++)
|
||||
for (RegSpan *span : all_spans)
|
||||
{
|
||||
if (all_spans[sid]->nregf==nregf && all_spans[sid]->contains(opid))
|
||||
if (span->nregf == nregf && span->contains(opid))
|
||||
cc++;
|
||||
}
|
||||
return cc;
|
||||
|
|
@ -1050,11 +1037,9 @@ struct RegAlloc
|
|||
{
|
||||
int rv=0;
|
||||
|
||||
for (u32 sid=0;sid<all_spans.size();sid++)
|
||||
for (RegSpan *span : all_spans)
|
||||
{
|
||||
RegSpan* spn=all_spans[sid];
|
||||
|
||||
if (spn->preload && spn->begining(opid))
|
||||
if (span->preload && span->begining(opid))
|
||||
rv++;
|
||||
}
|
||||
|
||||
|
|
@ -1065,11 +1050,9 @@ struct RegAlloc
|
|||
{
|
||||
int rv=0;
|
||||
|
||||
for (u32 sid=0;sid<all_spans.size();sid++)
|
||||
for (RegSpan *span : all_spans)
|
||||
{
|
||||
RegSpan* spn=all_spans[sid];
|
||||
|
||||
if (spn->writeback && spn->ending(opid))
|
||||
if (span->writeback && span->ending(opid))
|
||||
rv++;
|
||||
}
|
||||
|
||||
|
|
@ -1080,23 +1063,21 @@ struct RegAlloc
|
|||
{
|
||||
current_opid=opid;
|
||||
|
||||
for (u32 sid=0;sid<all_spans.size();sid++)
|
||||
for (RegSpan *span : all_spans)
|
||||
{
|
||||
RegSpan* spn=all_spans[sid];
|
||||
|
||||
if (spn->begining(current_opid) && spn->preload)
|
||||
if (span->begining(current_opid) && span->preload)
|
||||
{
|
||||
if (spn->fpr)
|
||||
if (span->fpr)
|
||||
{
|
||||
//printf("Op %d: Preloading f%d to %d\n",current_opid,spn->regstart,spn->nregf);
|
||||
preload_fpu++;
|
||||
Preload_FPU(spn->regstart,spn->nregf);
|
||||
Preload_FPU(span->regstart,span->nregf);
|
||||
}
|
||||
else
|
||||
{
|
||||
//printf("Op %d: Preloading r%d to %d\n",current_opid,spn->regstart,spn->nreg);
|
||||
preload_gpr++;
|
||||
Preload(spn->regstart,spn->nreg);
|
||||
Preload(span->regstart,span->nreg);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
|
@ -1104,23 +1085,21 @@ struct RegAlloc
|
|||
|
||||
void OpEnd(shil_opcode* op)
|
||||
{
|
||||
for (u32 sid=0;sid<all_spans.size();sid++)
|
||||
for (RegSpan *span : all_spans)
|
||||
{
|
||||
RegSpan* spn=all_spans[sid];
|
||||
|
||||
if (spn->ending(current_opid) && spn->writeback)
|
||||
if (span->ending(current_opid) && span->writeback)
|
||||
{
|
||||
if (spn->fpr)
|
||||
if (span->fpr)
|
||||
{
|
||||
//printf("Op %d: Writing back f%d from %d\n",current_opid,spn->regstart,spn->nregf);
|
||||
writeback_fpu++;
|
||||
Writeback_FPU(spn->regstart,spn->nregf);
|
||||
Writeback_FPU(span->regstart,span->nregf);
|
||||
}
|
||||
else
|
||||
{
|
||||
//printf("Op %d: Writing back r%d from %d\n",current_opid,spn->regstart,spn->nreg);
|
||||
writeback_gpr++;
|
||||
Writeback(spn->regstart,spn->nreg);
|
||||
Writeback(span->regstart,span->nreg);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
|
@ -1128,23 +1107,17 @@ struct RegAlloc
|
|||
|
||||
void BailOut(u32 opid)
|
||||
{
|
||||
for (u32 sid = 0; sid < all_spans.size(); sid++)
|
||||
for (RegSpan *span : all_spans)
|
||||
{
|
||||
RegSpan* spn = all_spans[sid];
|
||||
|
||||
if (spn->end >= opid && spn->start < opid && spn->writeback)
|
||||
if (span->end >= opid && span->start < opid && span->writeback)
|
||||
{
|
||||
if (spn->fpr)
|
||||
if (span->fpr)
|
||||
{
|
||||
//printf("Op %d: Writing back f%d from %d\n",current_opid,spn->regstart,spn->nregf);
|
||||
writeback_fpu++;
|
||||
Writeback_FPU(spn->regstart,spn->nregf);
|
||||
Writeback_FPU(span->regstart, span->nregf);
|
||||
}
|
||||
else
|
||||
{
|
||||
//printf("Op %d: Writing back r%d from %d\n",current_opid,spn->regstart,spn->nreg);
|
||||
writeback_gpr++;
|
||||
Writeback(spn->regstart,spn->nreg);
|
||||
Writeback(span->regstart, span->nreg);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
|
@ -1161,8 +1134,8 @@ struct RegAlloc
|
|||
spans[sid]=0;
|
||||
}
|
||||
|
||||
for (size_t sid=0;sid<all_spans.size();sid++)
|
||||
delete all_spans[sid];
|
||||
for (RegSpan *span : all_spans)
|
||||
delete span;
|
||||
|
||||
all_spans.clear();
|
||||
}
|
||||
|
|
|
|||
Loading…
Reference in New Issue