Make pass correct

attempt to build new ast
moved to transformations
2025-10-23 14:54:43 +03:00 · 2025-10-22 17:00:27 +03:00 · 2025-10-22 17:00:27 +03:00 · 2025-10-22 17:00:27 +03:00 · 2025-10-22 17:00:27 +03:00 · 2025-10-22 17:00:27 +03:00
161 changed files with 3240 additions and 2307 deletions
--- a/CMakeLists.txt
+++ b/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})
@@ -154,42 +163,49 @@ 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(SWAP_OPERATORS src/SwapOperators/swapOperators.cpp
-        src/SwapOperators/swapOperators.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_SWAP_OPERATORS src/Transformations/SwapOperators/swap_operators.cpp
+        src/Transformations/SwapOperators/swap_operators.h)

 set(TRANSFORMS 
        ${TR_DEAD_CODE}
@@ -209,10 +225,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_SWAP_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
@@ -290,10 +312,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
@@ -305,18 +323,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
@@ -406,12 +417,9 @@ set(SOURCE_EXE
    ${DISTR}
    ${DVMH_REG}
    ${DYNA}
-    ${EXPR_TRANSFORM}
    ${GR_CALL}
    ${GR_LOOP}
-    ${INLINER}
    ${LOOP_ANALYZER}
-    ${RENAME_SYMBOLS}
    ${TRANSFORMS}
    ${PARALLEL_REG}
    ${PRIV}
@@ -428,15 +436,14 @@ set(SOURCE_EXE
    ${ZLIB}
    ${GR_LAYOUT}
    ${PR_PARAM}
-    ${PROJ_MAN}
-    ${SWAP_OPERATORS})
+    ${PROJ_MAN})

 add_executable(Sapfor_F ${SOURCE_EXE})
 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})
@@ -444,17 +451,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\\SwapOperators FILES ${TR_SWAP_OPERATORS})


 source_group (CreateIntervals FILES ${CREATE_INTER_T})
@@ -473,7 +481,6 @@ source_group (Utils FILES ${UTILS})
 source_group (VerificationCode FILES ${VERIF})       
 source_group (ProjectParameters FILES ${PR_PARAM})
 source_group (ProjectManipulation FILES ${PROJ_MAN})
-source_group (SwapOperators FILES ${SWAP_OPERATORS})

 source_group (VisualizerCalls FILES ${VS_CALLS})
 source_group (VisualizerCalls\\GraphLayout FILES ${GR_LAYOUT})
@@ -484,7 +491,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()
@@ -493,7 +500,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)
--- a/projects/dvm
+++ b/projects/dvm
--- a/src/CFGraph/CFGraph.cpp
+++ b/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());
 }
--- a/src/CFGraph/CFGraph.h
+++ b/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);
--- a/src/CFGraph/DataFlow/backward_data_flow.h
+++ b/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"

--- a/src/CFGraph/DataFlow/backward_data_flow_impl.h
+++ b/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"
--- a/src/CFGraph/DataFlow/data_flow.h
+++ b/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"

--- a/src/CFGraph/DataFlow/data_flow_impl.h
+++ b/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"

--- a/src/CFGraph/IR.cpp
+++ b/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"
--- a/src/CFGraph/IR.h
+++ b/src/CFGraph/IR.h
@@ -6,7 +6,7 @@
 #include <algorithm>

 #include "CFGraph.h"
-#include "../Utils/CommonBlock.h"
+#include "CommonBlock.h"

 namespace SAPFOR
 {
--- a/src/CFGraph/IR_domTree.cpp
+++ b/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);
+    }
+}
--- a/src/CFGraph/IR_domTree.h
+++ b/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). <20> 1979. <20> Vol. 1, no. 1. <20> Pp. 121<32>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);
+}
--- a/src/CFGraph/RD_subst.cpp
+++ b/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
--- a/src/CFGraph/RD_subst.h
+++ b/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"
--- a/src/CFGraph/live_variable_analysis.h
+++ b/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
--- a/src/CFGraph/private_variables_analysis.cpp
+++ b/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"
@@ -250,7 +250,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();
@@ -450,7 +450,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);
--- a/src/CFGraph/private_variables_analysis.h
+++ b/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>
--- a/src/CreateInterTree/CreateInterTree.cpp
+++ b/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;
--- a/src/CreateInterTree/CreateInterTree.h
+++ b/src/CreateInterTree/CreateInterTree.h
@@ -8,7 +8,7 @@

 #include "dvm.h"

-#include "../GraphLoop/graph_loops_func.h"
+#include "graph_loops_func.h"

 struct SpfInterval
 {
--- a/src/DirectiveProcessing/directive_analyzer.cpp
+++ b/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;
--- a/src/DirectiveProcessing/directive_analyzer.h
+++ b/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);
--- a/src/DirectiveProcessing/directive_creator.cpp
+++ b/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

--- a/src/DirectiveProcessing/directive_creator.h
+++ b/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, 
--- a/src/DirectiveProcessing/directive_creator_base.cpp
+++ b/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;
    }

--- a/src/DirectiveProcessing/directive_omp_parser.cpp
+++ b/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;
--- a/src/DirectiveProcessing/directive_omp_parser.h
+++ b/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
--- a/src/DirectiveProcessing/directive_parser.cpp
+++ b/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;
--- a/src/DirectiveProcessing/directive_parser.h
+++ b/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
--- a/src/DirectiveProcessing/insert_directive.cpp
+++ b/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"
--- a/src/DirectiveProcessing/remote_access.cpp
+++ b/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;
--- a/src/DirectiveProcessing/remote_access_base.cpp
+++ b/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"

--- a/src/DirectiveProcessing/shadow.cpp
+++ b/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"
--- a/src/DirectiveProcessing/spf_directive_preproc.cpp
+++ b/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"

--- a/src/Distribution/Array.cpp
+++ b/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;

--- a/src/Distribution/Array.h
+++ b/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;
--- a/src/Distribution/ArrayAnalysis.cpp
+++ b/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
--- a/src/Distribution/CreateDistributionDirs.cpp
+++ b/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;
--- a/src/Distribution/CreateDistributionDirs.h
+++ b/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, 
--- a/src/Distribution/Cycle.cpp
+++ b/src/Distribution/Cycle.cpp
@@ -1,4 +1,4 @@
-#include "../Utils/leak_detector.h"
+#include "leak_detector.h"

 #include <vector>
 #include <algorithm>
--- a/src/Distribution/Cycle.h
+++ b/src/Distribution/Cycle.h
@@ -3,7 +3,7 @@
 #include <vector>
 #include <algorithm>

-#include "../Utils/types.h"
+#include "types.h"

 namespace Distribution
 {
--- a/src/Distribution/Distribution.cpp
+++ b/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"<EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>, <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD> " + 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"<EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>, <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD> " + 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
        {
--- a/src/Distribution/DvmhDirective.cpp
+++ b/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"

@@ -346,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;
                            }
                        }
--- a/src/Distribution/DvmhDirective.h
+++ b/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;

--- a/src/Distribution/DvmhDirectiveBase.cpp
+++ b/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;
--- a/src/Distribution/DvmhDirectiveBase.h
+++ b/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;
--- a/src/Distribution/DvmhDirective_func.h
+++ b/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);
--- a/src/Distribution/GraphCSR.cpp
+++ b/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"<22><><EFBFBD><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD> <20> <20><><EFBFBD><EFBFBD><EFBFBD>, <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD> ") + wstring(treeM.begin(), treeM.end()) + L" <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD> " + 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)
        {
--- a/src/Distribution/GraphCSR.h
+++ b/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;

--- a/src/DvmhRegions/DvmhRegion.h
+++ b/src/DvmhRegions/DvmhRegion.h
@@ -1,6 +1,6 @@
 #pragma once

-#include "../GraphLoop/graph_loops_func.h"
+#include "graph_loops_func.h"

 #include <string>

--- a/src/DvmhRegions/DvmhRegionInserter.cpp
+++ b/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;
--- a/src/DvmhRegions/DvmhRegionInserter.h
+++ b/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"

--- a/src/DvmhRegions/LoopChecker.h
+++ b/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>
--- a/src/DvmhRegions/ReadWriteAnalyzer.h
+++ b/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>
--- a/src/DvmhRegions/TypedSymbol.h
+++ b/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 };
--- a/src/DynamicAnalysis/createParallelRegions.cpp
+++ b/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>
--- a/src/DynamicAnalysis/createParallelRegions.h
+++ b/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>
--- a/src/DynamicAnalysis/gCov_parser.cpp
+++ b/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;

--- a/src/DynamicAnalysis/gCov_parser_func.h
+++ b/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"

--- a/src/DynamicAnalysis/gcov_info.cpp
+++ b/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"

--- a/src/DynamicAnalysis/gcov_info.h
+++ b/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
--- a/src/GraphCall/graph_calls.cpp
+++ b/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())
--- a/src/GraphCall/graph_calls.h
+++ b/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",
--- a/src/GraphCall/graph_calls_base.cpp
+++ b/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;
--- a/src/GraphCall/graph_calls_func.h
+++ b/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"

--- a/src/GraphLoop/graph_loops.cpp
+++ b/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();
--- a/src/GraphLoop/graph_loops.h
+++ b/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;
    
--- a/src/GraphLoop/graph_loops_base.cpp
+++ b/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", 
--- a/src/LoopAnalyzer/allocations_prepoc.cpp
+++ b/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;
--- a/src/LoopAnalyzer/dep_analyzer.cpp
+++ b/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"
--- a/src/LoopAnalyzer/loop_analyzer.cpp
+++ b/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"
@@ -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;
@@ -2188,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);
                }
            }
@@ -2212,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);

@@ -2340,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)
        {
--- a/src/LoopAnalyzer/loop_analyzer.h
+++ b/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"

--- a/src/ParallelizationRegions/ParRegions.cpp
+++ b/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;
--- a/src/ParallelizationRegions/ParRegions.h
+++ b/src/ParallelizationRegions/ParRegions.h
@@ -9,12 +9,12 @@
 #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
--- a/src/ParallelizationRegions/ParRegions_func.h
+++ b/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);
--- a/src/ParallelizationRegions/expand_extract_reg.cpp
+++ b/src/ParallelizationRegions/expand_extract_reg.cpp
@@ -1,4 +1,4 @@
-#include "../Utils/leak_detector.h"
+#include "leak_detector.h"

 #include <map>
 #include <string>
--- a/src/ParallelizationRegions/expand_extract_reg.h
+++ b/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);
--- a/src/ParallelizationRegions/resolve_par_reg_conflicts.cpp
+++ b/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;
--- a/src/ParallelizationRegions/resolve_par_reg_conflicts.h
+++ b/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);
--- a/src/Predictor/PredictScheme.cpp
+++ b/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"

--- a/src/Predictor/PredictScheme.h
+++ b/src/Predictor/PredictScheme.h
@@ -1,8 +1,8 @@
 #pragma once
 #include <vector>
 #include "dvm.h"
-#include "../GraphCall/graph_calls.h"
-#include "../Utils/json.hpp"
+#include "graph_calls.h"
+#include "json.hpp"

 class ParallelStats
 {
--- a/src/PrivateAnalyzer/private_analyzer.cpp
+++ b/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;

--- a/src/PrivateAnalyzer/private_analyzer.h
+++ b/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);
--- a/src/PrivateAnalyzer/private_arrays_search.cpp
+++ b/src/PrivateAnalyzer/private_arrays_search.cpp
@@ -9,13 +9,13 @@
 #include "private_arrays_search.h"
 #include "range_structures.h"
 #include "region.h"
-#include "../Utils/SgUtils.h"
-#include "../GraphLoop/graph_loops.h"
-#include "../CFGraph/CFGraph.h"
+#include "SgUtils.h"
+#include "graph_loops.h"
+#include "CFGraph/CFGraph.h"

 using namespace std;

-void Collapse(Region* region)
+static void Collapse(Region* region)
 {
    if (region->getBasickBlocks().empty())
        return;
--- a/src/PrivateAnalyzer/private_arrays_search.h
+++ b/src/PrivateAnalyzer/private_arrays_search.h
@@ -5,10 +5,8 @@
 #include <unordered_set>

 #include "range_structures.h"
-#include "region.h"
-#include "../GraphLoop/graph_loops.h"
-#include "../CFGraph/CFGraph.h"
+#include "graph_loops.h"
+#include "CFGraph/CFGraph.h"

-void Collapse(Region* region);
 std::map<LoopGraph*, ArrayAccessingIndexes> FindPrivateArrays(std::map<std::string, std::vector<LoopGraph*>>& loopGraph, std::map<FuncInfo*, std::vector<SAPFOR::BasicBlock*>>& FullIR);
 std::pair<SAPFOR::BasicBlock*, std::unordered_set<SAPFOR::BasicBlock*>> GetBasicBlocksForLoop(const LoopGraph* loop, const std::vector<SAPFOR::BasicBlock*> blocks);
--- a/src/PrivateAnalyzer/range_structures.cpp
+++ b/src/PrivateAnalyzer/range_structures.cpp
@@ -2,8 +2,8 @@
 #include <map>
 #include <unordered_set>
 #include <string>
-#include <numeric>

+#include "utils.h"
 #include "range_structures.h"

 using namespace std;
--- a/src/PrivateAnalyzer/region.cpp
+++ b/src/PrivateAnalyzer/region.cpp
@@ -8,7 +8,7 @@
 #include "range_structures.h"
 #include "region.h"

-#include "../Utils/SgUtils.h"
+#include "SgUtils.h"

 using namespace std;

@@ -51,7 +51,7 @@ pair<SAPFOR::BasicBlock*, unordered_set<SAPFOR::BasicBlock*>> GetBasicBlocksForL
 }

 static void BuildLoopIndex(map<string, LoopGraph*>& loopForIndex, LoopGraph* loop) {
-    string index = loop->loopSymbol;
+    string index = loop->loopSymbol();
    loopForIndex[index] = loop;

    for (const auto& childLoop : loop->children)
@@ -146,7 +146,7 @@ static int GetDefUseArray(SAPFOR::BasicBlock* block, LoopGraph* loop, ArrayAcces
            {
                auto var = index_vars.back();
                int currentVarPos = refPos.back();
-                pair currentCoefs = coefsForDims.back();
+                pair<int, int> currentCoefs = coefsForDims.back();
                ArrayDimension current_dim;
                if (var->getType() == SAPFOR::CFG_ARG_TYPE::CONST)
                    current_dim = { stoul(var->getValue()), 1, 1 };
--- a/src/PrivateAnalyzer/region.h
+++ b/src/PrivateAnalyzer/region.h
@@ -5,8 +5,8 @@
 #include <unordered_set>
 #include <string>

-#include "../GraphLoop/graph_loops.h"
-#include "../CFGraph/CFGraph.h"
+#include "graph_loops.h"
+#include "CFGraph/CFGraph.h"

 class Region : public SAPFOR::BasicBlock {
 public:
--- a/src/ProjectManipulation/ConvertFiles.cpp
+++ b/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;
--- a/src/ProjectManipulation/FileInfo.cpp
+++ b/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;

--- a/src/ProjectManipulation/ParseFiles.cpp
+++ b/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" <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD><EFBFBD> '" + to_wstring(file) + L"'");
-#else 
-        sendMessage_2lvl(L" processing file '" + to_wstring(file) + L"'");
-#endif        
+        sendMessage_2lvl(3, file);
+
        StdCapture::Init();
        string errorMessage = "";
        try
@@ -443,20 +441,12 @@ 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);
@@ -475,13 +465,22 @@ static int dumpErrors(const vector<FileInfo>& listOfProject, const vector<string
            }
        }

-        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;
    }

@@ -576,11 +575,8 @@ static void parseFiles(int& iters, vector<string>& errors, vector<FileInfo>& lis

    do
    {
-#ifdef _WIN32
-        sendMessage_1lvl(L"<EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD> " + std::to_wstring((iters + 1)) + L" <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>");
-#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)
@@ -713,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)
@@ -745,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);

@@ -809,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)
@@ -838,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);
 }
--- a/src/ProjectManipulation/PerfAnalyzer.cpp
+++ b/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"

--- a/src/ProjectParameters/projectParameters.cpp
+++ b/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));
+    }
+}
--- a/src/ProjectParameters/projectParameters.h
+++ b/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);
--- a/src/SageAnalysisTool/defUse.cpp
+++ b/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"
--- a/src/SageAnalysisTool/depGraph.cpp
+++ b/src/SageAnalysisTool/depGraph.cpp
@@ -15,8 +15,8 @@ extern "C" void removeFromCollection(void *pointer);
 #endif
 extern int passDone;

-#include "../GraphCall/graph_calls.h"
-#include "../Utils/errors.h"
+#include "graph_calls.h"
+#include "errors.h"
 #include "../VisualizerCalls/get_information.h"

 #include "sage++user.h"
--- a/src/Sapfor.cpp
+++ b/src/Sapfor.cpp
@@ -24,8 +24,6 @@
 #include "ParallelizationRegions/resolve_par_reg_conflicts.h"
 #include "ParallelizationRegions/expand_extract_reg.h"

-#include "Transformations/replace_dist_arrays_in_io.h"
-
 #include "Distribution/Distribution.h"
 #include "Distribution/GraphCSR.h"
 #include "Distribution/Arrays.h"
@@ -56,7 +54,7 @@
 #include "Distribution/CreateDistributionDirs.h"
 #include "PrivateAnalyzer/private_analyzer.h"
 #include "PrivateAnalyzer/private_arrays_search.h"
-#include "ExpressionTransform/expr_transform.h"
+#include "expr_transform.h"

 #include "Predictor/PredictScheme.h"
 #include "Predictor/PredictorModel.h"
@@ -72,26 +70,27 @@
 #include "VisualizerCalls/SendMessage.h"
 #include "VisualizerCalls/BuildGraph.h"

-#include "SwapOperators/swapOperators.h"
+#include "Transformations/ReplaceArraysInIO/replace_dist_arrays_in_io.h"
+#include "Transformations/LoopEndDoConverter/enddo_loop_converter.h"
+#include "Transformations/LoopNesting/loop_transform.h"
+#include "Transformations/VectorAssignToLoop/array_assign_to_loop.h"
+#include "Transformations/PrivateArrayResizing/private_arrays_resizing.h"
+#include "Transformations/LoopSplitting/loops_splitter.h"
+#include "Transformations/LoopCombining/loops_combiner.h"
+#include "Transformations/LoopUnrolling/loops_unrolling.h"
+#include "Transformations/FunctionDuplication/uniq_call_chain_dup.h"
+#include "Transformations/CheckPoints/checkpoints.h"
+#include "Transformations/ArrayDimsSwapping/swap_array_dims.h"
+#include "Transformations/FunctionPurifying/function_purifying.h"
+#include "Transformations/PrivateArrayRemoving/private_removing.h"
+#include "Transformations/GlobalVariables/fix_common_blocks.h"
+#include "Transformations/ConvertToC/convert_to_c.h"
+#include "Transformations/SetImplicitNone/set_implicit_none.h"
+#include "Transformations/DeadCodeRemoving/dead_code.h"
+#include "Transformations/RenameSymbols/rename_symbols.h"
+#include "Transformations/FunctionInlining/inliner.h"
+#include "Transformations/SwapOperators/swap_operators.h"

-#include "Transformations/enddo_loop_converter.h"
-#include "Transformations/loop_transform.h"
-#include "Transformations/array_assign_to_loop.h"
-#include "Transformations/private_arrays_resizing.h"
-#include "Transformations/loops_splitter.h"
-#include "Transformations/loops_combiner.h"
-#include "Transformations/loops_unrolling.h"
-#include "Transformations/uniq_call_chain_dup.h"
-#include "Transformations/checkpoints.h"
-#include "Transformations/swap_array_dims.h"
-#include "Transformations/function_purifying.h"
-#include "Transformations/private_removing.h"
-#include "Transformations/fix_common_blocks.h"
-#include "Transformations/convert_to_c.h"
-#include "Transformations/set_implicit_none.h"
-#include "Transformations/dead_code.h"
-
-#include "RenameSymbols/rename_symbols.h"
 #include "ProjectParameters/projectParameters.h"

 #include "CFGraph/IR.h"
@@ -101,8 +100,6 @@
 #include "CFGraph/live_variable_analysis.h"
 #include "CFGraph/private_variables_analysis.h"

-#include "Inliner/inliner.h"
-
 #include "dvm.h"
 #include "Sapfor.h"
 #include "Utils/PassManager.h"
@@ -402,11 +399,7 @@ static bool runAnalysis(SgProject &project, const int curr_regime, const bool ne
    __spf_print(DEBUG_LVL1, "RUN PASS with name %s\n", passNames[curr_regime]);

    auto toSendStrMessage = string(passNames[curr_regime]);
-#ifdef _WIN32
-    sendMessage_1lvl(wstring(L"выполняется проход '") + wstring(toSendStrMessage.begin(), toSendStrMessage.end()) + L"'");
-#else
-    sendMessage_1lvl(wstring(L"running pass '") + wstring(toSendStrMessage.begin(), toSendStrMessage.end()) + L"'");
-#endif
+    sendMessage_1lvl(1, toSendStrMessage);

    const int n = project.numberOfFiles();
    bool verifyOK = true;
@@ -454,11 +447,7 @@ static bool runAnalysis(SgProject &project, const int curr_regime, const bool ne
        SgFile *file = &(project.file(i));

        toSendStrMessage = file->filename();
-#ifdef _WIN32
-        sendMessage_2lvl(wstring(L"обработка файла '") + wstring(toSendStrMessage.begin(), toSendStrMessage.end()) + L"'");
-#else 
-        sendMessage_2lvl(wstring(L"processing file '") + wstring(toSendStrMessage.begin(), toSendStrMessage.end()) + L"'");
-#endif
+        sendMessage_2lvl(3, toSendStrMessage);
        sendMessage_progress(std::to_wstring((int)(((double)(n - i) / n) * 100)));

        const char *file_name = file->filename();
@@ -912,7 +901,7 @@ static bool runAnalysis(SgProject &project, const int curr_regime, const bool ne
        else if (curr_regime == ADD_TEMPL_TO_USE_ONLY)
            fixUseOnlyStmt(file, parallelRegions);
        else if (curr_regime == GCOV_PARSER)
-            parse_gcovfile(file, consoleMode == 1 ? file_name : "./visualiser_data/gcov/" + string(file_name), getObjectForFileFromMap(file_name, gCovInfo), keepFiles);        
+            parse_gcovfile(file, consoleMode == 1 ? file_name : string(VISUALIZER_DATA_PATH) + "/gcov/" + file_name, getObjectForFileFromMap(file_name, gCovInfo), keepFiles);
        else if(curr_regime == PRIVATE_ARRAYS_EXPANSION)
        {
            auto founded = loopGraph.find(file->filename());
@@ -951,10 +940,8 @@ static bool runAnalysis(SgProject &project, const int curr_regime, const bool ne
                    internalExit = err;
            }
        }
-        else if (curr_regime == SWAP_OPERATORS)
-        {
-            runSwapOperators(file, loopGraph, fullIR, countOfTransform);
-        }
+        else if (curr_regime == SWAP_OPERATORS)        
+            runSwapOperators(file, loopGraph, fullIR, countOfTransform);        
        else if (curr_regime == PRIVATE_REMOVING_ANALYSIS)
        {
            auto itFound = loopGraph.find(file->filename());
@@ -968,7 +955,7 @@ static bool runAnalysis(SgProject &project, const int curr_regime, const bool ne
            vector<string> include_functions;
            
            createInterTree(file, getObjectForFileFromMap(file_name, intervals), removeNestedIntervals, getObjectForFileFromMap(file_name, SPF_messages));
-            assignCallsToFile(consoleMode == 1 ? file_name : "./visualiser_data/gcov/" + string(file_name), getObjectForFileFromMap(file_name, intervals));
+            assignCallsToFile(consoleMode == 1 ? file_name : string(VISUALIZER_DATA_PATH) + "/gcov/" + file_name, getObjectForFileFromMap(file_name, intervals));
            removeNodes(intervals_threshold, getObjectForFileFromMap(file_name, intervals), include_functions);
        }
        else if (curr_regime == INSERT_INTER_TREE)
@@ -1066,7 +1053,7 @@ static bool runAnalysis(SgProject &project, const int curr_regime, const bool ne
        throw -11;
    }

-    sendMessage_2lvl(wstring(L""));
+    sendMessage_2lvl(2);
    // **********************************  ///
    /// SECOND AGGREGATION STEP            ///
    // **********************************  ///
@@ -1298,7 +1285,6 @@ static bool runAnalysis(SgProject &project, const int curr_regime, const bool ne
        detectCopies(allFuncInfo);
        fillInterfaceBlock(allFuncInfo);
        intentInsertToInterfaces(allFuncInfo);
-        createInterfacesForAssumedSize(allFuncInfo);

        //this call is only for testing
        //setPureStatus(allFuncInfo);
@@ -1722,7 +1708,7 @@ static bool runAnalysis(SgProject &project, const int curr_regime, const bool ne
    }
    else if (curr_regime == GCOV_PARSER)
    {
-        parseTimesDvmStatisticFile((consoleMode == 1) ? string("statistic.txt") : "./visualiser_data/statistic/" + string("statistic.txt"), intervals);
+        parseTimesDvmStatisticFile((consoleMode == 1) ? string("statistic.txt") : string(VISUALIZER_DATA_PATH) + "/statistic/statistic.txt", intervals);

        //fixed count, devide by value from PROG_HEDR
        SgStatement* mainUnit = findMainUnit(&project, SPF_messages);
@@ -1904,7 +1890,7 @@ static bool runAnalysis(SgProject &project, const int curr_regime, const bool ne
    else if (curr_regime == RENAME_SYMBOLS)
        runRenameSymbols(&project, commonBlocks);
    else if (curr_regime == FIND_PARAMETERS)
-        parametersOfProject = findParameters(defUseByFunctions, commonBlocks, allFuncInfo);
+        findParameters(parametersOfProject, fullIR, declaredArrays);
    else if (curr_regime == BUILD_IR)
    {
        auto CFG_forFile = buildCFG(commonBlocks, allFuncInfo_IR, SAPFOR::CFG_Settings(0));
@@ -1932,12 +1918,14 @@ static bool runAnalysis(SgProject &project, const int curr_regime, const bool ne
        calculateStatsForPredictor(allFuncInfo, gCovInfo);
        parseDvmDirForPredictor(declaredArrays, commonBlocks, allFuncInfo, gCovInfo);
    }
+    else if (curr_regime == TRANSFORM_ASSUMED_SIZE_PARAMETERS)
+        transformAssumedSizeParameters(allFuncInfo);

    const float elapsed = duration_cast<milliseconds>(high_resolution_clock::now() - timeForPass).count() / 1000.;
    const float elapsedGlobal = duration_cast<milliseconds>(high_resolution_clock::now() - globalTime).count() / 1000.;
    __spf_print(1, "PROFILE: time for this pass = %f sec (total %f sec)\n", elapsed, elapsedGlobal);

-    sendMessage_2lvl(wstring(L""));
+    sendMessage_2lvl(2);
    if (internalExit != 0)
        throw -1;

@@ -2167,6 +2155,8 @@ void runPass(const int curr_regime, const char *proj_name, const char *folderNam
        runAnalysis(*project, REMOVE_COPIES, false);
        runAnalysis(*project, SWAP_LOOPS, false);

+        runPass(TRANSFORM_ASSUMED_SIZE_PARAMETERS, proj_name, folderName);
+
        if (folderName || consoleMode)
            runAnalysis(*project, UNPARSE_FILE, true, additionalName.c_str(), folderName);
    }
@@ -2650,7 +2640,10 @@ int main(int argc, char **argv)
        }

        if (curr_regime == INSERT_PARALLEL_DIRS_NODIST)
+        {
            ignoreArrayDistributeState = true;
+            sharedMemoryParallelization = 1;
+        }

        if (runAsClient)
        {
@@ -2672,32 +2665,12 @@ int main(int argc, char **argv)
        printStackTrace();
        printf("exception occurred\n");
        
-        json byFileArray = json::array();
-        for (auto& byFile : SPF_messages)
-        {
-            json inFile;
-            inFile["file"] = byFile.first;
-
-            json messages = json::array();
-            for (auto& message : byFile.second)
-            {
-                message.print(byFile.first);
-                messages.push_back(message.toJson());
-            }
-            inFile["messages"] = messages;
-            byFileArray.push_back(inFile);
-        }
-        json allMessages;
-        allMessages["allMessage"] = byFileArray;
-
-        FILE* outF = fopen("dump_messages.json", "w");
-        fprintf(outF, "%s", allMessages.dump().c_str());
-        fclose(outF);        
+        dumpMessages(true, SPF_messages, VISUALIZER_DATA_PATH);
    }
+    dumpMessages(false, SPF_messages, VISUALIZER_DATA_PATH);

    deleteAllAllocatedData(withDel);

-
 #if _WIN32 && _DEBUG
    if (leakMemDump)
    {
--- a/src/Sapfor.h
+++ b/src/Sapfor.h
@@ -187,6 +187,8 @@ enum passes {

    FIND_PRIVATE_ARRAYS,

+    TRANSFORM_ASSUMED_SIZE_PARAMETERS,
+
    TEST_PASS,
    EMPTY_PASS
 };
@@ -374,6 +376,8 @@ static void setPassValues()
    passNames[INSERT_NO_DISTR_FLAGS_FROM_GUI] = "INSERT_NO_DISTR_FLAGS_FROM_GUI";
    passNames[FIND_PRIVATE_ARRAYS] = "FIND_PRIVATE_ARRAYS";

+    passNames[TRANSFORM_ASSUMED_SIZE_PARAMETERS] = "TRANSFORM_ASSUMED_SIZE_PARAMETERS";
+
    passNames[TEST_PASS] = "TEST_PASS";
 }

--- a/src/SapforData.h
+++ b/src/SapforData.h
@@ -49,6 +49,7 @@ bool withTemplateInfo = false;
 bool inlcudeAllFiles = false; // for pass INSERT_INLCUDES
 bool runAsClient = false; // run console project as client for Visualizer
 bool printSymbTable = false;
+const char* VISUALIZER_DATA_PATH = "visualiser_data";

 uint64_t currentAvailMemory = 0;
 int QUALITY; // quality of conflicts search in graph
@@ -168,7 +169,7 @@ std::map<int, UserFiles> filesInfo; // information about open,close,write and re
 //

 //for FIND_PARAMETERS
-std::map< std::pair<std::string, int>, std::set<std::string>> parametersOfProject; // [file, line] -> set[vars]
+std::set<std::tuple<std::string, int, std::string>> parametersOfProject; // [file, line, varname]
 //

 //for GET_MIN_MAX_BLOCK_DIST
--- a/src/SwapOperators/swapOperators.cpp
+++ b/src/SwapOperators/swapOperators.cpp
@@ -1,353 +0,0 @@
-#include <map>
-#include <unordered_set>
-#include <vector>
-#include <queue>
-#include <iostream>
-
-#include "../Utils/errors.h"
-#include "../Utils/SgUtils.h"
-#include "../GraphCall/graph_calls.h"
-#include "../GraphCall/graph_calls_func.h"
-#include "../CFGraph/CFGraph.h"
-#include "../CFGraph/IR.h"
-#include "../GraphLoop/graph_loops.h"
-#include "swapOperators.h"
-
-using namespace std;
-
-
-unordered_set<int> loop_tags = {FOR_NODE/*, FORALL_NODE, WHILE_NODE, DO_WHILE_NODE*/};
-unordered_set<int> importantDepsTags = {FOR_NODE, IF_NODE};
-unordered_set<int> importantUpdDepsTags = {ELSEIF_NODE};
-unordered_set<int> importantEndTags = {CONTROL_END};
-
-
-vector<SAPFOR::IR_Block*> findInstructionsFromOperator(SgStatement* st, vector<SAPFOR::BasicBlock*> Blocks)
-{
-    vector<SAPFOR::IR_Block*> result;
-    string filename = st -> fileName();
-    for (auto& block: Blocks)
-    {
-        vector<SAPFOR::IR_Block*> instructionsInBlock = block -> getInstructions();
-        for (auto& instruction: instructionsInBlock)
-        {
-            SgStatement* curOperator = instruction -> getInstruction() -> getOperator();
-            if (curOperator -> lineNumber() == st -> lineNumber())
-                result.push_back(instruction);
-        }
-    }
-    return result;
-}
-
-vector<SAPFOR::BasicBlock*> findFuncBlocksByFuncStatement(SgStatement *st, map<FuncInfo*, vector<SAPFOR::BasicBlock*>>& FullIR)
-{
-    vector<SAPFOR::BasicBlock*> result;
-    Statement* forSt = (Statement*)st;
-    for (auto& func: FullIR)
-    {
-        if (func.first -> funcPointer -> getCurrProcessFile() == forSt -> getCurrProcessFile()
-            && func.first -> funcPointer -> lineNumber() == forSt -> lineNumber())
-            result = func.second;
-    }
-    return result;
-}
-
-map<SgForStmt*, vector<SAPFOR::BasicBlock*>> findAndAnalyzeLoops(SgStatement *st, vector<SAPFOR::BasicBlock*> blocks)
-{
-    map<SgForStmt*, vector<SAPFOR::BasicBlock*>> result;
-    SgStatement *lastNode = st->lastNodeOfStmt();
-    while (st && st != lastNode)
-    {
-        if (loop_tags.find(st -> variant()) != loop_tags.end())
-        {
-            // part with find statements of loop
-            SgForStmt *forSt = (SgForStmt*)st;
-            SgStatement *loopBody = forSt -> body();
-            SgStatement *lastLoopNode = st->lastNodeOfStmt();
-            // part with find blocks and instructions of loops
-            unordered_set<int> blocks_nums;
-            while (loopBody && loopBody != lastLoopNode)
-            {
-                SAPFOR::IR_Block* IR = findInstructionsFromOperator(loopBody, blocks).front();
-                if (blocks_nums.find(IR -> getBasicBlock() -> getNumber()) == blocks_nums.end())
-                {
-                    result[forSt].push_back(IR -> getBasicBlock());
-                    blocks_nums.insert(IR -> getBasicBlock() -> getNumber());
-                }
-                loopBody = loopBody -> lexNext();
-            }
-            std::sort(result[forSt].begin(), result[forSt].end());
-        }
-        st = st -> lexNext();
-    }
-    return result;
-}
-
-map<SgStatement*, set<SgStatement*>> AnalyzeLoopAndFindDeps(SgForStmt* forStatement, vector<SAPFOR::BasicBlock*> loopBlocks, map<FuncInfo*, vector<SAPFOR::BasicBlock*>>& FullIR)
-{
-    map<SgStatement*, set<SgStatement*>> result;
-    for (SAPFOR::BasicBlock* bb: loopBlocks)
-    {
-        map<SAPFOR::Argument*, set<int>> blockReachingDefinitions = bb -> getRD_In();
-        vector<SAPFOR::IR_Block*> instructions = bb -> getInstructions();
-        for (SAPFOR::IR_Block* irBlock: instructions)
-        {
-            // TODO: Think about what to do with function calls and array references. Because there are also dependencies there that are not reflected in RD, but they must be taken into account
-            SAPFOR::Instruction* instr = irBlock -> getInstruction();
-            result[instr -> getOperator()];
-            // take Argument 1 and it's RD and push operators to final set
-            if (instr -> getArg1() != NULL)
-            {
-                SAPFOR::Argument* arg = instr -> getArg1();
-                set<int> prevInstructionsNumbers = blockReachingDefinitions[arg];
-                for (int i: prevInstructionsNumbers)
-                {
-                    SAPFOR::Instruction* foundInstruction = getInstructionAndBlockByNumber(FullIR, i).first;
-                    if (foundInstruction != NULL)
-                    {
-                        SgStatement* prevOp = foundInstruction -> getOperator();
-                        if (prevOp != forStatement && instr -> getOperator() != forStatement && instr -> getOperator() -> lineNumber() > prevOp -> lineNumber()
-                            && prevOp -> lineNumber() > forStatement -> lineNumber())
-                            result[instr -> getOperator()].insert(prevOp);
-                    }
-                }
-            }
-            // take Argument 2 (if exists) and it's RD and push operators to final set
-            if (instr -> getArg2() != NULL)
-            {
-                SAPFOR::Argument* arg = instr -> getArg2();
-                set<int> prevInstructionsNumbers = blockReachingDefinitions[arg];
-                for (int i: prevInstructionsNumbers)
-                {
-                    SAPFOR::Instruction* foundInstruction = getInstructionAndBlockByNumber(FullIR, i).first;
-                    if (foundInstruction != NULL)
-                    {
-                        SgStatement* prevOp = foundInstruction -> getOperator();
-                        if (prevOp != forStatement && instr -> getOperator() != forStatement&& instr -> getOperator() -> lineNumber() > prevOp -> lineNumber()
-                            && prevOp -> lineNumber() > forStatement -> lineNumber())
-                            result[instr -> getOperator()].insert(prevOp);
-                    }
-                }
-            }
-            // update RD
-            if (instr -> getResult() != NULL)
-                blockReachingDefinitions[instr -> getResult()] = {instr -> getNumber()};
-        }
-    }
-    return result;
-}
-
-void buildAdditionalDeps(SgForStmt* forStatement, map<SgStatement*, set<SgStatement*>>& dependencies)
-{
-    SgStatement* lastNode = forStatement->lastNodeOfStmt();
-    vector<SgStatement*> importantDeps;
-    SgStatement* st = (SgStatement*) forStatement;
-    st = st -> lexNext();
-    SgStatement* logIfOp = NULL;
-    while (st && st != lastNode)
-    {
-        if(importantDeps.size() != 0)
-        {
-            if (st != importantDeps.back())
-            {
-                dependencies[st].insert(importantDeps.back());
-            }
-        }
-        if (logIfOp != NULL)
-        {
-            dependencies[st].insert(logIfOp);
-            logIfOp = NULL;
-        }
-        if (st -> variant() == LOGIF_NODE)
-        {
-            logIfOp = st;
-        }
-        if (importantDepsTags.find(st -> variant()) != importantDepsTags.end())
-        {
-            importantDeps.push_back(st);
-        }
-        if (importantUpdDepsTags.find(st -> variant()) != importantUpdDepsTags.end())
-        {
-            importantDeps.pop_back();
-            importantDeps.push_back(st);
-        }
-        if (importantEndTags.find(st -> variant()) != importantEndTags.end())
-        {
-            if(importantDeps.size() != 0)
-            {
-                importantDeps.pop_back();
-            }
-        }
-        st = st -> lexNext();
-    }
-}
-
-struct ReadyOp {
-    SgStatement* stmt;
-    int degree;
-    size_t arrival;
-    ReadyOp(SgStatement* s, int d, size_t a): stmt(s), degree(d), arrival(a) {}
-};
-
-struct ReadyOpCompare {
-    bool operator()(const ReadyOp& a, const ReadyOp& b) const {
-        if (a.degree != b.degree)
-            return a.degree > b.degree;
-        else
-            return a.arrival > b.arrival;
-    }
-};
-
-vector<SgStatement*> scheduleOperations(const map<SgStatement*, set<SgStatement*>>& dependencies)
-{
-    // get all statements
-    unordered_set<SgStatement*> allStmtsSet;
-    for (const auto& pair : dependencies)
-    {
-        allStmtsSet.insert(pair.first);
-        for (SgStatement* dep : pair.second)
-        {
-            allStmtsSet.insert(dep);
-        }
-    }
-    vector<SgStatement*> allStmts(allStmtsSet.begin(), allStmtsSet.end());
-    // count deps and build reversed graph
-    unordered_map<SgStatement*, vector<SgStatement*>> graph;
-    unordered_map<SgStatement*, int> inDegree;
-    unordered_map<SgStatement*, int> degree;
-    for (auto op : allStmts)
-        inDegree[op] = 0;
-    // find and remember initial dependencies
-    unordered_set<SgStatement*> dependentStmts;
-    for (const auto& pair : dependencies)
-    {
-        SgStatement* op = pair.first;
-        const auto& deps = pair.second;
-        degree[op] = deps.size();
-        inDegree[op] = deps.size();
-        if (!deps.empty())
-            dependentStmts.insert(op);
-        for (auto dep : deps)
-            graph[dep].push_back(op);
-    }
-    for (SgStatement* op : allStmts)
-    {
-        if (!degree.count(op))
-        {
-            degree[op] = 0;
-        }
-    }
-    // build queues
-    using PQ = priority_queue<ReadyOp, vector<ReadyOp>, ReadyOpCompare>;
-    PQ readyDependent;
-    queue<SgStatement*> readyIndependent;
-    size_t arrivalCounter = 0;
-    for (auto op : allStmts)
-    {
-        if (inDegree[op] == 0)
-        {
-            if (dependentStmts.count(op))
-            {
-                readyDependent.emplace(op, degree[op], arrivalCounter++);
-            }
-            else
-            {
-                readyIndependent.push(op);
-            }
-        }
-    }
-    // main sort algorythm
-    vector<SgStatement*> executionOrder;
-    while (!readyDependent.empty() || !readyIndependent.empty())
-    {
-        SgStatement* current = nullptr;
-        if (!readyDependent.empty())
-        {
-            current = readyDependent.top().stmt;
-            readyDependent.pop();
-        }
-        else
-        {
-            current = readyIndependent.front();
-            readyIndependent.pop();
-        }
-        executionOrder.push_back(current);
-        for (SgStatement* neighbor : graph[current])
-        {
-            inDegree[neighbor]--;
-            if (inDegree[neighbor] == 0) {
-                if (dependentStmts.count(neighbor))
-                {
-                    readyDependent.emplace(neighbor, degree[neighbor], arrivalCounter++);
-                }
-                else
-                {
-                    readyIndependent.push(neighbor);
-                }
-            }
-        }
-    }
-    return executionOrder;
-}
-
-void buildNewAST(SgStatement* loop, vector<SgStatement*>& newBody)
-{
-    SgStatement* endDo = loop->lastNodeOfStmt();
-    SgStatement* st = loop;
-    int lineNum = loop -> lineNumber() + 1;
-    for (int i = 0; i < newBody.size(); i++)
-    {
-        st -> setLexNext(*newBody[i]);
-        st = st -> lexNext();
-        st -> setlineNumber(lineNum);
-        lineNum++;
-    }
-    st -> setLexNext(*endDo);
-}
-
-
-
-void runSwapOperators(SgFile *file, std::map<std::string, std::vector<LoopGraph*>>& loopGraph, std::map<FuncInfo*, std::vector<SAPFOR::BasicBlock*>>& FullIR, int& countOfTransform)
-{
-    std::cout << "SWAP_OPERATORS Pass" << std::endl;    // to remove
-    countOfTransform += 1;                              // to remove
-
-    const int funcNum = file -> numberOfFunctions();
-    for (int i = 0; i < funcNum; ++i)
-    {
-        SgStatement *st = file -> functions(i);
-        vector<SAPFOR::BasicBlock*> blocks = findFuncBlocksByFuncStatement(st, FullIR);
-        map<SgForStmt*, vector<SAPFOR::BasicBlock*>> loopsMapping = findAndAnalyzeLoops(st, blocks);
-        for (pair<SgForStmt*, vector<SAPFOR::BasicBlock*>> loopForAnalyze: loopsMapping)
-        {
-            map<SgStatement*, set<SgStatement*>> dependencyGraph = AnalyzeLoopAndFindDeps(loopForAnalyze.first, loopForAnalyze.second, FullIR);
-            // TODO: Write a function that will go through the operators and update all dependencies so that there are no mix-ups and splits inside the semantic blocks (for if, do and may be some other cases)
-            buildAdditionalDeps(loopForAnalyze.first, dependencyGraph);
-            cout << endl;
-            int firstLine = loopForAnalyze.first -> lineNumber();
-            int lastLine = loopForAnalyze.first -> lastNodeOfStmt() -> lineNumber();
-            cout << "LOOP ANALYZE FROM " << firstLine << " TO " << lastLine << " RES" << endl;
-            // for (auto &v: dependencyGraph) {
-            //     cout << "OPERATOR: " << v.first -> lineNumber()  << "    " << v.first -> variant() << "\nDEPENDS ON:" << endl;
-            //     if (v.second.size() != 0)
-            //         for (auto vv: v.second)
-            //             cout << vv -> lineNumber() << "  ";
-            //     cout << endl;
-            // }
-            vector<SgStatement*> new_order = scheduleOperations(dependencyGraph);
-            cout << "RESULT ORDER:" << endl;
-            for (auto v: new_order) 
-                if (v -> lineNumber() > firstLine) 
-                    cout << v -> lineNumber() << endl;
-            buildNewAST(loopForAnalyze.first, new_order);
-            st = loopForAnalyze.first -> lexNext();
-            while (st != loopForAnalyze.first -> lastNodeOfStmt())
-            {
-                cout << st -> lineNumber() << "    " << st -> sunparse() << endl;
-                st = st -> lexNext();
-            }
-        }
-    }
-
-    return;
-};
--- a/src/Transformations/ArrayDimsSwapping/swap_array_dims.cpp
+++ b/src/Transformations/ArrayDimsSwapping/swap_array_dims.cpp
@@ -11,9 +11,9 @@
 #include "../Distribution/Array.h"
 #include "dvm.h"

-#include "../Utils/errors.h"
-#include "../Utils/utils.h"
-#include "../Utils/SgUtils.h"
+#include "errors.h"
+#include "utils.h"
+#include "SgUtils.h"

 using namespace std;

--- a/Show More
+++ b/Show More
Author	SHA1	Message	Date
Egor Mayorov	e9d5a2ee70	Make pass correct	2025-10-23 14:54:43 +03:00
Egor Mayorov	2746d072d4	attempt to build new ast	2025-10-22 17:00:27 +03:00
Alexander	f7005a2735	moved to transformations	2025-10-22 17:00:27 +03:00
Egor Mayorov	a86a76705e	swap operators in AST	2025-10-22 17:00:27 +03:00
Egor Mayorov	7fed8f13c3	Use more complex algorythm for building new order of statements	2025-10-22 17:00:27 +03:00
Egor Mayorov	2aba5e07bf	update in new order	2025-10-22 17:00:27 +03:00
Egor Mayorov	601c6b6e88	biulding new order	2025-10-22 17:00:27 +03:00
Egor Mayorov	97689d999b	some loop analysis done	2025-10-22 17:00:27 +03:00
Egor Mayorov	a85cf28965	Add _bin to gitignore	2025-10-22 17:00:27 +03:00
Egor Mayorov	3c6f5a7a56	Some actions simplify analyzing IR	2025-10-22 17:00:27 +03:00
Egor Mayorov	e7661998fe	Pass with output file added	2025-10-22 17:00:27 +03:00
Egor Mayorov	01d769f38b	change pass deps	2025-10-22 17:00:27 +03:00
Egor Mayorov	63e6d22d49	New pass	2025-10-22 17:00:27 +03:00
Alexander_KS	47e2b961e2	Merge pull request 'replace_io_arrays' (#67 ) from replace_io_arrays into master	2025-10-01 18:13:01 +00:00
ALEXks	b95b336372	version updated	2025-10-01 21:12:49 +03:00
xnpster	f35d7cb4bd	REMOVE_DIST_ARRAYS_FROM_IO: consider write/read statements with nested loops	2025-10-01 19:48:34 +03:00
xnpster	54615e34d4	REMOVE_DIST_ARRAYS_FROM_IO: use more general isSgVarListDeclStmt and isSgNestedVarListDeclStmt functions	2025-10-01 18:54:55 +03:00
xnpster	8752f4a139	REMOVE_DIST_ARRAYS_FROM_IO: consider labels and goto statements while inserting copy statements	2025-10-01 18:54:55 +03:00
xnpster	453105d273	REMOVE_DIST_ARRAYS_FROM_IO: consider array declarations from common blocks and dimension statements	2025-10-01 18:54:55 +03:00
Alexander_KS	cad0a0b217	Merge pull request 'cmake: set -O2 optimization level only if CMAKE_BUILD_TYPE is not specified' (#66 ) from cmake_linux_opt_level into master	2025-09-25 18:13:00 +00:00
xnpster	9c0fd40e7b	cmake: change default optimization level to O3	2025-09-25 20:49:11 +03:00
xnpster	c7a31c8bbb	cmake: set -O2 optimization level only if CMAKE_BUILD_TYPE is not specified	2025-09-25 13:44:10 +03:00
ALEXks	9900929349	refactored	2025-09-23 08:21:05 +03:00
ALEXks	e1ba299159	cleanup	2025-09-21 08:47:42 +03:00
ALEXks	8de18d1788	added json to global results	2025-09-18 21:09:43 +03:00
Alexander_KS	06aabdbee6	Merge pull request 'REMOVE_DIST_ARRAYS_FROM_IO Handle assumed-size and assumed-shape arrays' (#64 ) from replace_io_arrays into master	2025-09-16 05:23:30 +00:00
ALEXks	c6f290bb56	trivial, version updated	2025-09-16 08:22:53 +03:00
xnpster	49d3b9b96e	REMOVE_DIST_ARRAYS_FROM_IO: revert hotfix for issue with generated intent statements	2025-09-15 21:25:57 +03:00
xnpster	280beb13cc	REMOVE_DIST_ARRAYS_FROM_IO: regard generated intent statements, carefully detect assumed-shape arrays	2025-09-13 20:48:24 +03:00
xnpster	3bc9351641	REMOVE_DIST_ARRAYS_FROM_IO: do not process arrays from headers, copy from correct declarations, improve style	2025-09-13 20:48:24 +03:00
xnpster	16b2c6b42b	REMOVE_DIST_ARRAYS_FROM_IO: remove debug prints	2025-09-13 20:48:24 +03:00
xnpster	fe31df0ef2	REMOVE_DIST_ARRAYS_FROM_IO: handle assumed-size and assumed-shape arrays	2025-09-13 20:48:24 +03:00
ALEXks	4c8681bfe2	dvm updated	2025-09-13 20:25:59 +03:00
ALEXks	d330a6ee23	changed line numbers to negative for INTENT and INTRINSIC	2025-09-13 20:21:56 +03:00
ALEXks	b439759e9b	updated dvm for SAPFOR	2025-09-11 17:20:44 +03:00
Alexander_KS	b11973cb64	Merge pull request 'ArrayAnalysis: consider case of IO_PRIV array from module' (#65 ) from io_priv_module_arrays into master	2025-09-11 05:07:39 +00:00
ALEXks	df9a9a30bb	fixed DIST::IO_PRIV detection	2025-09-11 08:07:14 +03:00
ALEXks	2cd02c295f	fixed expression calculation, fixed addArg	2025-08-20 14:34:17 +03:00
ALEXks	278fc1ff9c	fixed replace_dist_array pass: added more file switching	2025-07-27 08:52:28 +03:00
ALEXks	80eac5b957	fixed region inserter	2025-07-27 08:20:36 +03:00
ALEXks	0c9eed4bb7	fixed transformation	2025-07-27 07:59:25 +03:00
ALEXks	d3d6d0bec7	added TRANSFORM_ASSUMED_SIZE_PARAMETERS pass, fixed shared memory parallelization	2025-07-26 20:22:15 +03:00
ALEXks	3095510826	improved cmake	2025-07-22 08:54:21 +03:00
ALEXks	85e2a60183	removed createInterfacesForAssumedSize call	2025-07-09 14:46:29 +03:00
ALEXks	68bd21b7b0	fixed inout analysis for function's parameters	2025-07-09 12:00:27 +03:00
ALEXks	177433a95b	turn off createInterfacesForAssumedSize call	2025-07-05 20:58:12 +03:00
ALEXks	29ece9072e	fixed shared memory parallelization	2025-07-05 20:49:23 +03:00
ALEXks	feafa43f32	fixed declare insertion	2025-07-02 12:02:30 +03:00
ALEXks	b8f429256f	added removedUnreachableBlocks call for buildCFG	2025-06-29 16:02:37 +03:00
ALEXks	2f53d6ae2e	fixed	2025-06-22 09:22:10 +03:00
ALEXks	65237e4d63	added inductive variables and loop type to LoopGraph	2025-06-22 09:19:37 +03:00
ALEXks	7533739488	moved to removedUnreachableBlocks	2025-06-18 16:26:43 +03:00
Alexander_KS	c1d31b809b	Merge pull request 'REMOVE_DIST_ARRAYS_FROM_IO: improve parsing of IO operators, fix substitution borders' (#63 ) from replace_io_arrays into master Reviewed-on: #63	2025-06-15 17:07:00 +00:00
Alexander	537f3eb6e9	version updated	2025-06-15 20:06:35 +03:00
xnpster	f5f99f6e8a	REMOVE_DIST_ARRAYS_FROM_IO: improve parsing of IO operators, fix substitution borders	2025-06-15 15:08:11 +03:00
ALEXks	fc47a1685c	version updated	2025-06-14 21:07:24 +03:00
Alexander_KS	383d8df826	Merge pull request 'REMOVE_DIST_ARRAYS_FROM_IO: use isArrayRef' (#62 ) from replace_io_arrays into master Reviewed-on: #62	2025-06-14 18:06:19 +00:00
xnpster	ebc5a1cbc1	REMOVE_DIST_ARRAYS_FROM_IO: use isArrayRef	2025-06-14 20:25:23 +03:00
ALEXks	0eee799867	fixed dependencies pass order	2025-06-14 16:03:14 +03:00
ALEXks	50dd54cec1	improved	2025-06-14 15:15:51 +03:00
ALEXks	6a59bc0e09	added missing	2025-06-14 12:52:57 +03:00
ALEXks	9e777ceeab	fixed shared memory parallelization, moved messages to single file	2025-06-14 12:50:04 +03:00
ALEXks	10636427ed	fixed findArrayRef in loop_graph	2025-06-14 12:20:34 +03:00
ALEXks	a0704038db	fixed compilation	2025-06-11 15:17:32 +03:00
Alexander_KS	623f6c0d73	Merge pull request 'dynamic parameters' (#61 ) from dyn_params into master Reviewed-on: #61	2025-06-11 12:07:36 +00:00
ALEXks	622159cba6	improved	2025-06-11 15:07:06 +03:00
ALEXks	db26a2c332	merged master	2025-06-11 14:50:27 +03:00
ALEXks	8ad19cbfa5	fixed merging	2025-06-11 11:31:48 +03:00
ALEXks	1895a4b02a	fixed	2025-06-06 08:15:10 +03:00
ALEXks	623898d913	added message dumping for -parse option if running from console	2025-06-05 19:04:56 +03:00
ALEXks	a96a4bcaa6	added dump messages function	2025-06-04 15:07:20 +03:00
ALEXks	a7764847c4	fixed	2025-06-04 13:55:37 +03:00
ALEXks	fca4f632e4	refactoring: removed unnecessary	2025-06-04 13:08:38 +03:00
ALEXks	f53d514a47	added VISUALIZER_DATA_PATH variable	2025-06-04 13:01:50 +03:00
Vladislav Abrosimov	ae9cc2bf3b	Fix set iterators invalidation in find_parameters	2025-06-04 09:19:10 +03:00
Vladislav Abrosimov	c6a0c73287	fix UB in dom tree builder	2025-06-04 09:18:24 +03:00
ALEXks	db32a3e2b2	small fix	2025-06-04 08:32:25 +03:00
ALEXks	a0a401c42a	refactored transformation: added folders for each transformation	2025-06-02 19:08:09 +03:00
Vladislav Abrosimov	b454858647	delete zero from directive	2025-05-30 12:00:56 +03:00
ALEXks	ad99446b12	added missing	2025-05-30 11:57:39 +03:00
ALEXks	d3e8c481d2	fixed code style, moved dom tree building to IR	2025-05-30 11:34:32 +03:00
Vladislav Abrosimov	4e16638c36	Clean up	2025-05-29 09:14:12 +03:00
Vladislav Abrosimov	6742932862	Add SPF directive insertion	2025-05-29 09:14:12 +03:00
Vladislav Abrosimov	8b2e59356a	Extend interprocedural analysis	2025-05-29 09:14:12 +03:00
Vladislav Abrosimov	f9d52c0c3e	unparse after	2025-05-29 09:14:12 +03:00
Vladislav Abrosimov	537d60222f	Add Dominator tree builder and interprocedural analysis	2025-05-29 09:14:12 +03:00
Vladislav Abrosimov	4eb057731f	trivial case for local variables only	2025-05-29 09:14:12 +03:00