Alexander_KS/SAPFOR
4
2
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

Merge pull request 'private_removing: some small fixes' (#35) from private_removing into master

Browse Source
This commit was merged in pull request #35.
This commit is contained in:
Alexander_KS
2024-04-05 17:37:29 +00:00
parent 841eb0314d 42f64531b8
commit 2cc9cf3254
1 changed files with 88 additions and 67 deletions
Download Patch File Download Diff File Expand all files Collapse all files

147
sapfor/experts/Sapfor_2017/_src/Transformations/private_removing.cpp
View File

@@ -44,7 +44,7 @@ static bool operator<(const RegularExpr& left, const RegularExpr& right)
} }
// FixedSubscript represents subscript of array. Subscript is fixed if it is INT_VAL value // FixedSubscript represents subscript of array. Subscript is fixed if it is INT_VAL value
struct FixedSubscript { struct ArraySubscript {
bool isFixed; bool isFixed;
int value; int value;
@@ -52,7 +52,7 @@ struct FixedSubscript {
RegularExpr regExprStart; RegularExpr regExprStart;
RegularExpr regExprEnd; RegularExpr regExprEnd;
FixedSubscript() { ArraySubscript() {
isFixed = false; isFixed = false;
value = 0; value = 0;
isRegIndex = false; isRegIndex = false;
@@ -240,6 +240,7 @@ static vector<int> getShortFixedSubscriptsVector(SgArrayRefExp* arrayRef, const
if (vars != varToRemove.arrayRefToIterationVarsMap.end()) if (vars != varToRemove.arrayRefToIterationVarsMap.end())
iterationVars = vars->second; iterationVars = vars->second;
} }
return getShortFixedSubscriptsVector(arrayRef, varToRemove.fixedDimensions, return getShortFixedSubscriptsVector(arrayRef, varToRemove.fixedDimensions,
varToRemove.regime, iterationVars); varToRemove.regime, iterationVars);
} }
@@ -278,8 +279,12 @@ static bool isSymbolInExpression(SgSymbol* symbol, SgExpression* exp)
if (exp == nullptr) if (exp == nullptr)
return false; return false;
if (exp->symbol() != nullptr && isEqSymbols(exp->symbol(), symbol)) if (exp->symbol() != nullptr &&
(exp->variant() == VAR_REF || exp->variant() == ARRAY_REF) &&
isEqSymbols(exp->symbol(), symbol))
{
return true; return true;
}
return isSymbolInExpression(symbol, exp->lhs()) || return isSymbolInExpression(symbol, exp->lhs()) ||
isSymbolInExpression(symbol, exp->rhs()); isSymbolInExpression(symbol, exp->rhs());
@@ -312,6 +317,20 @@ static FuncInfo* getCurrectFunc(SgStatement* stmt, const map<string, vector<Func
return nullptr; return nullptr;
} }
// fillIterationVariables fill vars set with iteration variables of all loops
// from stmt to outerLoopStmt
static void fillIterationVars(SgStatement* stmt, SgStatement* outerLoopStmt, vector<SgSymbol*>& vars)
{
if (stmt == nullptr)
return;
if (stmt->variant() == FOR_NODE)
vars.push_back(((SgForStmt*)stmt)->doName());
if (stmt->id() != outerLoopStmt->id())
fillIterationVars(stmt->controlParent(), outerLoopStmt, vars);
}
/* ************************************** * /* ************************************** *
* End of block of common used functions: * * End of block of common used functions: *
* ************************************** */ * ************************************** */
@@ -369,18 +388,19 @@ static void addMessageCannotFindRD(vector<Messages>& messages, string varName, i
messages.push_back(Messages(typeMessage::WARR, loopLineNum, messageR, messageE, 2021)); messages.push_back(Messages(typeMessage::WARR, loopLineNum, messageR, messageE, 2021));
} }
static void addMessageMoreThanOneRD(vector<Messages>& messages, string varName, int loopLineNum) // TODO: unused:
{ //static void addMessageMoreThanOneRD(vector<Messages>& messages, string varName, int loopLineNum)
__spf_print(1, "WARR: cannot remove private var '%s' - more than one definition reaches the statement in line %d\n", //{
varName.c_str(), loopLineNum); // __spf_print(1, "WARR: cannot remove private var '%s' - more than one definition reaches the statement in line %d\n",
// varName.c_str(), loopLineNum);
wstring messageE, messageR; //
__spf_printToLongBuf(messageE, L"Cannot remove private var '%s' - more than one definition reaches the statement", // wstring messageE, messageR;
to_wstring(varName).c_str()); // __spf_printToLongBuf(messageE, L"Cannot remove private var '%s' - more than one definition reaches the statement",
__spf_printToLongBuf(messageR, R193, to_wstring(varName).c_str()); // to_wstring(varName).c_str());
// __spf_printToLongBuf(messageR, R193, to_wstring(varName).c_str());
messages.push_back(Messages(typeMessage::WARR, loopLineNum, messageR, messageE, 2020)); //
} // messages.push_back(Messages(typeMessage::WARR, loopLineNum, messageR, messageE, 2020));
//}
static void addMessageRecursiveDependency(vector<Messages>& messages, string varName, int lineNum) static void addMessageRecursiveDependency(vector<Messages>& messages, string varName, int lineNum)
{ {
@@ -499,7 +519,7 @@ static string getDimensionVarName(SgSymbol* var, const vector<int>& subscripts,
} }
// getDimensionVarName returns var name in style A(1, 2, *) // getDimensionVarName returns var name in style A(1, 2, *)
static string getDimensionVarName(SgSymbol* var, const vector<FixedSubscript>& fixedSubscripts) static string getDimensionVarName(SgSymbol* var, const vector<ArraySubscript>& fixedSubscripts)
{ {
string result = var->identifier(); string result = var->identifier();
@@ -607,15 +627,14 @@ static void fillReadShortFixedSubscripts(SgExpression* exp, const PrivateToRemov
if (exp == nullptr) if (exp == nullptr)
return; return;
if (exp->symbol() != nullptr) if (exp->symbol() != nullptr &&
{ (exp->symbol()->variant() == ARRAY_REF || exp->symbol()->variant() == VARIABLE_NAME) &&
if (isEqSymbols(exp->symbol(), var.varSymbol)) isEqSymbols(exp->symbol(), var.varSymbol))
{ {
auto subscripts = getShortFixedSubscriptsVector((SgArrayRefExp*)exp, var); auto subscripts = getShortFixedSubscriptsVector((SgArrayRefExp*)exp, var);
fixedSubscripts.insert(subscripts); fixedSubscripts.insert(subscripts);
return; return;
} }
}
fillReadShortFixedSubscripts(exp->lhs(), var, fixedSubscripts); fillReadShortFixedSubscripts(exp->lhs(), var, fixedSubscripts);
fillReadShortFixedSubscripts(exp->rhs(), var, fixedSubscripts); fillReadShortFixedSubscripts(exp->rhs(), var, fixedSubscripts);
@@ -718,10 +737,23 @@ static map<SgSymbol*, SgExpression*> getVarToExpMap(SgArrayRefExp* defRef, SgArr
// removeArray removes array by substituting it in DEF-USE pairs. // removeArray removes array by substituting it in DEF-USE pairs.
// Returns set of removed fixed subscripts // Returns set of removed fixed subscripts
static set<vector<int>> removeArray(string filename, const PrivateToRemove& arrayToRemove) static set<vector<int>> removeArray(string filename, PrivateToRemove& arrayToRemove)
{ {
set<vector<int>> removedFixedSubscripts; set<vector<int>> removedFixedSubscripts;
// again fill itaration vars:
arrayToRemove.arrayRefToIterationVarsMap.clear();
SgStatement* loopStmt = arrayToRemove.loop->loop->GetOriginal();
for (SgStatement* st = loopStmt->lexNext(); st != loopStmt->lastNodeOfStmt(); st = st->lexNext())
{
vector<SgSymbol*> iterationVars;
fillIterationVars(st, loopStmt, iterationVars);
vector<SgArrayRefExp*> arrayRefs = getDirectArrayRefsFromSingleStmt(st, arrayToRemove.varSymbol);
for (SgArrayRefExp* arrayRef : arrayRefs)
arrayToRemove.arrayRefToIterationVarsMap.insert(make_pair(arrayRef, iterationVars));
}
auto& fixedDimensions = arrayToRemove.fixedDimensions; auto& fixedDimensions = arrayToRemove.fixedDimensions;
for (auto& defUsePair : arrayToRemove.defUseStmtsPairs) for (auto& defUsePair : arrayToRemove.defUseStmtsPairs)
{ {
@@ -934,19 +966,6 @@ static vector<int> getShortFixedSubscriptsVector(Context* ctx, SgArrayRefExp* ar
return getShortFixedSubscriptsVector(arrayRef, ctx->fixedDimensionsMask, ctx->regime, iterationVars); return getShortFixedSubscriptsVector(arrayRef, ctx->fixedDimensionsMask, ctx->regime, iterationVars);
} }
// fillIterationVariables fill vars set with iteration variables of all loops
// from stmt to outerLoopStmt
static void fillIterationVars(SgStatement* stmt, SgStatement* outerLoopStmt, vector<SgSymbol*>& vars)
{
if (stmt == nullptr)
return;
if (stmt->variant() == FOR_NODE)
vars.push_back(((SgForStmt*)stmt)->doName());
if (stmt->id() != outerLoopStmt->id())
fillIterationVars(stmt->controlParent(), outerLoopStmt, vars);
}
// matchesFixedDimensionsMask checks if all array references have INT_VAL value in fixed dimension // matchesFixedDimensionsMask checks if all array references have INT_VAL value in fixed dimension
static bool checkFixedDimensionsMaskMatching(Context* ctx) static bool checkFixedDimensionsMaskMatching(Context* ctx)
@@ -1058,6 +1077,7 @@ static bool checkRegularIndexRefs(Context* ctx)
return false; return false;
} }
// TODO: possibly can be removed:
if (st->variant() == ASSIGN_STAT && isEqSymbols(st->expr(0)->symbol(), ctx->arraySymbol)) if (st->variant() == ASSIGN_STAT && isEqSymbols(st->expr(0)->symbol(), ctx->arraySymbol))
for (auto iterationVar : iterationVars) for (auto iterationVar : iterationVars)
if (isSymbolInExpression(iterationVar, st->expr(1))) if (isSymbolInExpression(iterationVar, st->expr(1)))
@@ -1117,17 +1137,17 @@ static SgForStmt* getLoopStmtForVar(SgStatement* stmt, string loopVar)
// getFixedSubscriptsVector returns vector of fixed INT_VAL subscripts of arrayRef // getFixedSubscriptsVector returns vector of fixed INT_VAL subscripts of arrayRef
// true - subscript is fixed, false - it isn't // true - subscript is fixed, false - it isn't
static vector<FixedSubscript> getFixedSubscriptsVector(SgArrayRefExp* arrayRef, int dimensionsNum = 0, static vector<ArraySubscript> getFixedSubscriptsVector(SgArrayRefExp* arrayRef, int dimensionsNum = 0,
SgStatement* stmt = nullptr) SgStatement* stmt = nullptr)
{ {
if (arrayRef->numberOfSubscripts() == 0) if (arrayRef->numberOfSubscripts() == 0)
return vector<FixedSubscript>(dimensionsNum); return vector<ArraySubscript>(dimensionsNum);
vector<FixedSubscript> subscriptsVector; vector<ArraySubscript> subscriptsVector;
for (int i = 0; i < arrayRef->numberOfSubscripts(); ++i) for (int i = 0; i < arrayRef->numberOfSubscripts(); ++i)
{ {
SgExpression* subscriptExpr = arrayRef->subscript(i); SgExpression* subscriptExpr = arrayRef->subscript(i);
FixedSubscript sub; ArraySubscript sub;
if (subscriptExpr->variant() == INT_VAL) if (subscriptExpr->variant() == INT_VAL)
{ {
@@ -1173,7 +1193,7 @@ static vector<FixedSubscript> getFixedSubscriptsVector(SgArrayRefExp* arrayRef,
// checkImplicitDirectUsage returns masks of array implicit usage (as out argument) // checkImplicitDirectUsage returns masks of array implicit usage (as out argument)
// in any function call in exp and writes message about each usage // in any function call in exp and writes message about each usage
static void checkImplicitDirectUsage(Context* ctx, SgExpression* exp, int stmtLineNum, static void checkImplicitDirectUsage(Context* ctx, SgExpression* exp, int stmtLineNum,
vector<vector<FixedSubscript>>& fixedSubscripts) vector<vector<ArraySubscript>>& fixedSubscripts)
{ {
if (exp == nullptr) if (exp == nullptr)
return; return;
@@ -1208,9 +1228,9 @@ static void checkImplicitDirectUsage(Context* ctx, SgExpression* exp, int stmtLi
// checkImplicitDirectUsage returns masks of array implicit usage (as out argument) // checkImplicitDirectUsage returns masks of array implicit usage (as out argument)
// and reference to whole array (like fcall(A, 1)) in any function call in loop // and reference to whole array (like fcall(A, 1)) in any function call in loop
// and writes message about each usage // and writes message about each usage
static vector<vector<FixedSubscript>> checkImplicitDirectUsage(Context* ctx) static vector<vector<ArraySubscript>> checkImplicitDirectUsage(Context* ctx)
{ {
vector<vector<FixedSubscript>> fixedSubscripts; vector<vector<ArraySubscript>> fixedSubscripts;
for (SgStatement* st = ctx->loopStmt->lexNext(); st != ctx->loopStmt->lastNodeOfStmt(); st = st->lexNext()) for (SgStatement* st = ctx->loopStmt->lexNext(); st != ctx->loopStmt->lastNodeOfStmt(); st = st->lexNext())
{ {
if (st->variant() != PROC_STAT) if (st->variant() != PROC_STAT)
@@ -1276,7 +1296,7 @@ static vector<Variable*> getCommonBlockGroupedVar(FuncInfo* curFunc, SgSymbol* v
// checkIndirectUsage returns masks of array indirect usage in function // checkIndirectUsage returns masks of array indirect usage in function
// (indirect usage is usage through common blocks) and writes messages about it // (indirect usage is usage through common blocks) and writes messages about it
static void checkIndirectUsage(Context* ctx, FuncInfo* curFunc, vector<Variable*> commonBlockGroupedVar, static void checkIndirectUsage(Context* ctx, FuncInfo* curFunc, vector<Variable*> commonBlockGroupedVar,
set<string>& visitedFuncs, vector<vector<FixedSubscript>>& indirectUsageMasks) set<string>& visitedFuncs, vector<vector<ArraySubscript>>& indirectUsageMasks)
{ {
if (visitedFuncs.find(curFunc->funcName) != visitedFuncs.end()) if (visitedFuncs.find(curFunc->funcName) != visitedFuncs.end())
return; return;
@@ -1307,9 +1327,9 @@ static void checkIndirectUsage(Context* ctx, FuncInfo* curFunc, vector<Variable*
// checkIndirectUsage returns masks of array indirect usage in any function call in loop // checkIndirectUsage returns masks of array indirect usage in any function call in loop
// (indirect usage is usage through common blocks) and writes messages about it // (indirect usage is usage through common blocks) and writes messages about it
static vector<vector<FixedSubscript>> checkIndirectUsage(Context* ctx) static vector<vector<ArraySubscript>> checkIndirectUsage(Context* ctx)
{ {
vector<vector<FixedSubscript>> indirectUsageMasks; vector<vector<ArraySubscript>> indirectUsageMasks;
FuncInfo* currentFunc = getCurrectFunc(ctx->loopStmt, ctx->allFuncInfo); FuncInfo* currentFunc = getCurrectFunc(ctx->loopStmt, ctx->allFuncInfo);
if (currentFunc == nullptr) if (currentFunc == nullptr)
printInternalError(convertFileName(__FILE__).c_str(), __LINE__); printInternalError(convertFileName(__FILE__).c_str(), __LINE__);
@@ -1327,10 +1347,10 @@ static vector<vector<FixedSubscript>> checkIndirectUsage(Context* ctx)
} }
// checkImplicitAndIndirectUsage returns masks of implicit or indirect array usage in loop // checkImplicitAndIndirectUsage returns masks of implicit or indirect array usage in loop
static vector<vector<FixedSubscript>> checkImplicitAndIndirectUsage(Context* ctx) static vector<vector<ArraySubscript>> checkImplicitAndIndirectUsage(Context* ctx)
{ {
vector<vector<FixedSubscript>> implicitMasks = checkImplicitDirectUsage(ctx); vector<vector<ArraySubscript>> implicitMasks = checkImplicitDirectUsage(ctx);
vector<vector<FixedSubscript>> indirectMasks = checkIndirectUsage(ctx); vector<vector<ArraySubscript>> indirectMasks = checkIndirectUsage(ctx);
implicitMasks.insert(implicitMasks.end(), indirectMasks.begin(), indirectMasks.end()); implicitMasks.insert(implicitMasks.end(), indirectMasks.begin(), indirectMasks.end());
return implicitMasks; return implicitMasks;
@@ -1338,7 +1358,7 @@ static vector<vector<FixedSubscript>> checkImplicitAndIndirectUsage(Context* ctx
// filterArrayRefs removes from arrayRefs all refs that are not different from fixedVectors // filterArrayRefs removes from arrayRefs all refs that are not different from fixedVectors
static void filterArrayRefs(Context* ctx, vector<SgArrayRefExp*>& arrayRefs, static void filterArrayRefs(Context* ctx, vector<SgArrayRefExp*>& arrayRefs,
const vector<vector<FixedSubscript>>& masks) const vector<vector<ArraySubscript>>& masks)
{ {
if (masks.empty()) if (masks.empty())
return; return;
@@ -1346,7 +1366,7 @@ static void filterArrayRefs(Context* ctx, vector<SgArrayRefExp*>& arrayRefs,
vector<SgArrayRefExp*> filteredArrayRefs; vector<SgArrayRefExp*> filteredArrayRefs;
for (auto arrayRef : arrayRefs) for (auto arrayRef : arrayRefs)
{ {
vector<FixedSubscript> arrayRefVec = getFixedSubscriptsVector(arrayRef, ctx->dimensionsNum); vector<ArraySubscript> arrayRefVec = getFixedSubscriptsVector(arrayRef, ctx->dimensionsNum);
bool isDifferent = false; bool isDifferent = false;
for (auto& mask : masks) for (auto& mask : masks)
@@ -1609,17 +1629,18 @@ static vector<DefUseStmtsPair> buildDefUsePairs(Context* ctx, const CFG_Type& CF
if (!defIsFound) if (!defIsFound)
{ {
// try to find definition not from RD_defArgs: // try to find definition not from RD_defArgs, by search in the block instructions:
string defVarName = useInsertedStmt.insertedStmt->expr(1)->symbol()->identifier(); string defVarName = useInsertedStmt.insertedStmt->expr(1)->symbol()->identifier();
SgStatement* blockStart = useInsAndBlock.second->getInstructions().front()->getInstruction()->getOperator(); const auto& blockInstructionsVector = useInsAndBlock.second->getInstructions();
SgStatement* blockEnd = useInsAndBlock.second->getInstructions().back()->getInstruction()->getOperator(); for (auto& instruction : blockInstructionsVector)
for (SgStatement* st = blockStart; st != blockEnd; st = st->lexNext())
{ {
if (st->variant() == ASSIGN_STAT && st->expr(0)->symbol()->identifier() == defVarName && SgStatement* stmt = instruction->getInstruction()->getOperator();
!isVarChangedBetween(defVarName, st, useInsertedStmt.insertedStmt)) if (stmt->variant() == ASSIGN_STAT
&& stmt->expr(0)->symbol()->identifier() == defVarName
&& !isVarChangedBetween(defVarName, stmt, useInsertedStmt.insertedStmt))
{ {
defIsFound = true; defIsFound = true;
defStmt = st; defStmt = stmt;
break; break;
} }
} }
@@ -1735,7 +1756,7 @@ static LoopGraph* leastCommonAncestor(LoopGraph* a, LoopGraph* b, LoopGraph* par
// fillFullFixedSubscriptsVectorsOfAllVars return vector of pairs (name of var, its fixed subscripts vector) // fillFullFixedSubscriptsVectorsOfAllVars return vector of pairs (name of var, its fixed subscripts vector)
// of all VAR_REF and ARRAY_REF vars in exp // of all VAR_REF and ARRAY_REF vars in exp
static void fillFixedSubscriptsVectorsOfAllVars(SgExpression* exp, static void fillFixedSubscriptsVectorsOfAllVars(SgExpression* exp,
vector<pair<string, vector<FixedSubscript>>>& vec, vector<pair<string, vector<ArraySubscript>>>& vec,
SgStatement* stmt = nullptr) SgStatement* stmt = nullptr)
{ {
if (exp == nullptr) if (exp == nullptr)
@@ -1749,7 +1770,7 @@ static void fillFixedSubscriptsVectorsOfAllVars(SgExpression* exp,
if (elem.first == exp->symbol()->identifier()) if (elem.first == exp->symbol()->identifier())
return; return;
vec.push_back(make_pair(exp->symbol()->identifier(), vector<FixedSubscript>{})); vec.push_back(make_pair(exp->symbol()->identifier(), vector<ArraySubscript>{}));
} }
else if (exp->variant() == ARRAY_REF) else if (exp->variant() == ARRAY_REF)
{ {
@@ -1768,7 +1789,7 @@ static void fillFixedSubscriptsVectorsOfAllVars(SgExpression* exp,
} }
// fixedSubscriptLess checks if left FixedSubscript is less than right // fixedSubscriptLess checks if left FixedSubscript is less than right
static bool fixedSubscriptLess(const FixedSubscript& left, const FixedSubscript& right) static bool fixedSubscriptLess(const ArraySubscript& left, const ArraySubscript& right)
{ {
if (left.isFixed && right.isFixed && left.value < right.value) if (left.isFixed && right.isFixed && left.value < right.value)
return true; return true;
@@ -1789,7 +1810,7 @@ static bool fixedSubscriptLess(const FixedSubscript& left, const FixedSubscript&
// fixedSubscriptLess checks if left and right FixedSubscripts are different, // fixedSubscriptLess checks if left and right FixedSubscripts are different,
// using empirical methods // using empirical methods
static bool possibleDifferent(FixedSubscript left, FixedSubscript right) static bool possibleDifferent(ArraySubscript left, ArraySubscript right)
{ {
// TODO: add warning? // TODO: add warning?
if (left.isFixed && right.isRegIndex && right.regExprStart == right.regExprEnd) { if (left.isFixed && right.isRegIndex && right.regExprStart == right.regExprEnd) {
@@ -1801,7 +1822,7 @@ static bool possibleDifferent(FixedSubscript left, FixedSubscript right)
// isDifferentRefs checks if exp (var reference) is different from var. Refs are different // isDifferentRefs checks if exp (var reference) is different from var. Refs are different
// if they has at least one different fixed subscript: arr(i, 1) is different from arr(j, 2) // if they has at least one different fixed subscript: arr(i, 1) is different from arr(j, 2)
static bool isDifferentRefs(SgExpression* exp, const pair<string, vector<FixedSubscript>>& var, SgStatement* stmt) static bool isDifferentRefs(SgExpression* exp, const pair<string, vector<ArraySubscript>>& var, SgStatement* stmt)
{ {
if (exp->symbol()->identifier() != var.first) if (exp->symbol()->identifier() != var.first)
return true; return true;
@@ -1809,7 +1830,7 @@ static bool isDifferentRefs(SgExpression* exp, const pair<string, vector<FixedSu
if (exp->variant() == VAR_REF) if (exp->variant() == VAR_REF)
return false; return false;
vector<FixedSubscript> leftVec = getFixedSubscriptsVector((SgArrayRefExp*)exp, 0, stmt); vector<ArraySubscript> leftVec = getFixedSubscriptsVector((SgArrayRefExp*)exp, 0, stmt);
if (leftVec.size() != var.second.size()) if (leftVec.size() != var.second.size())
printInternalError(convertFileName(__FILE__).c_str(), __LINE__); printInternalError(convertFileName(__FILE__).c_str(), __LINE__);
@@ -1852,7 +1873,7 @@ static bool checkDefUsePair(Context* ctx, const DefUseStmtsPair& defUse, const C
string arrayName = ctx->arraySymbol->identifier(); string arrayName = ctx->arraySymbol->identifier();
vector<pair<string, vector<FixedSubscript>>> dependOnVars; vector<pair<string, vector<ArraySubscript>>> dependOnVars;
SgArrayRefExp* defRef = (SgArrayRefExp*)defUse.first->expr(0); SgArrayRefExp* defRef = (SgArrayRefExp*)defUse.first->expr(0);
vector<SgArrayRefExp*> arrayUseRefs = getDirectArrayRefsFromSingleStmt(defUse.second, ctx->arraySymbol); vector<SgArrayRefExp*> arrayUseRefs = getDirectArrayRefsFromSingleStmt(defUse.second, ctx->arraySymbol);
for (auto useRef : arrayUseRefs) for (auto useRef : arrayUseRefs)