change reordering logic

src/ArrayConstantPropagation/propagation.cpp

@@ -3,35 +3,13 @@
 #include "../Utils/SgUtils.h"
 
 #include <iostream>
-#include <functional>
 #include <unordered_map>
 #include <unordered_set>
 #include <vector>
 
 using namespace std;
 
-namespace {
-
-    struct MyHash {
-        size_t operator()(const SgSymbol* s) const {
-            return std::hash<std::string_view>{}(s->identifier());
-        }
-    };
-
-    struct MyEq {
-        bool operator()(const SgSymbol* a, const SgSymbol* b) const {
-            return std::strcmp(a->identifier(), b->identifier()) == 0;
-        }
-    };
-
-}
-
-SgStatement* declPlace = NULL;
-unordered_set<SgStatement*> changed;
-unordered_set<SgSymbol*, MyHash, MyEq> variablesToAdd;
-unordered_set<SgStatement*> positionsToAdd;
-unordered_set<SgStatement*> statementsToRemove;
-unordered_map<string, vector<pair<SgStatement*, SgStatement*>>> expToChange;
+static SgStatement* declPlace = NULL;
 
 static bool CheckConstIndexes(SgExpression* exp)
 {
@@ -62,148 +40,158 @@ static SgExpression* CreateVar(int& variableNumber, SgType* type)
     string name = varName + std::to_string(variableNumber) + "__";
     variableNumber++;
 
-    SgStatement* funcStart = declPlace->controlParent();
-    SgSymbol* varSymbol = new SgSymbol(VARIABLE_NAME, name.c_str(), *type, *funcStart);
-
-    variablesToAdd.insert(varSymbol);
-    positionsToAdd.insert(declPlace);
-
-    return new SgExpression(VAR_REF, NULL, NULL, varSymbol, type->copyPtr());
-}
-
-static SgStatement* FindLastDeclStatement(SgStatement* funcStart)
-{
-    SgStatement* endSt = funcStart->lastNodeOfStmt();
-    SgStatement* cur = funcStart->lexNext();
-    SgStatement* lastDecl = funcStart;
-    const set<int> declVariants = { VAR_DECL, VAR_DECL_90, ALLOCATABLE_STMT, DIM_STAT,
-                                    EXTERN_STAT, COMM_STAT, HPF_TEMPLATE_STAT, DVM_VAR_DECL, STRUCT_DECL };
-
-    while (cur && cur != endSt)
-    {
-        if (cur->variant() == INTERFACE_STMT)
-            cur = cur->lastNodeOfStmt();
-
-        if (declVariants.find(cur->variant()) != declVariants.end())
-            lastDecl = cur;
-        else if (isSgExecutableStatement(cur))
-            break;
-
-        cur = cur->lexNext();
-    }
-
-    return lastDecl;
-}
-
-static void InsertCommonAndDeclsForFunction(SgStatement* funcStart, const unordered_set<SgSymbol*, MyHash, MyEq>& symbols)
-{
-    if (symbols.empty())
-        return;
+    SgSymbol* varSymbol = new SgSymbol(VARIABLE_NAME, name.c_str(), *type, *declPlace->controlParent());
 
     const string commonBlockName = "__propagation_common__";
 
-    SgStatement* funcEnd = funcStart->lastNodeOfStmt();
+    SgStatement* funcStart = declPlace->controlParent();
     SgStatement* commonStat = NULL;
     SgExpression* commonList = NULL;
 
-    for (SgStatement* cur = funcStart->lexNext();
-         cur && cur != funcEnd; cur = cur->lexNext())
+    SgStatement* funcEnd = funcStart->lastNodeOfStmt();
+    SgStatement* current = funcStart->lexNext();
+
+    while (current != funcEnd && current)
     {
-        if (cur->variant() != COMM_STAT)
-            continue;
-
-        for (SgExpression* exp = cur->expr(0); exp; exp = exp->rhs())
+        if (current->variant() == COMM_STAT)
         {
-            if (exp->variant() != COMM_LIST)
-                continue;
-
-            const char* id = exp->symbol() ? exp->symbol()->identifier() : NULL;
-            string existingName = id ? string(id) : string("spf_unnamed");
-            if (existingName == commonBlockName)
+            for (SgExpression* exp = current->expr(0); exp; exp = exp->rhs())
             {
-                commonStat = cur;
-                commonList = exp;
-                break;
+                if (exp->variant() == COMM_LIST)
+                {
+                    string existingName = exp->symbol() ?
+                        string(exp->symbol()->identifier()) :
+                        string("spf_unnamed");
+                    if (existingName == commonBlockName)
+                    {
+                        commonStat = current;
+                        commonList = exp;
+                        break;
+                    }
+                }
             }
+            if (commonStat)
+                break;
         }
-        if (commonStat)
-            break;
+        current = current->lexNext();
     }
 
     vector<SgExpression*> varRefs;
-    for (SgSymbol* sym : symbols)
+    if (commonList)
     {
-        if (!sym || sym->variant() != VARIABLE_NAME || string(sym->identifier()) == commonBlockName)
-            continue;
-        SgSymbol* symToAdd = new SgSymbol(VARIABLE_NAME, sym->identifier(), *sym->type(), *funcStart);
-        varRefs.push_back(new SgVarRefExp(symToAdd));
-    }
-    SgExpression* varList = makeExprList(varRefs, false);
-
-    SgStatement* insertAfter = FindLastDeclStatement(funcStart);
-    for (SgSymbol* sym : symbols)
-    {
-        SgStatement* declStmt = sym->makeVarDeclStmt();
-        if (!declStmt)
-            continue;
-
-        if (SgVarDeclStmt* vds = isSgVarDeclStmt(declStmt))
-            vds->setVariant(VAR_DECL_90);
-
-        declStmt->setFileName(funcStart->fileName());
-        declStmt->setFileId(funcStart->getFileId());
-        declStmt->setProject(funcStart->getProject());
-        declStmt->setlineNumber(getNextNegativeLineNumber());
-
-        insertAfter->insertStmtAfter(*declStmt, *funcStart);
-        insertAfter = declStmt;
-        statementsToRemove.insert(declStmt);
+        SgExpression* varList = commonList->lhs();
+        if (varList)
+        {
+            auto extractSymbol = [](SgExpression* exp) -> SgSymbol* {
+                if (!exp) 
+                    return NULL;
+                if (exp->symbol()) 
+                    return exp->symbol();
+                if (exp->lhs() && exp->lhs()->symbol())
+                    return exp->lhs()->symbol();
+                return NULL;
+                };
+            if (varList->variant() == EXPR_LIST)
+            {
+                for (SgExpression* exp = varList; exp; exp = exp->rhs())
+                {
+                    SgExpression* varExp = exp->lhs();
+                    SgSymbol* sym = extractSymbol(varExp);
+                    if (sym)
+                    {
+                        varRefs.push_back(new SgVarRefExp(sym));
+                    }
+                }
+            }
+            else
+            {
+                for (SgExpression* varExp = varList; varExp; varExp = varExp->rhs())
+                {
+                    SgSymbol* sym = extractSymbol(varExp);
+                    if (sym)
+                    {
+                        varRefs.push_back(new SgVarRefExp(sym));
+                    }
+                }
+            }
+        }
     }
 
     if (!commonList)
     {
+        current = funcStart->lexNext();
+        while (current != funcEnd && current)
+        {
+            if (current->variant() == COMM_STAT)
+            {
+                commonStat = current;
+                break;
+            }
+            current = current->lexNext();
+        }
+
         SgSymbol* commonSymbol = new SgSymbol(COMMON_NAME, commonBlockName.c_str());
-        commonList = new SgExpression(COMM_LIST, varList, NULL, commonSymbol);
+        commonList = new SgExpression(COMM_LIST, NULL, NULL, commonSymbol);
 
-        commonStat = new SgStatement(COMM_STAT);
-        commonStat->setFileName(funcStart->fileName());
-        commonStat->setFileId(funcStart->getFileId());
-        commonStat->setProject(funcStart->getProject());
-        commonStat->setlineNumber(getNextNegativeLineNumber());
-        commonStat->setExpression(0, commonList);
+        if (commonStat)
+        {
+            SgExpression* lastCommList = commonStat->expr(0);
+            if (lastCommList)
+            {
+                while (lastCommList->rhs())
+                    lastCommList = lastCommList->rhs();
+                lastCommList->setRhs(commonList);
+            }
+            else
+            {
+                commonStat->setExpression(0, commonList);
+            }
+        }
+        else
+        {
+            commonStat = new SgStatement(COMM_STAT);
+            commonStat->setFileName(declPlace->fileName());
+            commonStat->setFileId(declPlace->getFileId());
+            commonStat->setProject(declPlace->getProject());
+            commonStat->setlineNumber(getNextNegativeLineNumber());
+            commonStat->setExpression(0, commonList);
+
+            declPlace->insertStmtBefore(*commonStat, *declPlace->controlParent());
+        }
 
-        SgStatement* lastDecl = FindLastDeclStatement(funcStart);
-        lastDecl->insertStmtAfter(*commonStat, *funcStart);
-        statementsToRemove.insert(commonStat);
     }
-    else
+    varRefs.push_back(new SgVarRefExp(varSymbol));
+
+    if (varRefs.size() > 0)
     {
+        std::reverse(varRefs.begin(), varRefs.end());
+        SgExpression* varList = makeExprList(varRefs, false);
+
         commonList->setLhs(varList);
     }
 
+    return new SgExpression(VAR_REF, NULL, NULL, varSymbol, type->copyPtr());
 }
 
 static void TransformRightPart(SgStatement* st, SgExpression* exp, unordered_map<string, SgExpression*>& arrayToVariable, int& variableNumber) 
 {
     if (!exp)
+    {
         return;
+    }
+
     vector<SgExpression*> subnodes = { exp->lhs(), exp->rhs() };
 
     string expUnparsed;
     SgExpression* toAdd = NULL;
     if (exp->variant() == ARRAY_REF && CheckConstIndexes(exp->lhs()))
     {
-        expUnparsed = exp->unparse();
+        cout << st->unparse() << endl;
         if (arrayToVariable.find(expUnparsed) == arrayToVariable.end() && exp->symbol()->type()->baseType())
         {
             arrayToVariable[expUnparsed] = CreateVar(variableNumber, exp->symbol()->type()->baseType());  
         }
-        positionsToAdd.insert(declPlace);
-        SgSymbol* builder = arrayToVariable[expUnparsed]->symbol();
-        auto* sym = new SgSymbol(builder->variant(), builder->identifier(), builder->type(), st->controlParent());
-        auto* newVarExp = new SgVarRefExp(sym);
-        expToChange[st->fileName()].push_back({ st , st->copyPtr() });
-        st->setExpression(1, newVarExp);
+        st->setExpression(1, arrayToVariable[expUnparsed]->copyPtr());
         return;
     }
     for (int i = 0; i < 2; i++)
@@ -211,30 +199,27 @@ static void TransformRightPart(SgStatement* st, SgExpression* exp, unordered_map
         if (subnodes[i] && subnodes[i]->variant() == ARRAY_REF && subnodes[i]->symbol()->type()->baseType() && CheckConstIndexes(subnodes[i]->lhs()))
         {
             expUnparsed = subnodes[i]->unparse();
-            if (arrayToVariable.find(expUnparsed) == arrayToVariable.end())               
-                arrayToVariable[expUnparsed] = CreateVar(variableNumber, subnodes[i]->symbol()->type()->baseType());
-
-            positionsToAdd.insert(declPlace);
-            SgSymbol* builder = arrayToVariable[expUnparsed]->symbol();
-            auto* sym = new SgSymbol(builder->variant(), builder->identifier(), builder->type(), st->controlParent());
-            toAdd = new SgVarRefExp(sym);
+            if (arrayToVariable.find(expUnparsed) == arrayToVariable.end())
+            {                
+                arrayToVariable[expUnparsed] = CreateVar(variableNumber, subnodes[i]->symbol()->type()->baseType());;
+            }
+            toAdd = arrayToVariable[expUnparsed]->copyPtr();
             if (toAdd)
             {
                 if (i == 0)
                 {
-                    expToChange[st->fileName()].push_back({ st , st->copyPtr() });;
                     exp->setLhs(toAdd);
                 }
                 else
                 {
-                    expToChange[st->fileName()].push_back({ st , st->copyPtr() });;
                     exp->setRhs(toAdd);
                 }
             }
         }
         else
+        {
             TransformRightPart(st, subnodes[i], arrayToVariable, variableNumber);
-        
+        }
     }
 }
 
@@ -242,14 +227,11 @@ static void TransformLeftPart(SgStatement* st, SgExpression* exp, unordered_map<
 {
     if (exp->symbol()->type()->variant() == T_STRING)
         return;
-    if (changed.find(st) != changed.end())
-        return;
     string expUnparsed = exp->unparse();
     if (arrayToVariable.find(expUnparsed) == arrayToVariable.end() && exp->symbol()->type()->baseType())
     {
         arrayToVariable[expUnparsed] = CreateVar(variableNumber, exp->symbol()->type()->baseType());
     }
-    positionsToAdd.insert(declPlace);
     SgStatement* newStatement = new SgStatement(ASSIGN_STAT, NULL, NULL, arrayToVariable[expUnparsed]->copyPtr(), st->expr(1)->copyPtr(), NULL);
 
     newStatement->setFileId(st->getFileId());
@@ -258,59 +240,6 @@ static void TransformLeftPart(SgStatement* st, SgExpression* exp, unordered_map<
     newStatement->setlineNumber(getNextNegativeLineNumber());
     newStatement->setLocalLineNumber(st->lineNumber());
     st->insertStmtBefore(*newStatement, *st->controlParent());
-    changed.insert(st);
-    statementsToRemove.insert(newStatement);
-}
-
-static void TransformBorder(SgStatement* st, SgExpression* exp, unordered_map<string, SgExpression*>& arrayToVariable, int& variableNumber)
-{
-    SgStatement* firstStatement = declPlace->lexPrev();
-    st = st->lexPrev();
-    string array = exp->unparse();
-    if (arrayToVariable.find(array) == arrayToVariable.end())
-        arrayToVariable[array] = CreateVar(variableNumber, exp->symbol()->type()->baseType());
-    while (st != firstStatement)
-    {
-        if (st->variant() == ASSIGN_STAT && arrayToVariable.find(st->expr(0)->unparse()) != arrayToVariable.end())
-        {
-            if (st->expr(1))
-            {
-                TransformRightPart(st, st->expr(1), arrayToVariable, variableNumber);
-            }
-            if (st->expr(0) && st->expr(0)->variant() == ARRAY_REF && CheckConstIndexes(st->expr(0)->lhs()) && arrayToVariable.find(st->expr(0)->unparse()) != arrayToVariable.end())
-                TransformLeftPart(st, st->expr(0), arrayToVariable, variableNumber);
-        }
-        st = st->lexPrev();
-    }
-}
-
-static void CheckVariable(SgStatement* st, SgExpression* exp, unordered_map<string, SgExpression*>& arrayToVariable, int& variableNumber)
-{
-    SgStatement* firstStatement = declPlace->lexPrev();
-    st = st->lexPrev();
-    string varName = exp->unparse();
-    while (st != firstStatement)
-    {
-        if (st->variant() == ASSIGN_STAT && st->expr(0)->symbol() == exp->symbol())
-        {
-            TransformRightPart(st, st->expr(1), arrayToVariable, variableNumber);
-            positionsToAdd.insert(declPlace);
-        }
-        if (st->variant() == ASSIGN_STAT && arrayToVariable.find(st->expr(0)->unparse()) != arrayToVariable.end())
-        {
-            if (st->expr(1))
-            {
-                TransformRightPart(st, st->expr(1), arrayToVariable, variableNumber);
-                positionsToAdd.insert(declPlace);
-            }
-            if (st->expr(0) && st->expr(0)->variant() == ARRAY_REF && CheckConstIndexes(st->expr(0)->lhs()) && arrayToVariable.find(st->expr(0)->unparse()) != arrayToVariable.end())
-            {
-                TransformLeftPart(st, st->expr(0), arrayToVariable, variableNumber);
-                positionsToAdd.insert(declPlace);
-            }
-        }
-        st = st->lexPrev();
-    }
 }
 
 void ArrayConstantPropagation(SgProject& project) 
@@ -323,7 +252,7 @@ void ArrayConstantPropagation(SgProject& project)
 
         if (!file)
             continue;
-        SgFile::switchToFile(file->filename());
+
         const int funcNum = file->numberOfFunctions();
         for (int i = 0; i < funcNum; ++i)
         {
@@ -333,48 +262,40 @@ void ArrayConstantPropagation(SgProject& project)
 
             for (; st != lastNode; st = st->lexNext())
             {
-                if (st->variant() == FOR_NODE)
+                if (st->variant() == ASSIGN_STAT)
+                {
+                    if (st->expr(1))
+                    {
+                        TransformRightPart(st, st->expr(1), arrayToVariable, variableNumber);
+                    }
+                    if (st->expr(0) && st->expr(0)->variant() == ARRAY_REF && CheckConstIndexes(st->expr(0)->lhs()))
+                    {
+                        TransformLeftPart(st, st->expr(0), arrayToVariable, variableNumber);
+                    }
+                }
+                else if (st->variant() == FOR_NODE)
                 {
                     SgExpression* lowerBound = st->expr(0)->lhs();
                     SgExpression* upperBound = st->expr(0)->rhs();
-                    SgStatement* boundCopy = NULL;
                     string lowerBoundUnparsed = lowerBound->unparse(), upperBoundUnparsed = upperBound->unparse();
                     if (upperBound->variant() == ARRAY_REF && upperBound->symbol()->type()->baseType() && CheckConstIndexes(upperBound->lhs()))
                     {
-                        boundCopy = st->copyPtr();
-                        TransformBorder(st, upperBound, arrayToVariable, variableNumber);
+                        if (arrayToVariable.find(upperBoundUnparsed) == arrayToVariable.end())
+                        {
+                            arrayToVariable[upperBoundUnparsed] = CreateVar(variableNumber, upperBound->symbol()->type()->baseType());
+                        }
                         st->expr(0)->setRhs(arrayToVariable[upperBoundUnparsed]->copyPtr());
-                        expToChange[st->fileName()].push_back({ st ,boundCopy });;
-                        positionsToAdd.insert(declPlace);
                     }
-                    else if (upperBound->variant() == VAR_REF)
-                        CheckVariable(st, upperBound, arrayToVariable, variableNumber);
-
                     if (lowerBound->variant() == ARRAY_REF && lowerBound->symbol()->type()->baseType() && CheckConstIndexes(lowerBound->lhs()))
                     {
-                        boundCopy = st->copyPtr();
-                        TransformBorder(st, lowerBound, arrayToVariable, variableNumber);
+                        if (arrayToVariable.find(lowerBoundUnparsed) == arrayToVariable.end())
+                        {
+                            arrayToVariable[lowerBoundUnparsed] = CreateVar(variableNumber, lowerBound->symbol()->type()->baseType());
+                        }
                         st->expr(0)->setLhs(arrayToVariable[lowerBoundUnparsed]->copyPtr());
-                        expToChange[st->fileName()].push_back({ st , boundCopy });;
-                        positionsToAdd.insert(declPlace);
                     }
-                    else if (lowerBound->variant() == VAR_REF)
-                        CheckVariable(st, lowerBound, arrayToVariable, variableNumber);
                 }
             }
         }
     }
-    unordered_set<SgStatement*> funcStarts;
-    for (SgStatement* st : positionsToAdd)
-    {
-        SgFile::switchToFile(st->fileName());
-        SgStatement* scope = st->controlParent();
-        if (scope)
-            funcStarts.insert(scope);
-    }
-    for (const auto& st : funcStarts)
-    {
-        SgFile::switchToFile(st->fileName());
-        InsertCommonAndDeclsForFunction(st, variablesToAdd);
-    }
 }

src/ArrayConstantPropagation/propagation.h

@@ -1,20 +1,4 @@
 #pragma once
 #include "../Utils/SgUtils.h"
 
-#include <string>
-#include <vector>
-
-using namespace std;
-
-struct ExprRestoreEntry
-{
-    enum Kind { kStatementExpr, kExprChild };
-    Kind kind;
-    SgStatement* stmt;
-    int stmtExprIndex;
-    SgExpression* parent;
-    bool childIsRhs;
-    SgExpression* savedCopy;
-};
-
 void ArrayConstantPropagation(SgProject& project);

src/GraphCall/graph_calls.cpp

@@ -723,7 +723,7 @@ static void fillIn(FuncInfo *currF, SgExpression *ex, const map<string, int> &pa
 {
     if (ex)
     {
-        if (!isInFuncPar && (ex->variant() == VAR_REF || ex->variant() == ARRAY_REF))
+        if (!isInFuncPar && (ex->variant() == VAR_REF || isArrayRef(ex)))
         {
             const char *name = ex->symbol()->identifier();
             if (name && name != string(""))
@@ -800,58 +800,29 @@ static void fillInOut(FuncInfo *currF, SgStatement *start, SgStatement *last, co
 
     static map<string, vector<int>> supportedKeyWordArg = { {"system_clock", { OUT_BIT, OUT_BIT, OUT_BIT } } };
 
-    map<string, int> parNamesMain;
-    map<string, int> parNamesContains;
+    map<string, int> parNames;
 
     for (int i = 0; i < currF->funcParams.identificators.size(); ++i)
-        parNamesMain[currF->funcParams.identificators[i]] = i;
+        parNames[currF->funcParams.identificators[i]] = i;
 
-    map<string, int>& parNames = parNamesMain;
-
-    bool isContainsFunctions = false;
     for (auto st = start; st != last; st = st->lexNext())
     {
-        if (st->variant() == CONTAINS_STMT) {
-            isContainsFunctions = true;
-            continue;
-        }
-
-        if (isContainsFunctions) {
-            if (st->variant() == PROC_HEDR || st->variant() == FUNC_HEDR) {
-                parNamesContains = parNamesMain;
-                
-                SgProgHedrStmt* hedr = (SgProgHedrStmt*)st;
-
-                int numOfParams = hedr->numberOfParameters();
-                if (numOfParams > 0)
-                {
-                    for (int i = 0; i < numOfParams; ++i)
-                    {
-                        auto it = parNamesContains.find(hedr->parameter(i)->identifier());
-                        if (it != parNamesContains.end())
-                            parNamesContains.erase(it);
-                    }
-                }
-                parNames = parNamesContains;
-            }
-        }
+        if (st->variant() == CONTAINS_STMT)
+            break;
 
         if (st->variant() == ENTRY_STAT)
             continue;
         
         if (isSgExecutableStatement(st) == NULL) {
-            if (!isContainsFunctions)
-                checkInTypeDescription(st->expr(0), currF, parNames);
+            checkInTypeDescription(st->expr(0), currF, parNames);
             continue;
         }
 
         if (st->lineNumber() <= 0)
             continue;
 
-        //XXX: use parameters removing in block ... isContainsFunctions ...
-        //TODO need to use IR for parameters checking
-        /*if (activeOps.size() && activeOps.find(st) == activeOps.end())
-            continue; */
+        if (activeOps.size() && activeOps.find(st) == activeOps.end())
+            continue;
 
         if (st->variant() == ASSIGN_STAT)
         {
@@ -880,7 +851,7 @@ static void fillInOut(FuncInfo *currF, SgStatement *start, SgStatement *last, co
             for (auto ex = read->itemList(); ex; ex = ex->rhs())
             {
                 SgExpression* item = ex->lhs();
-                if (item && (item->variant() == VAR_REF || item->variant() == ARRAY_REF))
+                if (item->variant() == VAR_REF || isArrayRef(item))
                 {
                     string symb = "";
                     if (item->symbol())
@@ -901,7 +872,7 @@ static void fillInOut(FuncInfo *currF, SgStatement *start, SgStatement *last, co
                         if (item->rhs())
                             queue.push(item->rhs());
 
-                        if (item->variant() == VAR_REF || item->variant() == ARRAY_REF)
+                        if (item->variant() == VAR_REF || isArrayRef(item))
                         {
                             string symb = "";
                             if (item->symbol())

src/PrivateAnalyzer/private_arrays_search.cpp

@@ -7,24 +7,16 @@
 #include <numeric>
 #include <iostream>
 
-#include "ArrayConstantPropagation/propagation.h"
-#include "CFGraph/CFGraph.h"
-#include "Distribution/Array.h"
-#include "graph_loops.h"
 #include "private_arrays_search.h"
 #include "range_structures.h"
 #include "region.h"
 #include "SgUtils.h"
+#include "graph_loops.h"
+#include "CFGraph/CFGraph.h"
 #include "utils.h"
-#include "Utils/AstWrapper.h"
 
 using namespace std;
 
-extern std::map<std::tuple<int, std::string, std::string>, std::pair<DIST::Array*, DIST::ArrayAccessInfo*>> declaredArrays;
-
-extern unordered_set<SgStatement*> statementsToRemove;
-extern unordered_map<string, vector<pair<SgStatement*, SgStatement*>>> expToChange;
-
 static unordered_set<Region*> collapsed;
 
 static void RemoveEmptyPoints(ArrayAccessingIndexes& container)
@@ -41,9 +33,10 @@ static void RemoveEmptyPoints(ArrayAccessingIndexes& container)
                 points.push_back(arrayPoint);
         }
 
-        if (!points.empty())
+        if (points.size() < accessingSet.GetElements().size() && !points.empty())
             resultContainer[arrayName] = points;
-        else
+
+        if (points.empty())
             toRemove.insert(arrayName);
     }
 
@@ -288,6 +281,7 @@ static void SolveDataFlow(Region* DFG)
 
 static bool getArrayDeclaredDimensions(SgArrayRefExp* arrayRef, vector<uint64_t>& declaredDims)
 {
+    declaredDims.clear();
     if (!arrayRef || !arrayRef->symbol() || !isSgArrayType(arrayRef->symbol()->type()))
         return false;
     SgArrayType* arrayType = (SgArrayType*)arrayRef->symbol()->type();
@@ -296,83 +290,43 @@ static bool getArrayDeclaredDimensions(SgArrayRefExp* arrayRef, vector<uint64_t>
     {
         SgExpression* sizeExpr = arrayType->sizeInDim(i);
         SgConstantSymb* constValSymb = isSgConstantSymb(sizeExpr->symbol());
-        SgSubscriptExp* subscriptExpr = isSgSubscriptExp(sizeExpr);
-        uint64_t dimLength;
+        string strDimLength;
         if (sizeExpr && sizeExpr->variant() == INT_VAL)
-            dimLength = stol(sizeExpr->unparse());
+            strDimLength = sizeExpr->unparse();
         else if (constValSymb)
-            dimLength = stol(constValSymb->constantValue()->unparse());
-        else if (subscriptExpr)
-        {
-            dimLength = stol(subscriptExpr->rhs()->unparse()) - stol(subscriptExpr->lhs()->unparse());
-        }
+            strDimLength = constValSymb->constantValue()->unparse();
         else
             return false;
 
-        if (dimLength == 0)
+        if (strDimLength == "0")
             return false;
-        declaredDims.push_back(dimLength);
+        declaredDims.push_back((uint64_t)stoi(strDimLength));
     }
     return true;
 }
 
-static DIST::Array* getDistArrayBySymbol(SgSymbol* arrSym)
-{
-    if (!arrSym)
-        return nullptr;
-    for (auto& [key, val] : declaredArrays)
-    {
-        DIST::Array* distArr = val.first;
-        if (!distArr)
-            continue;
-        Symbol* declSym = distArr->GetDeclSymbol();
-        if (!declSym)
-            continue;
-        SgSymbol* sgDecl = declSym->GetOriginal();
-        if (sgDecl && isEqSymbols(sgDecl, arrSym))
-            return distArr;
-    }
-    return nullptr;
-}
-
 static bool CheckDimensionLength(const AccessingSet& array)
 {
     if (array.GetElements().empty())
         return false;
     size_t dimCount = array.GetElements()[0].size();
     SgArrayRefExp* arrayRef = array.GetElements()[0][0].array;
-    if (!arrayRef || !arrayRef->symbol())
+    if (!arrayRef)
         return false;
-
-    vector<uint64_t> declaredDims;
-    declaredDims.reserve(dimCount);
-
-    DIST::Array* distArr = getDistArrayBySymbol(arrayRef->symbol());
-    if (distArr && distArr->GetDimSize() == (int)dimCount)
+    vector<uint64_t> declaredDims(dimCount);
+    if (!getArrayDeclaredDimensions(arrayRef, declaredDims))
+        return false;
+    vector<ArrayDimension> testArray(dimCount);
+    for (size_t i = 0; i < dimCount; i++)
     {
-        const auto& sizes = distArr->GetSizes();
-        bool valid = true;
-        for (size_t i = 0; i < dimCount && valid; ++i)
-        {
-            int lo = sizes[i].first;
-            int hi = sizes[i].second;
-            if (lo > hi)
-                valid = false;
-            else
-                declaredDims.push_back((uint64_t)(hi - lo + 1));
-        }
-        if (valid && declaredDims.size() == dimCount)
-        {
-            vector<ArrayDimension> testArray(dimCount);
-            for (size_t i = 0; i < dimCount; i++)
-                testArray[i] = { 1, 1, declaredDims[i], nullptr };
-            return AccessingSet({ testArray }).Diff(array).GetElements().empty();
-        }
+        testArray[i] = { 1, 1, declaredDims[i], nullptr };
     }
+    AccessingSet diff = AccessingSet({ testArray }).Diff(array);
 
-    return false;
+    return diff.GetElements().empty();
 }
 
+
 static void AddPrivateArraysToLoop(LoopGraph* loop, const ArrayAccessingIndexes& privates, set<SgStatement*>& insertedPrivates)
 {
     SgStatement* spfStat = new SgStatement(SPF_ANALYSIS_DIR);
@@ -380,7 +334,6 @@ static void AddPrivateArraysToLoop(LoopGraph* loop, const ArrayAccessingIndexes&
     spfStat->setFileName(loop->loop->fileName());
     SgExpression* toAdd = new SgExpression(EXPR_LIST, new SgExpression(ACC_PRIVATE_OP), NULL, NULL);
     set<SgSymbol*> arraysToInsert;
-    std::cout << "First bp\n";
     for (const auto& [_, accessingSet] : privates)
     {
         if (!CheckDimensionLength(accessingSet))
@@ -438,15 +391,7 @@ void FindPrivateArrays(map<string, vector<LoopGraph*>>& loopGraph, map<FuncInfo*
             {
                 if (funcInfo->fileName == fileName && funcInfo->funcPointer->GetOriginal() == search_func)
                 {
-                    Region* loopRegion;
-                    try
-                    {
-                        loopRegion = new Region(loop, blocks);
-                    }
-                    catch (...)
-                    {
-                        continue;
-                    }
+                    Region* loopRegion = new Region(loop, blocks);
                     if (loopRegion->getBasickBlocks().size() <= 1)
                     {
                         delete(loopRegion);
@@ -458,24 +403,9 @@ void FindPrivateArrays(map<string, vector<LoopGraph*>>& loopGraph, map<FuncInfo*
                     delete(loopRegion);
                 }
             }
+
             if (result.find(loop) != result.end() && !result[loop].empty())
                 AddPrivateArraysToLoop(loop, result[loop], insertedPrivates);
         }
     }
-
-    for (SgStatement* st : statementsToRemove)
-    {
-        SgFile::switchToFile(st->fileName());
-        st->deleteStmt();
-    }
-
-    for (auto& [filename, statements] : expToChange)
-    {
-        SgFile::switchToFile(filename);
-        for (auto& [statement, statementCopy] : statements) 
-        {
-            statement->insertStmtBefore(*statementCopy, *statement->controlParent());
-            statement->deleteStmt();
-        }
-    }
 }

src/PrivateAnalyzer/region.cpp

@@ -150,8 +150,6 @@ static int GetDefUseArray(SAPFOR::BasicBlock* block, LoopGraph* loop, ArrayAcces
             vector<ArrayDimension> accessPoint(n);
 
             auto* ref = isSgArrayRefExp(instruction->getInstruction()->getExpression());
-            if (!ref)
-                continue;
             int fillCount = 0;
 
             vector<pair<int, int>> coeffsForDims;
@@ -206,7 +204,7 @@ static int GetDefUseArray(SAPFOR::BasicBlock* block, LoopGraph* loop, ArrayAcces
                     current_dim = { start, step, iters, ref };
                 }
 
-                if (current_dim.step != 0 && current_dim.tripCount != 0)
+                if (current_dim.start != 0 && current_dim.step != 0 && current_dim.tripCount != 0)
                 {
                     accessPoint[n - index_vars.size()] = current_dim;
                     fillCount++;
@@ -269,30 +267,13 @@ static void DFS(Region* block, vector<Region*>& result, unordered_set<Region*> c
     result.push_back(block);
 }
 
-bool HasCycle(Region* block, const std::unordered_set<Region*>& cycleBlocks, std::unordered_set<Region*>& visitedBlocks)
+void TopologySort(std::vector<Region*>& basikBlocks, Region* header)
 {
-    if (visitedBlocks.find(block) != visitedBlocks.end())
-        return true;
-    visitedBlocks.insert(block);
-    for (Region* nextBlock : block->getNextRegions())
-    {
-        if (cycleBlocks.find(nextBlock) != cycleBlocks.end() && HasCycle(nextBlock, cycleBlocks, visitedBlocks))
-            return true;
-    }
-    return false;
-}
-
-bool TopologySort(std::vector<Region*>& basikBlocks, Region* header)
-{
-    unordered_set<Region*> cycleBlocks(basikBlocks.begin(), basikBlocks.end());
-    unordered_set<Region*> visitedBlocks;
-    if (HasCycle(header, cycleBlocks, visitedBlocks))
-        return false;
     vector<Region*> result;
+    unordered_set<Region*> cycleBlocks(basikBlocks.begin(), basikBlocks.end());
     DFS(header, result, cycleBlocks);
     reverse(result.begin(), result.end());
-    basikBlocks = move(result);
-    return true;
+    basikBlocks = result;
 }
 
 static void SetConnections(unordered_map<SAPFOR::BasicBlock*, Region*>& bbToRegion, const unordered_set<SAPFOR::BasicBlock*>& blockSet)
@@ -332,8 +313,7 @@ static Region* CreateSubRegion(LoopGraph* loop, const vector<SAPFOR::BasicBlock*
             continue;
         region->addSubRegions(CreateSubRegion(childLoop, Blocks, bbToRegion));
     }
-    if (!TopologySort(region->getBasickBlocks(), region->getHeader()))
-        throw std::runtime_error("Unnoticed cycle");
+    TopologySort(region->getBasickBlocks(), region->getHeader());
     return region;
 }
 
@@ -357,7 +337,6 @@ Region::Region(LoopGraph* loop, const vector<SAPFOR::BasicBlock*>& Blocks)
         if (!childLoop->isFor())
             continue;
         subRegions.insert(CreateSubRegion(childLoop, Blocks, bbToRegion));
-        }
-    if (!TopologySort(basickBlocks, this->header))
-        throw std::runtime_error("Unnoticed cycle");
+    }
+    TopologySort(basickBlocks, this->header);
 }

src/PrivateAnalyzer/region.h

@@ -79,6 +79,4 @@ private:
     Region* header;
 };
 
-bool HasCycle(Region* block, const std::unordered_set<Region*>& cycleBlocks, std::unordered_set<Region*>& visitedBlocks);
-
-bool TopologySort(std::vector<Region*>& basikBlocks, Region* header);
+void TopologySort(std::vector<Region*>& basikBlocks, Region* header);

src/Transformations/MoveOperators/move_operators.cpp

@@ -470,6 +470,8 @@ static bool reorderOperatorsInBasicBlockUsingDeps(SAPFOR::BasicBlock* bb, const
     // as close as possible after its last dependency (if any).
     const auto depsMap = analyzeBasicBlockIntraDependencies(bb);
     vector<SgStatement*> order = ops;
+    const vector<SgStatement*> originalOrder = ops;
+    const int nOrig = (int)originalOrder.size();
 
     auto indexIn = [](const vector<SgStatement*>& v, SgStatement* s) -> int
     {
@@ -479,37 +481,59 @@ static bool reorderOperatorsInBasicBlockUsingDeps(SAPFOR::BasicBlock* bb, const
         return -1;
     };
 
+    auto indexInOriginal = [&](SgStatement* s) -> int
+    {
+        return indexIn(originalOrder, s);
+    };
+
     for (SgStatement* s : ops)
     {
         auto itDeps = depsMap.find(s);
         if (itDeps == depsMap.end() || itDeps->second.empty())
             continue;
 
+        int lastDepOrigIdx = -1;
+        for (SgStatement* dep : itDeps->second)
+        {
+            const int j = indexInOriginal(dep);
+            if (j >= 0)
+                lastDepOrigIdx = max(lastDepOrigIdx, j);
+        }
+        if (lastDepOrigIdx < 0)
+            continue;
+
+        SgStatement* successor = nullptr;
+        if (lastDepOrigIdx + 1 < nOrig)
+            successor = originalOrder[lastDepOrigIdx + 1];
+
         int posS = indexIn(order, s);
         if (posS < 0)
             continue;
 
-        int lastDepIdx = -1;
-        for (SgStatement* dep : itDeps->second)
+        if (successor == nullptr)
         {
-            const int j = indexIn(order, dep);
-            if (j >= 0)
-                lastDepIdx = max(lastDepIdx, j);
+            if (posS == (int)order.size() - 1)
+                continue;
+            order.erase(order.begin() + posS);
+            order.push_back(s);
+            continue;
         }
-        if (lastDepIdx < 0)
+
+        if (successor == s)
             continue;
 
-        if (posS == lastDepIdx + 1)
+        const int posSucc = indexIn(order, successor);
+        if (posSucc < 0)
+            continue;
+
+        if (posS + 1 == posSucc)
             continue;
 
         order.erase(order.begin() + posS);
-
-        int lp = lastDepIdx;
-        if (posS < lastDepIdx)
-            lp = lastDepIdx - 1;
-
-        const int insertAt = lp + 1;
-        order.insert(order.begin() + insertAt, s);
+        const int posSucc2 = indexIn(order, successor);
+        if (posSucc2 < 0)
+            printInternalError(convertFileName(__FILE__).c_str(), __LINE__);
+        order.insert(order.begin() + posSucc2, s);
     }
 
     bool changed = false;

src/Transformations/ReplaceArraysInIO/replace_dist_arrays_in_io.cpp

@@ -504,7 +504,7 @@ static void replaceArrayInFragment(SgSymbol* replace_symb,
     }
 }
 
-static bool ioRegionBorder(SgStatement* stat, SgStatement* last_io_bound)
+static bool ioReginBorder(SgStatement* stat, SgStatement* last_io_bound)
 {
     auto var = stat->variant();
 
@@ -535,24 +535,14 @@ static bool ioRegionBorder(SgStatement* stat, SgStatement* last_io_bound)
     if (last_io_bound && last_io_bound->lastNodeOfStmt() && last_io_bound->lastNodeOfStmt() == stat)
         return true;
 
+    int parent_var;
+
     if (var == CONTROL_END && border_stats.find(stat->controlParent()->variant()) != border_stats.end())
         return true;
 
     return false;
 }
 
-FuncInfo* getCurrentFuncInfo(const vector<FuncInfo*>& fileFuncInfo, int line)
-{
-    for (auto* func : fileFuncInfo)
-    {
-        if (func->linesNum.first <= line && line <= func->linesNum.second)
-            return func;
-    }
-
-    printInternalError(convertFileName(__FILE__).c_str(), __LINE__);
-    return NULL;
-}
-
 void replaceDistributedArraysInIO(vector<ParallelRegion*>& regions,
                                   const map<string, vector<FuncInfo*>>& allFuncInfo,
                                   map<string, vector<Messages>>& SPF_messages,
@@ -572,8 +562,6 @@ void replaceDistributedArraysInIO(vector<ParallelRegion*>& regions,
             if (SgFile::switchToFile(current_file_name) == -1)
                 printInternalError(convertFileName(__FILE__).c_str(), __LINE__);
 
-            FuncInfo *current_func_info = NULL;
-
             auto func_info_it = allFuncInfo.find(current_file_name);
             if (func_info_it == allFuncInfo.end())
                 printInternalError(convertFileName(__FILE__).c_str(), __LINE__);
@@ -600,12 +588,13 @@ void replaceDistributedArraysInIO(vector<ParallelRegion*>& regions,
                 {
                     curr_stmt = lines.stats.first->GetOriginal();
                     end = lines.stats.second->GetOriginal()->lexNext();
-                    current_func_info = getCurrentFuncInfo(func_info_it->second, curr_stmt->lineNumber());
                 }
 
                 map<SgSymbol*, set<SgStatement*>> need_replace;
                 SgStatement* last_io_bound = NULL;
 
+                FuncInfo *current_func_info = NULL;
+
                 while (curr_stmt != end)
                 {
                     if (!curr_stmt)
@@ -615,7 +604,18 @@ void replaceDistributedArraysInIO(vector<ParallelRegion*>& regions,
 
                     if (var == PROC_HEDR || var == PROG_HEDR || var == FUNC_HEDR)
                     {
-                        current_func_info = getCurrentFuncInfo(func_info_it->second, curr_stmt->lineNumber());
+                        current_func_info = NULL;
+                        for (auto *func_info : func_info_it->second)
+                        {
+                            if (func_info->funcName == curr_stmt->symbol()->identifier())
+                            {
+                                current_func_info = func_info;
+                                break;
+                            }
+                        }
+
+                        if (!current_func_info)
+                            printInternalError(convertFileName(__FILE__).c_str(), __LINE__);
 
                         curr_stmt = curr_stmt->lexNext();
                         while (curr_stmt && !isSgExecutableStatement(curr_stmt))
@@ -628,7 +628,7 @@ void replaceDistributedArraysInIO(vector<ParallelRegion*>& regions,
                             break;
                     }
 
-                    if (ioRegionBorder(curr_stmt, last_io_bound))
+                    if (ioReginBorder(curr_stmt, last_io_bound))
                     {
                         for (const auto& by_array_to_copy : need_replace)
                         {

src/Utils/PassManager.h

@@ -318,7 +318,7 @@ void InitPassesDependencies(map<passes, vector<passes>> &passDepsIn, set<passes>
 
     list({ VERIFY_INCLUDES, CORRECT_VAR_DECL }) <= Pass(SET_IMPLICIT_NONE);
 
-    list({ ARRAY_PROPAGATION, CALL_GRAPH2, CALL_GRAPH, BUILD_IR, LOOP_GRAPH, LOOP_ANALYZER_DATA_DIST_S2 }) <= Pass(FIND_PRIVATE_ARRAYS_ANALYSIS);
+    list({ CALL_GRAPH2, CALL_GRAPH, BUILD_IR, LOOP_GRAPH, LOOP_ANALYZER_DATA_DIST_S2 }) <= Pass(FIND_PRIVATE_ARRAYS_ANALYSIS);
     list({ FIND_PRIVATE_ARRAYS_ANALYSIS, CONVERT_LOOP_TO_ASSIGN, RESTORE_LOOP_FROM_ASSIGN, REVERT_SUBST_EXPR_RD }) <= Pass(FIND_PRIVATE_ARRAYS);
 
     list({ BUILD_IR, CALL_GRAPH2, RESTORE_LOOP_FROM_ASSIGN, REVERT_SUBST_EXPR_RD }) <= Pass(MOVE_OPERATORS);

src/Utils/SgUtils.cpp

@@ -658,7 +658,7 @@ string removeIncludeStatsAndUnparse(SgFile *file, const char *fileName, const ch
 
                 if (wasDeleted)
                 {
-                    if (str.size() && str.back() != '\n')
+                    if (str.size() || str.back() != '\n')
                         str += '\n';
                     st->setComments(str.c_str());
                 }

src/Utils/version.h

@@ -1,3 +1,3 @@
 #pragma once
 
-#define VERSION_SPF "2476"
+#define VERSION_SPF "2472"