void CopyPropagation::doCopyPropagation(void)
{
std::string CopyStr("");
RewriteHelper->getExprString(TheCopyExpr, CopyStr);
ExprSet *ESet = DominatedMap[TheCopyExpr];
TransAssert(ESet && "Empty Expr Set!");
for (ExprSet::iterator I = ESet->begin(), E = ESet->end(); I != E; ++I) {
RewriteHelper->replaceExpr((*I), CopyStr);
}
}
void AggregateToScalar::addOneExpr(const Expr *Exp)
{
IndexVector *Idx = new IndexVector();
const Expr *BaseE = getBaseExprAndIdxs(Exp, *Idx);
TransAssert(BaseE && "Invalid Base Expr for ArraySubscriptExpr!");
const DeclRefExpr *DRE = dyn_cast<DeclRefExpr>(BaseE);
if (!DRE) {
delete Idx;
return;
}
const ValueDecl *OrigDecl = DRE->getDecl();
const VarDecl *VD = dyn_cast<VarDecl>(OrigDecl);
if (!VD) {
delete Idx;
return;
}
if (dyn_cast<ParmVarDecl>(VD)) {
delete Idx;
return;
}
const VarDecl *CanonicalDecl = VD->getCanonicalDecl();
IdxVectorSet *IdxSet = ValidVars[CanonicalDecl];
if (!IdxSet) {
IdxSet = new IdxVectorSet();
ValidVars[VD] = IdxSet;
addOneIdx(Exp, VD, IdxSet, Idx);
return;
}
IndexVector *CachedIdx = NULL;
for (IdxVectorSet::iterator I = IdxSet->begin(), E = IdxSet->end();
I != E; ++I) {
if (isStructuralEqualVectors(*I, Idx)) {
CachedIdx = (*I);
break;
}
}
if (!CachedIdx) {
addOneIdx(Exp, VD, IdxSet, Idx);
return;
}
ExprSet *CachedESet = ValidExprs[CachedIdx];
TransAssert(CachedESet && "NULL CachedESet!");
CachedESet->insert(Exp);
delete Idx;
}
void AggregateToScalar::doRewrite(void)
{
ExprSet *TheExprSet = ValidExprs[TheIdx];
TransAssert(!TheExprSet->empty() && "TheExprSet cannot be empty!");
ExprSet::iterator I = TheExprSet->begin(), E = TheExprSet->end();
std::string VarName("");
createNewVar(*I, VarName);
for (; I != E; ++I) {
RewriteHelper->replaceExpr((*I), VarName);
}
}
void AggregateToScalar::addOneIdx(const Expr *E,
const VarDecl *VD,
IdxVectorSet *IdxSet,
IndexVector *Idx)
{
IdxSet->insert(Idx);
ExprSet *ESet = new ExprSet();
ValidExprs[Idx] = ESet;
ESet->insert(E);
ValidInstanceNum++;
if (ValidInstanceNum == TransformationCounter) {
TheVarDecl = VD;
TheIdx = Idx;
}
}
void CopyPropagation::addOneDominatedExpr(const Expr *CopyE,
const Expr *DominatedE)
{
if ((CopyE == DominatedE) || isRefToTheSameVar(CopyE, DominatedE) ||
hasSameStringRep(CopyE, DominatedE))
return;
ExprSet *ESet = DominatedMap[CopyE];
if (!ESet) {
ESet = new ExprSet();
TransAssert(ESet && "Couldn't new ExprSet");
DominatedMap[CopyE] = ESet;
ValidInstanceNum++;
if (TransformationCounter == ValidInstanceNum)
TheCopyExpr = CopyE;
}
ESet->insert(DominatedE);
}
