fix algorythm

src/ArrayConstantPropagation/propagation.cpp

@@ -3,35 +3,14 @@
 #include "../Utils/SgUtils.h"
 
 #include <iostream>
-#include <functional>
 #include <unordered_map>
 #include <unordered_set>
 #include <vector>
 
 using namespace std;
 
-namespace {
+static SgStatement* declPlace = NULL;
-
+static unordered_set<SgStatement*> changed;;
-    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 bool CheckConstIndexes(SgExpression* exp)
 {
@@ -58,152 +37,161 @@ static bool CheckConstIndexes(SgExpression* exp)
 
 static SgExpression* CreateVar(int& variableNumber, SgType* type)
 {
-    string varName = "__tmp_prop_var";
+    string varName = "tmp_prop_var";
     string name = varName + std::to_string(variableNumber) + "__";
     variableNumber++;
 
+    SgSymbol* varSymbol = new SgSymbol(VARIABLE_NAME, name.c_str(), *type, *declPlace->controlParent());
+
+    const string commonBlockName = "propagation_common__";
+
     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;
-
-    const string commonBlockName = "__propagation_common__";
-
-    SgStatement* funcEnd = funcStart->lastNodeOfStmt();
     SgStatement* commonStat = NULL;
     SgExpression* commonList = NULL;
 
-    for (SgStatement* cur = funcStart->lexNext();
+    SgStatement* funcEnd = funcStart->lastNodeOfStmt();
-         cur && cur != funcEnd; cur = cur->lexNext())
+    SgStatement* current = funcStart->lexNext();
+
+    while (current != funcEnd && current)
     {
-        if (cur->variant() != COMM_STAT)
+        if (current->variant() == COMM_STAT)
-            continue;
-
-        for (SgExpression* exp = cur->expr(0); exp; exp = exp->rhs())
         {
-            if (exp->variant() != COMM_LIST)
+            for (SgExpression* exp = current->expr(0); exp; exp = exp->rhs())
-                continue;
-
-            const char* id = exp->symbol() ? exp->symbol()->identifier() : NULL;
-            string existingName = id ? string(id) : string("spf_unnamed");
-            if (existingName == commonBlockName)
             {
-                commonStat = cur;
+                if (exp->variant() == COMM_LIST)
-                commonList = exp;
+                {
-                break;
+                    string existingName = exp->symbol() ?
+                        string(exp->symbol()->identifier()) :
+                        string("spf_unnamed");
+                    if (existingName == commonBlockName)
+                    {
+                        commonStat = current;
+                        commonList = exp;
+                        break;
+                    }
+                }
             }
+            if (commonStat)
+                break;
         }
-        if (commonStat)
+        current = current->lexNext();
-            break;
     }
 
     vector<SgExpression*> varRefs;
-    for (SgSymbol* sym : symbols)
+    if (commonList)
     {
-        if (!sym || sym->variant() != VARIABLE_NAME || string(sym->identifier()) == commonBlockName)
+        SgExpression* varList = commonList->lhs();
-            continue;
+        if (varList)
-        SgSymbol* symToAdd = new SgSymbol(VARIABLE_NAME, sym->identifier(), *sym->type(), *funcStart);
+        {
-        varRefs.push_back(new SgVarRefExp(symToAdd));
+            auto extractSymbol = [](SgExpression* exp) -> SgSymbol* {
-    }
+                if (!exp) 
-    SgExpression* varList = makeExprList(varRefs, false);
+                    return NULL;
-
+                if (exp->symbol()) 
-    SgStatement* insertAfter = FindLastDeclStatement(funcStart);
+                    return exp->symbol();
-    for (SgSymbol* sym : symbols)
+                if (exp->lhs() && exp->lhs()->symbol())
-    {
+                    return exp->lhs()->symbol();
-        SgStatement* declStmt = sym->makeVarDeclStmt();
+                return NULL;
-        if (!declStmt)
+                };
-            continue;
+            if (varList->variant() == EXPR_LIST)
-
+            {
-        if (SgVarDeclStmt* vds = isSgVarDeclStmt(declStmt))
+                for (SgExpression* exp = varList; exp; exp = exp->rhs())
-            vds->setVariant(VAR_DECL_90);
+                {
-
+                    SgExpression* varExp = exp->lhs();
-        declStmt->setFileName(funcStart->fileName());
+                    SgSymbol* sym = extractSymbol(varExp);
-        declStmt->setFileId(funcStart->getFileId());
+                    if (sym)
-        declStmt->setProject(funcStart->getProject());
+                    {
-        declStmt->setlineNumber(getNextNegativeLineNumber());
+                        varRefs.push_back(new SgVarRefExp(sym));
-
+                    }
-        insertAfter->insertStmtAfter(*declStmt, *funcStart);
+                }
-        insertAfter = declStmt;
+            }
-        statementsToRemove.insert(declStmt);
+            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);
+        if (commonStat)
-        commonStat->setFileName(funcStart->fileName());
+        {
-        commonStat->setFileId(funcStart->getFileId());
+            SgExpression* lastCommList = commonStat->expr(0);
-        commonStat->setProject(funcStart->getProject());
+            if (lastCommList)
-        commonStat->setlineNumber(getNextNegativeLineNumber());
+            {
-        commonStat->setExpression(0, commonList);
+                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);
+        st->setExpression(1, arrayToVariable[expUnparsed]->copyPtr());
-        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);
         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())               
+            if (arrayToVariable.find(expUnparsed) == arrayToVariable.end())
-                arrayToVariable[expUnparsed] = CreateVar(variableNumber, subnodes[i]->symbol()->type()->baseType());
+            {                
-
+                arrayToVariable[expUnparsed] = CreateVar(variableNumber, subnodes[i]->symbol()->type()->baseType());;
-            positionsToAdd.insert(declPlace);
+            }
-            SgSymbol* builder = arrayToVariable[expUnparsed]->symbol();
+            toAdd = arrayToVariable[expUnparsed]->copyPtr();
-            auto* sym = new SgSymbol(builder->variant(), builder->identifier(), builder->type(), st->controlParent());
-            toAdd = new SgVarRefExp(sym);
             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);
-        
+        }
     }
 }
 
@@ -249,17 +234,15 @@ static void TransformLeftPart(SgStatement* st, SgExpression* exp, unordered_map<
     {
         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());
+   newStatement->setFileId(st->getFileId());
     newStatement->setProject(st->getProject()); 
 
     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)
@@ -267,8 +250,7 @@ static void TransformBorder(SgStatement* st, SgExpression* exp, unordered_map<st
     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());
-        arrayToVariable[array] = CreateVar(variableNumber, exp->symbol()->type()->baseType());
     while (st != firstStatement)
     {
         if (st->variant() == ASSIGN_STAT && arrayToVariable.find(st->expr(0)->unparse()) != arrayToVariable.end())
@@ -278,7 +260,9 @@ static void TransformBorder(SgStatement* st, SgExpression* exp, unordered_map<st
                 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();
     }
@@ -294,19 +278,16 @@ static void CheckVariable(SgStatement* st, SgExpression* exp, unordered_map<stri
         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();
@@ -323,7 +304,7 @@ void ArrayConstantPropagation(SgProject& project)
 
         if (!file)
             continue;
-        SgFile::switchToFile(file->filename());
+
         const int funcNum = file->numberOfFunctions();
         for (int i = 0; i < funcNum; ++i)
         {
@@ -337,44 +318,25 @@ void ArrayConstantPropagation(SgProject& project)
                 {
                     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);
                         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);
                         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);
                 }
             }
+            cout << file->functions(i)->unparse() << endl;
         }
     }
-    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/CreateInterTree/CreateInterTree.cpp

@@ -17,7 +17,7 @@ using std::fstream;
 static long int getNextTag()
 {
     static long int INTERVAL_TAG = 0;
-    return -(INTERVAL_TAG++);
+    return INTERVAL_TAG++;
 }
 
 //Debug funcs
@@ -413,7 +413,7 @@ static void findIntervals(SpfInterval *interval, map<int, int> &labelsRef, map<i
         inter->lineFile = std::make_pair(currentSt->lineNumber(), currentSt->fileName());
         inter->parent = interval;
         inter->exit_levels.push_back(0);
-        inter->tag = currentSt->lineNumber();//getNextTag();
+        inter->tag = getNextTag();
         interval->nested.push_back(inter);
 
         findIntervals(inter, labelsRef, gotoStmts, currentSt);

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> parNames;
-    map<string, int> parNamesContains;
 
     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) {
+        if (st->variant() == CONTAINS_STMT)
-            isContainsFunctions = true;
+            break;
-            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() == 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 ...
+        if (activeOps.size() && activeOps.find(st) == activeOps.end())
-        //TODO need to use IR for parameters checking
+            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);
     }
 
@@ -90,7 +83,7 @@ static void Collapse(Region* region)
 
     RegionInstruction instruction;
     instruction.def = move(region->array_def);
-
+    
 
     for (auto& byBlock : region->getBasickBlocks())
     {
@@ -114,13 +107,13 @@ static void Collapse(Region* region)
         region->array_priv[arrayName] = useUnionB[arrayName].Diff(region->array_use[arrayName]);
 
     instruction.use = move(region->array_use);
-
+    
     for (Region* prevBlock : region->getHeader()->getPrevRegions())
     {
         prevBlock->replaceInNextRegions(region, region->getHeader());
         region->addPrevRegion(prevBlock);
     }
-
+    
     for (Region* nextBlock : region->getHeader()->getNextRegions())
     {
         nextBlock->replaceInPrevRegions(region, region->getHeader());
@@ -130,7 +123,7 @@ static void Collapse(Region* region)
 
 }
 
-static void SolveDataFlowIteratively(Region* DFG)
+static void SolveDataFlowIteratively(Region* DFG) 
 {
     auto blocks = DFG->getBasickBlocks();
     std::unordered_set<Region*> worklist(blocks.begin(), blocks.end());
@@ -157,7 +150,7 @@ static void SolveDataFlowIteratively(Region* DFG)
                 for (const auto& [arrayName, accessSet] : prevBlock->array_out)
                 {
                     if (newIn.find(arrayName) != newIn.end())
-                        newIn[arrayName] = newIn[arrayName].Intersect(accessSet);
+                        newIn[arrayName] = newIn[arrayName].Intersect(accessSet);                    
                     else
                         newIn[arrayName] = AccessingSet();
                 }
@@ -167,7 +160,7 @@ static void SolveDataFlowIteratively(Region* DFG)
         b->array_in = move(newIn);
         ArrayAccessingIndexes newOut;
 
-        if (b->array_def.empty())
+        if (b->array_def.empty())        
             newOut = b->array_in;
         else if (b->array_in.empty())
             newOut = b->array_def;
@@ -183,11 +176,12 @@ static void SolveDataFlowIteratively(Region* DFG)
         }
 
         /* can not differ */
-        if (newOut != b->array_out)
+        if (newOut != b->array_out) 
             b->array_out = newOut;
         else
             worklist.erase(b);
-    } while (!worklist.empty());
+    } 
+    while (!worklist.empty());
 }
 
 static void SolveForBasickBlock(Region* block)
@@ -288,6 +282,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 +291,43 @@ static bool getArrayDeclaredDimensions(SgArrayRefExp* arrayRef, vector<uint64_t>
     {
         SgExpression* sizeExpr = arrayType->sizeInDim(i);
         SgConstantSymb* constValSymb = isSgConstantSymb(sizeExpr->symbol());
-        SgSubscriptExp* subscriptExpr = isSgSubscriptExp(sizeExpr);
+        string strDimLength;
-        uint64_t dimLength;
         if (sizeExpr && sizeExpr->variant() == INT_VAL)
-            dimLength = stol(sizeExpr->unparse());
+            strDimLength = sizeExpr->unparse();
         else if (constValSymb)
-            dimLength = stol(constValSymb->constantValue()->unparse());
+            strDimLength = constValSymb->constantValue()->unparse();
-        else if (subscriptExpr)
-        {
-            dimLength = stol(subscriptExpr->rhs()->unparse()) - stol(subscriptExpr->lhs()->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(dimCount);
-    vector<uint64_t> declaredDims;
+    if (!getArrayDeclaredDimensions(arrayRef, declaredDims))
-    declaredDims.reserve(dimCount);
+        return false;
-
+    vector<ArrayDimension> testArray(dimCount);
-    DIST::Array* distArr = getDistArrayBySymbol(arrayRef->symbol());
+    for (size_t i = 0; i < dimCount; i++)
-    if (distArr && distArr->GetDimSize() == (int)dimCount)
     {
-        const auto& sizes = distArr->GetSizes();
+        testArray[i] = { 1, 1, declaredDims[i], nullptr };
-        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();
-        }
     }
+    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 +335,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))
@@ -411,7 +365,7 @@ static void AddPrivateArraysToLoop(LoopGraph* loop, const ArrayAccessingIndexes&
         }
         toAdd->setLhs(new SgVarRefExp(elem));
     }
-
+    
     if (arraysToInsert.size() != 0)
     {
         loop->loop->insertStmtBefore(*spfStat, *loop->loop->controlParent());
@@ -419,8 +373,8 @@ static void AddPrivateArraysToLoop(LoopGraph* loop, const ArrayAccessingIndexes&
     }
 }
 
-void FindPrivateArrays(map<string, vector<LoopGraph*>>& loopGraph, map<FuncInfo*, vector<SAPFOR::BasicBlock*>>& FullIR, set<SgStatement*>& insertedPrivates)
+void FindPrivateArrays(map<string, vector<LoopGraph*>> &loopGraph, map<FuncInfo*, vector<SAPFOR::BasicBlock*>>& FullIR, set<SgStatement*> &insertedPrivates)
-{
+{  
     map<LoopGraph*, ArrayAccessingIndexes> result;
     for (const auto& [fileName, loops] : loopGraph)
     {
@@ -434,19 +388,11 @@ void FindPrivateArrays(map<string, vector<LoopGraph*>>& loopGraph, map<FuncInfo*
             while (search_func && (!isSgProgHedrStmt(search_func)))
                 search_func = search_func->controlParent();
 
-            for (const auto& [funcInfo, blocks] : FullIR)
+            for (const auto& [funcInfo, blocks]: FullIR)
-            {
+            {   
                 if (funcInfo->fileName == fileName && funcInfo->funcPointer->GetOriginal() == search_func)
                 {
-                    Region* loopRegion;
+                    Region* loopRegion = new Region(loop, blocks);
-                    try
-                    {
-                        loopRegion = new Region(loop, blocks);
-                    }
-                    catch (...)
-                    {
-                        continue;
-                    }
                     if (loopRegion->getBasickBlocks().size() <= 1)
                     {
                         delete(loopRegion);
@@ -458,24 +404,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/range_structures.cpp

@@ -29,7 +29,7 @@ static ArrayDimension* DimensionIntersection(const ArrayDimension& dim1, const A
     vector<uint64_t> partSolution = FindParticularSolution(dim1, dim2);
     if (partSolution.empty())
         return NULL;
-
+    
     int64_t x0 = partSolution[0], y0 = partSolution[1];
     /* x = x_0 + c * t */
     /* y = y_0 + d * t */
@@ -44,10 +44,10 @@ static ArrayDimension* DimensionIntersection(const ArrayDimension& dim1, const A
     uint64_t tMax = min(tXMax, tYMax);
     if (tMin > tMax)
         return NULL;
-
+    
     uint64_t start3 = dim1.start + x0 * dim1.step;
     uint64_t step3 = c * dim1.step;
-    ArrayDimension* result = new(ArrayDimension){ start3, step3, tMax + 1 , dim1.array };
+    ArrayDimension* result = new(ArrayDimension){ start3, step3, tMax + 1 , dim1.array};
     return result;
 }
 
@@ -57,12 +57,12 @@ static vector<ArrayDimension> DimensionDifference(const ArrayDimension& dim1, co
     ArrayDimension* intersection = DimensionIntersection(dim1, dim2);
     if (!intersection)
         return { dim1 };
-
+    
     vector<ArrayDimension> result;
     /* add the part before intersection */
-    if (dim1.start < intersection->start)
+    if (dim1.start < intersection->start)    
-        result.push_back({ dim1.start, dim1.step, (intersection->start - dim1.start) / dim1.step, dim1.array });
+        result.push_back({ dim1.start, dim1.step, (intersection->start - dim1.start) / dim1.step, dim1.array});
-
+    
     /* add the parts between intersection steps */
     if (intersection->step > dim1.step)
     {
@@ -70,7 +70,7 @@ static vector<ArrayDimension> DimensionDifference(const ArrayDimension& dim1, co
         uint64_t interValue = intersection->start;
         for (int64_t i = start; interValue <= intersection->start + intersection->step * (intersection->tripCount - 1); i++)
         {
-            result.push_back({ interValue + dim1.step, dim1.step, intersection->step / dim1.step, dim1.array });
+            result.push_back({interValue + dim1.step, dim1.step, intersection->step / dim1.step, dim1.array});
             interValue += intersection->step;
         }
     }
@@ -109,7 +109,7 @@ static vector<ArrayDimension> ElementsIntersection(const vector<ArrayDimension>&
 {
     if (firstElement.empty() || secondElement.empty())
         return {};
-
+    
     size_t dimAmount = firstElement.size();
     /* check if there is no intersecction */
     for (size_t i = 0; i < dimAmount; i++)
@@ -136,12 +136,12 @@ static vector<vector<ArrayDimension>> ElementsDifference(const vector<ArrayDimen
         return {};
     if (secondElement.empty())
         return { firstElement };
-
+    
     vector<ArrayDimension> intersection = ElementsIntersection(firstElement, secondElement);
     vector<vector<ArrayDimension>> result;
     if (intersection.empty())
         return { firstElement };
-
+    
     for (int i = 0; i < firstElement.size(); i++)
     {
         auto dimDiff = DimensionDifference(firstElement[i], secondElement[i]);
@@ -293,4 +293,4 @@ bool operator!=(const ArrayAccessingIndexes& lhs, const ArrayAccessingIndexes& r
             return true;
 
     return false;
-}
+}

src/PrivateAnalyzer/region.cpp

@@ -9,6 +9,8 @@
 
 #include "range_structures.h"
 #include "region.h"
+
+#include "..\Transformations\ExpressionSubstitution\expr_transform.h"
 #include "SgUtils.h"
 
 using namespace std;
@@ -62,14 +64,14 @@ static void BuildLoopIndex(map<string, LoopGraph*>& loopForIndex, LoopGraph* loo
 static string FindIndexName(int pos, SAPFOR::BasicBlock* block, map<string, LoopGraph*>& loopForIndex) {
     unordered_set<SAPFOR::Argument*> args = { block->getInstructions()[pos]->getInstruction()->getArg1() };
 
-    for (int i = pos - 1; i >= 0; i--)
+    for (int i = pos - 1; i >= 0; i--) 
     {
         SAPFOR::Argument* res = block->getInstructions()[i]->getInstruction()->getResult();
-        if (res && args.find(res) != args.end())
+        if (res && args.find(res) != args.end()) 
         {
             SAPFOR::Argument* arg1 = block->getInstructions()[i]->getInstruction()->getArg1();
             SAPFOR::Argument* arg2 = block->getInstructions()[i]->getInstruction()->getArg2();
-            if (arg1)
+            if (arg1) 
             {
                 string name = arg1->getValue();
                 int idx = name.find('%');
@@ -93,7 +95,7 @@ static string FindIndexName(int pos, SAPFOR::BasicBlock* block, map<string, Loop
     return "";
 }
 
-static int GetDefUseArray(SAPFOR::BasicBlock* block, LoopGraph* loop, ArrayAccessingIndexes& def, ArrayAccessingIndexes& use, Region* region) {
+static int GetDefUseArray(SAPFOR::BasicBlock* block, LoopGraph* loop, ArrayAccessingIndexes& def, ArrayAccessingIndexes& use, ArrayAccessingIndexes& all_use, Region* region) {
     auto instructions = block->getInstructions();
     map<string, LoopGraph*> loopForIndex;
     BuildLoopIndex(loopForIndex, loop);
@@ -150,8 +152,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;
@@ -166,7 +166,7 @@ static int GetDefUseArray(SAPFOR::BasicBlock* block, LoopGraph* loop, ArrayAcces
                 }
 
             }
-            coeffsForDims = { coeffsForDims.rbegin(), coeffsForDims.rend() };
+            coeffsForDims = {coeffsForDims.rbegin(), coeffsForDims.rend()};
 
             while (!index_vars.empty() && !refPos.empty() && !coeffsForDims.empty())
             {
@@ -180,22 +180,22 @@ static int GetDefUseArray(SAPFOR::BasicBlock* block, LoopGraph* loop, ArrayAcces
                     string name, full_name = var->getValue();
                     int pos = full_name.find('%');
                     LoopGraph* currentLoop;
-                    if (pos != -1)
+                    if (pos != -1) 
                     {
                         name = full_name.substr(pos + 1);
                         if (loopForIndex.find(name) != loopForIndex.end())
-                            currentLoop = loopForIndex[name];
+                            currentLoop = loopForIndex[name];                        
                         else
                             return -1;
                     }
-                    else
+                    else 
                     {
                         name = FindIndexName(currentVarPos, block, loopForIndex);
                         if (name == "")
                             return -1;
 
                         if (loopForIndex.find(name) != loopForIndex.end())
-                            currentLoop = loopForIndex[name];
+                            currentLoop = loopForIndex[name];                        
                         else
                             return -1;
                     }
@@ -206,7 +206,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++;
@@ -227,6 +227,7 @@ static int GetDefUseArray(SAPFOR::BasicBlock* block, LoopGraph* loop, ArrayAcces
                 else
                 {
                     instruction.use[array_name] = { { accessPoint } };
+                    all_use[array_name].Insert(accessPoint);
                     if (def.find(array_name) == def.end())
                         use[array_name].Insert(accessPoint);
                     else
@@ -269,30 +270,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);
+    basikBlocks = result;
-    return true;
 }
 
 static void SetConnections(unordered_map<SAPFOR::BasicBlock*, Region*>& bbToRegion, const unordered_set<SAPFOR::BasicBlock*>& blockSet)
@@ -302,7 +286,7 @@ static void SetConnections(unordered_map<SAPFOR::BasicBlock*, Region*>& bbToRegi
         for (SAPFOR::BasicBlock* nextBlock : block->getNext())
             if (bbToRegion.find(nextBlock) != bbToRegion.end())
                 bbToRegion[block]->addNextRegion(bbToRegion[nextBlock]);
-
+         
         for (SAPFOR::BasicBlock* prevBlock : block->getPrev())
             if (bbToRegion.find(prevBlock) != bbToRegion.end())
                 bbToRegion[block]->addPrevRegion(bbToRegion[prevBlock]);
@@ -315,25 +299,24 @@ static Region* CreateSubRegion(LoopGraph* loop, const vector<SAPFOR::BasicBlock*
     auto [header, blockSet] = GetBasicBlocksForLoop(loop, Blocks);
     RemoveHeaderConnection(header, blockSet, bbToRegion);
     if (bbToRegion.find(header) != bbToRegion.end())
-        region->setHeader(bbToRegion.at(header));
+        region->setHeader(bbToRegion.at(header));    
     else
     {
         printInternalError(convertFileName(__FILE__).c_str(), __LINE__);
         return NULL;
     }
-
+    
     for (SAPFOR::BasicBlock* block : blockSet)
         if (bbToRegion.find(block) != bbToRegion.end())
             region->addBasickBlocks(bbToRegion.at(block));
-
+    
     for (LoopGraph* childLoop : loop->children)
     {
         if (!childLoop->isFor())
             continue;
         region->addSubRegions(CreateSubRegion(childLoop, Blocks, bbToRegion));
     }
-    if (!TopologySort(region->getBasickBlocks(), region->getHeader()))
+    TopologySort(region->getBasickBlocks(), region->getHeader());
-        throw std::runtime_error("Unnoticed cycle");
     return region;
 }
 
@@ -345,7 +328,7 @@ Region::Region(LoopGraph* loop, const vector<SAPFOR::BasicBlock*>& Blocks)
     {
         bbToRegion[poiner] = new Region(*poiner);
         this->basickBlocks.push_back(bbToRegion[poiner]);
-        GetDefUseArray(poiner, loop, bbToRegion[poiner]->array_def, bbToRegion[poiner]->array_use, bbToRegion[poiner]);
+        GetDefUseArray(poiner, loop, bbToRegion[poiner]->array_def, bbToRegion[poiner]->array_use, bbToRegion[poiner]->array_all_use, bbToRegion[poiner]);
 
     }
     this->header = bbToRegion[header];
@@ -357,7 +340,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))
+    TopologySort(basickBlocks, this->header);
-        throw std::runtime_error("Unnoticed cycle");
+}
-}

src/PrivateAnalyzer/region.h

@@ -33,7 +33,7 @@ public:
 
     std::unordered_set<Region*>& getNextRegions() { return nextRegions; }
 
-    void removeNextRegion(Region* region)
+    void removeNextRegion(Region* region) 
     {
         if (nextRegions.find(region) != nextRegions.end())
             nextRegions.erase(region);
@@ -67,7 +67,7 @@ public:
 
     std::vector<RegionInstruction> instructions;
 
-    ArrayAccessingIndexes array_def, array_use, array_out, array_in, array_priv;
+    ArrayAccessingIndexes array_def, array_use, array_out, array_in, array_priv, array_all_use;
 
 private:
     std::vector<Region*> basickBlocks;
@@ -79,6 +79,4 @@ private:
     Region* header;
 };
 
-bool HasCycle(Region* block, const std::unordered_set<Region*>& cycleBlocks, std::unordered_set<Region*>& visitedBlocks);
+void TopologySort(std::vector<Region*>& basikBlocks, Region* header);
-
-bool TopologySort(std::vector<Region*>& basikBlocks, Region* header);

src/Sapfor.cpp

@@ -1,4 +1,4 @@
-#include "Utils/leak_detector.h"
+#include "Utils/leak_detector.h"
 
 #pragma comment(linker, "/STACK:536870912") // 512 МБ
 
@@ -943,7 +943,7 @@ static bool runAnalysis(SgProject &project, const int curr_regime, const bool ne
             }
         }
         else if (curr_regime == MOVE_OPERATORS)        
-            moveOperators(file, fullIR, countOfTransform);
+            moveOperators(file, loopGraph, fullIR, countOfTransform);        
         else if (curr_regime == PRIVATE_REMOVING_ANALYSIS)
         {
             auto itFound = loopGraph.find(file->filename());

src/Transformations/FunctionInlining/inliner.cpp

@@ -1089,8 +1089,6 @@ static int clean(const string& funcName, SgStatement* funcSt, const map<string,
             }
 
             SgGotoStmt* gotoSt = new SgGotoStmt(*contLab);
-            if (st->label())
-                gotoSt->setLabel(*st->label());
             st->insertStmtBefore(*gotoSt, *st->controlParent());
 
             toDelete.push_back(st);

src/Transformations/MoveOperators/move_operators.h

@@ -3,4 +3,4 @@
 #include "../../GraphLoop/graph_loops.h"
 #include "../../CFGraph/CFGraph.h"
 
-void moveOperators(SgFile* file, const std::map<FuncInfo*, std::vector<SAPFOR::BasicBlock*>>& FullIR, int& countOfTransform);
+void moveOperators(SgFile *file, std::map<std::string, std::vector<LoopGraph*>>& loopGraph, const std::map<FuncInfo*, std::vector<SAPFOR::BasicBlock*>>& FullIR, int& countOfTransform);

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

@@ -577,20 +577,10 @@ string removeIncludeStatsAndUnparse(SgFile *file, const char *fileName, const ch
                 for (auto& incl : inclByPos.second)
                     inlcude += (renameIncludes ? renameInclude(incl) : incl);
 
-            //check inserted operators
+            if (st->comments())
-            SgStatement* toInsert = st;
+                st->setComments((inlcude + st->comments()).c_str());
-            do {
-                auto lexPrev = toInsert->lexPrev();
-                if (lexPrev && lexPrev->variant() > 0 && lexPrev->lineNumber() < 0)
-                    toInsert = lexPrev;
-                else
-                    break;                
-            } while (true);
-
-            if (toInsert->comments())
-                toInsert->setComments((inlcude + toInsert->comments()).c_str());
             else
-                toInsert->addComment(inlcude.c_str());
+                st->addComment(inlcude.c_str());
         }
     }
 
@@ -658,7 +648,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 "2465"