fixed deps

Reviewed-on: #63

.gitignore

@@ -74,6 +74,8 @@ Sapfor/Sapc++/Sapc++/x64/
 Sapfor/Sapc++/x64/
 
 /build
+/cmake-build-debug
 
 Sapfor/out/
 Sapfor/_bin/*
+_bin/*

CMakeLists.txt

@@ -12,6 +12,7 @@ add_definitions("-D SYS5")
 add_definitions("-D YYDEBUG")
 
 set(CMAKE_CXX_STANDARD 17)
+set(CMAKE_C_STANDARD 17)
 
 set(fdvm_include    projects/dvm/fdvmh/include/fdvmh/)
 set(fdvm_sources    projects/dvm/fdvmh/tools/fdvmh/)
@@ -27,6 +28,14 @@ set(libpred_sources projects/libpredictor/src/)
 set(libpred_include projects/libpredictor/include/)
 
 include_directories(src)
+include_directories(src/Utils)
+include_directories(src/SgUtils)
+include_directories(src/Distribution)
+include_directories(src/GraphCall)
+include_directories(src/GraphLoop)
+include_directories(src/Transformations/ExpressionSubstitution)
+include_directories(src/Transformations)
+
 #Sage lib includes
 include_directories(${fdvm_include})
 include_directories(${sage_include_1})
@@ -113,7 +122,13 @@ set(OMEGA src/SageAnalysisTool/OmegaForSage/add-assert.cpp
         src/SageAnalysisTool/set.cpp)
 
 set(PRIV src/PrivateAnalyzer/private_analyzer.cpp
-        src/PrivateAnalyzer/private_analyzer.h)
+        src/PrivateAnalyzer/private_analyzer.h
+        src/PrivateAnalyzer/private_arrays_search.cpp
+        src/PrivateAnalyzer/private_arrays_search.h
+        src/PrivateAnalyzer/range_structures.cpp
+        src/PrivateAnalyzer/range_structures.h
+        src/PrivateAnalyzer/region.cpp
+        src/PrivateAnalyzer/region.h)
 
 set(FDVM ${fdvm_sources}/acc.cpp
          ${fdvm_sources}/acc_across.cpp
@@ -148,40 +163,53 @@ set(PARALLEL_REG src/ParallelizationRegions/ParRegions.cpp
         src/ParallelizationRegions/resolve_par_reg_conflicts.cpp
         src/ParallelizationRegions/resolve_par_reg_conflicts.h)
 
-set(TR_DEAD_CODE src/Transformations/dead_code.cpp
-        src/Transformations/dead_code.h)
-set(TR_CP src/Transformations/checkpoints.cpp
-        src/Transformations/checkpoints.h)
-set(TR_VECTOR src/Transformations/array_assign_to_loop.cpp
-        src/Transformations/array_assign_to_loop.h)
-set(TR_ENDDO_LOOP src/Transformations/enddo_loop_converter.cpp
-        src/Transformations/enddo_loop_converter.h)
-set(TR_LOOP_NEST src/Transformations/loop_transform.cpp
-        src/Transformations/loop_transform.h)
-set(TR_LOOP_COMB src/Transformations/loops_combiner.cpp
-        src/Transformations/loops_combiner.h)
-set(TR_LOOP_SPLIT src/Transformations/loops_splitter.cpp
-        src/Transformations/loops_splitter.h)
-set(TR_LOOP_UNROLL src/Transformations/loops_unrolling.cpp
-        src/Transformations/loops_unrolling.h)     
-set(TR_PRIV_BR src/Transformations/private_arrays_resizing.cpp
-        src/Transformations/private_arrays_resizing.h)
-set(TR_PRIV_DEL src/Transformations/private_removing.cpp
-        src/Transformations/private_removing.h)
-set(TR_SWAP_ARR_DIMS src/Transformations/swap_array_dims.cpp
-        src/Transformations/swap_array_dims.h)
-set(TR_FUNC_DUP src/Transformations/uniq_call_chain_dup.cpp
-        src/Transformations/uniq_call_chain_dup.h)
-set(TR_FUNC_PURE src/Transformations/function_purifying.cpp
-        src/Transformations/function_purifying.h)  
-set(TR_GV src/Transformations/fix_common_blocks.cpp
-        src/Transformations/fix_common_blocks.h)
-set(TR_CONV src/Transformations/convert_to_c.cpp
-        src/Transformations/convert_to_c.h)
-set(TR_IMPLICIT_NONE src/Transformations/set_implicit_none.cpp
-        src/Transformations/set_implicit_none.h)
-set(TR_REPLACE_ARRAYS_IN_IO src/Transformations/replace_dist_arrays_in_io.cpp
-        src/Transformations/replace_dist_arrays_in_io.h)
+set(ARRAY_PROP src/ArrayConstantPropagation/propagation.cpp
+	src/ArrayConstantPropagation/propagation.h	
+)
+
+set(TR_DEAD_CODE src/Transformations/DeadCodeRemoving/dead_code.cpp
+        src/Transformations/DeadCodeRemoving/dead_code.h)
+set(TR_CP src/Transformations/CheckPoints/checkpoints.cpp
+        src/Transformations/CheckPoints/checkpoints.h)
+set(TR_VECTOR src/Transformations/VectorAssignToLoop/array_assign_to_loop.cpp
+        src/Transformations/VectorAssignToLoop/array_assign_to_loop.h)
+set(TR_ENDDO_LOOP src/Transformations/LoopEndDoConverter/enddo_loop_converter.cpp
+        src/Transformations/LoopEndDoConverter/enddo_loop_converter.h)
+set(TR_LOOP_NEST src/Transformations/LoopNesting/loop_transform.cpp
+        src/Transformations/LoopNesting/loop_transform.h)
+set(TR_LOOP_COMB src/Transformations/LoopCombining/loops_combiner.cpp
+        src/Transformations/LoopCombining/loops_combiner.h)
+set(TR_LOOP_SPLIT src/Transformations/LoopSplitting/loops_splitter.cpp
+        src/Transformations/LoopSplitting/loops_splitter.h)
+set(TR_LOOP_UNROLL src/Transformations/LoopUnrolling/loops_unrolling.cpp
+        src/Transformations/LoopUnrolling/loops_unrolling.h)     
+set(TR_PRIV_BR src/Transformations/PrivateArrayResizing/private_arrays_resizing.cpp
+        src/Transformations/PrivateArrayResizing/private_arrays_resizing.h)
+set(TR_PRIV_DEL src/Transformations/PrivateArrayRemoving/private_removing.cpp
+        src/Transformations/PrivateArrayRemoving/private_removing.h)
+set(TR_SWAP_ARR_DIMS src/Transformations/ArrayDimsSwapping/swap_array_dims.cpp
+        src/Transformations/ArrayDimsSwapping/swap_array_dims.h)
+set(TR_FUNC_DUP src/Transformations/FunctionDuplication/uniq_call_chain_dup.cpp
+        src/Transformations/FunctionDuplication/uniq_call_chain_dup.h)
+set(TR_FUNC_PURE src/Transformations/FunctionPurifying/function_purifying.cpp
+        src/Transformations/FunctionPurifying/function_purifying.h)  
+set(TR_GV src/Transformations/GlobalVariables/fix_common_blocks.cpp
+        src/Transformations/GlobalVariables/fix_common_blocks.h)
+set(TR_CONV src/Transformations/ConvertToC/convert_to_c.cpp
+        src/Transformations/ConvertToC/convert_to_c.h)
+set(TR_IMPLICIT_NONE src/Transformations/SetImplicitNone/set_implicit_none.cpp
+        src/Transformations/SetImplicitNone/set_implicit_none.h)
+set(TR_REPLACE_ARRAYS_IN_IO src/Transformations/ReplaceArraysInIO/replace_dist_arrays_in_io.cpp
+        src/Transformations/ReplaceArraysInIO/replace_dist_arrays_in_io.h)
+set(TR_EXPR_TRANSFORM src/Transformations/ExpressionSubstitution/control_flow_graph_part.cpp
+        src/Transformations/ExpressionSubstitution/expr_transform.cpp
+        src/Transformations/ExpressionSubstitution/expr_transform.h)        
+set(TR_INLINER src/Transformations/FunctionInlining/inliner.cpp
+        src/Transformations/FunctionInlining/inliner.h)
+set(TR_RENAME_SYMBOLS  src/Transformations/RenameSymbols/rename_symbols.cpp
+        src/Transformations/RenameSymbols/rename_symbols.h)
+SET(TR_MOVE_OPERATORS src/Transformations/MoveOperators/move_operators.cpp
+        src/Transformations/MoveOperators/move_operators.h)
 
 set(TRANSFORMS 
         ${TR_DEAD_CODE}
@@ -201,10 +229,16 @@ set(TRANSFORMS
         ${TR_CONV}
         ${TR_PRIV_DEL}
         ${TR_IMPLICIT_NONE}
-        ${TR_REPLACE_ARRAYS_IN_IO})
+        ${TR_REPLACE_ARRAYS_IN_IO}
+        ${TR_EXPR_TRANSFORM}
+        ${TR_INLINER}
+        ${TR_RENAME_SYMBOLS}
+        ${TR_MOVE_OPERATORS})
         
 set(CFG src/CFGraph/IR.cpp
         src/CFGraph/IR.h
+        src/CFGraph/IR_domTree.cpp
+        src/CFGraph/IR_domTree.h
         src/CFGraph/CFGraph.cpp
         src/CFGraph/CFGraph.h
         src/CFGraph/RD_subst.cpp
@@ -282,10 +316,6 @@ set(DYNA src/DynamicAnalysis/createParallelRegions.cpp
         src/DynamicAnalysis/gcov_info.h
         src/DynamicAnalysis/gCov_parser.cpp
         src/DynamicAnalysis/gCov_parser_func.h)
-
-set(EXPR_TRANSFORM src/ExpressionTransform/control_flow_graph_part.cpp
-        src/ExpressionTransform/expr_transform.cpp
-        src/ExpressionTransform/expr_transform.h)
         
 set(GR_CALL src/GraphCall/graph_calls.cpp
         src/GraphCall/graph_calls.h
@@ -297,18 +327,11 @@ set(GR_LOOP src/GraphLoop/graph_loops_base.cpp
         src/GraphLoop/graph_loops.h
         src/GraphLoop/graph_loops_func.h)
         
-set(INLINER src/Inliner/inliner.cpp
-        src/Inliner/inliner.h)
-        
 set(LOOP_ANALYZER  src/LoopAnalyzer/allocations_prepoc.cpp
         src/LoopAnalyzer/dep_analyzer.cpp        
         src/LoopAnalyzer/loop_analyzer.cpp
         src/LoopAnalyzer/loop_analyzer.h)
 
-set(RENAME_SYMBOLS  src/RenameSymbols/rename_symbols.cpp
-                    src/RenameSymbols/rename_symbols.h)
-
-
 set(MAIN src/Sapfor.cpp
         src/Sapfor.h
         src/SapforData.h
@@ -398,15 +421,13 @@ set(SOURCE_EXE
     ${DISTR}
     ${DVMH_REG}
     ${DYNA}
-    ${EXPR_TRANSFORM}
     ${GR_CALL}
     ${GR_LOOP}
-    ${INLINER}
     ${LOOP_ANALYZER}
-    ${RENAME_SYMBOLS}
     ${TRANSFORMS}
     ${PARALLEL_REG}
     ${PRIV}
+    ${ARRAY_PROP}
     ${FDVM}
     ${OMEGA}
     ${UTILS}
@@ -427,7 +448,7 @@ source_group (CFGraph FILES ${CFG})
 source_group (CFGraph\\DataFlow FILES ${DATA_FLOW})
 
 source_group (Transformations\\DeadCodeRemoving FILES ${TR_DEAD_CODE})
-source_group (Transformations\\ExpressionSubstitution FILES ${EXPR_TRANSFORM})
+source_group (Transformations\\ExpressionSubstitution FILES ${TR_EXPR_TRANSFORM})
 source_group (Transformations\\CheckPoints FILES ${TR_CP})
 source_group (Transformations\\LoopEndDoConverter FILES ${TR_ENDDO_LOOP})
 source_group (Transformations\\LoopNesting FILES ${TR_LOOP_NEST})
@@ -435,17 +456,18 @@ source_group (Transformations\\LoopCombining FILES ${TR_LOOP_COMB})
 source_group (Transformations\\LoopSplitting FILES ${TR_LOOP_SPLIT})
 source_group (Transformations\\LoopUnrolling FILES ${TR_LOOP_UNROLL})
 source_group (Transformations\\FunctionDuplication FILES ${TR_FUNC_DUP})
-source_group (Transformations\\FunctionInlining FILES ${INLINER})
+source_group (Transformations\\FunctionInlining FILES ${TR_INLINER})
 source_group (Transformations\\FunctionPurifying FILES ${TR_FUNC_PURE})
 source_group (Transformations\\ArrayDimsSwapping FILES ${TR_SWAP_ARR_DIMS})
 source_group (Transformations\\PrivateArrayResizing FILES ${TR_PRIV_BR})
 source_group (Transformations\\PrivateArrayRemoving FILES ${TR_PRIV_DEL})
 source_group (Transformations\\VectorAssignToLoop FILES ${TR_VECTOR})
-source_group (Transformations\\RenameSymbols FILES ${RENAME_SYMBOLS})
+source_group (Transformations\\RenameSymbols FILES ${TR_RENAME_SYMBOLS})
 source_group (Transformations\\GlobalVariables FILES ${TR_GV})
 source_group (Transformations\\ConvertToC FILES ${TR_CONV})
 source_group (Transformations\\SetImplicitNone FILES ${TR_IMPLICIT_NONE})
 source_group (Transformations\\ReplaceArraysInIO FILES ${TR_REPLACE_ARRAYS_IN_IO})
+source_group (Transformations\\MoveOperators FILES ${TR_MOVE_OPERATORS})
 
 
 source_group (CreateIntervals FILES ${CREATE_INTER_T})
@@ -458,6 +480,7 @@ source_group (GraphLoop FILES ${GR_LOOP})
 source_group (LoopAnalyzer FILES ${LOOP_ANALYZER})
 source_group (ParallelizationRegions FILES ${PARALLEL_REG})
 source_group (PrivateAnalyzer FILES ${PRIV})      
+source_group (ArrayConstantPropagation FILES ${ARRAY_PROP})      
 source_group (FDVM_Compiler FILES ${FDVM})
 source_group (SageExtension FILES ${OMEGA})
 source_group (Utils FILES ${UTILS})
@@ -474,7 +497,7 @@ source_group (Predictor\\Library FILES ${LIBPREDICTOR})
 source_group (Parser FILES ${PARSER})
 source_group (PPPA\\PPPA FILES ${PPPA})
 source_group (PPPA\\ZLib FILES ${ZLIB})
-   
+
 if (MSVC_IDE)   
    set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} /MP /Zc:__cplusplus")
 else()
@@ -483,7 +506,9 @@ else()
     else()
         set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -std=c++11")
     endif()
-   set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -O2")
+    if(NOT CMAKE_BUILD_TYPE)
+        set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -O3")
+    endif()
 endif()
 
 add_subdirectory(projects/Fdvm)

src/ArrayConstantPropagation/propagation.cpp

@@ -0,0 +1,301 @@
+#include "propagation.h"
+
+#include "../Utils/SgUtils.h"
+
+#include <iostream>
+#include <unordered_map>
+#include <unordered_set>
+#include <vector>
+
+using namespace std;
+
+static SgStatement* declPlace = NULL;
+
+static bool CheckConstIndexes(SgExpression* exp)
+{
+    if (!exp)
+    {
+        return true;
+    }
+    SgExpression* lhs = exp->lhs();
+    SgExpression* rhs = exp->rhs();
+    do
+    {
+        if (lhs->variant() != INT_VAL)
+        {
+            return false;
+        }
+        if (rhs)
+        {
+            lhs = rhs->lhs();
+            rhs = rhs->rhs();
+        }
+    } while (rhs);
+    return true;
+}
+
+static SgExpression* CreateVar(int& variableNumber, SgType* type)
+{
+    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();
+    SgStatement* commonStat = NULL;
+    SgExpression* commonList = NULL;
+
+    SgStatement* funcEnd = funcStart->lastNodeOfStmt();
+    SgStatement* current = funcStart->lexNext();
+
+    while (current != funcEnd && current)
+    {
+        if (current->variant() == COMM_STAT)
+        {
+            for (SgExpression* exp = current->expr(0); exp; exp = exp->rhs())
+            {
+                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;
+        }
+        current = current->lexNext();
+    }
+
+    vector<SgExpression*> varRefs;
+    if (commonList)
+    {
+        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, NULL, NULL, commonSymbol);
+
+        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());
+        }
+
+    }
+    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()))
+    {
+        cout << st->unparse() << endl;
+        if (arrayToVariable.find(expUnparsed) == arrayToVariable.end() && exp->symbol()->type()->baseType())
+        {
+            arrayToVariable[expUnparsed] = CreateVar(variableNumber, exp->symbol()->type()->baseType());  
+        }
+        st->setExpression(1, arrayToVariable[expUnparsed]->copyPtr());
+        return;
+    }
+    for (int i = 0; i < 2; i++)
+    {
+        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());;
+            }
+            toAdd = arrayToVariable[expUnparsed]->copyPtr();
+            if (toAdd)
+            {
+                if (i == 0)
+                {
+                    exp->setLhs(toAdd);
+                }
+                else
+                {
+                    exp->setRhs(toAdd);
+                }
+            }
+        }
+        else
+        {
+            TransformRightPart(st, subnodes[i], arrayToVariable, variableNumber);
+        }
+    }
+}
+
+static void TransformLeftPart(SgStatement* st, SgExpression* exp, unordered_map<string, SgExpression*>& arrayToVariable, int& variableNumber)
+{
+    if (exp->symbol()->type()->variant() == T_STRING)
+        return;
+    string expUnparsed = exp->unparse();
+    if (arrayToVariable.find(expUnparsed) == arrayToVariable.end() && exp->symbol()->type()->baseType())
+    {
+        arrayToVariable[expUnparsed] = CreateVar(variableNumber, exp->symbol()->type()->baseType());
+    }
+    SgStatement* newStatement = new SgStatement(ASSIGN_STAT, NULL, NULL, arrayToVariable[expUnparsed]->copyPtr(), st->expr(1)->copyPtr(), NULL);
+
+    newStatement->setFileId(st->getFileId());
+    newStatement->setProject(st->getProject()); 
+
+    newStatement->setlineNumber(getNextNegativeLineNumber());
+    newStatement->setLocalLineNumber(st->lineNumber());
+    st->insertStmtBefore(*newStatement, *st->controlParent());
+}
+
+void ArrayConstantPropagation(SgProject& project) 
+{
+    unordered_map<string, SgExpression*> arrayToVariable;
+    int variableNumber = 0;
+    for (int i = 0; i < project.numberOfFiles(); i++) 
+    {
+        SgFile* file = &(project.file(i));
+
+        if (!file)
+            continue;
+
+        const int funcNum = file->numberOfFunctions();
+        for (int i = 0; i < funcNum; ++i)
+        {
+            SgStatement* st = file->functions(i);
+            declPlace = st->lexNext();
+            SgStatement* lastNode = st->lastNodeOfStmt();
+
+            for (; st != lastNode; st = st->lexNext())
+            {
+                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();
+                    string lowerBoundUnparsed = lowerBound->unparse(), upperBoundUnparsed = upperBound->unparse();
+                    if (upperBound->variant() == ARRAY_REF && upperBound->symbol()->type()->baseType() && CheckConstIndexes(upperBound->lhs()))
+                    {
+                        if (arrayToVariable.find(upperBoundUnparsed) == arrayToVariable.end())
+                        {
+                            arrayToVariable[upperBoundUnparsed] = CreateVar(variableNumber, upperBound->symbol()->type()->baseType());
+                        }
+                        st->expr(0)->setRhs(arrayToVariable[upperBoundUnparsed]->copyPtr());
+                    }
+                    if (lowerBound->variant() == ARRAY_REF && lowerBound->symbol()->type()->baseType() && CheckConstIndexes(lowerBound->lhs()))
+                    {
+                        if (arrayToVariable.find(lowerBoundUnparsed) == arrayToVariable.end())
+                        {
+                            arrayToVariable[lowerBoundUnparsed] = CreateVar(variableNumber, lowerBound->symbol()->type()->baseType());
+                        }
+                        st->expr(0)->setLhs(arrayToVariable[lowerBoundUnparsed]->copyPtr());
+                    }
+                }
+            }
+        }
+    }
+}

src/ArrayConstantPropagation/propagation.h

@@ -0,0 +1,4 @@
+#pragma once
+#include "../Utils/SgUtils.h"
+
+void ArrayConstantPropagation(SgProject& project);

src/CFGraph/CFGraph.cpp

@@ -1,5 +1,5 @@
 #define _LEAK_
-#include "../Utils/leak_detector.h"
+#include "leak_detector.h"
 
 #include <stdlib.h>
 #include <stdio.h>
@@ -8,9 +8,9 @@
 #include <chrono>
 #include <functional>
 
-#include "../Utils/SgUtils.h"
-#include "../Utils/CommonBlock.h"
-#include "../GraphCall/graph_calls.h"
+#include "SgUtils.h"
+#include "CommonBlock.h"
+#include "graph_calls.h"
 
 #include "dvm.h"
 #include "IR.h"
@@ -1149,9 +1149,22 @@ map<FuncInfo*, vector<BBlock*>> buildCFG(const map<string, CommonBlock*>& common
     if (settings.withRD)
         buildReachingDefs(result, settings);
 
+    if (settings.withDominators)
+    {
+        auto t = high_resolution_clock::now();
+        for (auto& [func, bblocks] : result)
+            SAPFOR::buildDominatorTree(bblocks);
+
+        auto msec = duration_cast<milliseconds>(high_resolution_clock::now() - t).count();
+        __spf_print(1, "    dominator build time is %.3f sec\n", msec / 1000.);
+    }
+
     if (SgFile::switchToFile(oldFile) == -1)
         printInternalError(convertFileName(__FILE__).c_str(), __LINE__);
 
+    for (auto& [func, blocks] : result)
+        removedUnreachableBlocks(blocks);
+
     return result;
 }
 
@@ -1226,4 +1239,49 @@ map<FuncInfo*, vector<SAPFOR::BasicBlock*>>
             fileFuncInfoMap[callFrom->fileName].push_back(callFrom);
 
     return buildCFG(commonBlocks, fileFuncInfoMap, settings);
+}
+
+
+void removedUnreachableBlocks(vector<SAPFOR::BasicBlock*>& blocks)
+{
+    set<SAPFOR::BasicBlock*> reachable;
+
+    for (auto& b : blocks)
+        if (b->getInstructions().front()->isHeader() ||
+            b->getInstructions().front()->getInstruction()->getOperation() == SAPFOR::CFG_OP::ENTRY)
+            reachable.insert(b);
+
+    set<SAPFOR::BasicBlock*> worklist = reachable;
+    while (worklist.size() != 0)
+    {
+        set<SAPFOR::BasicBlock*> to_insert;
+
+        for (auto& b : worklist)
+            for (auto& next : b->getNext())
+                if (reachable.insert(next).second)
+                    to_insert.insert(next);
+
+        worklist = to_insert;
+    }
+
+    auto remove_unreachable_it = remove_if(blocks.begin(), blocks.end(),
+        [&reachable](SAPFOR::BasicBlock* b)
+        {
+            if (reachable.find(b) == reachable.end())
+            {
+                for (auto& next : b->getNext())
+                    if (reachable.find(next) != reachable.end())
+                        next->removePrev(b);
+
+                delete b;
+                return true;
+            }
+
+            return false;
+        }
+    );
+
+    reachable.clear();
+
+    blocks.erase(remove_unreachable_it, blocks.end());
 }

src/CFGraph/CFGraph.h

@@ -6,6 +6,7 @@
 #include <vector>
 
 #include "IR.h"
+#include "IR_domTree.h"
 
 namespace SAPFOR
 {
@@ -24,7 +25,7 @@ namespace SAPFOR
 
         std::vector<BasicBlock*> next;
         std::vector<BasicBlock*> prev;
-        
+        BasicBlock* directDominator = NULL;
         //reaching definition
         std::map<SAPFOR::Argument*, std::set<int>> RD_in, RD_out;
 
@@ -34,6 +35,7 @@ namespace SAPFOR
         bool addLive(const std::map<SAPFOR::Argument*, std::vector<SAPFOR::BasicBlock*>>& to_add, bool in);
         std::map<SAPFOR::Argument*, std::vector<SAPFOR::BasicBlock*>> getLive(bool in) const;
         bool removeLive(SAPFOR::Argument* to_remove, bool in);
+
     public:
         BasicBlock() { num = lastNumBlock++; }
         BasicBlock(IR_Block* item);
@@ -42,6 +44,7 @@ namespace SAPFOR
         void addInstruction(IR_Block* item);
         void addPrev(BasicBlock* prev_) { prev.push_back(prev_); }
         void addNext(BasicBlock* next_) { next.push_back(next_); }
+        void setDom(BasicBlock* dom) { directDominator = dom; }
 
         int removePrev(BasicBlock* removed);
         int removeNext(BasicBlock* removed);
@@ -69,7 +72,11 @@ namespace SAPFOR
         const std::vector<IR_Block*>& getInstructions() const { return instructions; }
         const std::vector<BasicBlock*>& getNext() const { return next; }
         const std::vector<BasicBlock*>& getPrev() const { return prev; }
-        
+        BasicBlock* getDom() const 
+        {
+            return directDominator; 
+        }
+
         /*
         *  FOR LIVE ANALYSIS
         */                
@@ -105,13 +112,15 @@ namespace SAPFOR
         bool withDVM = false;
         bool withCallsInBlocks = false; // separate each F_CALL to own BasicBlock
         bool withCallFrom = true;
+        bool withDominators = true;
 
         explicit CFG_Settings(int) { }
 
         explicit CFG_Settings(bool atLeastOneIterInLoop = false, bool withRD = true, bool withRegisters = false, 
-                              bool withDVM = false, bool withSPF = false, bool withCallsInBlocks = false, bool withCallFrom = true) :
+                              bool withDVM = false, bool withSPF = false, bool withCallsInBlocks = false, 
+                              bool withCallFrom = true, bool withDominators = true) :
             atLeastOneIterInLoop(atLeastOneIterInLoop), withRD(withRD), withRegisters(withRegisters), withDVM(withDVM), withSPF(withSPF), 
-            withCallsInBlocks(withCallsInBlocks), withCallFrom(withCallFrom)
+            withCallsInBlocks(withCallsInBlocks), withCallFrom(withCallFrom), withDominators(withDominators)
         { }
     };
 }
@@ -146,4 +155,6 @@ static inline void deleteCFG(std::map<FuncInfo*, std::vector<SAPFOR::BasicBlock*
         byFunc.second.clear();
     }
     cfg.clear();
-}
+}
+
+void removedUnreachableBlocks(std::vector<SAPFOR::BasicBlock*>& blocks);

src/CFGraph/DataFlow/backward_data_flow.h

@@ -5,7 +5,7 @@
 #include <set>
 #include <algorithm>
 
-#include "../../Utils/SgUtils.h"
+#include "SgUtils.h"
 #include "../CFGraph.h"
 #include "../IR.h"
 

src/CFGraph/DataFlow/backward_data_flow_impl.h

@@ -5,7 +5,7 @@
 #include <set>
 #include <algorithm>
 
-#include "../../Utils/SgUtils.h"
+#include "SgUtils.h"
 #include "../CFGraph.h"
 #include "../IR.h"
 #include "../RD_subst.h"

src/CFGraph/DataFlow/data_flow.h

@@ -2,7 +2,7 @@
 #include<vector>
 #include<set>
 
-#include "../../Utils/SgUtils.h"
+#include "SgUtils.h"
 #include "../CFGraph.h"
 #include "../IR.h"
 

src/CFGraph/DataFlow/data_flow_impl.h

@@ -4,7 +4,7 @@
 #include<vector>
 #include<set>
 
-#include "../../Utils/SgUtils.h"
+#include "SgUtils.h"
 #include "../CFGraph.h"
 #include "../IR.h"
 

src/CFGraph/IR.cpp

@@ -1,14 +1,14 @@
-#include "../Utils/leak_detector.h"
+#include "leak_detector.h"
 
 #include <stdlib.h>
 #include <stdio.h>
 #include <vector>
 #include <set>
 
-#include "../Utils/SgUtils.h"
-#include "../Utils/CommonBlock.h"
-#include "../GraphCall/graph_calls.h"
-#include "../ExpressionTransform/expr_transform.h"
+#include "SgUtils.h"
+#include "CommonBlock.h"
+#include "graph_calls.h"
+#include "expr_transform.h"
 
 #include "dvm.h"
 #include "IR.h"
@@ -395,7 +395,7 @@ static SAPFOR::Argument* processExpression(SgExpression* ex, vector<IR_Block*>&
     if (ex)
     {
         const int var = ex->variant();
-        if ((var == VAR_REF || var == CONST_REF || var == LABEL_REF) && !ex->lhs() && !ex->rhs()) // îáðàùåíèå ê ïåðåìåííîé
+        if ((var == VAR_REF || var == CONST_REF || var == LABEL_REF) && !ex->lhs() && !ex->rhs()) // variable reference
         {
             if (var == CONST_REF)
             {
@@ -450,7 +450,7 @@ static SAPFOR::Argument* processExpression(SgExpression* ex, vector<IR_Block*>&
                 return arg1;
 
             auto reg = isLeft ? NULL : createRegister();
-            Instruction* instr = new Instruction(isLeft ? CFG_OP::STORE : CFG_OP::LOAD, arg1, createConstArg(numArgs), isLeft ? isLeft : reg);
+            Instruction* instr = new Instruction(isLeft ? CFG_OP::STORE : CFG_OP::LOAD, arg1, createConstArg(numArgs), isLeft ? isLeft : reg, NULL, ex);
             blocks.push_back(new IR_Block(instr));
             return reg;
         }
@@ -485,7 +485,7 @@ static SAPFOR::Argument* processExpression(SgExpression* ex, vector<IR_Block*>&
             auto arg1 = arrayRef ? arrayRef : createArrayArg(ref, blocks, func, numArgs, commonVars);
 
             auto reg = isLeft ? NULL : createRegister();
-            instr = new Instruction(isLeft ? CFG_OP::STORE : CFG_OP::LOAD, arg1, createConstArg(1), isLeft ? isLeft : reg);
+            instr = new Instruction(isLeft ? CFG_OP::STORE : CFG_OP::LOAD, arg1, createConstArg(1), isLeft ? isLeft : reg, NULL, ex);
             blocks.push_back(new IR_Block(instr));
             return reg;
         }
@@ -602,7 +602,7 @@ static SAPFOR::Argument* processExpression(SgExpression* ex, vector<IR_Block*>&
                 {
                     if (returnReg == NULL)
                     {
-                        Instruction* instr = new Instruction(CFG_OP::LOAD, arg, NULL, reg);
+                        Instruction* instr = new Instruction(CFG_OP::LOAD, arg, NULL, reg, NULL, ex);
                         blocks.push_back(new IR_Block(instr));
                     }
                     else
@@ -1572,7 +1572,7 @@ vector<IR_Block*> buildIR(SgStatement* function, const FuncInfo* func, const vec
     else
         findReturn(0, blocks.size(), blocks, blocks.back()->getNumber());
 
-    // äîáàâëåíèå ñâÿçåé ïî GOTO è ïåðåõîäàì
+    // adding links by GOTO and jumps
     for (int z = 0; z < blocks.size(); ++z)
     {
         auto op = blocks[z]->getInstruction()->getOperation();
@@ -1592,7 +1592,7 @@ vector<IR_Block*> buildIR(SgStatement* function, const FuncInfo* func, const vec
 
                 blocks[z]->setJump(it->second);
 
-                // çàìåíèì ìåòêó íà íîìåð èíñòðóêöèè
+                // replacing the label with the instruction number
                 arg->setValue(to_string(it->second->getNumber())); 
                 arg->setType(CFG_ARG_TYPE::INSTR);
             }

src/CFGraph/IR.h

@@ -6,7 +6,7 @@
 #include <algorithm>
 
 #include "CFGraph.h"
-#include "../Utils/CommonBlock.h"
+#include "CommonBlock.h"
 
 namespace SAPFOR
 {

src/CFGraph/IR_domTree.cpp

@@ -0,0 +1,102 @@
+#include "dvm.h"
+#include "IR_domTree.h"
+
+namespace SAPFOR {
+    void DominatorFinder::DFS(BasicBlock* v, int parent_num) {
+        dfs_num[v] = n;
+        vertex[n] = n;
+        semi[n] = n;
+        label[n] = n;
+        ancestor[n] = -1;
+        parent[n] = parent_num;
+        vertices[n++] = v;
+
+        for (const auto& w : v->getNext()) {
+            if (dfs_num[w] == -1)
+                DFS(w, dfs_num[v]);
+        }
+    }
+
+    void DominatorFinder::Compress(int v) {
+        if (ancestor[ancestor[v]] != -1) {
+            Compress(ancestor[v]);
+
+            if (semi[label[ancestor[v]]] < semi[label[v]])
+                label[v] = label[ancestor[v]];
+            ancestor[v] = ancestor[ancestor[v]];
+        }
+    }
+
+    int DominatorFinder::Eval(int v) {
+        if (ancestor[v] == -1) 
+            return v;
+
+        Compress(v);
+        return label[v];
+    }
+
+    void DominatorFinder::Link(int v, int w) {
+        ancestor[w] = v;
+    }
+
+    DominatorFinder::DominatorFinder(std::vector<BasicBlock*>& blocks) {
+        if (blocks.empty()) 
+            return;
+
+        entry = blocks[0];
+        n = 0;
+
+        for (auto block : blocks) 
+            dfs_num[block] = -1;
+
+        int max_size = blocks.size();
+        vertices.resize(max_size);
+        parent.assign(max_size, -1);
+        semi.assign(max_size, -1);
+        vertex.assign(max_size, -1);
+        ancestor.assign(max_size, -1);
+        label.assign(max_size, -1);
+        bucket.resize(max_size);
+
+        DFS(entry, -1);
+
+        for (int i = n - 1; i > 0; --i) {
+            int w = vertex[i];
+
+            for (BasicBlock* v : vertices[w]->getPrev()) {
+                if (dfs_num[v] == -1)
+                    continue;
+                int u = Eval(dfs_num[v]);
+
+                if (semi[u] < semi[w])
+                    semi[w] = semi[u];
+            }
+
+            bucket[vertex[semi[w]]].push_back(w);
+            Link(parent[w], w);
+
+            for (int v : bucket[parent[w]])
+            {
+                int u = Eval(v);
+                if (semi[u] < semi[v])
+                    vertices[v]->setDom(vertices[u]);
+                else
+                    vertices[v]->setDom(vertices[parent[w]]);
+            }
+            bucket[parent[w]].clear();
+        }
+
+        for (int i = 1; i < n; ++i) {
+            int w = vertex[i];
+
+            if (vertices[w]->getDom() != vertices[vertex[semi[w]]])
+                vertices[w]->setDom(vertices[w]->getDom()->getDom());
+        }
+
+        entry->setDom(nullptr);
+    }
+
+    void buildDominatorTree(std::vector<BasicBlock*>& blocks) {
+        DominatorFinder finder(blocks);
+    }
+}

src/CFGraph/IR_domTree.h

@@ -0,0 +1,35 @@
+#pragma once
+
+#include <vector>
+#include <map>
+#include <unordered_map>
+
+#include "CFGraph.h"
+
+// Lengauer, Thomas. A fast algorithm for finding dominators in a flowgraph / Thomas Lengauer, Robert Endre Tarjan 
+// ACM Transactions on Programming Languages and Systems (TOPLAS). — 1979. — Vol. 1, no. 1. — Pp. 121–141.
+
+namespace SAPFOR {
+
+class BasicBlock;
+
+class DominatorFinder {
+private:
+    BasicBlock* entry;
+    std::vector<BasicBlock*> vertices;
+    std::unordered_map<BasicBlock*, int> dfs_num;
+    std::vector<int> parent, semi, vertex, ancestor, label;
+    std::vector<std::vector<int>> bucket;
+    int n;
+
+    void DFS(BasicBlock* v, int parent_num);
+    void Compress(int v);
+    int  Eval(int v);
+    void Link(int v, int w);
+
+public:
+    DominatorFinder(std::vector<BasicBlock*>& blocks);
+};
+
+void buildDominatorTree(std::vector<BasicBlock*>& blocks);
+}

src/CFGraph/RD_subst.cpp

@@ -8,10 +8,10 @@
 #include <unordered_map>
 #include <unordered_set>
 
-#include "../Utils/SgUtils.h"
-#include "../Utils/CommonBlock.h"
-#include "../GraphCall/graph_calls.h"
-#include "../ExpressionTransform/expr_transform.h"
+#include "SgUtils.h"
+#include "CommonBlock.h"
+#include "graph_calls.h"
+#include "expr_transform.h"
 
 #define PRINT_PROF_INFO 0
 #define DEBUG_CHECKS 0

src/CFGraph/RD_subst.h

@@ -2,9 +2,9 @@
 
 #include<unordered_map>
 
-#include "../Utils/SgUtils.h"
-#include "../Utils/CommonBlock.h"
-#include "../GraphCall/graph_calls.h"
+#include "SgUtils.h"
+#include "CommonBlock.h"
+#include "graph_calls.h"
 
 #include "CFGraph.h"
 #include "IR.h"

src/CFGraph/live_variable_analysis.h

@@ -1,6 +1,6 @@
 #pragma once
 
-#include "../Utils/SgUtils.h"
+#include "SgUtils.h"
 #include "CFGraph.h"
 
 namespace LIVE_VARIABLES

src/CFGraph/private_variables_analysis.cpp

@@ -1,6 +1,6 @@
-#include "../Utils/errors.h"
+#include "errors.h"
 #include "private_variables_analysis.h"
-#include "../GraphLoop/graph_loops.h"
+#include "graph_loops.h"
 #include "../LoopAnalyzer/loop_analyzer.h"
 #include "../SageAnalysisTool/depGraph.h"
 #include "../DirectiveProcessing/directive_parser.h"
@@ -200,20 +200,46 @@ static void fillOutForFunc(const FuncInfo* func, const vector<SAPFOR::BasicBlock
     outForFunc[func->funcName] = { defined, common_defined };
 }
 
-static void getDefsFromBlock(SAPFOR::BasicBlock* block, set<SAPFOR::Argument*>& res, 
+static bool isInstructionSpfParameter(SAPFOR::Instruction* instr)
+{
+    SgStatement* st = instr->getOperator();
+
+    // check if this operator is SPF(ANALYSIS(PARAMETER( )))
+    if (st && st->variant() == ASSIGN_STAT)
+    {
+        if (st->lineNumber() < 0 && st->numberOfAttributes())
+        {
+            for (int i = 0; i < st->numberOfAttributes(); ++i)
+            {
+                SgAttribute* attr = st->getAttribute(i);
+                SgStatement* attributeStatement = (SgStatement*)(attr->getAttributeData());
+                int type = st->attributeType(i);
+
+                if (type == SPF_PARAMETER_OP)
+                    return true;
+            }
+        }
+    }
+    return false;
+}
+
+static void getDefsFromBlock(SAPFOR::BasicBlock* block, set<SAPFOR::Argument*>& res,
                              const vector<pair<const Variable*, CommonBlock*>>& commonVars,
                              const FuncInfo* func)
 {
     vector<SAPFOR::Argument*> lastParamRef;
 
-    for (auto ir_block : block->getInstructions())
+    for (const auto &ir_block : block->getInstructions())
     {
         SAPFOR::Instruction* instr = ir_block->getInstruction();
+        if (isInstructionSpfParameter(instr))
+            continue;
+
         SAPFOR::CFG_OP instr_operation = instr->getOperation();
         if (instr_operation == SAPFOR::CFG_OP::PARAM)
         {
             SAPFOR::Argument* arg = instr->getArg1();
-            if(arg->getType() == SAPFOR::CFG_ARG_TYPE::VAR)
+            if (arg->getType() == SAPFOR::CFG_ARG_TYPE::VAR)
                 addPlaceWithDef(commonVars, func, arg, instr);
 
             lastParamRef.push_back(arg);
@@ -236,12 +262,20 @@ static void getDefsFromBlock(SAPFOR::BasicBlock* block, set<SAPFOR::Argument*>&
     int last_instr_num = block->getInstructions().back()->getNumber();
 
     for (const auto& def : block->getRD_Out())
+    {
         for (int place : def.second)
+        {
             if (place >= first_instr_num && place <= last_instr_num && def.first->getType() == SAPFOR::CFG_ARG_TYPE::VAR)
             {
+                SAPFOR::Instruction* instr = block->getInstructions()[place - first_instr_num]->getInstruction();
+                if (isInstructionSpfParameter(instr))
+                    continue;
+
                 res.insert(def.first);
-                addPlaceWithDef(commonVars, func, def.first, block->getInstructions()[place - first_instr_num]->getInstruction());
+                addPlaceWithDef(commonVars, func, def.first, instr);
             }
+        }
+    }
 }
 
 // recursively analyze FOR loops 
@@ -250,7 +284,7 @@ static set<SAPFOR::BasicBlock*> analyzeLoop(LoopGraph* loop, const set<SAPFOR::B
                                             const map<string, SgSymbol*>& commonArgs, FuncInfo* func,
                                             map<string, vector<Messages>>& messages)
 {
-    if (!loop->isFor)
+    if (!loop->isFor())
         printInternalError(convertFileName(__FILE__).c_str(), __LINE__); //should be called only with FOR loops
 
     SgStatement* loop_operator = loop->loop->GetOriginal();
@@ -266,7 +300,7 @@ static set<SAPFOR::BasicBlock*> analyzeLoop(LoopGraph* loop, const set<SAPFOR::B
     SAPFOR::BasicBlock* head_block = NULL;
 
     int loop_start = loop->lineNum, loop_end = loop->lineNumAfterLoop;
-    for (auto bb : blocks)
+    for (const auto &bb : blocks)
     {
         if (!bb || (bb->getInstructions().size() == 0))
             continue;
@@ -348,7 +382,7 @@ static set<SAPFOR::BasicBlock*> analyzeLoop(LoopGraph* loop, const set<SAPFOR::B
         getDefsFromBlock(*loop_it, changeValueOnExit, commonVars, func);
 
 
-    for (auto bb : currentLoop)
+    for (const auto &bb : currentLoop)
     {
         //fill LiveWhenLoopEnds
         bool has_next_outside_body = false;
@@ -450,7 +484,7 @@ static void recAnalyzeLoop(LoopGraph* loop, const set<SAPFOR::BasicBlock*>& bloc
                            const map<string, SgSymbol*>& commonArgs,
                            FuncInfo* func, map<string, vector<Messages>>& messages)
 {
-    const auto& loop_body = loop->isFor ? analyzeLoop(loop, blocks, commonVars, commonArgs, func, messages) : blocks;
+    const auto& loop_body = loop->isFor() ? analyzeLoop(loop, blocks, commonVars, commonArgs, func, messages) : blocks;
     
     for (const auto& inner_loop : loop->children)
         recAnalyzeLoop(inner_loop, loop_body, commonVars, commonArgs, func, messages);

src/CFGraph/private_variables_analysis.h

@@ -1,5 +1,5 @@
-#include "../Utils/SgUtils.h"
-#include "../GraphLoop/graph_loops.h"
+#include "SgUtils.h"
+#include "graph_loops.h"
 #include "CFGraph.h"
 
 #include <string>

src/CreateInterTree/CreateInterTree.cpp

@@ -1,7 +1,7 @@
 #include "CreateInterTree.h"
-#include "../Utils/SgUtils.h"
-#include "../Utils/utils.h"
-#include "../GraphCall/graph_calls_func.h"
+#include "SgUtils.h"
+#include "utils.h"
+#include "graph_calls_func.h"
 
 using std::string;
 using std::wstring;

src/CreateInterTree/CreateInterTree.h

@@ -8,7 +8,7 @@
 
 #include "dvm.h"
 
-#include "../GraphLoop/graph_loops_func.h"
+#include "graph_loops_func.h"
 
 struct SpfInterval
 {

src/DirectiveProcessing/directive_analyzer.cpp

@@ -1,4 +1,4 @@
-#include "../Utils/leak_detector.h"
+#include "leak_detector.h"
 
 #include <cstdio>
 #include <cstdlib>
@@ -16,9 +16,9 @@
 #include <assert.h>
 
 #include "../Distribution/DvmhDirective.h"
-#include "../GraphLoop/graph_loops.h"
+#include "graph_loops.h"
 #include "directive_analyzer.h"
-#include "../Utils/utils.h"
+#include "utils.h"
 
 using std::vector;
 using std::map;

src/DirectiveProcessing/directive_analyzer.h

@@ -1,6 +1,6 @@
 #pragma once
 
 #include <vector>
-#include "../GraphLoop/graph_loops.h"
+#include "graph_loops.h"
 
 void UniteNestedDirectives(std::vector<LoopGraph*> &loopGraph);

src/DirectiveProcessing/directive_creator.cpp

@@ -1,4 +1,4 @@
-#include "../Utils/leak_detector.h"
+#include "leak_detector.h"
 
 #include <cstdio>
 #include <cstdlib>
@@ -15,18 +15,18 @@
 #include "../Distribution/Distribution.h"
 #include "../Distribution/DvmhDirective_func.h"
 
-#include "../Utils/errors.h"
+#include "errors.h"
 #include "../LoopAnalyzer/loop_analyzer.h"
 #include "directive_parser.h"
 #include "directive_creator.h"
-#include "../Utils/SgUtils.h"
+#include "SgUtils.h"
 #include "../Sapfor.h"
-#include "../GraphLoop/graph_loops_func.h"
-#include "../Transformations/loop_transform.h"
-#include "../ExpressionTransform/expr_transform.h"
-#include "../GraphCall/graph_calls_func.h"
+#include "graph_loops_func.h"
+#include "LoopNesting/loop_transform.h"
+#include "expr_transform.h"
+#include "graph_calls_func.h"
 
-#include "../Utils/AstWrapper.h"
+#include "AstWrapper.h"
 
 #define PRINT_DIR_RESULT 0
 

src/DirectiveProcessing/directive_creator.h

@@ -1,9 +1,9 @@
 #pragma once
 
 #include "../Distribution/Distribution.h"
-#include "../Utils/errors.h"
-#include "../GraphLoop/graph_loops.h"
-#include "../Utils/types.h"
+#include "errors.h"
+#include "graph_loops.h"
+#include "types.h"
 
 void createParallelDirectives(const std::map<LoopGraph*, std::map<DIST::Array*, ArrayInfo*>> &loopInfo,
                               const std::vector<ParallelRegion*>& regions, 

src/DirectiveProcessing/directive_creator_base.cpp

@@ -1,4 +1,4 @@
-#include "../Utils/leak_detector.h"
+#include "leak_detector.h"
 
 #include <cstdio>
 #include <cstdlib>
@@ -10,9 +10,9 @@
 
 #include "../ParallelizationRegions/ParRegions.h"
 #include "../Distribution/Arrays.h"
-#include "../Transformations/loop_transform.h"
+#include "LoopNesting/loop_transform.h"
 
-#include "../Utils/errors.h"
+#include "errors.h"
 #include "directive_parser.h"
 #include "directive_creator.h"
 
@@ -75,7 +75,7 @@ static LoopGraph* createDirectiveForLoop(LoopGraph *currentLoop, MapToArray &mai
         }
     }
 
-    directive->parallel.push_back(currentLoop->loopSymbol);
+    directive->parallel.push_back(currentLoop->loopSymbol());
     directive->arrayRef = mainArray.arrayRef;
 
     DIST::Array *tmp = mainArray.arrayRef;
@@ -84,7 +84,7 @@ static LoopGraph* createDirectiveForLoop(LoopGraph *currentLoop, MapToArray &mai
         for (int i = 0; i < tmp->GetDimSize(); ++i)
         {
             if (i == pos)
-                directive->on.push_back(make_pair(currentLoop->loopSymbol, mainAccess));
+                directive->on.push_back(make_pair(currentLoop->loopSymbol(), mainAccess));
             else
                 directive->on.push_back(make_pair("*", make_pair(0, 0)));
         }
@@ -808,7 +808,7 @@ void createParallelDirectives(const map<LoopGraph*, map<DIST::Array*, ArrayInfo*
                             for (int i = 0; i < mainArrayOfLoop->GetDimSize(); ++i)
                             {
                                 if (i == dimPos)
-                                    parDir->on2.push_back(make_pair(currLoop->loopSymbol, mainAccess));
+                                    parDir->on2.push_back(make_pair(currLoop->loopSymbol(), mainAccess));
                                 else
                                     parDir->on2.push_back(make_pair("*", make_pair(0, 0)));
                             }
@@ -1100,7 +1100,7 @@ static bool tryToResolveUnmatchedDims(const map<DIST::Array*, vector<bool>> &dim
     LoopGraph* tmpL = loop;
     for (int z = 0; z < nested; ++z)
     {
-        deprecateToMatch.insert(tmpL->loopSymbol);
+        deprecateToMatch.insert(tmpL->loopSymbol());
         if (tmpL->children.size())
             tmpL = tmpL->children[0];
         else if (z != nested - 1)
@@ -1113,7 +1113,7 @@ static bool tryToResolveUnmatchedDims(const map<DIST::Array*, vector<bool>> &dim
     tmpL = loop->parent;
     while (tmpL)
     {
-        if (!tmpL->isFor) // TODO: need to add all inductive variables!
+        if (tmpL->isWhile()) // TODO: need to add all inductive variables!
         {
             SgWhileStmt* dow = isSgWhileStmt(tmpL->loop->GetOriginal());
             if (dow->conditional())
@@ -1124,7 +1124,7 @@ static bool tryToResolveUnmatchedDims(const map<DIST::Array*, vector<bool>> &dim
             }
         }
         else
-            deprecateToMatch.insert(tmpL->loopSymbol);
+            deprecateToMatch.insert(tmpL->loopSymbol());
         tmpL = tmpL->parent;
     }
 
@@ -1601,7 +1601,7 @@ static bool matchParallelAndDist(const pair<DIST::Array*, const DistrVariant*>&
         parallelOn = NULL;
         for (auto& refOn : realRefs)
         {
-            linkWithTempl = parallelOn->GetLinksWithTemplate(regionId);
+            linkWithTempl = refOn->GetLinksWithTemplate(regionId);
             int z = 0;
             for (int k = 0; k < linkWithTempl.size(); ++k)
                 if (linkWithTempl[k] != -1)

src/DirectiveProcessing/directive_omp_parser.cpp

@@ -1,4 +1,4 @@
-#include "../Utils/leak_detector.h"
+#include "leak_detector.h"
 
 #include <cstdio>
 #include <cstdlib>
@@ -9,7 +9,7 @@
 #include "directive_omp_parser.h"
 #include "directive_parser.h"
 
-#include "../Utils/SgUtils.h"
+#include "SgUtils.h"
 
 using std::vector;
 using std::map;

src/DirectiveProcessing/directive_omp_parser.h

@@ -4,7 +4,7 @@
 #include <map>
 #include <vector>
 
-#include "../Utils/errors.h"
+#include "errors.h"
 
 #define SPF_USER_DIR 777
 #define SPF_USER_DIR_COPY 999

src/DirectiveProcessing/directive_parser.cpp

@@ -1,4 +1,4 @@
-#include "../Utils/leak_detector.h"
+#include "leak_detector.h"
 
 #include <cstdio>
 #include <cstring>
@@ -12,10 +12,10 @@
 #include <assert.h>
 
 #include "directive_parser.h"
-#include "../Utils/SgUtils.h"
+#include "SgUtils.h"
 #include "../LoopAnalyzer/loop_analyzer.h"
-#include "../Utils/AstWrapper.h"
-#include "../Utils/errors.h"
+#include "AstWrapper.h"
+#include "errors.h"
 
 using std::string;
 using std::vector;

src/DirectiveProcessing/directive_parser.h

@@ -4,8 +4,8 @@
 #include <set>
 #include <map>
 
-#include "../Utils/AstWrapper.h"
-#include "../GraphLoop/graph_loops.h"
+#include "AstWrapper.h"
+#include "graph_loops.h"
 #include "../Distribution/DvmhDirective.h"
 
 struct DvmDirective

src/DirectiveProcessing/insert_directive.cpp

@@ -1,4 +1,4 @@
-#include "../Utils/leak_detector.h"
+#include "leak_detector.h"
 
 #include <cstdio>
 #include <cstdlib>
@@ -16,13 +16,13 @@
 #include "../Distribution/Arrays.h"
 #include "../Distribution/Distribution.h"
 #include "../Distribution/DvmhDirective_func.h"
-#include "../GraphLoop/graph_loops_func.h"
-#include "../GraphCall/graph_calls_func.h"
+#include "graph_loops_func.h"
+#include "graph_calls_func.h"
 
-#include "../Utils/errors.h"
+#include "errors.h"
 #include "../LoopAnalyzer/loop_analyzer.h"
 #include "directive_parser.h"
-#include "../Utils/SgUtils.h"
+#include "SgUtils.h"
 #include "../Sapfor.h"
 #include "directive_creator.h"
 #include "insert_directive.h"
@@ -853,12 +853,21 @@ static pair<string, string> getModuleRename(const set<SgStatement*>& allocatable
         return make_pair("", "");
 }
 
+static void doRename(string& str, const pair<string, string>& renamePair)
+{
+    auto it = str.find(renamePair.first);
+    if (it != string::npos)
+        if (str[it + renamePair.first.size()] == '(' && str[it - 1] == ' ')
+            str = str.replace(it, renamePair.first.size(), renamePair.second);
+}
+
 static pair<DIST::Array*, string>
 getNewDirective(const string &fullArrayName, 
                 const vector<string> &distrRules,
                 const vector<string> &alignRules,
                 const DataDirective &dataDir,
-                const set<SgStatement*>& allocatableStmts)
+                const set<SgStatement*>& allocatableStmts,
+                const pair<string, int>& position_decl)
 {
     string out = "";
     DIST::Array* outA = NULL;
@@ -877,7 +886,8 @@ getNewDirective(const string &fullArrayName,
 
     for (int i = 0; i < dataDir.alignRules.size(); ++i)
     {
-        if (dataDir.alignRules[i].alignArray->GetName() == fullArrayName)
+        auto alignArray = dataDir.alignRules[i].alignArray;
+        if (alignArray->GetName() == fullArrayName)
         {
             string rule = alignRules[i];
             if (allocatableStmts.size())
@@ -889,21 +899,21 @@ getNewDirective(const string &fullArrayName,
                     it = rule.find("ALIGN", it + 7);
                 }
                 
-                auto renamePair = getModuleRename(allocatableStmts, dataDir.alignRules[i].alignArray);
-                if (renamePair.first != "")
-                {
-                    it = rule.find(renamePair.first);
-                    if (it != string::npos)
-                        if (rule[it + renamePair.first.size()] == '(' && rule[it - 1] == ' ')
-                            rule = rule.replace(it, renamePair.first.size(), renamePair.second);
-                }
+                auto renamePair = getModuleRename(allocatableStmts, alignArray);
+                doRename(rule, renamePair);
+            }
+            else if (alignArray->GetLocation().first == DIST::l_COMMON)
+            {
+                auto symb = alignArray->GetDeclSymbol(position_decl);
+                if (symb->identifier() != alignArray->GetShortName())
+                    doRename(rule, make_pair(alignArray->GetShortName(), symb->identifier()));
             }
 
             out += "!DVM$ " + rule + "\n";
             if (!out_free_form)
                 out = splitDirective(out);
 
-            return make_pair(dataDir.alignRules[i].alignArray, out);
+            return make_pair(alignArray, out);
         }
     }
     
@@ -1743,7 +1753,7 @@ void insertDistributionToFile(SgFile *file, const char *fin_name, const DataDire
                             if (allocatableStmtsCopy.size())
                                 allocatableStmts = filterAllocateStats(file, allocatableStmtsCopy, currSymb->identifier());
    
-                            pair<DIST::Array*, string> dirWithArray = getNewDirective(fullArrayName, distrRules, alignRules, dataDir, allocatableStmts);
+                            pair<DIST::Array*, string> dirWithArray = getNewDirective(fullArrayName, distrRules, alignRules, dataDir, allocatableStmts, make_pair(st->fileName(), st->lineNumber()));
 
                             string toInsert = dirWithArray.second;
                             if (toInsert != "")
@@ -1975,20 +1985,27 @@ void insertDistributionToFile(SgFile *file, const char *fin_name, const DataDire
                 set<string> toInsertArrays;
                 for (auto &array : dynamicArraysLocal)
                 {
+                    string name = array->GetShortName();
+                    if (array->GetLocation().first == DIST::l_COMMON)
+                    {
+                        auto symb = array->GetDeclSymbol(make_pair(st->fileName(), st->lineNumber()));
+                        name = symb->identifier();
+                    }
+
                     if (extractDir)
                     {
-                        if (dynamicArraysAdded.find(array->GetShortName()) != dynamicArraysAdded.end())
+                        if (dynamicArraysAdded.find(name) != dynamicArraysAdded.end())
                         {
-                            dynamicArraysAdded.erase(array->GetShortName());
-                            toInsertArrays.insert(array->GetShortName());
+                            dynamicArraysAdded.erase(name);
+                            toInsertArrays.insert(name);
                         }
                     }
                     else
                     {
-                        if (dynamicArraysAdded.find(array->GetShortName()) == dynamicArraysAdded.end())
+                        if (dynamicArraysAdded.find(name) == dynamicArraysAdded.end())
                         {
-                            dynamicArraysAdded.insert(array->GetShortName());
-                            toInsertArrays.insert(array->GetShortName());
+                            dynamicArraysAdded.insert(name);
+                            toInsertArrays.insert(name);
                         }
                     }
                 }
@@ -2145,7 +2162,14 @@ void insertShadowSpecToFile(SgFile *file, const char *fin_name, const set<string
 
                     if (needToGen)
                     {
-                        string shadowSpecInsert = "!DVM$ SHADOW " + array->GetShortName() + "(";
+                        string name = array->GetShortName();
+                        if (array->GetLocation().first == DIST::l_COMMON)
+                        {
+                            auto symb = array->GetDeclSymbol(make_pair(st->fileName(), st->lineNumber()));
+                            name = symb->identifier();
+                        }
+
+                        string shadowSpecInsert = "!DVM$ SHADOW " + name + "(";
                         for (int k = 0; k < currSpec.size(); ++k)
                         {
                             char buf[256];
@@ -2157,7 +2181,7 @@ void insertShadowSpecToFile(SgFile *file, const char *fin_name, const set<string
                         shadowSpecInsert += ")\n";
 
                         shadowsSpecsString.push_back(shadowSpecInsert);
-                        pair<SgExpression*, SgExpression*> newSpec = genShadowSpec(file, make_pair(array->GetShortName(), currSpec));
+                        pair<SgExpression*, SgExpression*> newSpec = genShadowSpec(file, make_pair(name, currSpec));
                         if (newSpec.first == NULL || newSpec.second == NULL)
                             printInternalError(convertFileName(__FILE__).c_str(), __LINE__);
                         shadowsSpecs.push_back(newSpec);

src/DirectiveProcessing/remote_access.cpp

@@ -1,4 +1,4 @@
-#include "../Utils/leak_detector.h"
+#include "leak_detector.h"
 
 #include <cstdio>
 #include <cstdlib>
@@ -18,13 +18,13 @@
 
 #include "dvm.h"
 #include "../LoopAnalyzer/loop_analyzer.h"
-#include "../Utils/types.h"
-#include "../Utils/errors.h"
-#include "../Utils/SgUtils.h"
+#include "types.h"
+#include "errors.h"
+#include "SgUtils.h"
 #include "../Distribution/Arrays.h"
-#include "../GraphCall/graph_calls.h"
-#include "../GraphCall/graph_calls_func.h"
-#include "../GraphLoop/graph_loops_func.h"
+#include "graph_calls.h"
+#include "graph_calls_func.h"
+#include "graph_loops_func.h"
 #include "remote_access.h"
 
 using std::vector;

src/DirectiveProcessing/remote_access_base.cpp

@@ -1,4 +1,4 @@
-#include "../Utils/leak_detector.h"
+#include "leak_detector.h"
 
 #include <cstdio>
 #include <cstdlib>
@@ -17,8 +17,8 @@
 #include <assert.h>
 
 #include "../Distribution/Arrays.h"
-#include "../GraphCall/graph_calls.h"
-#include "../GraphLoop/graph_loops.h"
+#include "graph_calls.h"
+#include "graph_loops.h"
 #include "../ParallelizationRegions/ParRegions.h"
 #include "remote_access.h"
 

src/DirectiveProcessing/shadow.cpp

@@ -1,21 +1,21 @@
-#include "../Utils/leak_detector.h"
+#include "leak_detector.h"
 
 #include <set>
 #include <map>
 #include <string>
 #include <vector>
 
-#include "../Utils/errors.h"
-#include "../Utils/utils.h"
-#include "../GraphLoop/graph_loops_func.h"
-#include "../GraphCall/graph_calls.h"
-#include "../GraphCall/graph_calls_func.h"
+#include "errors.h"
+#include "utils.h"
+#include "graph_loops_func.h"
+#include "graph_calls.h"
+#include "graph_calls_func.h"
 #include "directive_parser.h"
 #include "../Distribution/DvmhDirective_func.h"
-#include "../Utils/SgUtils.h"
-#include "../ExpressionTransform/expr_transform.h"
+#include "SgUtils.h"
+#include "expr_transform.h"
 
-#include "../CFGraph/CFGraph.h"
+#include "CFGraph/CFGraph.h"
 
 #include "shadow.h"
 #include "dvm.h"

src/DirectiveProcessing/spf_directive_preproc.cpp

@@ -1,4 +1,4 @@
-#include "../Utils/leak_detector.h"
+#include "leak_detector.h"
 
 #include <cstdio>
 #include <cstdlib>
@@ -12,13 +12,13 @@
 
 #include "dvm.h"
 #include "../Sapfor.h"
-#include "../GraphLoop/graph_loops.h"
-#include "../GraphCall/graph_calls_func.h"
+#include "graph_loops.h"
+#include "graph_calls_func.h"
 #include "../SageAnalysisTool/depInterfaceExt.h"
-#include "../Utils/SgUtils.h"
-#include "../Utils/errors.h"
+#include "SgUtils.h"
+#include "errors.h"
 #include "directive_parser.h"
-#include "../ExpressionTransform/expr_transform.h"
+#include "expr_transform.h"
 #include "../LoopAnalyzer/loop_analyzer.h"
 #include "../DirectiveProcessing/directive_omp_parser.h"
 

src/Distribution/Array.cpp

@@ -1,7 +1,7 @@
 #include "Array.h"
-#include "../Utils/errors.h"
-#include "../Utils/utils.h"
-#include "../GraphCall/graph_calls.h"
+#include "errors.h"
+#include "utils.h"
+#include "graph_calls.h"
 
 using namespace std;
 

src/Distribution/Array.h

@@ -7,9 +7,9 @@
 #include <algorithm>
 #include <climits>
 #include "DvmhDirectiveBase.h"
-#include "../Utils/utils.h"
-#include "../Utils/errors.h"
-#include "../Utils/json.hpp"
+#include "utils.h"
+#include "errors.h"
+#include "json.hpp"
 
 class Symbol;
 class Expression;
@@ -106,7 +106,7 @@ namespace Distribution
         MAP<STRING, SET<int>> usagePlaces;
 
         VECTOR<bool> mappedDims;
-        VECTOR<bool> depracateToDistribute;
+        VECTOR<bool> deprecateToDistribute;
 
         bool ompThreadPrivate;
         bool privateInLoop;
@@ -171,7 +171,7 @@ namespace Distribution
             sizes.resize(dimSize);
             sizesExpr.resize(dimSize);
             mappedDims.resize(dimSize);
-            depracateToDistribute.resize(dimSize);
+            deprecateToDistribute.resize(dimSize);
 
             for (int z = 0; z < dimSize; ++z)
             {
@@ -179,7 +179,7 @@ namespace Distribution
                 PAIR<int, int> initVal = std::make_pair(0, 0);
                 sizesExpr[z] = std::make_pair(std::make_pair((Expression*)NULL, initVal), std::make_pair((Expression*)NULL, initVal));
                 mappedDims[z] = false;
-                depracateToDistribute[z] = false;
+                deprecateToDistribute[z] = false;
             }
                         
             GenUniqKey();
@@ -214,7 +214,7 @@ namespace Distribution
             uniqKey = copy.uniqKey;
             containsInRegions = copy.containsInRegions;
             mappedDims = copy.mappedDims;
-            depracateToDistribute = copy.depracateToDistribute;
+            deprecateToDistribute = copy.deprecateToDistribute;
             ompThreadPrivate = copy.ompThreadPrivate;
             privateInLoop = copy.privateInLoop;
             inEquivalence = copy.inEquivalence;
@@ -226,7 +226,7 @@ namespace Distribution
             int countToRem = 0;
             for (int z = 0; z < dimSize; ++z)
             {
-                if (!mappedDims[z] || depracateToDistribute[z])
+                if (!mappedDims[z] || deprecateToDistribute[z])
                 {
                     needToRemove = true;
                     countToRem++;
@@ -246,19 +246,19 @@ namespace Distribution
 
             for (int z = 0; z < dimSize; ++z)
             {
-                if (mappedDims[z] && !depracateToDistribute[z])
+                if (mappedDims[z] && !deprecateToDistribute[z])
                 {
                     newSizes.push_back(sizes[z]);
                     newSizesExpr.push_back(sizesExpr[z]);
                     newMappedDims.push_back(mappedDims[z]);
-                    newDepr.push_back(depracateToDistribute[z]);
+                    newDepr.push_back(deprecateToDistribute[z]);
                 }
             }
 
             sizes = newSizes;
             sizesExpr = newSizesExpr;
             mappedDims = newMappedDims;
-            depracateToDistribute = newDepr;
+            deprecateToDistribute = newDepr;
             dimSize = (int)sizes.size();
 
             return false;
@@ -336,9 +336,24 @@ namespace Distribution
             if (pos != STRING::npos)
             {
                 name.erase(pos, shortName.size());
-                shortName = newName;
                 name += newName;
             }
+            else if (locationPos.first == l_COMMON) // name of array in common may be different
+            {
+                pos = name.rfind("_");
+                if (pos != STRING::npos)
+                {
+                    name.erase(pos + 1, shortName.size());
+                    name += newName;
+                }
+                else
+                {
+#if __SPF
+                    printInternalError(convertFileName(__FILE__).c_str(), __LINE__);
+#endif
+                }
+            }
+            shortName = newName;
             GenUniqKey();
         }
 
@@ -433,6 +448,7 @@ namespace Distribution
             retVal["id"] = (int64_t)id;
             retVal["name"] = name;
             retVal["shortName"] = shortName;
+            retVal["packedAddress"] = std::to_string((long long)this);
 
             retVal["dimSize"] = dimSize;
             retVal["typeSize"] = typeSize;
@@ -444,9 +460,9 @@ namespace Distribution
             retVal["isLoopArrayFlag"] = (int)isLoopArrayFlag;
 
             JSON deprToDist = nlohmann::json::array();
-            for (int i = 0; i < depracateToDistribute.size(); ++i)
-                deprToDist.push_back((int)depracateToDistribute[i]);
-            retVal["depracateToDist"] = deprToDist;
+            for (int i = 0; i < deprecateToDistribute.size(); ++i)
+                deprToDist.push_back((int)deprecateToDistribute[i]);
+            retVal["deprecateToDist"] = deprToDist;
 
             JSON mappedDimsJ = nlohmann::json::array();
             for (int i = 0; i < mappedDims.size(); ++i)
@@ -541,6 +557,44 @@ namespace Distribution
             return NULL; 
         }
 
+        Symbol* GetDeclSymbol(const PAIR<STRING, int>& position_decl) const
+        {
+            if (!IsArray() || locationPos.first != l_COMMON)
+                return declSymbol;
+
+            auto it = declPlacesSymbol.find(position_decl);
+            if (it != declPlacesSymbol.end())
+                return it->second;
+            else // find nearest
+            {
+                MAP<PAIR<STRING, int>, Symbol*> currFile;
+                for (auto& [position, symb] : declPlacesSymbol)
+                {
+                    if (position.first == position_decl.first)
+                        currFile[position] = symb;
+                }
+
+                PAIR<int, Symbol*> nearest = { (int)0, NULL };
+                const int needed_pos = position_decl.second;
+
+                for (auto& [position, symb] : currFile)
+                {
+                    if (nearest.second == NULL)
+                        nearest = { abs(position.second - needed_pos), symb };
+
+                    if (abs(position.second - needed_pos) < nearest.first)
+                        nearest = { abs(position.second - needed_pos), symb };
+                }
+
+                if (nearest.second)
+                    return nearest.second;
+#if __SPF
+                printInternalError(convertFileName(__FILE__).c_str(), __LINE__);
+#endif
+            }
+            return NULL;
+        }
+
         Symbol* GetDeclSymbol() const { return declSymbol; }
         void SetDeclSymbol(Symbol *s) { declSymbol = s; }
 
@@ -604,13 +658,13 @@ namespace Distribution
         {
             if (dim >= dimSize)
                 return;
-            depracateToDistribute[dim] = value;
+            deprecateToDistribute[dim] = value;
         }
 
         void DeprecateAllDims()
         {
             for (int dim = 0; dim < dimSize; ++dim)
-                depracateToDistribute[dim] = true;
+                deprecateToDistribute[dim] = true;
         }
 
         bool IsDimDepracated(const int dim) const
@@ -620,9 +674,9 @@ namespace Distribution
             else
             {
                 if (templateDimsOrder.size() == 0)
-                    return depracateToDistribute[dim];
+                    return deprecateToDistribute[dim];
                 else
-                    return depracateToDistribute[templateDimsOrder[dim]];
+                    return deprecateToDistribute[templateDimsOrder[dim]];
             }
         }
         
@@ -630,11 +684,11 @@ namespace Distribution
         {
             bool ret = true;
             for (int z = 0; z < dimSize; ++z)
-                ret = ret && depracateToDistribute[z];
+                ret = ret && deprecateToDistribute[z];
             return ret;
         }
 
-        const VECTOR<bool>& GetDeprecetedDims() const { return depracateToDistribute; }
+        const VECTOR<bool>& GetDeprecetedDims() const { return deprecateToDistribute; }
 
         int GetTypeSize() const { return typeSize; }
 
@@ -826,4 +880,4 @@ namespace Distribution
 #undef PAIR
 #undef MAP
 #undef SET
-#undef TO_STR
+#undef TO_STR

src/Distribution/ArrayAnalysis.cpp

@@ -1,8 +1,8 @@
 #include "Array.h"
-#include "../Utils/errors.h"
-#include "../Utils/utils.h"
-#include "../GraphCall/graph_calls.h"
-#include "../Utils/SgUtils.h"
+#include "errors.h"
+#include "utils.h"
+#include "graph_calls.h"
+#include "SgUtils.h"
 #include "../DirectiveProcessing/directive_parser.h"
 #include "../DirectiveProcessing/directive_omp_parser.h"
 #include "../LoopAnalyzer/loop_analyzer.h"
@@ -241,13 +241,15 @@ static void findArrayRefs (SgExpression* ex, SgStatement* st, string fName, int
                 itNew->second.first->SetRegionPlace(reg);
 
             const auto oldVal = itNew->second.first->GetDistributeFlagVal();
-            bool isarrayInModule = (itNew->second.first->GetLocation().first == DIST::l_MODULE);
+            bool isArrayInModule = (itNew->second.first->GetLocation().first == DIST::l_MODULE);
 
             if (oldVal == DIST::DISTR || oldVal == DIST::NO_DISTR)
             {
                 if (itNew->second.first->IsOmpThreadPrivate())
                     itNew->second.first->SetDistributeFlag(DIST::SPF_PRIV);
-                else if (privates.find(symb->identifier()) != privates.end() || isarrayInModule)
+                else if (deprecatedByIO.find(symb->identifier()) != deprecatedByIO.end())
+                    itNew->second.first->SetDistributeFlag(DIST::IO_PRIV);
+                else if (isArrayInModule || privates.find(symb->identifier()) != privates.end())
                 {
                     //check in module
                     if (itNew->second.first->GetLocation().first == DIST::l_MODULE)
@@ -274,8 +276,6 @@ static void findArrayRefs (SgExpression* ex, SgStatement* st, string fName, int
                     else
                         itNew->second.first->SetDistributeFlag(DIST::SPF_PRIV);
                 }
-                else if (deprecatedByIO.find(symb->identifier()) != deprecatedByIO.end())
-                    itNew->second.first->SetDistributeFlag(DIST::IO_PRIV);
                 else if (isSgConstantSymb(symb) || inDataStat)
                     itNew->second.first->SetDistributeFlag(DIST::SPF_PRIV);
                 else

src/Distribution/CreateDistributionDirs.cpp

@@ -1,4 +1,4 @@
-#include "../Utils/leak_detector.h"
+#include "leak_detector.h"
 
 #include <stdio.h>
 #include <stdlib.h>
@@ -14,9 +14,9 @@
 #include "GraphCSR.h"
 #include "Arrays.h"
 
-#include "../Utils/errors.h"
-#include "../Utils/utils.h"
-#include "../GraphLoop/graph_loops.h"
+#include "errors.h"
+#include "utils.h"
+#include "graph_loops.h"
 
 using std::vector;
 using std::set;
@@ -274,7 +274,7 @@ static void convertTrees(const map<DIST::Array*, int> &treesIn, map<int, vector<
 static DIST::Array* findBestInEqual(vector<DIST::Array*> &arrays, DIST::GraphCSR<int, double, attrType> &reducedG, DIST::Arrays<int> &allArrays)
 {
     DIST::Array *retVal = NULL;
-    vector<vector<attrType>> coefsByDims;
+    vector<vector<attrType>> coeffsByDims;
     for (auto &array : arrays)
     {
         vector<int> verts;
@@ -285,7 +285,7 @@ static DIST::Array* findBestInEqual(vector<DIST::Array*> &arrays, DIST::GraphCSR
         {
             retVal = array;
             for (auto &V : verts)
-                coefsByDims.push_back(reducedG.GetAllAttributes(V));
+                coeffsByDims.push_back(reducedG.GetAllAttributes(V));
         }
         else
         {
@@ -294,11 +294,11 @@ static DIST::Array* findBestInEqual(vector<DIST::Array*> &arrays, DIST::GraphCSR
                 toCmp.push_back(reducedG.GetAllAttributes(V));
             for (int z = 0; z < toCmp.size(); ++z)
             {
-                if (toCmp[z].size() && coefsByDims[z].size())
+                if (toCmp[z].size() && coeffsByDims[z].size())
                 {
-                    if (toCmp[z].back().first.first > coefsByDims[z].back().first.first)
+                    if (toCmp[z].back().first.first > coeffsByDims[z].back().first.first)
                     {
-                        coefsByDims = toCmp;
+                        coeffsByDims = toCmp;
                         retVal = array;
                         break;
                     }

src/Distribution/CreateDistributionDirs.h

@@ -1,7 +1,7 @@
 #pragma once
 
-#include "../GraphLoop/graph_loops.h"
-#include "../Utils/errors.h"
+#include "graph_loops.h"
+#include "errors.h"
 
 void createDistributionDirs(DIST::GraphCSR<int, double, attrType> &reducedG, DIST::Arrays<int> &allArrays, 
                             DataDirective &dataDirectives, std::map<std::string, std::vector<Messages>> &allMessages, 

src/Distribution/Cycle.cpp

@@ -1,4 +1,4 @@
-#include "../Utils/leak_detector.h"
+#include "leak_detector.h"
 
 #include <vector>
 #include <algorithm>

src/Distribution/Cycle.h

@@ -3,7 +3,7 @@
 #include <vector>
 #include <algorithm>
 
-#include "../Utils/types.h"
+#include "types.h"
 
 namespace Distribution
 {

src/Distribution/Distribution.cpp

@@ -1,4 +1,4 @@
-#include "../Utils/leak_detector.h"
+#include "leak_detector.h"
 
 #include <cstdio>
 #include <cstdlib>
@@ -30,9 +30,9 @@ using namespace std::chrono;
 #include "Arrays.h"
 #include "Array.h"
 #include "Distribution.h"
-#include "../Utils/utils.h"
-#include "../Utils/errors.h"
-#include "../Utils/types.h"
+#include "utils.h"
+#include "errors.h"
+#include "types.h"
 #include "../Distribution/Cycle.h"
 #include "../VisualizerCalls/get_information.h"
 #include "../VisualizerCalls/SendMessage.h"
@@ -455,15 +455,7 @@ namespace Distribution
             }
 
             if (needPrint)
-            {
-#if _WIN32
-                wstring treeM = L"ðàçðåøåíèå êîíôëèêòîâ, îáðàáîòêà ãðóïïû " + std::to_wstring(k + 1) + L"/" + std::to_wstring(AllCycles.size());
-#else
-                wstring treeM = L"conflict resolution, processing group " + std::to_wstring(k + 1) + L"/" + std::to_wstring(AllCycles.size());
-#endif
-                sendMessage_2lvl(treeM);
-
-            }
+                sendMessage_2lvl(4, k, (int)AllCycles.size());
 
             auto timeR = steady_clock::now();
             if (countConflicts != 0)
@@ -516,7 +508,7 @@ namespace Distribution
         }
 
         if (needPrint)
-            sendMessage_2lvl(L"");
+            sendMessage_2lvl(2);
 
         return make_pair(allOnlySecondType, globalSum);
     }
@@ -572,13 +564,7 @@ namespace Distribution
             for (int z = 0; z < arraysV.size(); ++z)
             {
                 const DIST::Array *array = arraysV[z];
-
-#ifdef _WIN32
-                wstring treeM = L"ðàçðåøåíèå êîíôëèêòîâ, îáðàáîòêà ìàññèâà " + std::to_wstring(z + 1) + L"/" + std::to_wstring(arrays.size());
-#else
-                wstring treeM = L"conflict resolution, processing array " + std::to_wstring(z + 1) + L"/" + std::to_wstring(arrays.size());
-#endif
-                sendMessage_2lvl(treeM);
+                sendMessage_2lvl(5, z, (int)arrays.size());
 
                 vector<vType> verts;
 
@@ -605,7 +591,7 @@ namespace Distribution
                     }
                 }
             }
-            sendMessage_2lvl(L"");
+            sendMessage_2lvl(2);
         }
         else
         {

src/Distribution/DvmhDirective.cpp

@@ -1,4 +1,4 @@
-#include "../Utils/leak_detector.h"
+#include "leak_detector.h"
 
 #include <stdio.h>
 #include <stdlib.h>
@@ -7,12 +7,12 @@
 #include <string>
 #include <algorithm>
 
-#include "../Utils/types.h"
+#include "types.h"
 #include "DvmhDirective.h"
-#include "../Utils/errors.h"
-#include "../Utils/SgUtils.h"
+#include "errors.h"
+#include "SgUtils.h"
 #include "../Sapfor.h"
-#include "../GraphCall/graph_calls_func.h"
+#include "graph_calls_func.h"
 
 #include "dvm.h"
 
@@ -45,10 +45,10 @@ static bool findArrayRefAndCheck(SgExpression *ex, const DIST::Array* currArray,
                 int countOfShadows = 0;
                 for (int i = 0; i < ref->numberOfSubscripts(); ++i)
                 {
-                    const vector<int*> &coefs = getAttributes<SgExpression*, int*>(ref->subscript(i), set<int>{ INT_VAL });
-                    if (coefs.size() == 1)
+                    const vector<int*> &coeffs = getAttributes<SgExpression*, int*>(ref->subscript(i), set<int>{ INT_VAL });
+                    if (coeffs.size() == 1)
                     {
-                        const pair<int, int> coef(coefs[0][0], coefs[0][1]);
+                        const pair<int, int> coef(coeffs[0][0], coeffs[0][1]);
                         auto it = shiftsByAccess[i].find(coef);
                         if (it != shiftsByAccess[i].end())
                             if (it->second != 0)
@@ -199,15 +199,6 @@ static set<string> fillUsedSymbols(SgStatement *loop)
     return usedS;
 }
 
-static string correctSymbolModuleName(const string& origFull)
-{
-    auto it = origFull.find("::");
-    if (it == string::npos)
-        return origFull;
-    else
-        return origFull.substr(it + 2);
-}
-
 static SgStatement* getModuleScope(const string& origFull, vector<SgStatement*>& moduleList, SgStatement *local)
 {
     auto it = origFull.find("::");
@@ -355,7 +346,7 @@ static vector<SgExpression*>
                             {
                                 needToAdd = true;
                                 dim_found = true;
-                                subs[i] = new SgVarRefExp(findSymbolOrCreate(file, currLoop->loopSymbol));
+                                subs[i] = new SgVarRefExp(findSymbolOrCreate(file, currLoop->loopSymbol()));
                                 break;
                             }
                         }
@@ -959,7 +950,7 @@ ParallelDirective::genDirective(File* file, const vector<pair<DIST::Array*, cons
                 SgSymbol* redS;
                 string clearName = correctSymbolModuleName(red);
                 if (clearName != red)
-                    redS = getNameInLocation(parentFunc, clearName, getModuleScope(red, moduleList, parentFunc)->symbol()->identifier());
+                    redS = getNameInLocation(parentFunc, red, getModuleScope(red, moduleList, parentFunc)->symbol()->identifier());
                 else
                     redS = findSymbolOrCreate(file, clearName, NULL, parentFunc);
 
@@ -1017,12 +1008,12 @@ ParallelDirective::genDirective(File* file, const vector<pair<DIST::Array*, cons
                 string clearName2 = correctSymbolModuleName(get<1>(list));
 
                 if (clearName1 != get<0>(list))
-                    redS1 = getNameInLocation(parentFunc, clearName1, getModuleScope(get<0>(list), moduleList, parentFunc)->symbol()->identifier());
+                    redS1 = getNameInLocation(parentFunc, get<0>(list), getModuleScope(get<0>(list), moduleList, parentFunc)->symbol()->identifier());
                 else
                     redS1 = findSymbolOrCreate(file, clearName1, NULL, parentFunc);
 
                 if (clearName2 != get<1>(list))
-                    redS2 = getNameInLocation(parentFunc, clearName2, getModuleScope(get<1>(list), moduleList, parentFunc)->symbol()->identifier());
+                    redS2 = getNameInLocation(parentFunc, get<1>(list), getModuleScope(get<1>(list), moduleList, parentFunc)->symbol()->identifier());
                 else
                     redS2 = findSymbolOrCreate(file, clearName2, NULL, parentFunc);
 

src/Distribution/DvmhDirective.h

@@ -7,9 +7,9 @@
 
 #include "Array.h"
 #include "DvmhDirectiveBase.h"
-#include "../Utils/AstWrapper.h"
-#include "../Utils/types.h"
-#include "../Utils/utils.h"
+#include "AstWrapper.h"
+#include "types.h"
+#include "utils.h"
 
 extern int sharedMemoryParallelization;
 

src/Distribution/DvmhDirectiveBase.cpp

@@ -1,4 +1,4 @@
-#include "../Utils/leak_detector.h"
+#include "leak_detector.h"
 
 #include <stdio.h>
 #include <stdlib.h>
@@ -10,11 +10,11 @@
 #include "../Distribution/Array.h"
 #include "../Distribution/Arrays.h"
 #include "../Distribution/GraphCSR.h"
-#include "../Utils/errors.h"
-#include "../Utils/utils.h"
-#include "../Utils/json.hpp"
+#include "errors.h"
+#include "utils.h"
+#include "json.hpp"
 
-#include "../GraphCall/graph_calls_func.h"
+#include "graph_calls_func.h"
 
 using std::vector;
 using std::tuple;
@@ -364,11 +364,11 @@ static inline string calculateShifts(DIST::GraphCSR<int, double, attrType> &redu
             {
                 if (sharedMemoryParallelization)
                 {
-                    for (auto& coefs : currReadOp->first[k].coefficients)
+                    for (auto& coeffs : currReadOp->first[k].coefficients)
                     {
-                        auto currAccess = coefs.first;
+                        auto currAccess = coeffs.first;
 
-                        const int currShift = coefs.first.second;
+                        const int currShift = coeffs.first.second;
 
                         auto itFound = shiftsByAccess[k].find(currAccess);
                         if (itFound == shiftsByAccess[k].end())
@@ -393,9 +393,9 @@ static inline string calculateShifts(DIST::GraphCSR<int, double, attrType> &redu
                             int minShift = 9999999;
                             int maxShift = -9999999;
 
-                            for (auto &coefs : currReadOp->first[k].coefficients)
+                            for (auto &coeffs : currReadOp->first[k].coefficients)
                             {
-                                auto currAccess = coefs.first;
+                                auto currAccess = coeffs.first;
                                 auto result = DIST::Fx(currAccess, currRuleShadow);
 
                                 if (result.first == loopRule.first)
@@ -417,7 +417,7 @@ static inline string calculateShifts(DIST::GraphCSR<int, double, attrType> &redu
                                     auto it = remoteRegularReads.find(calcForArray);
                                     if (it == remoteRegularReads.end())
                                         it = remoteRegularReads.insert(it, make_pair(calcForArray, vector<ArrayOp>(calcForArray->GetDimSize())));
-                                    it->second[k].coefficients.insert(coefs);
+                                    it->second[k].coefficients.insert(coeffs);
                                 }
                             }
 
@@ -760,6 +760,8 @@ json AlignRuleBase::toJson()
         tuple["dimNum"] = dimNum;
         tuple["a"] = AB.first;
         tuple["b"] = AB.second;
+
+        alignRuleWithJ.push_back(tuple);
     }
     retVal["alignRuleWith"] = alignRuleWithJ;
     return retVal;

src/Distribution/DvmhDirectiveBase.h

@@ -3,7 +3,7 @@
 #include <vector>
 #include <string>
 
-#include "../Utils/json.hpp"
+#include "json.hpp"
 
 typedef enum lang : int { LANG_C, LANG_F } language;
 typedef enum dist : int { BLOCK, NONE } distType;

src/Distribution/DvmhDirective_func.h

@@ -4,7 +4,7 @@
 #include <string>
 #include <set>
 #include "dvm.h"
-#include "../Utils/types.h"
+#include "types.h"
 
 SgExpression* createAndSetNext(const int side, const int variant, SgExpression *p);
 std::vector<SgExpression*> genSubscripts(const std::vector<std::pair<int, int>> &shadowRenew, const std::vector<std::pair<int, int>> &shadowRenewShifts);

src/Distribution/GraphCSR.cpp

@@ -1,4 +1,4 @@
-#include "../Utils/leak_detector.h"
+#include "leak_detector.h"
 
 #include <algorithm>
 #include <string>
@@ -19,8 +19,8 @@ extern int passDone;
 #include "Cycle.h"
 #include "Arrays.h"
 #include "Array.h"
-#include "../Utils/errors.h"
-#include "../Utils/utils.h"
+#include "errors.h"
+#include "utils.h"
 #include "../VisualizerCalls/get_information.h"
 #include "../VisualizerCalls/SendMessage.h"
 
@@ -830,13 +830,13 @@ namespace Distribution
                         color[k] = WHITE;
 
                     findFrom = currentV;
-#ifdef _WIN32
+/*#ifdef _WIN32
                     if (needPrint)
                     {
                         wstring vertexM = std::to_wstring(k + 1) + L"/" + std::to_wstring(vertByTrees[t].size());
                         sendMessage_2lvl(wstring(L"ïîèñê ïðîñòûõ öèêëîâ â ãðàôå, îáðàáîòêà äåðåâà ") + wstring(treeM.begin(), treeM.end()) + L" âåðøèíû " + wstring(vertexM.begin(), vertexM.end()));
                     }
-#endif
+#endif*/
                     __spf_print(PRINT_TIMES && needPrint, "v (tree %d) = %d (with neighb %d) ", t, i, neighbors[i + 1] - neighbors[i]);
                     activeV[activeCounter++] = currentV;
                     FindLoop(cyclesTmp[t], currentV, currentV, numbers);
@@ -847,8 +847,8 @@ namespace Distribution
                 maxLoopDim = wasMaxLoopDim;
             }
 
-            if (needPrint)
-                sendMessage_2lvl(L"");
+            /*if (needPrint)
+                sendMessage_2lvl(2);*/
         }
         catch (int code)
         {

src/Distribution/GraphCSR.h

@@ -5,7 +5,7 @@
 #include <set>
 #include <tuple>
 
-#include "../Utils/RationalNum.h"
+#include "RationalNum.h"
 
 typedef enum links { RR_link, WR_link, WW_link } LinkType;
 

src/DvmhRegions/DvmhRegion.h

@@ -1,6 +1,6 @@
 #pragma once
 
-#include "../GraphLoop/graph_loops_func.h"
+#include "graph_loops_func.h"
 
 #include <string>
 

src/DvmhRegions/DvmhRegionInserter.cpp

@@ -11,9 +11,9 @@
 #include "DvmhRegionInserter.h"
 #include "DvmhRegions/RegionsMerger.h"
 #include "../VerificationCode/verifications.h"
-#include "../Transformations/function_purifying.h"
 #include "../LoopAnalyzer/loop_analyzer.h"
 #include "../DirectiveProcessing/directive_parser.h"
+#include "FunctionPurifying/function_purifying.h"
 
 using namespace std;
 
@@ -794,154 +794,6 @@ ArraySet DvmhRegionInserter::get_used_arrs_for_block(SgStatement* st, int usage_
     return usages;
 }
 
-static bool filterFromList(SgStatement* st, const set<string>& idents, bool exclude = false)
-{
-    bool empty = false;
-    SgExpression* list = st->expr(0);
-    vector<SgExpression*> newList;
-
-    int total = 0;
-    while (list)
-    {
-        if (exclude)
-        {
-            if (idents.find(list->lhs()->symbol()->identifier()) == idents.end())
-                newList.push_back(list->lhs());
-        }
-        else
-        {
-            if (idents.find(list->lhs()->symbol()->identifier()) != idents.end())
-                newList.push_back(list->lhs());
-        }
-        total++;
-        list = list->rhs();
-    }
-
-    if (newList.size() == 0)
-        empty = true;
-    else if (total != newList.size())
-        st->setExpression(0, makeExprList(newList));
-
-    return empty;
-}
-
-static string getInterfaceBlock(SgStatement* func, const FuncParam& pars)
-{
-    string oldFile = current_file->filename();
-    if (!func->switchToFile())
-        printInternalError(convertFileName(__FILE__).c_str(), __LINE__);
-
-    auto copy = duplicateProcedure(func, NULL, false, false, false, true);
-    const set<string> idents(pars.identificators.begin(), pars.identificators.end());
-
-    bool need = (func->symbol()->identifier() == string("bl182"));
-
-    //remove all exec
-    SgStatement* st = copy->lexNext();
-    SgStatement* last = copy->lastNodeOfStmt();
-    vector<SgStatement*> toExtract;
-
-    while (st != last)
-    {
-        if (isDVM_stat(st) || isSPF_stat(st))
-        {
-            if (st->variant() != ACC_ROUTINE_DIR)
-            {
-                toExtract.push_back(st);
-                st = st->lexNext();
-            }
-            else
-                st = st->lexNext();
-        }
-        else if (isSgExecutableStatement(st))
-        {
-            SgStatement* next = st->lastNodeOfStmt();
-            if (next != last)
-                next = next->lexNext();
-            toExtract.push_back(st);
-            st = next;
-        }
-        else
-            st = st->lexNext();
-    }  
-
-    //remove unused declarations
-    st = copy->lexNext();
-    while (st != last)
-    {
-        const int var = st->variant();
-
-        if (var == VAR_DECL
-            || var == VAR_DECL_90
-            || var == DIM_STAT
-            || var == INTENT_STMT
-            || var == EXTERN_STAT)
-        {
-            bool empty = filterFromList(st, idents);
-            if (empty)
-            {
-                toExtract.push_back(st);
-                st = st->lexNext();
-                continue;
-            }
-        }
-        else if (!isDVM_stat(st) && !isSPF_stat(st))
-            toExtract.push_back(st);
-
-        if (st->variant() == CONTAINS_STMT)
-            break;
-        st = st->lexNext();
-    }
-
-    for (auto& elem : toExtract)
-        elem->extractStmt();
-
-    string retVal = copy->unparse();
-
-    if (SgFile::switchToFile(oldFile) == -1)
-        printInternalError(convertFileName(__FILE__).c_str(), __LINE__);
-
-    return retVal;
-}
-
-static void insertInterface(SgStatement* func, const string& iface, const string& fName)
-{
-    string oldFile = current_file->filename();
-    if (!func->switchToFile())
-        printInternalError(convertFileName(__FILE__).c_str(), __LINE__);
-
-    SgStatement* st = func->lexNext();
-    SgStatement* last = func->lastNodeOfStmt();
-    while (st != last)
-    {
-        if (st->variant() == VAR_DECL || st->variant() == VAR_DECL_90)
-        {
-            bool empty = filterFromList(st, { fName }, true);
-            if (empty)
-            {
-                SgStatement* next = st->lexNext();
-                st->extractStmt();
-                st = next;
-                continue;
-            }
-        }
-
-        if (isSgExecutableStatement(st))
-            break;
-        st = st->lexNext();
-    }
-    SgStatement* ifaceBlock = new SgStatement(INTERFACE_STMT);
-    addControlEndToStmt(ifaceBlock->thebif);
-
-    ifaceBlock->setlineNumber(getNextNegativeLineNumber()); // st->lineNumber()
-    ifaceBlock->setFileName(st->fileName());
-    st->insertStmtBefore(*ifaceBlock, *st->controlParent());    
-    ifaceBlock->lastNodeOfStmt()->addComment(iface.c_str());
-
-    if (SgFile::switchToFile(oldFile) == -1)
-        printInternalError(convertFileName(__FILE__).c_str(), __LINE__);
-}
-
 static LoopGraph* getParallelLoop(LoopGraph* loop)
 {
     auto prev_st = loop->loop->lexPrev();
@@ -1172,7 +1024,7 @@ static bool isPure(SgStatement* func)
 
 void DvmhRegionInserter::createInterfaceBlockForOutCall(FuncInfo* func, FuncInfo* callFrom)
 {
-    insertInterface(func->funcPointer, getInterfaceBlock(callFrom->funcPointer->GetOriginal(), callFrom->funcParams), callFrom->funcName);
+    insertInterface(func->funcPointer, callFrom);
 }
 
 void DvmhRegionInserter::createInterfaceBlockForParallelFunctions(bool onlyRoutine)
@@ -1445,7 +1297,10 @@ static set<DIST::Array*>
                 {
                     declStat = SgStatement::getStatementByFileAndLine(decl.first, decl.second);
                     if (declStat == NULL) // check in inlcudes 
-                    {                        
+                    {
+                        if (!main->switchToFile())
+                            printInternalError(convertFileName(__FILE__).c_str(), __LINE__);
+
                         for (auto st = main; st != main->lastNodeOfStmt() && !declStat; st = st->lexNext())
                         {
                             if (st->fileName() == decl.first && st->lineNumber() == decl.second)
@@ -1457,7 +1312,7 @@ static set<DIST::Array*>
                     }
                     else
                     {
-                        declStat = getFuncStat(declStat);
+                        declStat = getFuncStat(declStat, { BLOCK_DATA });
                         if (declStat != main)
                         {
                             declStat = NULL;

src/DvmhRegions/DvmhRegionInserter.h

@@ -1,10 +1,10 @@
 #pragma once
 
-#include "../GraphCall/graph_calls_func.h"
-#include "../GraphLoop/graph_loops_func.h"
-#include "../ExpressionTransform/expr_transform.h"
+#include "graph_calls_func.h"
+#include "graph_loops_func.h"
+#include "expr_transform.h"
 #include "../ParallelizationRegions/ParRegions.h"
-#include "../Utils/SgUtils.h"
+#include "SgUtils.h"
 #include "ReadWriteAnalyzer.h"
 #include "DvmhRegion.h"
 

src/DvmhRegions/LoopChecker.h

@@ -1,7 +1,7 @@
 #pragma once
 
-#include "../GraphLoop/graph_loops_func.h"
-#include "../GraphCall/graph_calls_func.h"
+#include "graph_loops_func.h"
+#include "graph_calls_func.h"
 
 #include <vector>
 #include <string>

src/DvmhRegions/ReadWriteAnalyzer.h

@@ -1,7 +1,7 @@
 #pragma once
 
 #include "dvm.h"
-#include "../Utils/SgUtils.h"
+#include "SgUtils.h"
 #include "VarUsages.h"
 #include <set>
 #include <tuple>

src/DvmhRegions/TypedSymbol.h

@@ -1,7 +1,7 @@
 #pragma once
 
 #include "dvm.h"
-#include "../Utils/SgUtils.h"
+#include "SgUtils.h"
 #include <string>
 
 enum class VAR_TYPE { VAR_ARR, VAR_DISTR_ARR, VAR_SCALAR, VAR_ANY, VAR_UNDEFINED };

src/DynamicAnalysis/createParallelRegions.cpp

@@ -5,10 +5,10 @@
 #include "./createParallelRegions.h"
 
 #include "../CreateInterTree/CreateInterTree.h"
-#include "../GraphCall/graph_calls.h"
+#include "graph_calls.h"
 #include "./gcov_info.h"
 #include "./gCov_parser_func.h"
-#include "../Utils/leak_detector.h"
+#include "leak_detector.h"
 
 #include <map>
 #include <vector>

src/DynamicAnalysis/createParallelRegions.h

@@ -1,10 +1,10 @@
 #pragma once
 
-#include "../Utils/utils.h"
+#include "utils.h"
 
 #include "./gcov_info.h"
 #include "../CreateInterTree/CreateInterTree.h"
-#include "../GraphCall/graph_calls.h"
+#include "graph_calls.h"
 
 #include <map>
 #include <vector>

src/DynamicAnalysis/gCov_parser.cpp

@@ -1,4 +1,4 @@
-#include "../Utils/leak_detector.h"
+#include "leak_detector.h"
 
 #include <stdio.h>
 #include <fstream>
@@ -8,7 +8,7 @@
 
 #include "dvm.h"
 #include "gCov_parser_func.h"
-#include "../Utils/SgUtils.h"
+#include "SgUtils.h"
 
 using namespace std;
 

src/DynamicAnalysis/gCov_parser_func.h

@@ -5,7 +5,7 @@
 #include <vector>
 
 #include "dvm.h"
-#include "../Utils/errors.h"
+#include "errors.h"
 #include "gcov_info.h"
 #include "../CreateInterTree/CreateInterTree.h"
 

src/DynamicAnalysis/gcov_info.cpp

@@ -1,10 +1,10 @@
-#include "../Utils/leak_detector.h"
+#include "leak_detector.h"
 
 #include <iostream>
 #include <map>
 #include <algorithm>
 
-#include "../Utils/errors.h"
+#include "errors.h"
 
 #include "gcov_info.h"
 

src/DynamicAnalysis/gcov_info.h

@@ -5,7 +5,7 @@
 #include <map>
 #include <stdint.h>
 
-#include "../Utils/utils.h"
+#include "utils.h"
 
 //make 'class' - need friend for Gcov_info
 struct Perform

src/GraphCall/graph_calls.cpp

@@ -1,4 +1,4 @@
-#include "../Utils/leak_detector.h"
+#include "leak_detector.h"
 
 #include <cstdio>
 #include <cstdlib>
@@ -14,14 +14,14 @@
 #include "dvm.h"
 #include "graph_calls_func.h"
 
-#include "../CFGraph/CFGraph.h"
-#include "../GraphLoop/graph_loops_func.h"
+#include "CFGraph/CFGraph.h"
+#include "graph_loops_func.h"
 #include "../DirectiveProcessing/directive_parser.h"
-#include "../Utils/SgUtils.h"
-#include "../Utils/json.hpp"
+#include "SgUtils.h"
+#include "json.hpp"
 #include "../ParallelizationRegions/ParRegions_func.h"
 #include "../DynamicAnalysis/gCov_parser_func.h"
-#include "../ExpressionTransform/expr_transform.h"
+#include "expr_transform.h"
 #include "../LoopAnalyzer/loop_analyzer.h"
 #include "../VerificationCode/verifications.h"
 
@@ -779,6 +779,20 @@ static void checkSpecList(SgExpression *spec, FuncInfo* currF, const map<string,
     }
 }
 
+static void checkInTypeDescription(SgExpression *ex, FuncInfo* currF, const map<string, int>& parNames)
+{
+    if (ex)
+    {
+        if (ex->variant() == ARRAY_REF)
+            fillIn(currF, ex->lhs(), parNames, false);
+        else
+        {
+            checkInTypeDescription(ex->lhs(), currF, parNames);
+            checkInTypeDescription(ex->rhs(), currF, parNames);
+        }
+    }
+}
+
 static void fillInOut(FuncInfo *currF, SgStatement *start, SgStatement *last, const set<SgStatement*>& activeOps)
 {
     if (currF->funcParams.countOfPars == 0)
@@ -798,8 +812,13 @@ static void fillInOut(FuncInfo *currF, SgStatement *start, SgStatement *last, co
 
         if (st->variant() == ENTRY_STAT)
             continue;
+        
+        if (isSgExecutableStatement(st) == NULL) {
+            checkInTypeDescription(st->expr(0), currF, parNames);
+            continue;
+        }
 
-        if (isSgExecutableStatement(st) == NULL || st->lineNumber() <= 0)
+        if (st->lineNumber() <= 0)
             continue;
 
         if (activeOps.size() && activeOps.find(st) == activeOps.end())

src/GraphCall/graph_calls.h

@@ -3,10 +3,10 @@
 #include <string>
 #include <set>
 
-#include "../Utils/AstWrapper.h"
-#include "../Utils/utils.h"
+#include "AstWrapper.h"
+#include "utils.h"
 #include "../DirectiveProcessing/shadow.h"
-#include "../GraphLoop/graph_loops.h"
+#include "graph_loops.h"
 
 static const char* paramNames[] = 
 { "NONE_T", "ARRAY_T", "STRING_ARRAY_T", "STRING_T", "SCALAR_CHAR_T", "SCALAR_BOOL_T", "SCALAR_SHORT_T", "SCALAR_INT_T", "SCALAR_LONG_INT_T",

src/GraphCall/graph_calls_base.cpp

@@ -1,4 +1,4 @@
-#include "../Utils/leak_detector.h"
+#include "leak_detector.h"
 
 #include <cstdio>
 #include <cstdlib>
@@ -10,10 +10,10 @@
 #include <set>
 #include <string>
 
-#include "../Utils/errors.h"
+#include "errors.h"
 #include "graph_calls.h"
 #include "../Distribution/Distribution.h"
-#include "../Utils/utils.h"
+#include "utils.h"
 #include "../ParallelizationRegions/ParRegions.h"
 
 using std::vector;

src/GraphCall/graph_calls_func.h

@@ -5,7 +5,7 @@
 #include <set>
 
 #include "graph_calls.h"
-#include "../GraphLoop/graph_loops.h"
+#include "graph_loops.h"
 #include "../ParallelizationRegions/ParRegions.h"
 #include "Utils/json.hpp"
 

src/GraphLoop/graph_loops.cpp

@@ -1,4 +1,4 @@
-#include "../Utils/leak_detector.h"
+#include "leak_detector.h"
 
 #include <cstdio>
 #include <cstdlib>
@@ -12,26 +12,26 @@
 
 #include "dvm.h"
 #include "../Sapfor.h"
-#include "../GraphCall/graph_calls_func.h"
+#include "graph_calls_func.h"
 #include "../ParallelizationRegions/ParRegions_func.h"
-#include "../ExpressionTransform/expr_transform.h"
+#include "expr_transform.h"
 
 #include "../Distribution/GraphCSR.h"
 #include "../Distribution/Arrays.h"
 #include "../Distribution/Distribution.h"
 
 #include "graph_loops.h"
-#include "../Utils/utils.h"
-#include "../Utils/SgUtils.h"
+#include "utils.h"
+#include "SgUtils.h"
 
-#include "../Utils/errors.h"
-#include "../Utils/AstWrapper.h"
-#include "../Utils/json.hpp"
+#include "errors.h"
+#include "AstWrapper.h"
+#include "json.hpp"
 
 #include "../DirectiveProcessing/directive_parser.h"
 #include "../DynamicAnalysis/gCov_parser_func.h"
 
-#include "../Transformations/array_assign_to_loop.h"
+#include "VectorAssignToLoop/array_assign_to_loop.h"
 
 using std::vector;
 using std::map;
@@ -520,7 +520,7 @@ static void findArrayRef(SgExpression *exp, bool isWirte, set<DIST::Array*>& use
 {
     if (exp)
     {
-        if (exp->variant() == ARRAY_REF)
+        if (isArrayRef(exp))
         {
             DIST::Array *arrayRef = NULL;
             SgSymbol *symbS = OriginalSymbol(exp->symbol());
@@ -699,7 +699,12 @@ void loopGraphAnalyzer(SgFile *file, vector<LoopGraph*> &loopGraph, const vector
                 newLoop->hasPrints = hasThisIds(st, newLoop->linesOfIO, { WRITE_STAT, READ_STAT, OPEN_STAT, CLOSE_STAT, PRINT_STAT } ); // FORMAT_STAT
                 newLoop->hasStops = hasThisIds(st, newLoop->linesOfStop, { STOP_STAT, PAUSE_NODE });
                 newLoop->hasDvmIntervals = hasThisIds(st, tmpLines, { DVM_INTERVAL_DIR, DVM_ENDINTERVAL_DIR, DVM_EXIT_INTERVAL_DIR });
-                newLoop->isFor = isSgForStmt(st) ? true : false;
+                if (isSgForStmt(st))
+                    newLoop->loopType = LoopType::FOR;
+                else if (isSgWhileStmt(st))
+                    newLoop->loopType = LoopType::WHILE;
+                else 
+                    newLoop->loopType = LoopType::NONE;
                 newLoop->inCanonicalFrom = isSgForStmt(st) ? true : false;
                 newLoop->hasSubstringRefs = hasSubstringRef(st);
 
@@ -777,7 +782,7 @@ void loopGraphAnalyzer(SgFile *file, vector<LoopGraph*> &loopGraph, const vector
                     newLoop->startEndExpr = std::make_pair((Expression*)NULL, (Expression*)NULL);
 
                 newLoop->loop = new Statement(st);
-                newLoop->loopSymbol = st->symbol() ? st->symbol()->identifier() : "unknown";
+                newLoop->loopSymbols.addMainVar(st->symbol() ? st->symbol()->identifier() : "unknown");
                 findArrayRefs(newLoop);
 
                 SgStatement *lexPrev = st->lexPrev();

src/GraphLoop/graph_loops.h

@@ -5,8 +5,8 @@
 #include <map>
 #include <set>
 
-#include "../Utils/errors.h"
-#include "../Utils/types.h"
+#include "errors.h"
+#include "types.h"
 #include "../Distribution/DvmhDirective.h"
 #include "../Distribution/Distribution.h"
 
@@ -25,6 +25,33 @@ namespace DIST = Distribution;
 void getRealArrayRefs(DIST::Array* addTo, DIST::Array* curr, std::set<DIST::Array*>& realArrayRefs, const std::map<DIST::Array*, std::set<DIST::Array*>>& arrayLinksByFuncCalls);
 void getAllArrayRefs(DIST::Array* addTo, DIST::Array* curr, std::set<DIST::Array*>& realArrayRefs, const std::map<DIST::Array*, std::set<DIST::Array*>>& arrayLinksByFuncCalls);
 
+enum class LoopType { NONE, FOR, WHILE, IMPLICIT };
+
+struct InductiveVariables
+{
+private:
+    std::string mainVar;
+    std::set<std::string> allVars;
+
+public:
+    InductiveVariables() { }
+
+    explicit InductiveVariables(const std::string& mainVar, const std::set<std::string>& allVars) : mainVar(mainVar), allVars(allVars) { };
+
+    std::string getMainVar() const { return mainVar; }
+    std::set<std::string> getAllVars() const { return allVars; }
+
+    void addVar(const std::string& var) { allVars.insert(var); }
+    void addMainVar(const std::string& var) { mainVar = var; allVars.insert(var); }
+
+    void replaceMainVar(const std::string& var) 
+    {
+        allVars.erase(mainVar);
+
+        addMainVar(var);
+    }
+};
+
 struct LoopGraph
 {
 private:
@@ -70,7 +97,7 @@ public:
         calculatedCountOfIters = 0;
         executionTimeInSec = -1.0;
         inDvmhRegion = 0;
-        isFor = false;
+        loopType = LoopType::NONE;
         inCanonicalFrom = false;
         hasAccessToSubArray = false;
         hasSubstringRefs = false;
@@ -113,21 +140,24 @@ public:
     {
         return hasUnknownArrayDep || hasUnknownScalarDep || hasGoto || hasPrints || (hasConflicts.size() != 0) || hasStops || hasNonPureProcedures ||
                hasUnknownArrayAssigns || hasNonRectangularBounds || hasIndirectAccess || hasWritesToNonDistribute || hasDifferentAlignRules || hasDvmIntervals ||
-               !isFor || lastprivateScalars.size() || hasAccessToSubArray || hasSubstringRefs;
+               !isFor() || lastprivateScalars.size() || hasAccessToSubArray || hasSubstringRefs;
     }
     
     bool hasLimitsToSplit() const
     {
-        return hasGoto || hasStops || !isFor || hasPrints;
+        return hasGoto || hasStops || !isFor() || hasPrints;
     }
 
     bool hasLimitsToCombine() const
     {
-        return hasGoto || hasStops || !isFor || hasPrints || linesOfCycle.size();
+        return hasGoto || hasStops || !isFor() || hasPrints || linesOfCycle.size();
     }
 
     void addConflictMessages(std::vector<Messages> *messages)
     {
+        if (messages == NULL)
+            return;
+
         const int line = altLineNum > 0 ? altLineNum : lineNum;
         if (hasUnknownArrayDep)
             messages->push_back(Messages(NOTE, line, R113, L"unknown array dependency prevents parallelization of this loop", 3006));
@@ -168,7 +198,7 @@ public:
         if (hasDvmIntervals)
             messages->push_back(Messages(NOTE, line, R145, L"DVM intervals prevent parallelization of this loop", 3006));
 
-        if (!isFor || !inCanonicalFrom)
+        if (!isFor() || !inCanonicalFrom)
             messages->push_back(Messages(NOTE, line, R178, L"This type of loop is not supported by the system", 3006));
 
         if (lastprivateScalars.size())
@@ -393,6 +423,14 @@ public:
 
     void* getRealStat(const char* file) const;
 
+    bool isFor() const { return loopType == LoopType::FOR; }
+
+    bool isWhile() const { return loopType == LoopType::WHILE; }
+
+    bool isImplicit() const { return loopType == LoopType::IMPLICIT; }
+
+    std::string loopSymbol() const { return loopSymbols.getMainVar(); }
+
 public:
     int lineNum;
     int altLineNum;
@@ -407,7 +445,7 @@ public:
     int startVal, endVal, stepVal;
     std::tuple<Expression*, Expression*, Expression*> startEndStepVals;
 
-    std::string loopSymbol;
+    InductiveVariables loopSymbols;
     std::pair<Expression*, Expression*> startEndExpr;
 
     bool hasGoto;
@@ -448,7 +486,7 @@ public:
 
     bool hasSubstringRefs;
 
-    bool isFor;
+    LoopType loopType;
 
     bool inCanonicalFrom;
     

src/GraphLoop/graph_loops_base.cpp

@@ -1,4 +1,4 @@
-#include "../Utils/leak_detector.h"
+#include "leak_detector.h"
 
 #include <cstdio>
 #include <cstdlib>
@@ -23,8 +23,8 @@ using std::make_pair;
 using std::get;
 
 #include "graph_loops.h"
-#include "../GraphCall/graph_calls_func.h"
-#include "../Utils/errors.h"
+#include "graph_calls_func.h"
+#include "errors.h"
 #include "../Distribution/Distribution.h"
 #include "../Distribution/CreateDistributionDirs.h"
 #include "../ParallelizationRegions/ParRegions.h"
@@ -551,7 +551,7 @@ void addToDistributionGraph(const map<LoopGraph*, map<DIST::Array*, ArrayInfo*>>
             continue;
         }
 
-        if (!loopAccess.first->isFor)
+        if (!loopAccess.first->isFor())
             continue;
 
         DIST::GraphCSR<int, double, attrType>& G = currReg->GetGraphToModify();
@@ -775,7 +775,7 @@ static void isAllOk(const vector<LoopGraph*> &loops, vector<Messages> &currMessa
     {
         if (loops[i]->region)
         {            
-            if (loops[i]->countOfIters == 0 && loops[i]->region && loops[i]->isFor)
+            if (loops[i]->countOfIters == 0 && loops[i]->region && loops[i]->isFor())
             {
                 wstring bufE, bufR;
                 __spf_printToLongBuf(bufE, L"  Can not calculate count of iterations for this loop, information about iterations in all loops in parallel regions '%s' will be ignored", 
@@ -1137,9 +1137,9 @@ static bool isMapped(const vector<ArrayOp> &allOps)
     bool mapped = false;
     for (auto &ops : allOps)
     {
-        for (auto &coefs : ops.coefficients)
+        for (auto &coeffs : ops.coefficients)
         {
-            if (coefs.first.first != 0)
+            if (coeffs.first.first != 0)
             {
                 mapped = true;
                 break;

src/LoopAnalyzer/allocations_prepoc.cpp

@@ -1,4 +1,4 @@
-#include "../Utils/leak_detector.h"
+#include "leak_detector.h"
 
 #include <cstdio>
 #include <cstdlib>
@@ -8,8 +8,8 @@
 #include <set>
 
 #include "dvm.h"
-#include "../Utils/SgUtils.h"
-#include "../Utils/errors.h"
+#include "SgUtils.h"
+#include "errors.h"
 
 using std::set;
 using std::pair;

src/LoopAnalyzer/dep_analyzer.cpp

@@ -1,4 +1,4 @@
-#include "../Utils/leak_detector.h"
+#include "leak_detector.h"
 
 #include <cstdio>
 #include <cstdlib>
@@ -20,8 +20,8 @@
 #include "dvm.h"
 #include "loop_analyzer.h"
 
-#include "../Utils/utils.h"
-#include "../Utils/SgUtils.h"
+#include "utils.h"
+#include "SgUtils.h"
 #include "../ParallelizationRegions/ParRegions_func.h"
 #include "../SageAnalysisTool/depGraph.h"
 #include "../SageAnalysisTool/OmegaForSage/include/lang-interf.h"

src/LoopAnalyzer/loop_analyzer.cpp

@@ -18,7 +18,7 @@
 #include <tuple>
 #include <stack>
 
-#include "../Utils/leak_detector.h"
+#include "leak_detector.h"
 
 #if _WIN32 && NDEBUG && __BOOST
 #include <boost/thread.hpp>
@@ -30,25 +30,25 @@ extern int passDone;
 #include "../Distribution/Arrays.h"
 #include "../ParallelizationRegions/ParRegions.h"
 
-#include "../Utils/errors.h"
+#include "errors.h"
 #include "../DirectiveProcessing/directive_parser.h"
 #include "../DirectiveProcessing/directive_creator.h"
 
-#include "../Utils/SgUtils.h"
-#include "../Utils/AstWrapper.h"
+#include "SgUtils.h"
+#include "AstWrapper.h"
 
-#include "../GraphCall/graph_calls_func.h"
-#include "../GraphLoop/graph_loops_func.h"
+#include "graph_calls_func.h"
+#include "graph_loops_func.h"
 #include "../ParallelizationRegions/ParRegions_func.h"
 #include "../DynamicAnalysis/gCov_parser_func.h"
 
-#include "../ExpressionTransform/expr_transform.h"
+#include "expr_transform.h"
 #include "../SageAnalysisTool/depInterfaceExt.h"
 
 #include "../VisualizerCalls/get_information.h"
 #include "../VisualizerCalls/SendMessage.h"
 
-#include "../Transformations/enddo_loop_converter.h"
+#include "LoopEndDoConverter/enddo_loop_converter.h"
 
 #include "../DirectiveProcessing/remote_access.h"
 #include "../DirectiveProcessing/directive_omp_parser.h"
@@ -247,7 +247,7 @@ static vector<int> matchSubscriptToLoopSymbols(const vector<SgForStmt*> &parentL
         }
     }
 
-    pair<int, int> coefs = pair<int, int>(0, 0);
+    pair<int, int> coeffs = pair<int, int>(0, 0);
     // more than one loop symbol in subscription
     if (countOfSymbols > 1)
     {
@@ -326,16 +326,16 @@ static vector<int> matchSubscriptToLoopSymbols(const vector<SgForStmt*> &parentL
         {
             if (subscr->symbol()->id() == (parentLoops[position]->doName())->id())
             {
-                coefs.first = 1;
+                coeffs.first = 1;
                 needToCacl = false;
             }
         }
 
         if (needToCacl)
-            getCoefsOfSubscript(coefs, subscr, parentLoops[position]->doName());
-        __spf_print(PRINT_ARRAY_ARCS, " <%d %d> ", coefs.first, coefs.second);
+            getCoefsOfSubscript(coeffs, subscr, parentLoops[position]->doName());
+        __spf_print(PRINT_ARRAY_ARCS, " <%d %d> ", coeffs.first, coeffs.second);
 
-        if (coefs.first == 0) // && coefs.second == 0)
+        if (coeffs.first == 0) // && coeffs.second == 0)
         {
             if (currRegime == REMOTE_ACC)
             {
@@ -346,7 +346,7 @@ static vector<int> matchSubscriptToLoopSymbols(const vector<SgForStmt*> &parentL
             {                
                 const pair<bool, string> &arrayRefString = constructArrayRefForPrint(arrayRef, dimNum, origSubscr);
                 __spf_print(1, "WARN: can not calculate index expression for array ref '%s' at line %d\n", arrayRefString.second.c_str(), currLine);
-                addInfoToVectors(loopInfo, parentLoops[position], currOrigArrayS, dimNum, coefs, UNREC_OP, numOfSubscriptions, currentW);
+                addInfoToVectors(loopInfo, parentLoops[position], currOrigArrayS, dimNum, coeffs, UNREC_OP, numOfSubscriptions, currentW);
                 if (side == LEFT)
                     allPositions.clear();
 
@@ -371,19 +371,19 @@ static vector<int> matchSubscriptToLoopSymbols(const vector<SgForStmt*> &parentL
                         currOp.resize(numOfSubscriptions);
 
                     //add only uniq 
-                    auto itAdd = currOp[dimNum].coefficients.find(coefs);
+                    auto itAdd = currOp[dimNum].coefficients.find(coeffs);
                     if (itAdd == currOp[dimNum].coefficients.end())
-                        itAdd = currOp[dimNum].coefficients.insert(itAdd, make_pair(coefs, currentW));
+                        itAdd = currOp[dimNum].coefficients.insert(itAdd, make_pair(coeffs, currentW));
                 }
 
-                if (coefs.first < 0)
+                if (coeffs.first < 0)
                     addInfoToMap(loopInfo, parentLoops[position], currOrigArrayS, arrayRef, dimNum, REMOTE_TRUE, currLine, numOfSubscriptions);
                 else
                     //if we found regular access to array - set it false
                     addInfoToMap(loopInfo, parentLoops[position], currOrigArrayS, arrayRef, dimNum, REMOTE_FALSE, currLine, numOfSubscriptions);
             }
 
-            if (coefs.first < 0 && sharedMemoryParallelization == 0)
+            if (coeffs.first < 0 && sharedMemoryParallelization == 0)
             {
                 if (currRegime == DATA_DISTR)
                 {
@@ -402,15 +402,15 @@ static vector<int> matchSubscriptToLoopSymbols(const vector<SgForStmt*> &parentL
                     if (side == LEFT)
                         allPositions.clear();
                     else
-                        addInfoToVectors(loopInfo, parentLoops[position], currOrigArrayS, dimNum, coefs, UNREC_OP, numOfSubscriptions, currentW);
+                        addInfoToVectors(loopInfo, parentLoops[position], currOrigArrayS, dimNum, coeffs, UNREC_OP, numOfSubscriptions, currentW);
                 }
             }
             else
             {
                 if (side == LEFT)
-                    addInfoToVectors(loopInfo, parentLoops[position], currOrigArrayS, dimNum, coefs, WRITE_OP, numOfSubscriptions, currentW);
+                    addInfoToVectors(loopInfo, parentLoops[position], currOrigArrayS, dimNum, coeffs, WRITE_OP, numOfSubscriptions, currentW);
                 else
-                    addInfoToVectors(loopInfo, parentLoops[position], currOrigArrayS, dimNum, coefs, READ_OP, numOfSubscriptions, currentW);
+                    addInfoToVectors(loopInfo, parentLoops[position], currOrigArrayS, dimNum, coeffs, READ_OP, numOfSubscriptions, currentW);
             }
         }
     }
@@ -418,13 +418,13 @@ static vector<int> matchSubscriptToLoopSymbols(const vector<SgForStmt*> &parentL
     if (currRegime == ARRAY_ACC_CORNER)
     {
         int *valueSubs = new int[2];
-        valueSubs[0] = coefs.first;
-        valueSubs[1] = coefs.second;
+        valueSubs[0] = coeffs.first;
+        valueSubs[1] = coeffs.second;
 #ifdef __SPF
         addToCollection(__LINE__, __FILE__, valueSubs, 2);
 #endif
-        const vector<int*> &coefs = getAttributes<SgExpression*, int*>(subscr, set<int>{ INT_VAL });
-        if (coefs.size() == 0)
+        const vector<int*> &coeffs = getAttributes<SgExpression*, int*>(subscr, set<int>{ INT_VAL });
+        if (coeffs.size() == 0)
         {
             subscr->addAttribute(INT_VAL, valueSubs, sizeof(int*));
             if (position != -1 && allPositions.size() == 1 && position < parentLoops.size())
@@ -1633,17 +1633,7 @@ void loopAnalyzer(SgFile *file, vector<ParallelRegion*> &regions, map<tuple<int,
         createNeededException();
 
         string fName = file->functions(i)->symbol()->identifier();
-#if _WIN32
-        if (file->functions(i)->variant() != MODULE_STMT)
-            sendMessage_2lvl(wstring(L"îáðàáîòêà ôóíêöèè '") + wstring(fName.begin(), fName.end()) + L"'");
-        else
-            sendMessage_2lvl(wstring(L"îáðàáîòêà ìîäóëÿ '") + wstring(fName.begin(), fName.end()) + L"'");
-#else
-        if (file->functions(i)->variant() != MODULE_STMT)
-            sendMessage_2lvl(wstring(L"processing function '") + wstring(fName.begin(), fName.end()) + L"'");
-        else
-            sendMessage_2lvl(wstring(L"processing module '") + wstring(fName.begin(), fName.end()) + L"'");
-#endif
+        sendMessage_2lvl(0, (file->functions(i)->variant() != MODULE_STMT), fName);
 
         set<SgSymbol*> delcsSymbViewed;
         set<SgStatement*> delcsStatViewed;
@@ -1710,7 +1700,10 @@ void loopAnalyzer(SgFile *file, vector<ParallelRegion*> &regions, map<tuple<int,
         map<string, pair<SgSymbol*, SgStatement*>> notMappedDistributedArrays;
         set<string> mappedDistrbutedArrays;
 
+        const ParallelRegionLines* prevParLines = NULL;
+        double prevLinesWeight = 1.0;
         double currentWeight = 1.0;
+
         while (st != lastNode)
         {
             createNeededException();
@@ -1733,13 +1726,31 @@ void loopAnalyzer(SgFile *file, vector<ParallelRegion*> &regions, map<tuple<int,
             }
 
             const int currentLine = st->lineNumber() < -1 ? st->localLineNumber() : st->lineNumber();
-            ParallelRegion *currReg = getRegionByLine(regions, st->fileName(), currentLine);
+            auto regAndLines = getRegionAndLinesByLine(regions, st->fileName(), currentLine);
+
+            auto *currReg = regAndLines.first;
+            auto *parLines = regAndLines.second;
             if (currReg == NULL)
             {
                 st = st->lexNext();
                 continue;
             }
 
+            if (parLines != prevParLines)
+            {
+                prevParLines = parLines;
+                auto newParLinesWeight = parLines ? parLines->weight : 1.0;
+
+                if (prevParLines)
+                    currentWeight /= prevLinesWeight;
+
+                if (parLines)
+                    currentWeight *= newParLinesWeight;
+
+                prevLinesWeight = newParLinesWeight;
+                prevParLines = parLines;
+            }
+
             if (isSgExecutableStatement(st) == NULL)
                 delcsStatViewed.insert(st);
             else if (!sharedMemoryParallelization && 
@@ -2167,11 +2178,8 @@ void loopAnalyzer(SgFile *file, vector<ParallelRegion*> &regions, map<tuple<int,
                 if (!skipDeps)
                 {
                     string fName = file->functions(i)->symbol()->identifier();
-#ifdef _WIN32
-                    sendMessage_2lvl(wstring(L"îáðàáîòêà öèêëà ") + std::to_wstring(idx) + L"/" + std::to_wstring(convertedLoopInfo.size()));
-#else
-                    sendMessage_2lvl(wstring(L"processing loop ") + std::to_wstring(idx) + L"/" + std::to_wstring(convertedLoopInfo.size()));
-#endif
+                    sendMessage_2lvl(1, idx, (int)convertedLoopInfo.size());
+
                     tryToFindDependencies(loop.first, allLoops, funcWasInit, file, regions, currMessages, collection, funcByName, defUseByPlace);
                 }
             }
@@ -2191,7 +2199,7 @@ void loopAnalyzer(SgFile *file, vector<ParallelRegion*> &regions, map<tuple<int,
                             LoopGraph *tmpLoop = new LoopGraph();
 
                             tmpLoop->region = reg;
-                            tmpLoop->isFor = true;
+                            tmpLoop->loopType = LoopType::FOR;
 
                             tmpLoops.push_back(tmpLoop);
 
@@ -2319,7 +2327,7 @@ void loopAnalyzer(SgFile *file, vector<ParallelRegion*> &regions, map<tuple<int,
                 if (parallizeFreeLoops)
                     selectFreeLoopsForParallelization(loopsForFunction, funcName, (regime == DATA_DISTR), regions, messagesForFile);
             }
-            sendMessage_2lvl(L"");
+            sendMessage_2lvl(2);
         }
         else if (regime == COMP_DISTR)
         {

src/LoopAnalyzer/loop_analyzer.h

@@ -5,12 +5,12 @@
 #include <tuple>
 #include <vector>
 #include <set>
-#include "../GraphLoop/graph_loops.h"
-#include "../GraphCall/graph_calls.h"
+#include "graph_loops.h"
+#include "graph_calls.h"
 #include "../ParallelizationRegions/ParRegions.h"
 #include "../SageAnalysisTool/depInterfaceExt.h"
-#include "../Utils/AstWrapper.h"
-#include "../Utils/SgUtils.h"
+#include "AstWrapper.h"
+#include "SgUtils.h"
 
 #include "dvm.h"
 

src/ParallelizationRegions/ParRegions.cpp

@@ -1,4 +1,4 @@
-#include "../Utils/leak_detector.h"
+#include "leak_detector.h"
 
 #include <stdio.h>
 #include <stdlib.h>
@@ -10,12 +10,12 @@
 
 #include "dvm.h"
 #include "ParRegions.h"
-#include "../Utils/utils.h"
-#include "../Utils/SgUtils.h"
-#include "../GraphCall/graph_calls_func.h"
-#include "../GraphLoop/graph_loops.h"
+#include "utils.h"
+#include "SgUtils.h"
+#include "graph_calls_func.h"
+#include "graph_loops.h"
 #include "../Distribution/Distribution.h"
-#include "../ExpressionTransform/expr_transform.h"
+#include "expr_transform.h"
 
 using std::vector;
 using std::string;
@@ -93,8 +93,10 @@ static inline SgStatement* getParentStat(SgStatement *st)
     return iterator;
 }
 
-static void updateRegionInfo(SgStatement *st, map<string, pair<Statement*, Statement*>> &startEnd, map<string, pair<int, int>> &lines_,
-                             set<string> &funcCallFromReg, const map<string, FuncInfo*> &mapFuncs)
+static void updateRegionInfo(SgStatement *st, map<string, pair<Statement*, Statement*>> &startEnd,
+                             map<string, pair<int, int>> &lines_,
+                             map<string, map<string, set<int>>> &funcCallFromReg,
+                             const map<string, FuncInfo*> &mapFuncs)
 {    
     string containsPrefix = "";
     SgStatement *st_ps = getParentStat(st);
@@ -103,17 +105,26 @@ static void updateRegionInfo(SgStatement *st, map<string, pair<Statement*, State
         containsPrefix = st_ps->symbol()->identifier() + string(".");
 
     extendRegionInfo(st, startEnd, lines_);
+
+    set<string> callsFromStatement;
+
     if (st->variant() == PROC_STAT)
     {
         string fullName = st->symbol()->identifier();
         //check contains
         if (mapFuncs.find(containsPrefix + fullName) != mapFuncs.end())
             fullName = containsPrefix + fullName;
-        funcCallFromReg.insert(fullName);
+        callsFromStatement.insert(fullName);
     }
 
     for (int z = 0; z < 3; ++z)
-        findFuncCalls(st->expr(z), funcCallFromReg, containsPrefix, mapFuncs);
+        findFuncCalls(st->expr(z), callsFromStatement, containsPrefix, mapFuncs);
+
+    string filename = st->fileName();
+    int line = st->lineNumber();
+
+    for (const auto &func_name : callsFromStatement)
+        funcCallFromReg[func_name][filename].insert(line);
 }
 
 static void fillArrayNamesInReg(set<string> &usedArrayInRegion, SgExpression *exp)
@@ -318,8 +329,9 @@ void fillRegionLines(SgFile *file, vector<ParallelRegion*> &regions, vector<Mess
     string regionName = "";
     map<string, pair<Statement*, Statement*>> startEnd;
     map<string, pair<int, int>> lines_;
-    set<string> funcCallFromReg;
+    map<string, map<string, set<int>>> funcCallFromReg;
     bool regionStarted = false;
+    double fragmentWeight = 1.0;
 
     vector<SgStatement*> toDel;
     for (int i = 0; i < funcNum; ++i)
@@ -368,6 +380,33 @@ void fillRegionLines(SgFile *file, vector<ParallelRegion*> &regions, vector<Mess
                         itFunc->second->callRegions.insert(0);
                     }
                 }
+
+                // parse SPF_APPLY_FRAGMENT clause
+                auto *apply_fragment = data->expr(1);
+                fragmentWeight = 1.0;
+
+                while (apply_fragment)
+                {
+                    auto *curr = apply_fragment->lhs();
+                    if (curr)
+                    {
+                        __spf_print(1, "%s %d\n", curr->unparse(), curr->variant());
+
+                        if (curr->variant() == SPF_WEIGHT_OP)
+                        {
+                            if (curr->lhs() &&
+                                isSgValueExp(curr->lhs()) &&
+                                isSgValueExp(curr->lhs())->doubleValue())
+                            {
+                                fragmentWeight = strtod(isSgValueExp(curr->lhs())->doubleValue(), NULL);
+                                __spf_print(1, "->> %lf\n", fragmentWeight);
+                            }
+                            else
+                                __spf_print(1, "WEIGHT clause without double argument\n");
+                        }
+                    }
+                    apply_fragment = apply_fragment->rhs();
+                }
             }
 
             if (next && next->variant() == SPF_END_PARALLEL_REG_DIR)
@@ -400,10 +439,12 @@ void fillRegionLines(SgFile *file, vector<ParallelRegion*> &regions, vector<Mess
 
                 extendRegionInfo(st, startEnd, lines_, true);
                 for (auto itRegInfo = startEnd.begin(); itRegInfo != startEnd.end(); ++itRegInfo)
-                    currReg->AddLines(lines_[itRegInfo->first], itRegInfo->first, &itRegInfo->second);
+                    currReg->AddLines(lines_[itRegInfo->first], itRegInfo->first, &itRegInfo->second, fragmentWeight);
 
-                for (auto &func : funcCallFromReg)
-                    currReg->AddFuncCalls(func);
+                for (auto &by_func : funcCallFromReg)
+                    for (auto &by_file : by_func.second)
+                        for(auto &by_line : by_file.second)
+                            currReg->AddFuncCalls(by_func.first, by_file.first, by_line);
 
                 filterUserDirectives(currReg, usedArrayInRegion, userDvmRedistrDirs, userDvmRealignDirs, userDvmShadowDirs);
                 currReg->AddUserDirectives(userDvmRealignDirs, DVM_REALIGN_DIR);
@@ -496,34 +537,48 @@ void fillRegionLinesStep2(vector<ParallelRegion*> &regions, const map<string, ve
     {
         if (regions[i]->GetName() != "DEFAULT")
             for (auto &func : regions[i]->GetFuncCalls())
-                setExplicitFlag(func, funcMap);        
+                setExplicitFlag(func.first, funcMap);
     }
 
     for (int i = 0; i < regions.size(); ++i)
     {
         if (regions[i]->GetName() != "DEFAULT")
         {
-            set<string> uniqFuncCalls;
-            for (auto &elem : regions[i]->GetFuncCalls())
-                uniqFuncCalls.insert(elem);
+            map<string, double> uniqFuncCalls;
+            map<string, map<string, set<int>>> callPlaces;
+
+            for (auto &elem : regions[i]->GetFuncCalls())
+            {
+                double max_weight = 0;
+                for (auto* fragment : elem.second)
+                    if (fragment->weight > max_weight)
+                        max_weight = fragment->weight;
+
+                uniqFuncCalls[elem.first] = max_weight;
+            }
+
+            bool wasChanged = true;
+            auto funcsBefore = uniqFuncCalls;
 
-            bool wasChanged = 1;
             while (wasChanged)
             {
-                wasChanged = 0;
+                wasChanged = false;
+                auto updated = uniqFuncCalls;
+
                 for (auto &uniqF : uniqFuncCalls)
                 {
-                    auto func = funcMap.find(uniqF);
+                    auto func = funcMap.find(uniqF.first);
                     if (func != funcMap.end())
                     {
-                        for (auto &calls : func->second->callsFrom)
+                        for (auto &call : func->second->callsFromDetailed)
                         {
-                            auto it = uniqFuncCalls.find(calls);
-                            if (it == uniqFuncCalls.end())
-                            {
-                                uniqFuncCalls.insert(it, calls);
-                                wasChanged = 1;
-                            }
+                            auto it = updated.find(call.detailCallsFrom.first);
+                            if (it == updated.end())
+                                updated.insert({call.detailCallsFrom.first, uniqF.second});
+                            else
+                                it->second = std::max(it->second, uniqF.second);
+
+                            callPlaces[call.detailCallsFrom.first][func->second->fileName].insert(call.detailCallsFrom.second);
                         }
                     }
                 }
@@ -532,21 +587,27 @@ void fillRegionLinesStep2(vector<ParallelRegion*> &regions, const map<string, ve
             string toPrint = "";
             for (auto &elem : uniqFuncCalls)
             {
-                auto it = funcMap.find(elem);
+                auto it = funcMap.find(elem.first);
                 if (it != funcMap.end())
                 {
-                    regions[i]->AddLines(it->second->linesNum, it->second->fileName);
-                    regions[i]->AddFuncCallsToAllCalls(it->second);
+                    regions[i]->AddLines(it->second->linesNum, it->second->fileName, NULL, elem.second);
 
                     if (it->second->inRegion == 0)
                         it->second->inRegion = 2;
 
                     it->second->callRegions.insert(i);
 
-                    toPrint += elem + " ";
+                    toPrint += elem.first + " ";
                 }
             }
 
+            for (auto &elem : callPlaces)
+            {
+                for (const auto &byFile : elem.second)
+                    for (auto byLine : byFile.second)
+                        regions[i]->AddFuncCalls(elem.first, byFile.first, byLine);
+            }
+
             if (toPrint != "")
                 __spf_print(1, "[%s]: funcs: %s\n", regions[i]->GetName().c_str(), toPrint.c_str());
         }

src/ParallelizationRegions/ParRegions.h

@@ -9,17 +9,17 @@
 #include "../Distribution/DvmhDirective.h"
 #include "../Distribution/GraphCSR.h"
 #include "../Distribution/Distribution.h"
-#include "../Utils/AstWrapper.h"
+#include "AstWrapper.h"
 
-#include "../Utils/json.hpp"
+#include "json.hpp"
 
 #if __SPF
-#include "../Utils/SgUtils.h"
+#include "SgUtils.h"
 #endif
 
 struct ParallelRegionLines
 {
-    ParallelRegionLines() 
+    ParallelRegionLines(double weight = 1.0) : weight(weight)
     {
         lines = std::make_pair(-1, -1);
         stats = std::make_pair<Statement*, Statement*>(NULL, NULL);
@@ -27,14 +27,15 @@ struct ParallelRegionLines
         intervalAfter = std::make_pair<Statement*, Statement*>(NULL, NULL);
     }
 
-    ParallelRegionLines(const std::pair<int, int> &lines) : lines(lines) 
+    ParallelRegionLines(const std::pair<int, int> &lines, double weight = 1.0) : lines(lines), weight(weight)
     {
         stats = std::make_pair<Statement*, Statement*>(NULL, NULL);
         intervalBefore = std::make_pair<Statement*, Statement*>(NULL, NULL);
         intervalAfter = std::make_pair<Statement*, Statement*>(NULL, NULL);
     }
 
-    ParallelRegionLines(const std::pair<int, int> &lines, const std::pair<Statement*, Statement*> stats) : lines(lines), stats(stats)
+    ParallelRegionLines(const std::pair<int, int> &lines, const std::pair<Statement*, Statement*> stats, double weight = 1.0)
+        : lines(lines), stats(stats), weight(weight)
     {
         intervalBefore = std::make_pair<Statement*, Statement*>(NULL, NULL);
         intervalAfter = std::make_pair<Statement*, Statement*>(NULL, NULL);
@@ -62,6 +63,8 @@ struct ParallelRegionLines
     // <start, end> interval
     std::pair<Statement*, Statement*> intervalBefore;
     std::pair<Statement*, Statement*> intervalAfter;
+
+    double weight; // weight of the fragment among all fragments of this region
 };
 
 #if __SPF
@@ -116,7 +119,7 @@ public:
         currentVariant = copy.currentVariant;
     }
 
-    int AddLines(const std::pair<int, int> &linesToAdd, const std::string &file, const std::pair<Statement*, Statement*> *startEnd = NULL)
+    int AddLines(const std::pair<int, int> &linesToAdd, const std::string &file, const std::pair<Statement*, Statement*> *startEnd = NULL, double weight = 1.0)
     {
         if (linesToAdd.first > linesToAdd.second)
             return -1;
@@ -126,17 +129,29 @@ public:
             it = lines.insert(it, make_pair(file, std::vector<ParallelRegionLines>()));
 
         if (startEnd)
-            it->second.push_back(ParallelRegionLines(linesToAdd, *startEnd));
+            it->second.push_back(ParallelRegionLines(linesToAdd, *startEnd, weight));
         else
-            it->second.push_back(ParallelRegionLines(linesToAdd));
+            it->second.push_back(ParallelRegionLines(linesToAdd, weight));
 
         return 0;
     }
 
-    void AddFuncCalls(const std::string &func) { functionsCall.insert(func); }
+    void AddFuncCalls(const std::string &func, const std::string &file, const int line)
+    {
+        auto *found_lines = GetLinesByLine(file, line);
+
+        if (found_lines)
+            functionsCall[func].insert(found_lines);
+    }
 
 #if __SPF
-    void AddFuncCallsToAllCalls(FuncInfo *func) { allFunctionsCall.insert(func); }
+    void AddFuncCallsToAllCalls(FuncInfo *func, const std::string &file, const int line)
+    {
+        auto *found_lines = GetLinesByLine(file, line);
+
+        if (found_lines)
+            allFunctionsCall[func].insert(found_lines);
+    }
 #endif
 
     uint64_t GetId() const { return regionId; }
@@ -176,10 +191,10 @@ public:
     const DataDirective& GetDataDir() const { return dataDirectives; }
     DataDirective& GetDataDirToModify() { return dataDirectives; }
 
-    const std::set<std::string>& GetFuncCalls() const { return functionsCall; }
+    const std::map<std::string, std::set<const ParallelRegionLines*>>& GetFuncCalls() const { return functionsCall; }
 
 #if __SPF
-    const std::set<FuncInfo*>& GetAllFuncCalls() const { return allFunctionsCall; }
+    const std::map<FuncInfo*, std::set<const ParallelRegionLines*>>& GetAllFuncCalls() const { return allFunctionsCall; }
     const std::map<FuncInfo*, std::map<DIST::Array*, std::vector<ParallelRegionLines>>>& GetUsedLocalArrays() const { return usedLocalArrays; }
     const std::map<FuncInfo*, std::map<DIST::Array*, std::vector<ParallelRegionLines>>>& GetUsedCommonArrays() const { return usedCommonArrays; }
 
@@ -218,7 +233,7 @@ public:
     }
 #endif
 
-    bool HasThisLine(const int line, const std::string &file) const
+    bool HasThisLine(const int line, const std::string &file, const ParallelRegionLines** found = nullptr) const
     {
         bool retVal = false;
         auto it = lines.find(file);
@@ -229,6 +244,9 @@ public:
                 if (it->second[i].lines.first <= line && it->second[i].lines.second >= line)
                 {
                     retVal = true;
+                    if (found)
+                        *found = &(it->second[i]);
+
                     break;
                 }
             }
@@ -292,7 +310,7 @@ public:
         fprintf(fileOut, "  originalName '%s'\n", originalName.c_str());
         fprintf(fileOut, "  functions call from %d:\n", (int)functionsCall.size());
         for (auto &func : functionsCall)
-            fprintf(fileOut, "    '%s'\n", func.c_str());
+            fprintf(fileOut, "    '%s'\n", func.first.c_str());
         fprintf(fileOut, "  total lines %d:\n", (int)lines.size());
         for (auto &line : lines)
         {
@@ -362,11 +380,11 @@ private:
     std::string originalName;
     // file -> lines info
     std::map<std::string, std::vector<ParallelRegionLines>> lines;
-    std::set<std::string> functionsCall;
+    std::map<std::string, std::set<const ParallelRegionLines*>> functionsCall; // func name -> fragments with calls
 
 #if __SPF
     // for RESOLVE_PAR_REGIONS
-    std::set<FuncInfo*> allFunctionsCall;
+    std::map<FuncInfo*, std::set<const ParallelRegionLines*>> allFunctionsCall; // function -> fragments with calls
     std::map<FuncInfo*, std::map<DIST::Array*, std::vector<ParallelRegionLines>>> usedLocalArrays;  // func -> array -> lines
     std::map<FuncInfo*, std::map<DIST::Array*, std::vector<ParallelRegionLines>>> usedCommonArrays; // func -> array -> lines
     //
@@ -408,4 +426,5 @@ private:
 ParallelRegion* getRegionById(const std::vector<ParallelRegion*>& regions, const uint64_t regionId);
 ParallelRegion* getRegionByName(const std::vector<ParallelRegion*>& regions, const std::string& regionName);
 ParallelRegion* getRegionByLine(const std::vector<ParallelRegion*>& regions, const std::string& file, const int line);
+std::pair<ParallelRegion*, const ParallelRegionLines*> getRegionAndLinesByLine(const std::vector<ParallelRegion*>& regions, const std::string& file, const int line);
 std::set<ParallelRegion*> getAllRegionsByLine(const std::vector<ParallelRegion*>& regions, const std::string& file, const int line);

src/ParallelizationRegions/ParRegions_func.h

@@ -1,8 +1,8 @@
 #pragma once
 
 #include "ParRegions.h"
-#include "../GraphCall/graph_calls.h"
-#include "../GraphLoop/graph_loops.h"
+#include "graph_calls.h"
+#include "graph_loops.h"
 
 void fillRegionLines(SgFile *file, std::vector<ParallelRegion*> &regions, std::vector<Messages>& messagesForFile, std::vector<LoopGraph*> *loops = NULL, std::vector<FuncInfo*> *funcs = NULL);
 void fillRegionLinesStep2(std::vector<ParallelRegion*> &regions, const std::map<std::string, std::vector<FuncInfo*>> &allFuncInfo, std::map<std::string, std::vector<LoopGraph*>> *loopGraph = NULL);

src/ParallelizationRegions/expand_extract_reg.cpp

@@ -1,4 +1,4 @@
-#include "../Utils/leak_detector.h"
+#include "leak_detector.h"
 
 #include <map>
 #include <string>

src/ParallelizationRegions/expand_extract_reg.h

@@ -1,7 +1,7 @@
 #pragma once
 
 #include "ParRegions.h"
-#include "../Utils/SgUtils.h"
-#include "../Utils/errors.h"
+#include "SgUtils.h"
+#include "errors.h"
 
 bool expandExtractReg(const std::string &fileName, const int startLine, const int endLine, const std::vector<ParallelRegion*> &regions, std::vector<Messages> &messagesForFile, const bool toDelete = false);

src/ParallelizationRegions/resolve_par_reg_conflicts.cpp

@@ -1,4 +1,4 @@
-#include "../Utils/leak_detector.h"
+#include "leak_detector.h"
 
 #include <string>
 #include <vector>
@@ -11,14 +11,14 @@
 #include "ParRegions_func.h"
 #include "resolve_par_reg_conflicts.h"
 
-#include "../GraphCall/graph_calls_func.h"
-#include "../GraphLoop/graph_loops_func.h"
+#include "graph_calls_func.h"
+#include "graph_loops_func.h"
 #include "../LoopAnalyzer/loop_analyzer.h"
 #include "../DirectiveProcessing/directive_creator.h"
 #include "../DirectiveProcessing/insert_directive.h"
-#include "../Utils/SgUtils.h"
-#include "../ExpressionTransform/expr_transform.h"
-#include "../Transformations/function_purifying.h"
+#include "SgUtils.h"
+#include "expr_transform.h"
+#include "FunctionPurifying/function_purifying.h"
 
 using std::map;
 using std::pair;

src/ParallelizationRegions/resolve_par_reg_conflicts.h

@@ -1,9 +1,9 @@
 #pragma once
 
 #include "ParRegions.h"
-#include "../Utils/SgUtils.h"
-#include "../Utils/errors.h"
-#include "../GraphCall/graph_calls.h"
+#include "SgUtils.h"
+#include "errors.h"
+#include "graph_calls.h"
 
 void fillRegionIntervals(std::vector<ParallelRegion*> &regions);
 void fillRegionArrays(std::vector<ParallelRegion*> &regions, const std::map<std::string, std::vector<FuncInfo*>> &allFuncInfo, const std::map<std::string, CommonBlock*> &commonBlocks);

src/Predictor/PredictScheme.cpp

@@ -1,4 +1,4 @@
-#include "../Utils/leak_detector.h"
+#include "leak_detector.h"
 
 #include <cstdio>
 #include <cstdlib>
@@ -16,13 +16,13 @@
 #include "../DynamicAnalysis/gcov_info.h"
 #include "../DynamicAnalysis/gCov_parser_func.h"
 #include "PredictScheme.h"
-#include "../Utils/SgUtils.h"
+#include "SgUtils.h"
 #include "../DirectiveProcessing/directive_parser.h"
 #include "../Distribution/DvmhDirective.h"
-#include "../GraphLoop/graph_loops_func.h"
-#include "../ExpressionTransform/expr_transform.h"
+#include "graph_loops_func.h"
+#include "expr_transform.h"
 #include "../LoopAnalyzer/loop_analyzer.h"
-#include "../CFGraph/CFGraph.h"
+#include "CFGraph/CFGraph.h"
 
 #include "json.hpp"
 
@@ -326,7 +326,7 @@ static json parseAlign(const map<DIST::Array*, int>& byPos, SgSymbol* srcArr, Sg
         list = list->rhs();
     }
 
-    vector<pair<int, int>> coefs(srcSymbs.size());
+    vector<pair<int, int>> coeffs(srcSymbs.size());
     list = listTgt;
     while (list)
     {
@@ -337,8 +337,8 @@ static json parseAlign(const map<DIST::Array*, int>& byPos, SgSymbol* srcArr, Sg
             has = recSymbolFind(exp, srcSymbs[z].first, VAR_REF);
             if (has)
             {
-                getCoefsOfSubscript(coefs[z], exp, srcSymbs[z].second);
-                if (coefs[z].first == 0)
+                getCoefsOfSubscript(coeffs[z], exp, srcSymbs[z].second);
+                if (coeffs[z].first == 0)
                     printInternalError(convertFileName(__FILE__).c_str(), __LINE__);
                 break;
             }
@@ -346,14 +346,14 @@ static json parseAlign(const map<DIST::Array*, int>& byPos, SgSymbol* srcArr, Sg
         list = list->rhs();
     }
 
-    for (int z = 0; z < coefs.size(); ++z)
+    for (int z = 0; z < coeffs.size(); ++z)
     {
-        if (coefs[z].first == 0)
+        if (coeffs[z].first == 0)
             continue;
-        if (coefs[z].second)
-            align["rules"].push_back({ z, coefs[z].first });
+        if (coeffs[z].second)
+            align["rules"].push_back({ z, coeffs[z].first });
         else
-            align["rules"].push_back({ z, coefs[z].first, coefs[z].second });
+            align["rules"].push_back({ z, coeffs[z].first, coeffs[z].second });
     }
     return align;
 }

src/Predictor/PredictScheme.h

@@ -1,7 +1,8 @@
 #pragma once
 #include <vector>
 #include "dvm.h"
-#include "../GraphCall/graph_calls.h"
+#include "graph_calls.h"
+#include "json.hpp"
 
 class ParallelStats
 {
@@ -11,10 +12,10 @@ public:
         RemoteCount = ShadowCount = ReductionCount = AcrossCount = 0;
     }
      
-    int RemoteCount;
-    int ShadowCount;
-    int ReductionCount;
-    int AcrossCount;
+    int RemoteCount = 0;
+    int ShadowCount = 0;
+    int ReductionCount = 0;
+    int AcrossCount = 0;
 };
 
 class PredictorStats
@@ -27,28 +28,32 @@ public:
     }
      
     ParallelStats ParallelStat;
-    int ParallelCount;
-    int RemoteCount;
-    int RedistributeCount;
-    int IntervalCount;
-    int TotalScoreComm;
-    int TotalScorePar;
-    int TotalScoreDist;
+    int ParallelCount = 0;
+    int RemoteCount = 0;
+    int RedistributeCount = 0;
+    int IntervalCount = 0;
+    int TotalScoreComm = 0;
+    int TotalScorePar = 0;
+    int TotalScoreDist = 0;
 
-    std::string to_string()
+    nlohmann::json toJson()
     {
-        std::string res = "";
-        res += std::to_string(ParallelCount) + "|";
-        res += std::to_string(RemoteCount) + "|";
-        res += std::to_string(RedistributeCount) + "|";
-        res += std::to_string(IntervalCount) + "|";
+        nlohmann::json stat;
 
-        res += std::to_string(ParallelStat.RemoteCount) + "|";
-        res += std::to_string(ParallelStat.ShadowCount) + "|";
-        res += std::to_string(ParallelStat.ReductionCount) + "|";
-        res += std::to_string(ParallelStat.AcrossCount);
+        stat["ParallelCount"] = ParallelCount;
+        stat["RemoteCount"] = RemoteCount;
+        stat["RedistributeCount"] = RedistributeCount;
+        stat["IntervalCount"] = IntervalCount;
 
-        return res;
+        stat["PS_RemoteCount"] = ParallelStat.RemoteCount;
+        stat["PS_ShadowCount"] = ParallelStat.ShadowCount;
+        stat["PS_ReductionCount"] = ParallelStat.ReductionCount;
+        stat["PS_AcrossCount"] = ParallelStat.AcrossCount;
+
+        //TODO: need to improve
+        //                    (summed.TotalScoreComm != 0 ? 1.0 / summed.TotalScoreComm : 0.0) + (double)summed.TotalScorePar * 1000 + (countOfDist == 0 ? -5000 : countOfDist);
+        stat["TotalScore"] = -1 * (ParallelStat.RemoteCount + ParallelStat.ShadowCount + ParallelStat.ReductionCount + ParallelStat.AcrossCount);
+        return stat;
     }
 };
 

src/PrivateAnalyzer/private_analyzer.cpp

@@ -1,5 +1,5 @@
 #define _LEAK_
-#include "../Utils/leak_detector.h"
+#include "leak_detector.h"
 
 #include <cstdio>
 #include <cstring>
@@ -9,10 +9,10 @@
 #include <vector>
 #include <fstream>
 
-#include "../GraphCall/graph_calls.h"
+#include "graph_calls.h"
 #include "private_analyzer.h"
 #include "dvm.h"
-#include "../CFGraph/CFGraph.h"
+#include "CFGraph/CFGraph.h"
 
 using std::vector;
 

src/PrivateAnalyzer/private_analyzer.h

@@ -3,7 +3,7 @@
 #include <vector>
 
 #include "dvm.h"
-#include "../GraphCall/graph_calls.h"
+#include "graph_calls.h"
 
 extern void Private_Vars_Analyzer(SgStatement* start);
 void PrivateAnalyzer(SgFile *file, std::vector<FuncInfo*> &funcs);

src/PrivateAnalyzer/private_arrays_search.cpp

@@ -0,0 +1,234 @@
+#include <map>
+#include <unordered_set>
+#include <unordered_map>
+#include <vector>
+#include <queue>
+#include <numeric>
+#include <iostream>
+
+#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"
+
+using namespace std;
+
+static void RemoveEmptyPoints(ArrayAccessingIndexes& container)
+{
+    ArrayAccessingIndexes resultContainer;
+    unordered_set<string> toRemove;
+
+    for (auto& [arrayName, accessingSet] : container)
+    {
+        vector<vector<ArrayDimension>> points;
+        for (auto& arrayPoint : accessingSet.GetElements())
+        {
+            if (!arrayPoint.empty())
+                points.push_back(arrayPoint);
+        }
+
+        if (points.size() < accessingSet.GetElements().size() && !points.empty())
+            resultContainer[arrayName] = points;
+
+        if (points.empty())
+            toRemove.insert(arrayName);
+    }
+
+    for (const string& name : toRemove)
+        container.erase(name);
+
+    for (auto& [arrayName, accessingSet] : resultContainer)
+        container[arrayName] = accessingSet;
+}
+
+static void Collapse(Region* region)
+{
+    if (region->getBasickBlocks().empty())
+        return;
+
+    for (auto& [arrayName, arrayRanges] : region->getHeader()->array_out)
+    {
+        for (Region* byBlock : region->getBasickBlocks())
+        {
+            AccessingSet intersection = byBlock->array_def[arrayName].Intersect(arrayRanges);
+            region->array_def[arrayName] = region->array_def[arrayName].Union(intersection);
+        }
+    }
+
+    for (auto& byBlock : region->getBasickBlocks()) 
+    {
+        for (auto& [arrayName, arrayRanges] : byBlock->array_use)
+        {
+            AccessingSet diff = byBlock->array_use[arrayName].Diff(byBlock->array_in[arrayName]);
+            region->array_use[arrayName] = region->array_use[arrayName].Union(diff);
+        }
+    }
+
+    ArrayAccessingIndexes useUnion;
+    for (auto& byBlock : region->getBasickBlocks())
+        for (auto& [arrayName, arrayRanges] : byBlock->array_use)
+            useUnion[arrayName] = useUnion[arrayName].Union(byBlock->array_use[arrayName]);
+
+    region->array_priv = region->array_use;
+    
+    for (Region* prevBlock : region->getHeader()->getPrevRegions()) 
+        prevBlock->replaceInNextRegions(region, region->getHeader());
+    
+    for (Region* nextBlock : region->getHeader()->getNextRegions())
+        nextBlock->replaceInPrevRegions(region, region->getHeader());
+}
+
+static void SolveDataFlowIteratively(Region* DFG) 
+{
+    unordered_set<Region*> worklist(DFG->getBasickBlocks());
+    do
+    {
+        Region* b = *worklist.begin();
+        ArrayAccessingIndexes newIn;
+        bool flagFirst = true;
+        for (Region* prevBlock : b->getPrevRegions())
+        {
+            if (flagFirst)
+            {
+                newIn = prevBlock->array_out;
+                flagFirst = false;
+            }
+            else
+            {
+                if (prevBlock->array_out.empty())
+                {
+                    newIn.clear();
+                    continue;
+                }
+
+                for (const auto& [arrayName, accessSet] : prevBlock->array_out)
+                {
+                    if (newIn.find(arrayName) != newIn.end())
+                        newIn[arrayName] = newIn[arrayName].Intersect(accessSet);                    
+                    else
+                        newIn[arrayName] = AccessingSet();
+                }
+            }
+        }
+
+        b->array_in = move(newIn);
+        ArrayAccessingIndexes newOut;
+
+        if (b->array_def.empty())        
+            newOut = b->array_in;
+        else if (b->array_in.empty())
+            newOut = b->array_def;
+        else
+        {
+            for (auto& [arrayName, accessSet] : b->array_def)
+            {
+                if (newOut.find(arrayName) != newOut.end())
+                    newOut[arrayName] = b->array_def[arrayName].Union(b->array_in[arrayName]);
+                else
+                    newOut[arrayName] = accessSet;
+            }
+        }
+
+        /* can not differ */
+        if (newOut != b->array_out) 
+            b->array_out = newOut;
+        else
+            worklist.erase(b);
+    } 
+    while (!worklist.empty());
+}
+
+static void SolveDataFlow(Region* DFG)
+{
+    if (!DFG)
+        return;
+
+    SolveDataFlowIteratively(DFG);
+    for (Region* subRegion : DFG->getSubRegions())
+        SolveDataFlow(subRegion);
+    Collapse(DFG);
+}
+
+static void AddPrivateArraysToLoop(LoopGraph* loop, const ArrayAccessingIndexes& privates, set<SgStatement*>& insertedPrivates)
+{
+    SgStatement* spfStat = new SgStatement(SPF_ANALYSIS_DIR);
+    spfStat->setlineNumber(loop->loop->lineNumber());
+    spfStat->setFileName(loop->loop->fileName());
+    SgExpression* toAdd = new SgExpression(EXPR_LIST, new SgExpression(ACC_PRIVATE_OP), NULL, NULL);
+    set<SgSymbol*> arraysToInsert;
+    for (const auto& [_, accessingSet] : privates)
+    {
+        for (const auto& arrayElement : accessingSet.GetElements())
+        {
+            if (arrayElement.empty())
+                continue;
+            arraysToInsert.insert(arrayElement[0].array->symbol());
+        }
+    }
+
+    spfStat->setExpression(0, *toAdd);
+    toAdd = toAdd->lhs();
+    bool first = true;
+    for (auto& elem : arraysToInsert)
+    {
+        if (first)
+        {
+            toAdd->setLhs(new SgExpression(EXPR_LIST));
+            toAdd = toAdd->lhs();
+            first = false;
+        }
+        else
+        {
+            toAdd->setRhs(new SgExpression(EXPR_LIST));
+            toAdd = toAdd->rhs();
+        }
+        toAdd->setLhs(new SgVarRefExp(elem));
+    }
+    
+    if (arraysToInsert.size() == 0)
+        printInternalError(convertFileName(__FILE__).c_str(), __LINE__);
+
+    loop->loop->insertStmtBefore(*spfStat, *loop->loop->controlParent());
+    insertedPrivates.insert(spfStat);
+}
+
+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)
+    {
+        SgFile::switchToFile(fileName);
+        for (const auto& loop : loops)
+        {
+            if (!loop->isFor())
+                continue;
+            SgStatement* search_func = loop->loop->GetOriginal();
+
+            while (search_func && (!isSgProgHedrStmt(search_func)))
+                search_func = search_func->controlParent();
+
+            for (const auto& [funcInfo, blocks]: FullIR)
+            {   
+                if (funcInfo->fileName == fileName && funcInfo->funcPointer->GetOriginal() == search_func)
+                {
+                    Region* loopRegion = new Region(loop, blocks);
+                    if (loopRegion->getBasickBlocks().size() <= 1)
+                    {
+                        delete(loopRegion);
+                        continue;
+                    }
+                    SolveDataFlow(loopRegion);
+                    RemoveEmptyPoints(loopRegion->array_priv);
+                    result[loop] = loopRegion->array_priv;
+                    delete(loopRegion);
+                }
+            }
+
+            if (result.find(loop) != result.end() && !result[loop].empty())
+                AddPrivateArraysToLoop(loop, result[loop], insertedPrivates);
+        }
+    }
+}

src/PrivateAnalyzer/private_arrays_search.h

@@ -0,0 +1,13 @@
+#pragma once
+
+#include <vector>
+#include <map>
+#include <set>
+#include <unordered_set>
+
+#include "range_structures.h"
+#include "graph_loops.h"
+#include "CFGraph/CFGraph.h"
+
+void FindPrivateArrays(std::map<std::string, std::vector<LoopGraph*>>& loopGraph, std::map<FuncInfo*, std::vector<SAPFOR::BasicBlock*>>& FullIR, std::set<SgStatement*>& insertedPrivates);
+std::pair<SAPFOR::BasicBlock*, std::unordered_set<SAPFOR::BasicBlock*>> GetBasicBlocksForLoop(const LoopGraph* loop, const std::vector<SAPFOR::BasicBlock*> blocks);

src/PrivateAnalyzer/range_structures.cpp

@@ -0,0 +1,292 @@
+#include <vector>
+#include <map>
+#include <unordered_set>
+#include <string>
+
+#include "utils.h"
+#include "range_structures.h"
+
+using namespace std;
+
+static vector<uint64_t> FindParticularSolution(const ArrayDimension& dim1, const ArrayDimension& dim2)
+{
+    for (uint64_t i = 0; i < dim1.tripCount; i++)
+    {
+        uint64_t leftPart = dim1.start + i * dim1.step;
+        for (uint64_t j = 0; j < dim2.tripCount; j++)
+        {
+            uint64_t rightPart = dim2.start + j * dim2.step;
+            if (leftPart == rightPart)
+                return { i, j };
+        }
+    }
+    return {};
+}
+
+/* dim1 /\ dim2 */
+static ArrayDimension* DimensionIntersection(const ArrayDimension& dim1, const ArrayDimension& dim2)
+{
+    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 */
+    int64_t c = dim2.step / gcd(dim1.step, dim2.step);
+    int64_t d = dim1.step / gcd(dim1.step, dim2.step);
+    int64_t tXMin, tXMax, tYMin, tYMax;
+    tXMin = -x0 / c;
+    tXMax = (dim1.tripCount - 1 - x0) / c;
+    tYMin = -y0 / d;
+    tYMax = (dim2.tripCount - 1 - y0) / d;
+    int64_t tMin = max(tXMin, tYMin);
+    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};
+    return result;
+}
+
+/* dim1 / dim2 */
+static vector<ArrayDimension> DimensionDifference(const ArrayDimension& dim1, const ArrayDimension& dim2)
+{
+    ArrayDimension* intersection = DimensionIntersection(dim1, dim2);
+    if (!intersection)
+        return { dim1 };
+    
+    vector<ArrayDimension> result;
+    /* add the part before intersection */
+    if (dim1.start < intersection->start)    
+        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)
+    {
+        uint64_t start = (intersection->start - dim1.start) / dim1.step;
+        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});
+            interValue += intersection->step;
+        }
+    }
+    /* add the part after intersection */
+    if (intersection->start + intersection->step * (intersection->tripCount - 1) < dim1.start + dim1.step * (dim1.tripCount - 1))
+    {
+        /* first value after intersection */
+        uint64_t right_start = intersection->start + intersection->step * (intersection->tripCount - 1) + dim1.step;
+        uint64_t tripCount = (dim1.start + dim1.step * dim1.tripCount - right_start) / dim1.step;
+        result.push_back({ right_start, dim1.step, tripCount, dim1.array });
+    }
+    delete(intersection);
+    return result;
+}
+
+
+static vector<ArrayDimension> DimensionUnion(const ArrayDimension& dim1, const ArrayDimension& dim2)
+{
+    vector<ArrayDimension> res;
+    ArrayDimension* inter = DimensionIntersection(dim1, dim2);
+    if (!inter)
+        return { dim1, dim2 };
+
+    res.push_back(*inter);
+    delete(inter);
+
+    vector<ArrayDimension> diff1, diff2;
+    diff1 = DimensionDifference(dim1, dim2);
+    diff2 = DimensionDifference(dim2, dim1);
+    res.insert(res.end(), diff1.begin(), diff1.end());
+    res.insert(res.end(), diff2.begin(), diff2.end());
+    return res;
+}
+
+static vector<ArrayDimension> ElementsIntersection(const vector<ArrayDimension>& firstElement, const vector<ArrayDimension>& secondElement)
+{
+    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++)
+        if (FindParticularSolution(firstElement[i], secondElement[i]).empty())
+            return {};
+
+    vector<ArrayDimension> result(dimAmount);
+    for (size_t i = 0; i < dimAmount; i++)
+    {
+        ArrayDimension* resPtr = DimensionIntersection(firstElement[i], secondElement[i]);
+        if (resPtr)
+            result[i] = *resPtr;
+        else
+            return {};
+
+    }
+    return result;
+}
+
+static vector<vector<ArrayDimension>> ElementsDifference(const vector<ArrayDimension>& firstElement,
+    const vector<ArrayDimension>& secondElement)
+{
+    if (firstElement.empty() || secondElement.empty())
+        return {};
+    
+    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]);
+        if (!dimDiff.empty())
+        {
+            vector<ArrayDimension> firstCopy = firstElement;
+            for (const auto& range : dimDiff)
+            {
+                firstCopy[i] = range;
+                result.push_back(firstCopy);
+            }
+        }
+    }
+    return result;
+}
+
+static void ElementsUnion(const vector<ArrayDimension>& firstElement, const vector<ArrayDimension>& secondElement,
+    vector<vector<ArrayDimension>>& lc, vector<vector<ArrayDimension>>& rc,
+    vector<ArrayDimension>& intersection)
+{
+    /* lc(rc) is a set of ranges, which only exist in first(second) element*/
+    intersection = ElementsIntersection(firstElement, secondElement);
+    lc = ElementsDifference(firstElement, intersection);
+    rc = ElementsDifference(secondElement, intersection);
+}
+
+void AccessingSet::FindUncovered(const vector<ArrayDimension>& element, vector<vector<ArrayDimension>>& result) const {
+    vector<vector<ArrayDimension>> newTails;
+    result.push_back(element);
+    for (const auto& currentElement : allElements)
+    {
+        for (const auto& tailLoc : result)
+        {
+            auto intersection = ElementsIntersection(tailLoc, currentElement);
+            auto diff = ElementsDifference(tailLoc, intersection);
+            if (!diff.empty()) {
+                newTails.insert(newTails.end(), diff.begin(), diff.end());
+            }
+        }
+        result = newTails;
+        newTails.clear();
+    }
+}
+
+bool AccessingSet::ContainsElement(const vector<ArrayDimension>& element) const
+{
+    vector<vector<ArrayDimension>> tails;
+    FindUncovered(element, tails);
+    return !tails.empty();
+}
+
+void AccessingSet::FindCoveredBy(const vector<ArrayDimension>& element, vector<vector<ArrayDimension>>& result) const
+{
+    for (const auto& currentElement : allElements)
+    {
+        auto intersection = ElementsIntersection(element, currentElement);
+        if (!intersection.empty())
+            result.push_back(intersection);
+    }
+}
+
+vector<vector<ArrayDimension>> AccessingSet::GetElements() const { return allElements; }
+
+void AccessingSet::Insert(const vector<ArrayDimension>& element)
+{
+    vector<vector<ArrayDimension>> tails;
+    FindUncovered(element, tails);
+    allElements.insert(allElements.end(), tails.begin(), tails.end());
+}
+
+AccessingSet AccessingSet::Union(const AccessingSet& source) {
+    if (source.GetElements().empty())
+        return *this;
+    if (allElements.empty())
+        return source;
+    AccessingSet result;
+    for (auto& element : source.GetElements())
+        result.Insert(element);
+
+    for (auto& element : allElements)
+        result.Insert(element);
+    return result;
+}
+
+AccessingSet AccessingSet::Intersect(const AccessingSet& secondSet) const
+{
+    vector<vector<ArrayDimension>> result;
+    if (secondSet.GetElements().empty() || this->allElements.empty())
+        return AccessingSet(result);
+
+    for (const auto& element : allElements)
+    {
+        if (secondSet.ContainsElement(element))
+            result.push_back(element);
+        else
+        {
+            vector<vector<ArrayDimension>> coveredBy;
+            secondSet.FindCoveredBy(element, coveredBy);
+            if (!coveredBy.empty())
+                result.insert(result.end(), coveredBy.begin(), coveredBy.end());
+        }
+    }
+
+    return AccessingSet(result);
+}
+
+AccessingSet AccessingSet::Diff(const AccessingSet& secondSet) const
+{
+    if (secondSet.GetElements().empty() || allElements.empty())
+        return *this;
+
+    AccessingSet intersection = this->Intersect(secondSet);
+    AccessingSet uncovered = *this;
+    vector<vector<ArrayDimension>> result;
+    for (const auto& element : intersection.GetElements())
+    {
+        vector<vector<ArrayDimension>> current_uncovered;
+        uncovered.FindUncovered(element, current_uncovered);
+        uncovered = AccessingSet(current_uncovered);
+    }
+    return uncovered;
+}
+
+bool operator!=(const ArrayDimension& lhs, const ArrayDimension& rhs)
+{
+    return !(lhs.start == rhs.start && lhs.step == rhs.step && lhs.tripCount == rhs.tripCount);
+}
+
+
+bool operator!=(const AccessingSet& lhs, const AccessingSet& rhs)
+{
+    for (size_t i = 0; i < lhs.allElements.size(); i++)
+        for (size_t j = 0; j < lhs.allElements[i].size(); j++)
+            if (lhs.allElements[i][j] != rhs.allElements[i][j])
+                return true;
+
+    return false;
+}
+
+bool operator!=(const ArrayAccessingIndexes& lhs, const ArrayAccessingIndexes& rhs)
+{
+    if (lhs.size() != rhs.size())
+        return true;
+
+    for (auto& [key, value] : lhs)
+        if (rhs.find(key) == rhs.end())
+            return true;
+
+    return false;
+}

src/PrivateAnalyzer/range_structures.h

@@ -0,0 +1,40 @@
+#pragma once
+
+#include <vector>
+#include <map>
+#include <unordered_set>
+#include <string>
+#include <cstdint>
+
+#include "SgUtils.h"
+
+struct ArrayDimension
+{
+    uint64_t start, step, tripCount;
+    SgArrayRefExp* array;
+};
+
+class AccessingSet {
+private:
+    std::vector<std::vector<ArrayDimension>> allElements;
+
+public:
+    AccessingSet(std::vector<std::vector<ArrayDimension>> input) : allElements(input) {};
+    AccessingSet() {};
+    AccessingSet(const AccessingSet& a) { allElements = a.GetElements(); };
+    std::vector<std::vector<ArrayDimension>> GetElements() const;
+    void Insert(const std::vector<ArrayDimension>& element);
+    AccessingSet Union(const AccessingSet& source);
+    AccessingSet Intersect(const AccessingSet& secondSet) const;
+    AccessingSet Diff(const AccessingSet& secondSet) const;
+    bool ContainsElement(const std::vector<ArrayDimension>& element) const;
+    void FindCoveredBy(const std::vector<ArrayDimension>& element, std::vector<std::vector<ArrayDimension>>& result) const;
+    void FindUncovered(const std::vector<ArrayDimension>& element, std::vector<std::vector<ArrayDimension>>& result) const;
+    friend bool operator!=(const AccessingSet& lhs, const AccessingSet& rhs);
+};
+
+using ArrayAccessingIndexes = std::map<std::string, AccessingSet>;
+
+bool operator!=(const ArrayDimension& lhs, const ArrayDimension& rhs);
+bool operator!=(const AccessingSet& lhs, const AccessingSet& rhs);
+bool operator!=(const ArrayAccessingIndexes& lhs, const ArrayAccessingIndexes& rhs);

src/PrivateAnalyzer/region.cpp

@@ -0,0 +1,270 @@
+#include<vector>
+#include<map>
+#include<unordered_set>
+#include<unordered_map>
+#include<string>
+#include <numeric>
+#include <iostream>
+
+#include "range_structures.h"
+#include "region.h"
+
+#include "SgUtils.h"
+
+using namespace std;
+
+static bool isParentStmt(SgStatement* stmt, SgStatement* parent)
+{
+    for (; stmt; stmt = stmt->controlParent())
+        if (stmt == parent)
+            return true;
+
+    return false;
+}
+
+/*returns head block and loop*/
+pair<SAPFOR::BasicBlock*, unordered_set<SAPFOR::BasicBlock*>> GetBasicBlocksForLoop(const LoopGraph* loop, const vector<SAPFOR::BasicBlock*> blocks)
+{
+    unordered_set<SAPFOR::BasicBlock*> block_loop;
+    SAPFOR::BasicBlock* head_block = nullptr;
+    auto loop_operator = loop->loop->GetOriginal();
+    for (const auto& block : blocks)
+    {
+        if (!block || (block->getInstructions().size() == 0))
+            continue;
+
+        SgStatement* first = block->getInstructions().front()->getInstruction()->getOperator();
+        SgStatement* last = block->getInstructions().back()->getInstruction()->getOperator();
+        if (isParentStmt(first, loop_operator) && isParentStmt(last, loop_operator))
+        {
+            block_loop.insert(block);
+
+            if ((!head_block) && (first == loop_operator) && (last == loop_operator) &&
+                (block->getInstructions().size() == 2) &&
+                (block->getInstructions().back()->getInstruction()->getOperation() == SAPFOR::CFG_OP::JUMP_IF))
+            {
+                head_block = block;
+            }
+
+        }
+    }
+    return { head_block, block_loop };
+}
+
+static void BuildLoopIndex(map<string, LoopGraph*>& loopForIndex, LoopGraph* loop) {
+    string index = loop->loopSymbol();
+    loopForIndex[index] = loop;
+
+    for (const auto& childLoop : loop->children)
+        BuildLoopIndex(loopForIndex, childLoop);
+}
+
+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--) 
+    {
+        SAPFOR::Argument* res = block->getInstructions()[i]->getInstruction()->getResult();
+        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) 
+            {
+                string name = arg1->getValue();
+                int idx = name.find('%');
+                if (idx != -1 && loopForIndex.find(name.substr(idx + 1)) != loopForIndex.end())
+                    return name.substr(idx + 1);
+                else
+                    args.insert(arg1);
+            }
+
+            if (arg2)
+            {
+                string name = arg2->getValue();
+                int idx = name.find('%');
+                if (idx != -1 && loopForIndex.find(name.substr(idx + 1)) != loopForIndex.end())
+                    return name.substr(idx + 1);
+                else
+                    args.insert(arg2);
+            }
+        }
+    }
+    return "";
+}
+
+static int GetDefUseArray(SAPFOR::BasicBlock* block, LoopGraph* loop, ArrayAccessingIndexes& def, ArrayAccessingIndexes& use) {
+    auto instructions = block->getInstructions();
+    map<string, LoopGraph*> loopForIndex;
+    BuildLoopIndex(loopForIndex, loop);
+    for (int i = 0; i < instructions.size(); i++)
+    {
+        auto instruction = instructions[i];
+        if (!instruction->getInstruction()->getArg1())
+            continue;
+
+        auto operation = instruction->getInstruction()->getOperation();
+        auto type = instruction->getInstruction()->getArg1()->getType();
+        if (operation == SAPFOR::CFG_OP::ASSIGN && instruction->getInstruction()->getResult()->getType() == SAPFOR::CFG_ARG_TYPE::ARRAY)
+        {
+            SgStatement* op = instruction->getInstruction()->getOperator();
+            if (op && op->expr(0) && isArrayRef(op->expr(0)) && op->expr(0)->symbol() && op->expr(0)->type())
+            {
+                if (isSgArrayType(op->expr(0)->symbol()->type()))
+                {
+                    SgArrayType* arrayType = (SgArrayType*)op->expr(0)->symbol()->type();
+                    int dimCount = ((SgArrayType*)op->expr(0)->symbol()->type())->dimension();
+                    vector<ArrayDimension> point;
+                    for (int i = 0; i < dimCount; i++)
+                    {
+                        string strDimLength = arrayType->sizeInDim(i)->unparse();
+                        if (arrayType->sizeInDim(i)->variant() == INT_VAL && strDimLength != "0")
+                            point.push_back({ 1ULL, 1ULL, (uint64_t)stoi(strDimLength), (SgArrayRefExp*)op->expr(0) });
+                    }
+
+                    if (point.size() == dimCount)
+                        def[instruction->getInstruction()->getResult()->getValue()] = AccessingSet({point});
+                }
+            }
+        }
+        if ((operation == SAPFOR::CFG_OP::STORE || operation == SAPFOR::CFG_OP::LOAD) && type == SAPFOR::CFG_ARG_TYPE::ARRAY)
+        {
+            vector<SAPFOR::Argument*> index_vars;
+            vector<int> refPos;
+            string array_name = instruction->getInstruction()->getArg1()->getValue();            
+
+            int j = i - 1;
+            while (j >= 0 && instructions[j]->getInstruction()->getOperation() == SAPFOR::CFG_OP::REF)
+            {
+                index_vars.push_back(instructions[j]->getInstruction()->getArg1());
+                refPos.push_back(j);
+                j--;
+            }
+
+            /*to choose correct dimension*/
+            int n = index_vars.size();
+            vector<ArrayDimension> accessPoint(n);
+
+            auto* ref = isSgArrayRefExp(instruction->getInstruction()->getExpression());
+            int fillCount = 0;
+
+            while (!index_vars.empty() && !refPos.empty())
+            {
+                auto var = index_vars.back();
+                int currentVarPos = refPos.back();
+                ArrayDimension current_dim;
+                if (var->getType() == SAPFOR::CFG_ARG_TYPE::CONST)
+                    current_dim = { stoul(var->getValue()), 1, 1, ref};
+                else
+                {
+                    string name, full_name = var->getValue();
+                    int pos = full_name.find('%');
+                    LoopGraph* currentLoop;
+                    if (pos != -1) 
+                    {
+                        name = full_name.substr(pos + 1);
+                        if (loopForIndex.find(name) != loopForIndex.end())
+                            currentLoop = loopForIndex[name];                        
+                        else
+                            return -1;
+                    }
+                    else 
+                    {
+                        name = FindIndexName(currentVarPos, block, loopForIndex);
+                        if (name == "")
+                            return -1;
+
+                        if (loopForIndex.find(name) != loopForIndex.end())
+                            currentLoop = loopForIndex[name];                        
+                        else
+                            return -1;
+                    }
+
+                    uint64_t start = currentLoop->startVal;
+                    uint64_t step = currentLoop->stepVal;
+                    uint64_t iters = currentLoop->calculatedCountOfIters;
+                    current_dim = { start, step, iters, ref };
+                }
+
+                if (current_dim.start != 0 && current_dim.step != 0 && current_dim.tripCount != 0)
+                {
+                    accessPoint[n - index_vars.size()] = current_dim;
+                    fillCount++;
+                }
+                index_vars.pop_back();
+                refPos.pop_back();
+            }
+
+            if (fillCount == accessPoint.size())
+            {
+                if (operation == SAPFOR::CFG_OP::STORE)
+                    def[array_name].Insert(accessPoint);
+                else
+                    use[array_name].Insert(accessPoint);
+            }
+        }
+    }
+    return 0;
+
+}
+
+static void SetConnections(unordered_map<SAPFOR::BasicBlock*, Region*>& bbToRegion, const unordered_set<SAPFOR::BasicBlock*>& blockSet)
+{
+    for (SAPFOR::BasicBlock* block : blockSet)
+    {
+        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]);
+    }
+}
+
+static Region* CreateSubRegion(LoopGraph* loop, const vector<SAPFOR::BasicBlock*>& Blocks, const unordered_map<SAPFOR::BasicBlock*, Region*>& bbToRegion)
+{
+    Region* region = new Region;
+    auto [header, blockSet] = GetBasicBlocksForLoop(loop, Blocks);
+    if (bbToRegion.find(header) != bbToRegion.end())
+        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));
+    }
+    return region;
+}
+
+Region::Region(LoopGraph* loop, const vector<SAPFOR::BasicBlock*>& Blocks)
+{
+    auto [header, blockSet] = GetBasicBlocksForLoop(loop, Blocks);
+    unordered_map<SAPFOR::BasicBlock*, Region*> bbToRegion;
+    for (auto poiner : blockSet)
+    {
+        bbToRegion[poiner] = new Region(*poiner);
+        this->basickBlocks.insert(bbToRegion[poiner]);
+        GetDefUseArray(poiner, loop, bbToRegion[poiner]->array_def, bbToRegion[poiner]->array_use);
+
+    }
+    this->header = bbToRegion[header];
+    SetConnections(bbToRegion, blockSet);
+    //create subRegions
+    for (LoopGraph* childLoop : loop->children)
+    {
+        if (!childLoop->isFor())
+            continue;
+        subRegions.insert(CreateSubRegion(childLoop, Blocks, bbToRegion));
+    }
+}

src/PrivateAnalyzer/region.h

@@ -0,0 +1,60 @@
+#pragma once
+
+#include <vector>
+#include <map>
+#include <unordered_set>
+#include <string>
+
+#include "graph_loops.h"
+#include "CFGraph/CFGraph.h"
+
+class Region : public SAPFOR::BasicBlock {
+public:
+    Region() { header = nullptr; }
+
+    Region(SAPFOR::BasicBlock block) : SAPFOR::BasicBlock::BasicBlock(block) { header = nullptr; }
+
+    Region(LoopGraph* loop, const std::vector<SAPFOR::BasicBlock*>& Blocks);
+
+    Region* getHeader() { return header; }
+
+    void setHeader(Region* region) { header = region; }
+
+    std::unordered_set<Region*>& getBasickBlocks() { return basickBlocks; }
+
+    void addBasickBlocks(Region* region) { basickBlocks.insert(region); }
+
+    const std::unordered_set<Region*>& getPrevRegions() { return prevRegions; }
+
+    std::unordered_set<Region*> getNextRegions() { return nextRegions; }
+
+    void addPrevRegion(Region* region) { prevRegions.insert(region); }
+
+    void addNextRegion(Region* region) { nextRegions.insert(region); }
+
+    void replaceInPrevRegions(Region* source, Region* destination)
+    {
+        prevRegions.erase(destination);
+        prevRegions.insert(source);
+    }
+
+    void replaceInNextRegions(Region* source, Region* destination)
+    {
+        nextRegions.erase(destination);
+        nextRegions.insert(source);
+    }
+
+    std::unordered_set<Region*> getSubRegions() { return subRegions; }
+
+    void addSubRegions(Region* region) { subRegions.insert(region); }
+
+    ArrayAccessingIndexes array_def, array_use, array_out, array_in, array_priv;
+
+private:
+    std::unordered_set<Region*> subRegions, basickBlocks;
+    /*next Region which is BB for current BB Region*/
+    std::unordered_set<Region*> nextRegions;
+    /*prev Regions which is BBs for current BB Region*/
+    std::unordered_set<Region*> prevRegions;
+    Region* header;
+};

src/ProjectManipulation/ConvertFiles.cpp

@@ -1,4 +1,4 @@
-#include "../Utils/leak_detector.h"
+#include "leak_detector.h"
 
 #include <cstdio>
 #include <cstdlib>
@@ -6,9 +6,9 @@
 #include <string>
 #include <vector>
 
-#include "../Utils/errors.h"
-#include "../Utils/SgUtils.h"
-#include "../Utils/utils.h"
+#include "errors.h"
+#include "SgUtils.h"
+#include "utils.h"
 
 #include "../VerificationCode/verifications.h"
 
@@ -403,7 +403,7 @@ static int convertFile(int argc, char* argv[], const set<string>& filesInProj, c
             fprintf(stderr, "<<<<<  Unparsing   %s  >>>>>\n", fout_name);
 
         if (mod_gpu) /*ACC*/
-            UnparseTo_CufAndCu_Files(file, fout_cuf, fout_C_cu, fout_info);
+            UnparseTo_CufAndCu_Files(file, fout_cuf, fout_C_cu, fout_info, fout_name);
 
         const string fileN = file->filename();
         set<SgStatement*> toRemove;

src/ProjectManipulation/FileInfo.cpp

@@ -1,4 +1,4 @@
-#include "../Utils/leak_detector.h"
+#include "leak_detector.h"
 
 #include <cstdio>
 #include <cstdlib>
@@ -7,8 +7,8 @@
 #include <vector>
 
 #include "FileInfo.h"
-#include "../Utils/utils.h"
-#include "../Utils/errors.h"
+#include "utils.h"
+#include "errors.h"
 
 using namespace std;
 

src/ProjectManipulation/ParseFiles.cpp

@@ -1,4 +1,4 @@
-#include "../Utils/leak_detector.h"
+#include "leak_detector.h"
 
 #include <cstdio>
 #include <cstdlib>
@@ -22,8 +22,8 @@
 #include <thread>
 #include <stack>
 
-#include "../Utils/errors.h"
-#include "../Utils/SgUtils.h"
+#include "errors.h"
+#include "SgUtils.h"
 #include "../VisualizerCalls/get_information.h"
 #include "../VisualizerCalls/SendMessage.h"
 
@@ -34,6 +34,7 @@
 using namespace std;
 
 extern "C" int parse_file(int argc, char* argv[], char* proj_name);
+extern const char* VISUALIZER_DATA_PATH;
 
 static void findModuleDeclInProject(const string& name, const vector<string>& files, map<string, string>& modDecls)
 {
@@ -293,11 +294,8 @@ static vector<string> parseList(vector<FileInfo>& listOfProject,
             }
         }
 
-#ifdef _WIN32
-        sendMessage_2lvl(L" îáðàáîòêà ôàéëà '" + to_wstring(file) + L"'");
-#else 
-        sendMessage_2lvl(L" processing file '" + to_wstring(file) + L"'");
-#endif        
+        sendMessage_2lvl(3, file);
+
         StdCapture::Init();
         string errorMessage = "";
         try
@@ -387,7 +385,50 @@ static string shiftLines(const string &in, const map<string, const FileInfo*> &m
     return newStr;
 }
 
-static int dumpErrors(const vector<FileInfo>& listOfProject, const vector<string>& errors)
+static void addMessage(const string& in, const map<string, const FileInfo*>& mapOfFiles,
+                       const FileInfo* currF, map<string, vector<Messages>>& messages, typeMessage type)
+{
+    int byNum = 0;
+
+    auto it = in.find("on line ");
+    if (it != string::npos)
+        it += strlen("on line ");
+
+    int line = 0;
+    sscanf(in.c_str() + it, "%d", &line);
+
+    auto it1 = in.find("of", it + 1);
+    if (it1 == string::npos)
+        return;
+    it1 += 3;
+
+    string fileN = in.substr(it1, in.find(':', it1) - it1);
+    auto itF = mapOfFiles.find(fileN);
+    if (itF != mapOfFiles.end() && itF->second != currF)
+    {
+        byNum = itF->second->includesAdded;
+        if (byNum != 0)
+        {
+            if (line - byNum <= 0)
+            {
+                //return in;
+                printInternalError(convertFileName(__FILE__).c_str(), __LINE__);
+            }
+            else
+                line -= byNum;
+        }
+    }
+    
+    const string newStr = in.substr(0, it) + std::to_string(line) + in.substr(in.find(' ', it + 1));
+
+    wstring messageE, messageR;
+    __spf_printToLongBuf(messageE, L"%s", to_wstring(newStr).c_str());
+    __spf_printToLongBuf(messageR, L"%s", to_wstring(newStr).c_str());
+
+    messages[fileN].push_back(Messages(type, line, messageR, messageE, 6000));
+}
+
+static int dumpErrors(const vector<FileInfo>& listOfProject, const vector<string>& errors, map<string, vector<Messages>>& messages)
 {
     int errorsCount = 0;
     map<string, const FileInfo*> mapOfFiles;
@@ -400,41 +441,46 @@ static int dumpErrors(const vector<FileInfo>& listOfProject, const vector<string
         if (errors[z] == "")
         {
             FILE* ferr = fopen(file.errPath.c_str(), "w");
-            if (!ferr)
-                printInternalError(convertFileName(__FILE__).c_str(), __LINE__);
-            fclose(ferr);
+            if (ferr)
+                fclose(ferr);
             ++z;
             continue;
         }
 
-        FILE* ferr = fopen(file.errPath.c_str(), "w");
-        FILE* fout = fopen(file.outPath.c_str(), "w");
-        if (!ferr)
-            printInternalError(convertFileName(__FILE__).c_str(), __LINE__);
-        if (!fout)
-            printInternalError(convertFileName(__FILE__).c_str(), __LINE__);
-
         string errS = "", outS = "";
         vector<string> splited;
         splitString(errors[z], '\n', splited);
         for (auto& elem : splited)
         {
             if (elem.find("Warning 308") != string::npos)
+            {
+                addMessage(elem, mapOfFiles, &file, messages, WARR);
                 outS += shiftLines(elem, mapOfFiles, &file) + "\n";
+            }
             else if (elem.find("Error") != string::npos)
             {
+                addMessage(elem, mapOfFiles, &file, messages, ERROR);
                 errS += shiftLines(elem, mapOfFiles, &file) + "\n";
                 errorsCount++;
             }
         }
 
-        fprintf(fout, "%s", outS.c_str());
-        fprintf(ferr, "%s", errS.c_str());
+
+        FILE* ferr = fopen(file.errPath.c_str(), "w");
+        FILE* fout = fopen(file.outPath.c_str(), "w");
+        if (ferr)
+        {
+            fprintf(ferr, "%s", errS.c_str());
+            fclose(ferr);
+        }
+
+        if (fout)
+        {
+            fprintf(fout, "%s", outS.c_str());
+            fclose(fout);
+        }
 
         fflush(NULL);
-
-        fclose(fout);
-        fclose(ferr);
         ++z;
     }
 
@@ -529,11 +575,8 @@ static void parseFiles(int& iters, vector<string>& errors, vector<FileInfo>& lis
 
     do
     {
-#ifdef _WIN32
-        sendMessage_1lvl(L"âûïîëíÿåòñÿ " + std::to_wstring((iters + 1)) + L" èòåðàöèÿ ñèíòàêñè÷åñêîãî àíàëèçà");
-#else
-        sendMessage_1lvl(L"running " + std::to_wstring((iters + 1)) + L" iteration of syntax analisys");
-#endif
+        sendMessage_1lvl(0, iters + 1);
+
         errors = parseList(listOfProject, iters != 0, parseForInlining, mapModuleDeps, moduleDelc, modDirectOrder, isFromConsole);
         changed = createMapOfUse(errors, listOfProject, mapModuleDeps);
         if (iters != 0)
@@ -652,7 +695,7 @@ static int parseFiles(vector<string>& errors, vector<FileInfo>& listOfProject, v
     return rethrow;
 }
 
-int parseFiles(const char* proj, vector<string>& filesCompilationOrder, int parseForInlining)
+int parseFiles(const char* proj, vector<string>& filesCompilationOrder, int parseForInlining, map<string, vector<Messages>>& messages)
 {
     FILE* list = fopen(proj, "r");
     if (!list)
@@ -666,7 +709,7 @@ int parseFiles(const char* proj, vector<string>& filesCompilationOrder, int pars
 
     if (pathSplit.size() < 2)
         printInternalError(convertFileName(__FILE__).c_str(), __LINE__);
-    if (pathSplit[pathSplit.size() - 2] != "visualiser_data")
+    if (pathSplit[pathSplit.size() - 2] != VISUALIZER_DATA_PATH)
         printInternalError(convertFileName(__FILE__).c_str(), __LINE__);
     string fullPath = "";
     for (int z = 0; z < pathSplit.size() - 2; ++z)
@@ -698,9 +741,9 @@ int parseFiles(const char* proj, vector<string>& filesCompilationOrder, int pars
         else
             fileNameFixed = (toAdd.substr(0, 2) == "./") ? toAdd.substr(2) : toAdd;
 
-        const string optPath = fullPath + "visualiser_data/options/" + fileNameFixed + ".opt";
-        const string errPath = fullPath + "visualiser_data/options/" + fileNameFixed + ".err";
-        const string outPath = fullPath + "visualiser_data/options/" + fileNameFixed + ".out";
+        const string optPath = fullPath + VISUALIZER_DATA_PATH  + "/options/" + fileNameFixed + ".opt";
+        const string errPath = fullPath + VISUALIZER_DATA_PATH  + "/options/" + fileNameFixed + ".err";
+        const string outPath = fullPath + VISUALIZER_DATA_PATH  + "/options/" + fileNameFixed + ".out";
 
         const string fileText = readFileToStr(toAdd);
 
@@ -723,7 +766,7 @@ int parseFiles(const char* proj, vector<string>& filesCompilationOrder, int pars
     vector<string> errors;
 
     int rethrow = parseFiles(errors, listOfProject, filesCompilationOrder, parseForInlining);
-    int errCount = dumpErrors(listOfProject, errors);
+    int errCount = dumpErrors(listOfProject, errors, messages);
 
     if (rethrow != 0)
         throw rethrow;
@@ -732,6 +775,8 @@ int parseFiles(const char* proj, vector<string>& filesCompilationOrder, int pars
 
 void parseFiles(int argc, char** argv)
 {
+    map<string, vector<Messages>> messages;
+
     bool isInline = false;
     auto result = splitCommandLineForParse(argv, argc, isInline);
     if (result.second.size() == 0)
@@ -760,6 +805,8 @@ void parseFiles(int argc, char** argv)
         printf("  run parsing for inlining\n");
 
     int rethrow = parseFiles(errors, listOfProject, filesCompilationOrder, isInline, true);
+    int errCount = dumpErrors(listOfProject, errors, messages);
+
     if (rethrow == 0)
     {
         for (auto& err : errors)
@@ -789,5 +836,7 @@ void parseFiles(int argc, char** argv)
     }
     else
         printf("Parsing was completed with errors, throw code %d, errors count %d\n", rethrow, code);
+
+    dumpMessages(false, messages, VISUALIZER_DATA_PATH);
     exit(0);
 }

src/ProjectManipulation/ParseFiles.h

@@ -3,5 +3,5 @@
 #include <vector>
 #include <string>
 
-int parseFiles(const char* proj, std::vector<std::string>& filesCompilationOrder, int parseForInlining);
+int parseFiles(const char* proj, std::vector<std::string>& filesCompilationOrder, int parseForInlining, std::map<std::string, std::vector<Messages>>& messages);
 void parseFiles(int argc, char** argv);

src/ProjectManipulation/PerfAnalyzer.cpp

@@ -1,4 +1,4 @@
-#include "../Utils/leak_detector.h"
+#include "leak_detector.h"
 
 #include <cstdio>
 #include <cstdlib>
@@ -6,8 +6,8 @@
 #include <string>
 #include <vector>
 
-#include "../Utils/errors.h"
-#include "../Utils/SgUtils.h"
+#include "errors.h"
+#include "SgUtils.h"
 
 #include "StdCapture.h"
 

src/ProjectParameters/projectParameters.cpp

@@ -1,33 +1,443 @@
-#include "../Utils/leak_detector.h"
+#include "leak_detector.h"
 
 #include <cstdio>
 #include <cstring>
-#include <cstring>
 #include <fstream>
 #include <iostream>
 #include <cstdlib>
 #include <set>
+#include <string>
 #include <vector>
 #include <algorithm>
 #include <tuple>
 
+#include "CFGraph/CFGraph.h"
+#include "CFGraph/IR.h"
+#include "Distribution/Array.h"
 #include "dvm.h"
-#include "../Utils/errors.h"
-#include "../Utils/SgUtils.h"
-#include "../GraphCall/graph_calls.h"
-#include "../GraphCall/graph_calls_func.h"
+
+#include "errors.h"
+#include "SgUtils.h"
+#include "graph_calls.h"
+#include "graph_calls_func.h"
 
 #include "projectParameters.h"
 
-using namespace std;
+using std::set;
+using std::map;
+using std::string;
+using std::vector;
+using std::tuple;
+using std::pair;
+using std::make_tuple;
+using std::find_if;
 
-map< pair<string, int>, set<string>> 
-	findParameters(const map<string, vector<DefUseList>> &defUseByFunctions, 
-                   const map<string, CommonBlock*> &commonBlocks, 
-				   const map<string, vector<FuncInfo*>> &allFuncInfo)
+static map<FuncInfo*, vector<SAPFOR::Instruction*>> call_sites;
+
+enum class MODE
 {
-	map< pair<string, int>, set<string>> foundParameters;
-	
-	
-	return foundParameters;
-}
+    BEFORE,
+    AFTER
+};
+
+template<typename Iterator>
+static void extract_vars_from_reg(set<SAPFOR::Argument*>& worklist, SAPFOR::Argument* reg, Iterator instr, Iterator first_instr);
+
+static tuple<FuncInfo*, SAPFOR::Instruction*, SAPFOR::BasicBlock*>
+stmtToIR(const map<FuncInfo*, vector<SAPFOR::BasicBlock*>>& CFGraph, SgStatement* stmt)
+{
+    SgStatement* cur = stmt;
+    cur->switchToFile();
+    while (cur->variant() != PROC_HEDR && cur->variant() != PROG_HEDR && cur->variant() != FUNC_HEDR)
+        cur = cur->controlParent();
+
+    string funcName = ((SgProcHedrStmt*)cur)->nameWithContains();
+
+    int stmtID = stmt->id();
+    for (const auto& [func, bblocks] : CFGraph)
+    {
+        if (func->funcName != funcName)
+            continue;
+
+        for (auto basicBlock : bblocks)
+            for (auto ins : basicBlock->getInstructions())
+                if (stmtID == ins->getInstruction()->getOperator()->id())
+                    return make_tuple(func, ins->getInstruction(), basicBlock);
+    }
+
+    printInternalError(convertFileName(__FILE__).c_str(), __LINE__);
+    return { NULL, NULL, NULL };
+}
+
+static tuple<FuncInfo*, SAPFOR::Instruction*, SAPFOR::BasicBlock*>
+IRByNumber(const map<FuncInfo*, vector<SAPFOR::BasicBlock*>>& CFGraph, int num)
+{
+    if (num < 0)
+        return { NULL, NULL, NULL };
+
+    for (const auto& [func, bblocks] : CFGraph)
+        for (auto byBB : bblocks)
+            if (byBB->getInstructions().front()->getNumber() <= num && byBB->getInstructions().back()->getNumber() >= num)
+                return make_tuple(func, getInstructionByNumber(byBB->getInstructions(), num), byBB);
+
+    printInternalError(convertFileName(__FILE__).c_str(), __LINE__);
+    return { NULL, NULL, NULL };
+}
+
+template<typename Iterator>
+static void processArgument(set<SAPFOR::Argument*>& worklist,
+                            SAPFOR::Argument* arg,
+                            Iterator instr, Iterator first_instr)
+{
+    if (arg == NULL)
+        return;
+
+    if (arg->getType() == SAPFOR::CFG_ARG_TYPE::REG)
+        extract_vars_from_reg(worklist, arg, instr, first_instr);
+    else if (arg->getType() == SAPFOR::CFG_ARG_TYPE::VAR)
+        worklist.insert(arg);
+}
+
+template<typename Iterator>
+static void extract_vars_from_reg(set<SAPFOR::Argument*>& worklist,
+                                  SAPFOR::Argument* reg,
+                                  Iterator instr, Iterator first_instr)
+{
+    for (; instr >= first_instr; instr--)
+    {
+        if ((*instr)->getInstruction()->getResult() == reg)
+        {
+            processArgument(worklist, (*instr)->getInstruction()->getArg1(), instr, first_instr);
+            processArgument(worklist, (*instr)->getInstruction()->getArg2(), instr, first_instr);
+            return;
+        }
+    }
+}
+
+static void lookup_for_vars(set<tuple<SgStatement*, string, MODE>>& where_to_add,
+                            set<SAPFOR::Argument*>& worklist,
+                            SAPFOR::Instruction* instr,
+                            SAPFOR::BasicBlock* bblock,
+                            FuncInfo* cur_func,
+                            const map<FuncInfo*, vector<SAPFOR::BasicBlock*>>& fullIR)
+{
+    while (bblock)
+    {
+        auto first_instr = bblock->getInstructions().begin();
+        auto cur_instr = find_if(first_instr, bblock->getInstructions().end(), [instr](SAPFOR::IR_Block* i) {
+            return i->getInstruction() == instr;
+            });
+
+        for (; cur_instr >= bblock->getInstructions().begin(); --cur_instr)
+        {
+            auto instr = (*cur_instr)->getInstruction();
+            auto result_arg = instr->getResult();
+            auto arg1 = instr->getArg1();
+            auto arg2 = instr->getArg2();
+
+            if (worklist.count(result_arg))
+            {
+                worklist.erase(result_arg);
+                processArgument(worklist, arg1, cur_instr, first_instr);
+                processArgument(worklist, arg2, cur_instr, first_instr);
+            }
+
+            if (instr->getOperation() == SAPFOR::CFG_OP::PARAM && worklist.count(arg1))
+            {
+                // skip to F_CALL
+                auto f_call_instr = cur_instr;
+                while ((*f_call_instr)->getInstruction()->getOperation() != SAPFOR::CFG_OP::F_CALL)
+                    f_call_instr++;
+
+                if ((*f_call_instr)->getInstruction()->getArg1()->getValue() == "_READ")
+                {
+                    auto stmt_before = (*f_call_instr)->getInstruction()->getOperator();
+                    auto filename = stmt_before->fileName();
+                    auto line = stmt_before->lineNumber();
+                    auto var_name = arg1->getValue().substr(arg1->getValue().find('%') + 1);
+                    __spf_print(1, "Please specify value of variable %s on line %d of file %s\n", arg1->getValue().c_str(), line, filename);
+                    auto toAdd = make_tuple(stmt_before, var_name, MODE::AFTER);
+                    where_to_add.insert(toAdd);
+                    worklist.erase(arg1);
+                }
+            }
+        }
+
+        const auto& RD = bblock->getRD_In();
+        map<SAPFOR::BasicBlock*, SAPFOR::Instruction*> group_by_block;
+
+        set<SAPFOR::Argument*> to_erase;
+        for (auto& arg : worklist)
+        {
+            if (RD.count(arg))
+            {
+                if (RD.at(arg).size() == 1 && *RD.at(arg).begin() == SAPFOR::CFG_VAL::UNINIT)
+                    __spf_print(1, "variable %s has no definition\n", arg->getValue().c_str());
+                else if (RD.at(arg).size() > 1)
+                {
+                    auto stmt_after = (*first_instr)->getInstruction()->getOperator();
+                    auto filename = stmt_after->fileName();
+                    auto line = stmt_after->lineNumber();
+                    auto var_name = arg->getValue().substr(arg->getValue().find('%') + 1);
+                    __spf_print(1, "variable %s has multiple reaching definitions, further analysis is impossible\n", arg->getValue().c_str());
+                    __spf_print(1, "Please specify value of variable %s on line %d of file %s\n", arg->getValue().c_str(), line, filename);
+                    auto toAdd = make_tuple(stmt_after, var_name, MODE::BEFORE);
+                    where_to_add.insert(toAdd);
+                    to_erase.insert(arg);
+                }
+                else
+                {
+                    auto instr_num = *RD.at(arg).begin();
+                    auto [func, instr, bblock] = IRByNumber(fullIR, instr_num);
+                    if (cur_func == func && (group_by_block[bblock] == NULL || group_by_block[bblock]->getNumber() < instr_num))
+                        group_by_block[bblock] = instr;
+                }
+            }
+        }
+        for (const auto& arg : to_erase)
+            worklist.erase(arg);
+
+        while (bblock && group_by_block.find(bblock) == group_by_block.end())
+            bblock = bblock->getDom();
+
+        if (bblock)
+            instr = group_by_block[bblock];
+    }
+
+    // other variables are from global scope
+    const auto& RD = fullIR.at(cur_func).front()->getRD_In();
+    for (auto& arg : worklist)
+    {
+        if (arg->isMemGlobal())
+        {
+            set<int> found_rd;
+            if (RD.count(arg))
+                found_rd = RD.at(arg);
+
+            if (found_rd.size() == 0)
+            {
+                auto call_instr = call_sites[cur_func].size() ? call_sites[cur_func].front() : NULL;
+                while (call_instr && found_rd.size() == 0)
+                {
+                    auto [call_func, _, call_bblock] = IRByNumber(fullIR, call_instr->getNumber());
+                    if (call_bblock->getRD_Out().count(arg))
+                        found_rd = call_bblock->getRD_Out().at(arg);
+
+
+                    call_instr = call_sites[call_func].size() ? call_sites[call_func].front() : NULL;
+                }
+            }
+
+            if (found_rd.size() == 1 && *found_rd.begin() == SAPFOR::CFG_VAL::UNINIT)
+                __spf_print(1, "variable %s has no definition\n", arg->getValue().c_str());
+            else if (found_rd.size() > 1)
+            {
+                auto first_instr = fullIR.at(cur_func).front()->getInstructions().begin();
+                auto stmt_after = (*first_instr)->getInstruction()->getOperator();
+                auto filename = stmt_after->fileName();
+                auto line = stmt_after->lineNumber();
+                auto var_name = arg->getValue().substr(arg->getValue().find('%') + 1);
+                __spf_print(1, "variable %s has multiple reaching definitions, further analysis is impossible\n", arg->getValue().c_str());
+                __spf_print(1, "Please specify value of variable %s on line %d of file %s\n", arg->getValue().c_str(), line, filename);
+                auto toAdd = make_tuple(stmt_after, var_name, MODE::BEFORE);
+                where_to_add.insert(toAdd);
+            }
+            else
+            {
+                auto instr_num = *found_rd.begin();
+                auto [func, instr, bblock] = IRByNumber(fullIR, instr_num);
+                set<SAPFOR::Argument*> new_worklist = { arg };
+
+                lookup_for_vars(where_to_add, new_worklist, instr, bblock, func, fullIR);
+            }
+        }
+    }
+
+
+    for (const auto& call_instr : call_sites[cur_func])
+    {
+        set<SAPFOR::Argument*> new_worklist;
+        auto params_num = cur_func->funcParams.countOfPars;
+
+        auto [call_func, _, call_bblock] = IRByNumber(fullIR, call_instr->getNumber());
+        auto first_instr = call_bblock->getInstructions().begin();
+        auto cur_instr = find_if(first_instr, call_bblock->getInstructions().end(), [call_instr](SAPFOR::IR_Block* i) {
+            return i->getInstruction() == call_instr;
+            });
+
+        for (auto& arg : worklist)
+        {
+            if (arg->getMemType() == SAPFOR::CFG_MEM_TYPE::FUNC_PARAM_)
+            {
+                auto param_num = stoi(arg->getValue().substr(arg->getValue().find('%', arg->getValue().find('%') + 1) + 1));
+                auto param_instr = (cur_instr - (params_num - param_num));
+                auto param_arg = (*param_instr)->getInstruction()->getArg1();
+                processArgument(new_worklist, param_arg, param_instr, first_instr);
+            }
+        }
+        lookup_for_vars(where_to_add, new_worklist, call_instr, call_bblock, call_func, fullIR);
+    }
+
+}
+
+static void handle_single_allocate(set<tuple<SgStatement*, string, MODE>>& where_to_add,
+                                   SgStatement* alloc_statement,
+                                   const map<FuncInfo*, vector<SAPFOR::BasicBlock*>>& fullIR)
+{
+    auto [func, instr, bblock] = stmtToIR(fullIR, alloc_statement);
+
+    auto first_instr = bblock->getInstructions().begin();
+    auto cur_instr = find_if(first_instr, bblock->getInstructions().end(), [instr](SAPFOR::IR_Block* i) {
+        return i->getInstruction() == instr;
+        });
+    auto alloc_instr = cur_instr;
+
+    // skip to F_CALL _ALLOC n
+    while ((*alloc_instr)->getInstruction()->getOperation() != SAPFOR::CFG_OP::F_CALL ||
+        (*alloc_instr)->getInstruction()->getArg1()->getValue() != "_ALLOC")
+        alloc_instr++;
+
+    auto arrays_num = stoi((*alloc_instr)->getInstruction()->getArg2()->getValue());
+
+    set<SAPFOR::Argument*> worklist;
+    for (int i = 0; i < arrays_num; i++)
+    {
+        auto param_instr = --alloc_instr;
+        auto param_reg = (*param_instr)->getInstruction()->getArg1();
+
+        while ((*param_instr)->getInstruction()->getOperation() != SAPFOR::CFG_OP::LOAD ||
+            (*param_instr)->getInstruction()->getResult() != param_reg)
+            param_instr--;
+
+
+        auto dimensions_num = stoi((*param_instr)->getInstruction()->getArg2()->getValue());
+
+        for (int j = 0; j < dimensions_num; j++)
+        {
+            auto ref_instr = --param_instr;
+            if ((*ref_instr)->getInstruction()->getOperation() == SAPFOR::CFG_OP::RANGE)
+            {
+                vector<SAPFOR::Argument*> range_args = { (*ref_instr)->getInstruction()->getArg1(),
+                                                        (*ref_instr)->getInstruction()->getArg2(),
+                                                        (*ref_instr)->getInstruction()->getResult() };
+                for (auto& arg : range_args)
+                    processArgument(worklist, arg, ref_instr, first_instr);
+
+            }
+            else
+            {
+                auto arg = (*ref_instr)->getInstruction()->getArg1();
+                processArgument(worklist, arg, ref_instr, first_instr);
+            }
+        }
+    }
+    lookup_for_vars(where_to_add, worklist, instr, bblock, func, fullIR);
+}
+
+
+static void handle_single_loop(set<tuple<SgStatement*, string, MODE>>& where_to_add,
+                               SgStatement* loop_stmt,
+                               const map<FuncInfo*, vector<SAPFOR::BasicBlock*>>& fullIR)
+{
+    auto [func, instr, bblock] = stmtToIR(fullIR, loop_stmt);
+    auto cur_instr = bblock->getInstructions().end() - 1;
+
+    set<SAPFOR::Argument*> worklist;
+    extract_vars_from_reg(worklist, (*cur_instr)->getInstruction()->getResult(), cur_instr, bblock->getInstructions().begin());
+
+    lookup_for_vars(where_to_add, worklist, (*cur_instr)->getInstruction(), bblock, func, fullIR);
+}
+
+void findParameters(ResultSet& foundParameters,
+                    map<FuncInfo*, vector<SAPFOR::BasicBlock*>>& fullIR,
+                    const map<tuple<int, string, string>, pair<DIST::Array*, DIST::ArrayAccessInfo*>>& declaredArrays)
+{
+    set<tuple<SgStatement*, string, MODE>> where_to_add;
+
+    map<string, FuncInfo*> name_to_func;
+    for (const auto& [func, _] : fullIR)
+        name_to_func[func->funcName] = func;
+
+    for (auto& [func, bblocks] : fullIR)
+    {
+        for (const auto& block : bblocks)
+        {
+            for (const auto& ir_block : block->getInstructions())
+            {
+                auto instr = ir_block->getInstruction();
+                if (instr->getOperation() == SAPFOR::CFG_OP::F_CALL)
+                {
+                    auto func_name = instr->getArg1()->getValue();
+                    auto func_info = name_to_func.find(func_name);
+
+                    if (func_info != name_to_func.end())
+                        call_sites[func_info->second].push_back(instr);
+                }
+            }
+        }
+    }
+
+    set<SgStatement*> alloc_statements;
+    for (const auto& [func, bblocks] : fullIR)
+    {
+        for (const auto& block : bblocks)
+        {
+            for (auto instr = block->getInstructions().begin(); instr != block->getInstructions().end(); ++instr)
+            {
+                auto op = (*instr)->getInstruction()->getOperator();
+                if (op && op->variant() == ALLOCATE_STMT)
+                    alloc_statements.insert(op);
+            }
+        }
+    }
+
+    set<SgStatement*> for_statements;
+    // Find all FOR statements in the program
+    for (const auto& [func, bblocks] : fullIR)
+    {
+        for (const auto& block : bblocks)
+        {
+            for (auto instr = block->getInstructions().begin(); instr != block->getInstructions().end(); ++instr)
+            {
+                auto op = (*instr)->getInstruction()->getOperator();
+                if (op && op->variant() == FOR_NODE)
+                    for_statements.insert(op);
+            }
+        }
+    }
+
+    for (const auto& alloc_statement : alloc_statements)
+        handle_single_allocate(where_to_add, alloc_statement, fullIR);
+
+    for (const auto& stmt : for_statements)
+        handle_single_loop(where_to_add, stmt, fullIR);
+
+    for (const auto& [stmt_before, var_name, mode] : where_to_add)
+    {
+        stmt_before->switchToFile();
+
+        SgVariableSymb* var_symb = new SgVariableSymb(var_name.c_str());
+        SgVarRefExp* var = new SgVarRefExp(var_symb);
+        SgExprListExp* ex = new SgExprListExp();
+        auto assgn_op = new SgExpression(ASSGN_OP, var, NULL);
+        ex->setLhs(assgn_op);
+
+        SgExpression* parameter_op = new SgExpression(SPF_PARAMETER_OP, ex);
+        auto dir_list = new SgExprListExp();
+        dir_list->setLhs(parameter_op);
+        SgStatement* toAdd = new SgStatement(SPF_ANALYSIS_DIR, NULL, NULL, dir_list, NULL, NULL);
+
+        toAdd->setlineNumber(stmt_before->lineNumber());
+        toAdd->setLocalLineNumber(stmt_before->lineNumber());
+        toAdd->setFileId(stmt_before->getFileId());
+        toAdd->setProject(stmt_before->getProject());
+
+        //NOTE: only for debbuging, results will be transferred to the visualizer
+        /*if (mode == MODE::AFTER)
+            stmt_before->insertStmtAfter(*toAdd, *stmt_before->controlParent());
+        else
+            stmt_before->insertStmtBefore(*toAdd, *stmt_before->controlParent());*/
+
+        foundParameters.insert(make_tuple(stmt_before->fileName(), stmt_before->lineNumber(), var_name));
+    }
+}

src/ProjectParameters/projectParameters.h

@@ -1,3 +1,14 @@
 #pragma once
 
-std::map< std::pair<std::string, int>, std::set<std::string>> findParameters(const std::map<std::string, std::vector<DefUseList>> &defUseByFunctions, const std::map<std::string, CommonBlock*> &commonBlocks, const std::map<std::string, std::vector<FuncInfo*>> &allFuncInfo);
+#include <map>
+#include <string>
+#include <set>
+#include <vector>
+
+#include "../GraphCall/graph_calls.h"
+
+using ResultSet = std::set<std::tuple<std::string, int, std::string>>;
+
+void findParameters(ResultSet& foundParameters,
+                    std::map<FuncInfo*, std::vector<SAPFOR::BasicBlock*>>& fullIR,
+                    const std::map<std::tuple<int, std::string, std::string>, std::pair<DIST::Array*, DIST::ArrayAccessInfo*>>& declaredArrays);

src/SageAnalysisTool/defUse.cpp

@@ -4,9 +4,9 @@
 #include <map>
 #include <string>
 
-#include "../GraphCall/graph_calls.h"
-#include "../Utils/errors.h"
-#include "../Utils/utils.h"
+#include "graph_calls.h"
+#include "errors.h"
+#include "utils.h"
 #include "sage++user.h"
 #include "definesValues.h"
 #include "set.h"