Merge branch 'master' into analyze_loops_with_IR

.gitignore

@@ -78,4 +78,3 @@ Sapfor/Sapc++/x64/
 
 Sapfor/out/
 Sapfor/_bin/*
-_bin/*

CMakeLists.txt

@@ -12,7 +12,6 @@ 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/)
@@ -28,14 +27,6 @@ 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})
@@ -163,55 +154,40 @@ set(PARALLEL_REG src/ParallelizationRegions/ParRegions.cpp
         src/ParallelizationRegions/resolve_par_reg_conflicts.cpp
         src/ParallelizationRegions/resolve_par_reg_conflicts.h)
 
-set(ARRAY_PROP src/ArrayConstantPropagation/propagation.cpp
+set(TR_DEAD_CODE src/Transformations/dead_code.cpp
-	src/ArrayConstantPropagation/propagation.h	
+        src/Transformations/dead_code.h)
-)
+set(TR_CP src/Transformations/checkpoints.cpp
-set(MERGE_COPY_ARRAYS src/ParallelizationRegions/parse_merge_dirs.cpp
+        src/Transformations/checkpoints.h)
-         src/ParallelizationRegions/parse_merge_dirs.h)
+set(TR_VECTOR src/Transformations/array_assign_to_loop.cpp
-
+        src/Transformations/array_assign_to_loop.h)
-set(TR_DEAD_CODE src/Transformations/DeadCodeRemoving/dead_code.cpp
+set(TR_ENDDO_LOOP src/Transformations/enddo_loop_converter.cpp
-        src/Transformations/DeadCodeRemoving/dead_code.h)
+        src/Transformations/enddo_loop_converter.h)
-set(TR_CP src/Transformations/CheckPoints/checkpoints.cpp
+set(TR_LOOP_NEST src/Transformations/loop_transform.cpp
-        src/Transformations/CheckPoints/checkpoints.h)
+        src/Transformations/loop_transform.h)
-set(TR_VECTOR src/Transformations/VectorAssignToLoop/array_assign_to_loop.cpp
+set(TR_LOOP_COMB src/Transformations/loops_combiner.cpp
-        src/Transformations/VectorAssignToLoop/array_assign_to_loop.h)
+        src/Transformations/loops_combiner.h)
-set(TR_ENDDO_LOOP src/Transformations/LoopEndDoConverter/enddo_loop_converter.cpp
+set(TR_LOOP_SPLIT src/Transformations/loops_splitter.cpp
-        src/Transformations/LoopEndDoConverter/enddo_loop_converter.h)
+        src/Transformations/loops_splitter.h)
-set(TR_LOOP_NEST src/Transformations/LoopNesting/loop_transform.cpp
+set(TR_LOOP_UNROLL src/Transformations/loops_unrolling.cpp
-        src/Transformations/LoopNesting/loop_transform.h)
+        src/Transformations/loops_unrolling.h)     
-set(TR_LOOP_COMB src/Transformations/LoopCombining/loops_combiner.cpp
+set(TR_PRIV_BR src/Transformations/private_arrays_resizing.cpp
-        src/Transformations/LoopCombining/loops_combiner.h)
+        src/Transformations/private_arrays_resizing.h)
-set(TR_LOOP_SPLIT src/Transformations/LoopSplitting/loops_splitter.cpp
+set(TR_PRIV_DEL src/Transformations/private_removing.cpp
-        src/Transformations/LoopSplitting/loops_splitter.h)
+        src/Transformations/private_removing.h)
-set(TR_LOOP_UNROLL src/Transformations/LoopUnrolling/loops_unrolling.cpp
+set(TR_SWAP_ARR_DIMS src/Transformations/swap_array_dims.cpp
-        src/Transformations/LoopUnrolling/loops_unrolling.h)     
+        src/Transformations/swap_array_dims.h)
-set(TR_PRIV_BR src/Transformations/PrivateArrayResizing/private_arrays_resizing.cpp
+set(TR_FUNC_DUP src/Transformations/uniq_call_chain_dup.cpp
-        src/Transformations/PrivateArrayResizing/private_arrays_resizing.h)
+        src/Transformations/uniq_call_chain_dup.h)
-set(TR_PRIV_DEL src/Transformations/PrivateArrayRemoving/private_removing.cpp
+set(TR_FUNC_PURE src/Transformations/function_purifying.cpp
-        src/Transformations/PrivateArrayRemoving/private_removing.h)
+        src/Transformations/function_purifying.h)  
-set(TR_SWAP_ARR_DIMS src/Transformations/ArrayDimsSwapping/swap_array_dims.cpp
+set(TR_GV src/Transformations/fix_common_blocks.cpp
-        src/Transformations/ArrayDimsSwapping/swap_array_dims.h)
+        src/Transformations/fix_common_blocks.h)
-set(TR_FUNC_DUP src/Transformations/FunctionDuplication/uniq_call_chain_dup.cpp
+set(TR_CONV src/Transformations/convert_to_c.cpp
-        src/Transformations/FunctionDuplication/uniq_call_chain_dup.h)
+        src/Transformations/convert_to_c.h)
-set(TR_FUNC_PURE src/Transformations/FunctionPurifying/function_purifying.cpp
+set(TR_IMPLICIT_NONE src/Transformations/set_implicit_none.cpp
-        src/Transformations/FunctionPurifying/function_purifying.h)  
+        src/Transformations/set_implicit_none.h)
-set(TR_GV src/Transformations/GlobalVariables/fix_common_blocks.cpp
+set(TR_REPLACE_ARRAYS_IN_IO src/Transformations/replace_dist_arrays_in_io.cpp
-        src/Transformations/GlobalVariables/fix_common_blocks.h)
+        src/Transformations/replace_dist_arrays_in_io.h)
-set(TR_CONV src/Transformations/ConvertToC/convert_to_c.cpp
-        src/Transformations/ConvertToC/convert_to_c.h)
-set(TR_IMPLICIT_NONE src/Transformations/SetImplicitNone/set_implicit_none.cpp
-        src/Transformations/SetImplicitNone/set_implicit_none.h)
-set(TR_REPLACE_ARRAYS_IN_IO src/Transformations/ReplaceArraysInIO/replace_dist_arrays_in_io.cpp
-        src/Transformations/ReplaceArraysInIO/replace_dist_arrays_in_io.h)
-set(TR_EXPR_TRANSFORM src/Transformations/ExpressionSubstitution/control_flow_graph_part.cpp
-        src/Transformations/ExpressionSubstitution/expr_transform.cpp
-        src/Transformations/ExpressionSubstitution/expr_transform.h)        
-set(TR_INLINER src/Transformations/FunctionInlining/inliner.cpp
-        src/Transformations/FunctionInlining/inliner.h)
-set(TR_RENAME_SYMBOLS  src/Transformations/RenameSymbols/rename_symbols.cpp
-        src/Transformations/RenameSymbols/rename_symbols.h)
-SET(TR_MOVE_OPERATORS src/Transformations/MoveOperators/move_operators.cpp
-        src/Transformations/MoveOperators/move_operators.h)
 
 set(TRANSFORMS 
         ${TR_DEAD_CODE}
@@ -231,16 +207,11 @@ set(TRANSFORMS
         ${TR_CONV}
         ${TR_PRIV_DEL}
         ${TR_IMPLICIT_NONE}
-        ${TR_REPLACE_ARRAYS_IN_IO}
+        ${TR_REPLACE_ARRAYS_IN_IO})
-        ${TR_EXPR_TRANSFORM}
-        ${TR_INLINER}
-        ${TR_RENAME_SYMBOLS}
-        ${TR_MOVE_OPERATORS})
 
-set(CFG src/CFGraph/IR.cpp
+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
@@ -249,6 +220,8 @@ set(CFG src/CFGraph/IR.cpp
         src/CFGraph/live_variable_analysis.h
         src/CFGraph/private_variables_analysis.cpp
         src/CFGraph/private_variables_analysis.h
+	src/CFGraph/IRSSAForm.cpp
+	src/CFGraph/IRSSAForm.h
         )
         
 set(DATA_FLOW
@@ -319,6 +292,10 @@ set(DYNA src/DynamicAnalysis/createParallelRegions.cpp
         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
         src/GraphCall/graph_calls_base.cpp
@@ -329,11 +306,18 @@ 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
@@ -423,14 +407,15 @@ set(SOURCE_EXE
     ${DISTR}
     ${DVMH_REG}
     ${DYNA}
+    ${EXPR_TRANSFORM}
     ${GR_CALL}
     ${GR_LOOP}
+    ${INLINER}
     ${LOOP_ANALYZER}
+    ${RENAME_SYMBOLS}
     ${TRANSFORMS}
     ${PARALLEL_REG}
-    ${MERGE_COPY_ARRAYS}
     ${PRIV}
-    ${ARRAY_PROP}
     ${FDVM}
     ${OMEGA}
     ${UTILS}
@@ -451,7 +436,7 @@ source_group (CFGraph FILES ${CFG})
 source_group (CFGraph\\DataFlow FILES ${DATA_FLOW})
 
 source_group (Transformations\\DeadCodeRemoving FILES ${TR_DEAD_CODE})
-source_group (Transformations\\ExpressionSubstitution FILES ${TR_EXPR_TRANSFORM})
+source_group (Transformations\\ExpressionSubstitution FILES ${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})
@@ -459,18 +444,17 @@ 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 ${TR_INLINER})
+source_group (Transformations\\FunctionInlining FILES ${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 ${TR_RENAME_SYMBOLS})
+source_group (Transformations\\RenameSymbols FILES ${RENAME_SYMBOLS})
 source_group (Transformations\\GlobalVariables FILES ${TR_GV})
 source_group (Transformations\\ConvertToC FILES ${TR_CONV})
 source_group (Transformations\\SetImplicitNone FILES ${TR_IMPLICIT_NONE})
 source_group (Transformations\\ReplaceArraysInIO FILES ${TR_REPLACE_ARRAYS_IN_IO})
-source_group (Transformations\\MoveOperators FILES ${TR_MOVE_OPERATORS})
 
 
 source_group (CreateIntervals FILES ${CREATE_INTER_T})
@@ -482,9 +466,7 @@ source_group (GraphCall FILES ${GR_CALL})
 source_group (GraphLoop FILES ${GR_LOOP})
 source_group (LoopAnalyzer FILES ${LOOP_ANALYZER})
 source_group (ParallelizationRegions FILES ${PARALLEL_REG})
-source_group (MergeCopyArrays FILES ${MERGE_COPY_ARRAYS})
 source_group (PrivateAnalyzer FILES ${PRIV})      
-source_group (ArrayConstantPropagation FILES ${ARRAY_PROP})      
 source_group (FDVM_Compiler FILES ${FDVM})
 source_group (SageExtension FILES ${OMEGA})
 source_group (Utils FILES ${UTILS})
@@ -510,9 +492,7 @@ else()
     else()
         set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -std=c++11")
     endif()
-    if(NOT CMAKE_BUILD_TYPE)
+   set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -O2")
-        set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -O3")
-    endif()
 endif()
 
 add_subdirectory(projects/Fdvm)

src/ArrayConstantPropagation/propagation.cpp

@@ -1,301 +0,0 @@
-#include "propagation.h"
-
-#include "../Utils/SgUtils.h"
-
-#include <iostream>
-#include <unordered_map>
-#include <unordered_set>
-#include <vector>
-
-using namespace std;
-
-static SgStatement* declPlace = NULL;
-
-static bool CheckConstIndexes(SgExpression* exp)
-{
-    if (!exp)
-    {
-        return true;
-    }
-    SgExpression* lhs = exp->lhs();
-    SgExpression* rhs = exp->rhs();
-    do
-    {
-        if (lhs->variant() != INT_VAL)
-        {
-            return false;
-        }
-        if (rhs)
-        {
-            lhs = rhs->lhs();
-            rhs = rhs->rhs();
-        }
-    } while (rhs);
-    return true;
-}
-
-static SgExpression* CreateVar(int& variableNumber, SgType* type)
-{
-    string varName = "__tmp_prop_var";
-    string name = varName + std::to_string(variableNumber) + "__";
-    variableNumber++;
-
-    SgSymbol* varSymbol = new SgSymbol(VARIABLE_NAME, name.c_str(), *type, *declPlace->controlParent());
-
-    const string commonBlockName = "__propagation_common__";
-
-    SgStatement* funcStart = declPlace->controlParent();
-    SgStatement* commonStat = NULL;
-    SgExpression* commonList = NULL;
-
-    SgStatement* funcEnd = funcStart->lastNodeOfStmt();
-    SgStatement* current = funcStart->lexNext();
-
-    while (current != funcEnd && current)
-    {
-        if (current->variant() == COMM_STAT)
-        {
-            for (SgExpression* exp = current->expr(0); exp; exp = exp->rhs())
-            {
-                if (exp->variant() == COMM_LIST)
-                {
-                    string existingName = exp->symbol() ?
-                        string(exp->symbol()->identifier()) :
-                        string("spf_unnamed");
-                    if (existingName == commonBlockName)
-                    {
-                        commonStat = current;
-                        commonList = exp;
-                        break;
-                    }
-                }
-            }
-            if (commonStat)
-                break;
-        }
-        current = current->lexNext();
-    }
-
-    vector<SgExpression*> varRefs;
-    if (commonList)
-    {
-        SgExpression* varList = commonList->lhs();
-        if (varList)
-        {
-            auto extractSymbol = [](SgExpression* exp) -> SgSymbol* {
-                if (!exp) 
-                    return NULL;
-                if (exp->symbol()) 
-                    return exp->symbol();
-                if (exp->lhs() && exp->lhs()->symbol())
-                    return exp->lhs()->symbol();
-                return NULL;
-                };
-            if (varList->variant() == EXPR_LIST)
-            {
-                for (SgExpression* exp = varList; exp; exp = exp->rhs())
-                {
-                    SgExpression* varExp = exp->lhs();
-                    SgSymbol* sym = extractSymbol(varExp);
-                    if (sym)
-                    {
-                        varRefs.push_back(new SgVarRefExp(sym));
-                    }
-                }
-            }
-            else
-            {
-                for (SgExpression* varExp = varList; varExp; varExp = varExp->rhs())
-                {
-                    SgSymbol* sym = extractSymbol(varExp);
-                    if (sym)
-                    {
-                        varRefs.push_back(new SgVarRefExp(sym));
-                    }
-                }
-            }
-        }
-    }
-
-    if (!commonList)
-    {
-        current = funcStart->lexNext();
-        while (current != funcEnd && current)
-        {
-            if (current->variant() == COMM_STAT)
-            {
-                commonStat = current;
-                break;
-            }
-            current = current->lexNext();
-        }
-
-        SgSymbol* commonSymbol = new SgSymbol(COMMON_NAME, commonBlockName.c_str());
-        commonList = new SgExpression(COMM_LIST, NULL, NULL, commonSymbol);
-
-        if (commonStat)
-        {
-            SgExpression* lastCommList = commonStat->expr(0);
-            if (lastCommList)
-            {
-                while (lastCommList->rhs())
-                    lastCommList = lastCommList->rhs();
-                lastCommList->setRhs(commonList);
-            }
-            else
-            {
-                commonStat->setExpression(0, commonList);
-            }
-        }
-        else
-        {
-            commonStat = new SgStatement(COMM_STAT);
-            commonStat->setFileName(declPlace->fileName());
-            commonStat->setFileId(declPlace->getFileId());
-            commonStat->setProject(declPlace->getProject());
-            commonStat->setlineNumber(getNextNegativeLineNumber());
-            commonStat->setExpression(0, commonList);
-
-            declPlace->insertStmtBefore(*commonStat, *declPlace->controlParent());
-        }
-
-    }
-    varRefs.push_back(new SgVarRefExp(varSymbol));
-
-    if (varRefs.size() > 0)
-    {
-        std::reverse(varRefs.begin(), varRefs.end());
-        SgExpression* varList = makeExprList(varRefs, false);
-
-        commonList->setLhs(varList);
-    }
-
-    return new SgExpression(VAR_REF, NULL, NULL, varSymbol, type->copyPtr());
-}
-
-static void TransformRightPart(SgStatement* st, SgExpression* exp, unordered_map<string, SgExpression*>& arrayToVariable, int& variableNumber) 
-{
-    if (!exp)
-    {
-        return;
-    }
-
-    vector<SgExpression*> subnodes = { exp->lhs(), exp->rhs() };
-
-    string expUnparsed;
-    SgExpression* toAdd = NULL;
-    if (exp->variant() == ARRAY_REF && CheckConstIndexes(exp->lhs()))
-    {
-        cout << st->unparse() << endl;
-        if (arrayToVariable.find(expUnparsed) == arrayToVariable.end() && exp->symbol()->type()->baseType())
-        {
-            arrayToVariable[expUnparsed] = CreateVar(variableNumber, exp->symbol()->type()->baseType());  
-        }
-        st->setExpression(1, arrayToVariable[expUnparsed]->copyPtr());
-        return;
-    }
-    for (int i = 0; i < 2; i++)
-    {
-        if (subnodes[i] && subnodes[i]->variant() == ARRAY_REF && subnodes[i]->symbol()->type()->baseType() && CheckConstIndexes(subnodes[i]->lhs()))
-        {
-            expUnparsed = subnodes[i]->unparse();
-            if (arrayToVariable.find(expUnparsed) == arrayToVariable.end())
-            {                
-                arrayToVariable[expUnparsed] = CreateVar(variableNumber, subnodes[i]->symbol()->type()->baseType());;
-            }
-            toAdd = arrayToVariable[expUnparsed]->copyPtr();
-            if (toAdd)
-            {
-                if (i == 0)
-                {
-                    exp->setLhs(toAdd);
-                }
-                else
-                {
-                    exp->setRhs(toAdd);
-                }
-            }
-        }
-        else
-        {
-            TransformRightPart(st, subnodes[i], arrayToVariable, variableNumber);
-        }
-    }
-}
-
-static void TransformLeftPart(SgStatement* st, SgExpression* exp, unordered_map<string, SgExpression*>& arrayToVariable, int& variableNumber)
-{
-    if (exp->symbol()->type()->variant() == T_STRING)
-        return;
-    string expUnparsed = exp->unparse();
-    if (arrayToVariable.find(expUnparsed) == arrayToVariable.end() && exp->symbol()->type()->baseType())
-    {
-        arrayToVariable[expUnparsed] = CreateVar(variableNumber, exp->symbol()->type()->baseType());
-    }
-    SgStatement* newStatement = new SgStatement(ASSIGN_STAT, NULL, NULL, arrayToVariable[expUnparsed]->copyPtr(), st->expr(1)->copyPtr(), NULL);
-
-    newStatement->setFileId(st->getFileId());
-    newStatement->setProject(st->getProject()); 
-
-    newStatement->setlineNumber(getNextNegativeLineNumber());
-    newStatement->setLocalLineNumber(st->lineNumber());
-    st->insertStmtBefore(*newStatement, *st->controlParent());
-}
-
-void ArrayConstantPropagation(SgProject& project) 
-{
-    unordered_map<string, SgExpression*> arrayToVariable;
-    int variableNumber = 0;
-    for (int i = 0; i < project.numberOfFiles(); i++) 
-    {
-        SgFile* file = &(project.file(i));
-
-        if (!file)
-            continue;
-
-        const int funcNum = file->numberOfFunctions();
-        for (int i = 0; i < funcNum; ++i)
-        {
-            SgStatement* st = file->functions(i);
-            declPlace = st->lexNext();
-            SgStatement* lastNode = st->lastNodeOfStmt();
-
-            for (; st != lastNode; st = st->lexNext())
-            {
-                if (st->variant() == ASSIGN_STAT)
-                {
-                    if (st->expr(1))
-                    {
-                        TransformRightPart(st, st->expr(1), arrayToVariable, variableNumber);
-                    }
-                    if (st->expr(0) && st->expr(0)->variant() == ARRAY_REF && CheckConstIndexes(st->expr(0)->lhs()))
-                    {
-                        TransformLeftPart(st, st->expr(0), arrayToVariable, variableNumber);
-                    }
-                }
-                else if (st->variant() == FOR_NODE)
-                {
-                    SgExpression* lowerBound = st->expr(0)->lhs();
-                    SgExpression* upperBound = st->expr(0)->rhs();
-                    string lowerBoundUnparsed = lowerBound->unparse(), upperBoundUnparsed = upperBound->unparse();
-                    if (upperBound->variant() == ARRAY_REF && upperBound->symbol()->type()->baseType() && CheckConstIndexes(upperBound->lhs()))
-                    {
-                        if (arrayToVariable.find(upperBoundUnparsed) == arrayToVariable.end())
-                        {
-                            arrayToVariable[upperBoundUnparsed] = CreateVar(variableNumber, upperBound->symbol()->type()->baseType());
-                        }
-                        st->expr(0)->setRhs(arrayToVariable[upperBoundUnparsed]->copyPtr());
-                    }
-                    if (lowerBound->variant() == ARRAY_REF && lowerBound->symbol()->type()->baseType() && CheckConstIndexes(lowerBound->lhs()))
-                    {
-                        if (arrayToVariable.find(lowerBoundUnparsed) == arrayToVariable.end())
-                        {
-                            arrayToVariable[lowerBoundUnparsed] = CreateVar(variableNumber, lowerBound->symbol()->type()->baseType());
-                        }
-                        st->expr(0)->setLhs(arrayToVariable[lowerBoundUnparsed]->copyPtr());
-                    }
-                }
-            }
-        }
-    }
-}

src/ArrayConstantPropagation/propagation.h

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

src/CFGraph/CFGraph.cpp

@@ -1,5 +1,5 @@
 #define _LEAK_
-#include "leak_detector.h"
+#include "../Utils/leak_detector.h"
 
 #include <stdlib.h>
 #include <stdio.h>
@@ -8,9 +8,9 @@
 #include <chrono>
 #include <functional>
 
-#include "SgUtils.h"
+#include "../Utils/SgUtils.h"
-#include "CommonBlock.h"
+#include "../Utils/CommonBlock.h"
-#include "graph_calls.h"
+#include "../GraphCall/graph_calls.h"
 
 #include "dvm.h"
 #include "IR.h"
@@ -56,6 +56,23 @@ void BBlock::addInstruction(IR_Block* item)
     item->setBasicBlock(this);
 }
 
+void BBlock::addInstructionInFront(IR_Block* item)
+{
+    instructions.insert(instructions.begin(), item);
+    item->setBasicBlock(this);
+}
+
+void BBlock::addInstructionBeforeInstruction(IR_Block* item, Instruction* instruction)
+{
+    for (auto it = instructions.begin(); it != instructions.end(); ++it) {
+        if ((*it)->getInstruction() == instruction) {
+            instructions.insert(it, item);
+            item->setBasicBlock(this);
+            return;
+        }
+    }
+}
+
 int BBlock::removePrev(BBlock* removed)
 {
     auto it = std::remove(prev.begin(), prev.end(), removed);
@@ -512,7 +529,7 @@ static int buildReachingDefs(const vector<BBlock*>& CFG, const FuncInfo* currF,
     return iter;
 }
 
-//Kosaraju–Sharir algorithm
+//Kosaraju<EFBFBD>Sharir algorithm
 static vector<int> getStronglyConnectedComps(vector<vector<int>>& g) {
     // 1. For each vertex u of the graph, mark u as unvisited. Let l be empty.
     auto size = g.size();
@@ -1149,22 +1166,9 @@ 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;
 }
 
@@ -1240,48 +1244,3 @@ map<FuncInfo*, vector<SAPFOR::BasicBlock*>>
 
     return buildCFG(commonBlocks, fileFuncInfoMap, settings);
 }
-
-
-void removedUnreachableBlocks(vector<SAPFOR::BasicBlock*>& blocks)
-{
-    set<SAPFOR::BasicBlock*> reachable;
-
-    for (auto& b : blocks)
-        if (b->getInstructions().front()->isHeader() ||
-            b->getInstructions().front()->getInstruction()->getOperation() == SAPFOR::CFG_OP::ENTRY)
-            reachable.insert(b);
-
-    set<SAPFOR::BasicBlock*> worklist = reachable;
-    while (worklist.size() != 0)
-    {
-        set<SAPFOR::BasicBlock*> to_insert;
-
-        for (auto& b : worklist)
-            for (auto& next : b->getNext())
-                if (reachable.insert(next).second)
-                    to_insert.insert(next);
-
-        worklist = to_insert;
-    }
-
-    auto remove_unreachable_it = remove_if(blocks.begin(), blocks.end(),
-        [&reachable](SAPFOR::BasicBlock* b)
-        {
-            if (reachable.find(b) == reachable.end())
-            {
-                for (auto& next : b->getNext())
-                    if (reachable.find(next) != reachable.end())
-                        next->removePrev(b);
-
-                delete b;
-                return true;
-            }
-
-            return false;
-        }
-    );
-
-    reachable.clear();
-
-    blocks.erase(remove_unreachable_it, blocks.end());
-}

src/CFGraph/CFGraph.h

@@ -6,7 +6,6 @@
 #include <vector>
 
 #include "IR.h"
-#include "IR_domTree.h"
 
 namespace SAPFOR
 {
@@ -25,7 +24,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;
 
@@ -35,16 +34,16 @@ 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);
         BasicBlock(const BasicBlock& copyFrom);
 
+        void addInstructionBeforeInstruction(IR_Block* item, Instruction* istruction);
+        void addInstructionInFront(IR_Block* item);
         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);
@@ -72,10 +71,6 @@ 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
@@ -112,15 +107,13 @@ 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 withDVM = false, bool withSPF = false, bool withCallsInBlocks = false, bool withCallFrom = true) :
-                              bool withCallFrom = true, bool withDominators = true) :
             atLeastOneIterInLoop(atLeastOneIterInLoop), withRD(withRD), withRegisters(withRegisters), withDVM(withDVM), withSPF(withSPF), 
-            withCallsInBlocks(withCallsInBlocks), withCallFrom(withCallFrom), withDominators(withDominators)
+            withCallsInBlocks(withCallsInBlocks), withCallFrom(withCallFrom)
         { }
     };
 }
@@ -156,5 +149,3 @@ static inline void deleteCFG(std::map<FuncInfo*, std::vector<SAPFOR::BasicBlock*
     }
     cfg.clear();
 }
-
-void removedUnreachableBlocks(std::vector<SAPFOR::BasicBlock*>& blocks);

src/CFGraph/DataFlow/backward_data_flow.h

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

src/CFGraph/DataFlow/backward_data_flow_impl.h

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

src/CFGraph/DataFlow/data_flow.h

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

src/CFGraph/DataFlow/data_flow_impl.h

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

src/CFGraph/IR.cpp

@@ -1,14 +1,14 @@
-#include "leak_detector.h"
+#include "../Utils/leak_detector.h"
 
 #include <stdlib.h>
 #include <stdio.h>
 #include <vector>
 #include <set>
 
-#include "SgUtils.h"
+#include "../Utils/SgUtils.h"
-#include "CommonBlock.h"
+#include "../Utils/CommonBlock.h"
-#include "graph_calls.h"
+#include "../GraphCall/graph_calls.h"
-#include "expr_transform.h"
+#include "../ExpressionTransform/expr_transform.h"
 
 #include "dvm.h"
 #include "IR.h"
@@ -1613,3 +1613,429 @@ vector<IR_Block*> buildIR(SgStatement* function, const FuncInfo* func, const vec
 
     return blocks;
 }
+
+enum VisitState { UNVISITED = 0, VISITING = 1, VISITED = 2 };
+
+void dfs(SAPFOR::BasicBlock* block, map<int, int>& visit, vector<pair<SAPFOR::BasicBlock*, SAPFOR::BasicBlock*>>& startAndEnd, SAPFOR::BasicBlock* prev) {
+    if (!block) return;
+
+    if (visit[block->getNumber()] == VISITED) {
+        cout << "error";
+        return;
+    }
+
+    if (visit[block->getNumber()] == VISITING) {
+        visit[block->getNumber()] = VISITED;
+        startAndEnd.push_back(make_pair(prev, block));
+        return;
+    }
+
+    visit[block->getNumber()] = VISITING;
+    for (auto i : block->getNext()) {
+        dfs(i, visit, startAndEnd, block);
+    }
+}
+
+static void printBlock(SAPFOR::BasicBlock* block) {
+    cout << "block - " << block->getNumber() << endl;
+    cout << "next -";
+    for (auto i : block->getNext())
+    {
+        cout << " " << i->getNumber();
+    }
+    cout << endl << "prev -";
+    for (auto i : block->getPrev())
+    {
+        cout << " " << i->getNumber();
+    }
+    cout << endl;
+
+    for (auto i : block->getInstructions())
+    {
+        string resValue = "";
+        string arg1Value = "";
+        string arg2Value = "";
+        if (i->getInstruction()->getResult() != nullptr && i->getInstruction()->getResult()->getType() == CFG_ARG_TYPE::VAR) {
+            resValue = i->getInstruction()->getResult()->getValue();
+            i->getInstruction()->getResult()->setValue(i->getInstruction()->getResult()->getValue() + to_string(i->getInstruction()->getResult()->getNumber()));
+        }
+        if (i->getInstruction()->getArg1() != nullptr && i->getInstruction()->getArg1()->getType() == CFG_ARG_TYPE::VAR) {
+            arg1Value = i->getInstruction()->getArg1()->getValue();
+            i->getInstruction()->getArg1()->setValue(i->getInstruction()->getArg1()->getValue() + to_string(i->getInstruction()->getArg1()->getNumber()));
+        }
+        if (i->getInstruction()->getArg2() != nullptr && i->getInstruction()->getArg2()->getType() == CFG_ARG_TYPE::VAR) {
+            arg2Value = i->getInstruction()->getArg2()->getValue();
+            i->getInstruction()->getArg2()->setValue(i->getInstruction()->getArg2()->getValue() + to_string(i->getInstruction()->getArg2()->getNumber()));
+        }
+
+        cout << i->getNumber() << " " << i->getInstruction()->dump() << endl;
+
+        if (i->getInstruction()->getResult() != nullptr && i->getInstruction()->getResult()->getType() == CFG_ARG_TYPE::VAR) {
+            i->getInstruction()->getResult()->setValue(resValue);
+        }
+        if (i->getInstruction()->getArg1() != nullptr && i->getInstruction()->getArg1()->getType() == CFG_ARG_TYPE::VAR) {
+            i->getInstruction()->getArg1()->setValue(arg1Value);
+        }
+        if (i->getInstruction()->getArg2() != nullptr && i->getInstruction()->getArg2()->getType() == CFG_ARG_TYPE::VAR) {
+            i->getInstruction()->getArg2()->setValue(arg2Value);
+        }
+    }
+
+    cout << endl;
+}
+
+void getLoopBody(SAPFOR::BasicBlock* loopHeader, const std::set<SAPFOR::BasicBlock*>& loopExits, std::vector<SAPFOR::BasicBlock*>& loopBody) {
+    std::set<SAPFOR::BasicBlock*> visited;
+    std::stack<SAPFOR::BasicBlock*> stack;
+
+    stack.push(loopHeader);
+
+    while (!stack.empty()) {
+        auto block = stack.top();
+        stack.pop();
+
+        if (visited.count(block)) continue;
+        visited.insert(block);
+
+        for (auto succ : block->getNext()) {
+            if (loopExits.count(succ)) continue;
+            if (!visited.count(succ)) {
+                stack.push(succ);
+            }
+        }
+    }
+
+    std::set<SAPFOR::BasicBlock*> backReachable;
+    std::stack<SAPFOR::BasicBlock*> reverseStack;
+    reverseStack.push(loopHeader);
+
+    while (!reverseStack.empty()) {
+        auto block = reverseStack.top();
+        reverseStack.pop();
+
+        if (backReachable.count(block)) continue;
+        backReachable.insert(block);
+
+        for (auto pred : block->getPrev()) {
+            if (visited.count(pred) && !backReachable.count(pred)) {
+                reverseStack.push(pred);
+            }
+        }
+    }
+
+    for (auto block : visited) {
+        if (backReachable.count(block)) {
+            loopBody.push_back(block);
+        }
+    }
+}
+
+
+set<SAPFOR::Argument*> findRegisterSourceVariables(const std::vector<SAPFOR::BasicBlock*>& blocks, SAPFOR::Argument* var) {
+    std::set<SAPFOR::Argument*> result;
+    std::set<SAPFOR::Argument*> visited;
+    std::stack<SAPFOR::Argument*> workStack;
+    workStack.push(var);
+
+    auto isBinaryOp = [](SAPFOR::CFG_OP op) {
+        return op == SAPFOR::CFG_OP::ADD || op == SAPFOR::CFG_OP::SUBT ||
+            op == SAPFOR::CFG_OP::MULT || op == SAPFOR::CFG_OP::DIV ||
+            op == SAPFOR::CFG_OP::POW ||
+            op == SAPFOR::CFG_OP::GE || op == SAPFOR::CFG_OP::LE ||
+            op == SAPFOR::CFG_OP::GT || op == SAPFOR::CFG_OP::LT ||
+            op == SAPFOR::CFG_OP::EQ || op == SAPFOR::CFG_OP::NEQV ||
+            op == SAPFOR::CFG_OP::EQV || op == SAPFOR::CFG_OP::EMPTY ||
+            op == SAPFOR::CFG_OP::OR || op == SAPFOR::CFG_OP::AND;
+    };
+
+    auto isUnaryOp = [](SAPFOR::CFG_OP op) {
+        return op == SAPFOR::CFG_OP::UN_ADD || op == SAPFOR::CFG_OP::UN_MINUS ||
+            op == SAPFOR::CFG_OP::NOT || op == SAPFOR::CFG_OP::ASSIGN;
+    };
+
+    while (!workStack.empty()) {
+        auto variable = workStack.top();
+        workStack.pop();
+        if (!variable || visited.count(variable))
+            continue;
+        
+        visited.insert(variable);
+
+        for (auto block : blocks) {
+            for (auto instrWrapper : block->getInstructions()) {
+                auto instr = instrWrapper->getInstruction();
+                if (!instr || instr->getResult() != variable)
+                    continue;
+
+                auto op = instr->getOperation();
+                auto arg1 = instr->getArg1();
+                auto arg2 = instr->getArg2();
+
+                if (isBinaryOp(op) && arg1 && arg2) {
+                    if (arg1->getType() == CFG_ARG_TYPE::VAR)
+                        result.insert(arg1);
+                    else if (arg1->getType() == CFG_ARG_TYPE::REG)
+                        workStack.push(arg1);
+
+                    if (arg2->getType() == CFG_ARG_TYPE::VAR)
+                        result.insert(arg2);
+                    else if (arg2->getType() == CFG_ARG_TYPE::REG)
+                        workStack.push(arg2);
+                }
+                else if (isUnaryOp(op) && arg1) {
+                    if (arg1->getType() == CFG_ARG_TYPE::VAR)
+                        result.insert(arg1);
+                    else if (arg1->getType() == CFG_ARG_TYPE::REG)
+                        workStack.push(arg1);
+                }
+            }
+        }
+    }
+
+    return result;
+}
+
+std::vector<SAPFOR::Instruction*> getPhiArguments(SAPFOR::BasicBlock* block, SAPFOR::Instruction* phiInstr) {
+    std::vector<SAPFOR::Instruction*> result;
+
+    auto& instructions = block->getInstructions();
+    bool collecting = false;
+    for (int i = instructions.size() - 1; i >= 0; --i) {
+        auto instr = instructions[i]->getInstruction();
+
+        if (collecting) {
+            if (instr->getOperation() == SAPFOR::CFG_OP::PARAM) {
+                auto arg = instr->getArg1();
+                if (arg) {
+                    result.push_back(instr);
+                }
+            }
+            else {
+                break;
+            }
+        }
+
+        if (!instr) continue;
+
+        if (instr == phiInstr) {
+            collecting = true;
+            continue;
+        }
+    }
+
+    std::reverse(result.begin(), result.end());
+    return result;
+}
+
+SAPFOR::BasicBlock* findInstructionBlock(SAPFOR::Instruction* targetInstr, const std::vector<SAPFOR::BasicBlock*>& blocks) {
+    for (auto block : blocks) {
+        for (auto instrWrapper : block->getInstructions()) {
+            auto instr = instrWrapper->getInstruction();
+            if (instr == targetInstr) {
+                return block;
+            }
+        }
+    }
+    return nullptr;
+}
+
+SAPFOR::BasicBlock* findInstructionBlockByNumber(int number, const std::vector<SAPFOR::BasicBlock*>& blocks) {
+    for (auto block : blocks) {
+        for (auto instrWrapper : block->getInstructions()) {
+            auto instr = instrWrapper->getInstruction();
+            if (instr->getNumber() == number) {
+                return block;
+            }
+        }
+    }
+    return nullptr;
+}
+
+
+void findInductiveVars(const std::vector<SAPFOR::BasicBlock*>& blocks, const std::vector<SAPFOR::BasicBlock*>& Loopblocks, SAPFOR::BasicBlock* loopHeader, const std::set<SAPFOR::BasicBlock*>& loopExits) {
+    std::set<string> inductiveVars;
+    std::set<SAPFOR::BasicBlock*> relevantBlocks = { loopHeader };
+
+    for (auto block : relevantBlocks) {
+
+        for (auto instrWrapper : block->getInstructions()) {
+            auto instr = instrWrapper->getInstruction();
+            if (!instr) continue;
+
+            auto op = instr->getOperation();
+            auto res = instr->getResult();
+            auto arg1 = instr->getArg1();
+            auto arg2 = instr->getArg2();
+
+            if (op == CFG_OP::JUMP_IF) {
+                if (arg1 && arg1->getType() == CFG_ARG_TYPE::VAR) {
+                    inductiveVars.insert(arg1->getValue());
+                }
+                if (arg1 && arg1->getType() == CFG_ARG_TYPE::REG) {
+                    auto foundVariables = findRegisterSourceVariables(blocks, arg1);
+                    for (auto var : foundVariables) {
+                        inductiveVars.insert(var->getValue());
+                    }
+                }
+            }
+        }
+    }
+
+    std::set<string> finalInductiveVars;
+
+    for (auto instrWrapper : loopHeader->getInstructions()) {
+        auto instr = instrWrapper->getInstruction();
+        if (!instr || instr->getOperation() != SAPFOR::CFG_OP::F_CALL || !instr->getArg1() || instr->getArg1()->getValue() != "FI_FUNCTION") continue;
+
+        auto phiRes = instr->getResult();
+        if (!phiRes || !inductiveVars.count(phiRes->getValue())) continue;
+
+        auto currentBlock = findInstructionBlock(instr, blocks);
+        if (!currentBlock) continue;
+
+        auto phiArgs = getPhiArguments(currentBlock, instr);
+
+        bool hasInLoopDefinition = false;
+
+        for (const auto& argInstr : phiArgs) {
+            if (!argInstr) continue;
+
+            int definitionInstrNumber = stoi(argInstr->getArg1()->getValue());
+            if (definitionInstrNumber == -1) continue;
+
+            auto phiBlock = findInstructionBlockByNumber(definitionInstrNumber, blocks);
+            if (!phiBlock) continue;
+
+            if (std::find(Loopblocks.begin(), Loopblocks.end(), phiBlock) != Loopblocks.end()) {
+                hasInLoopDefinition = true;
+            }
+        }
+
+        if (hasInLoopDefinition) {
+            finalInductiveVars.insert(phiRes->getValue());
+        }
+    }
+
+    for (auto i : finalInductiveVars) {
+        std::cout << "Confirmed inductive variable: " << i << std::endl;
+    }
+
+    if (finalInductiveVars.empty()) {
+        std::cout << "No confirmed inductive variables found." << std::endl;
+    }
+}
+
+Instruction* findInstructionAfterLoop(const std::vector<SAPFOR::BasicBlock*>& loopBody) {
+    std::set<SAPFOR::BasicBlock*> loopSet(loopBody.begin(), loopBody.end());
+
+    for (auto block : loopBody) {
+        for (auto succ : block->getNext()) {
+            if (!loopSet.count(succ)) {
+                // Нашли выход из цикла — возьмём первую инструкцию
+                auto instructions = succ->getInstructions();
+                for (auto wrapper : instructions) {
+                    if (auto instr = wrapper->getInstruction()) {
+                        return instr;
+                    }
+                }
+            }
+        }
+    }
+
+    return nullptr; // не нашли
+}
+
+bool isEqual(const char* cstr, const std::string& str) {
+    return str == cstr;
+}
+
+void exploreLoops(map<FuncInfo*, vector<SAPFOR::BasicBlock*>>* fullIR, const char* fileName) {
+    for (auto& i : *fullIR)
+    {
+        //for (auto j : i.second)
+        //    printblock(j);
+
+        if (!isEqual(fileName, i.first->fileName))
+            continue;
+
+        map<int, int> visited;
+        for (auto i : i.second)
+            visited[i->getNumber()] = UNVISITED;
+        
+        //vector<int> visited(i.second.size(), UNVISITED);
+        vector<pair<SAPFOR::BasicBlock*, SAPFOR::BasicBlock*>> startAndEnd;
+        dfs(i.second[0], visited, startAndEnd, NULL);
+
+        vector<LoopGraph*> loops;
+
+        for (auto& [tail, header] : startAndEnd) {
+            set<SAPFOR::BasicBlock*> loopExits;
+
+            for (auto succ : tail->getNext()) {
+                if (succ != header) {
+                    loopExits.insert(succ);
+                }
+            }
+
+            vector<SAPFOR::BasicBlock*> loopBody;
+            getLoopBody(header, loopExits, loopBody);
+
+            cout << "LOOP DETECTED:" << endl;
+            cout << "  Header: " << header->getNumber() << endl;
+            cout << "  Tail: " << tail->getNumber() << endl;
+            cout << "  Body blocks: ";
+            for (auto block : loopBody) {
+                cout << block->getNumber() << " ";
+            }
+            cout << endl;
+
+            findInductiveVars(i.second, loopBody, header, loopExits);
+
+
+            Instruction* instructionAfterLoop = findInstructionAfterLoop(loopBody);
+
+            if (instructionAfterLoop == NULL) {
+                cout << "Warning: instruction after loop not found!" << endl;
+                continue;
+            }
+            auto firstInstruction = header->getInstructions()[0]->getInstruction();
+            auto lastInstruction = tail->getInstructions().back()->getInstruction();
+
+            cout << "first - " << firstInstruction->getNumber() << " last - " << lastInstruction->getNumber() << " after - " << instructionAfterLoop->getNumber() << endl;
+            auto x = firstInstruction->getOperator();
+
+            auto tmpLoop = new LoopGraph();
+            tmpLoop->isFor = true;
+            tmpLoop->lineNum = firstInstruction->getOperator()->lineNumber();
+            tmpLoop->lineNumAfterLoop = instructionAfterLoop->getOperator()->lineNumber();
+
+            if (firstInstruction->getOperator()->variant() == FOR_NODE) {
+                SgForStmt* stmt = isSgForStmt(firstInstruction->getOperator());
+
+                cout << "for loop" << endl;// << stmt->sunparse() << endl;
+            }
+            else if (firstInstruction->getOperator()->variant() == WHILE_NODE) {
+                SgWhileStmt* stmt = isSgWhileStmt(firstInstruction->getOperator());
+
+                cout << (stmt->conditional() == NULL ? "infinit" : "") << "while loop" << endl;//<< stmt->sunparse() << endl;
+            }
+            else if (firstInstruction->getOperator()->variant() == DO_WHILE_NODE) {
+                SgWhileStmt* stmt = isSgDoWhileStmt(firstInstruction->getOperator());
+
+                cout << "do while loop" << endl;// << stmt->sunparse() << endl;
+            }
+            else if (firstInstruction->getOperator()->variant() == LOOP_NODE) {
+                cout << "not known loop" << endl;// << firstInstruction->getOperator()->sunparse() << endl;
+            }
+            else {
+                
+                cout << "goto loop" << endl;// firstInstruction->getOperator()->sunparse() << endl;
+            }
+
+            cout << "loop start line " << tmpLoop->lineNum << endl;
+            cout << "after loop line " << tmpLoop->lineNumAfterLoop << endl << endl;
+
+            loops.push_back(tmpLoop);
+        }
+    }
+}

src/CFGraph/IR.h

@@ -6,7 +6,7 @@
 #include <algorithm>
 
 #include "CFGraph.h"
-#include "CommonBlock.h"
+#include "../Utils/CommonBlock.h"
 
 namespace SAPFOR
 {
@@ -42,6 +42,7 @@ namespace SAPFOR
         Argument() : number(lastNumArg++), type(CFG_ARG_TYPE::NONE), value(""), mType(CFG_MEM_TYPE::NONE_) { }
         Argument(CFG_ARG_TYPE type, CFG_MEM_TYPE mType) : number(lastNumArg++), type(type), mType(mType), value("") { }
         Argument(CFG_ARG_TYPE type, CFG_MEM_TYPE mType, const std::string& value) : number(lastNumArg++), type(type), mType(mType), value(value) { }
+        Argument(CFG_ARG_TYPE type, CFG_MEM_TYPE mType, const std::string& value, int num) : number(num), type(type), mType(mType), value(value) { }
         Argument(CFG_ARG_TYPE type, const std::string& value) : number(lastNumArg++), type(type), mType(CFG_MEM_TYPE::NONE_), value(value) 
         {
             if (type != CFG_ARG_TYPE::INSTR && type == CFG_ARG_TYPE::LAB &&
@@ -50,6 +51,12 @@ namespace SAPFOR
                 printInternalError(convertFileName(__FILE__).c_str(), __LINE__);
             }
         }
+        Argument(const Argument& other)
+            : number(other.number),
+            type(other.type),
+            mType(other.mType),
+            value(other.value)
+        { }
 
         void setType(CFG_ARG_TYPE newType) { type = newType; }
         CFG_ARG_TYPE getType() const { return type; }
@@ -344,3 +351,5 @@ SAPFOR::Instruction* getInstructionByNumber(const std::vector<SAPFOR::IR_Block*>
 std::pair<SAPFOR::Instruction*, SAPFOR::BasicBlock*> getInstructionAndBlockByNumber(const std::map<FuncInfo*, std::vector<SAPFOR::BasicBlock*>>& CFGraph, int num);
 std::pair<SAPFOR::Instruction*, SAPFOR::BasicBlock*> getInstructionAndBlockByStatement(const std::map<FuncInfo*, std::vector<SAPFOR::BasicBlock*>>& CFGraph, SgStatement* stmt);
 int getParamIndex(SAPFOR::Argument* func_param, int max_index);
+
+void exploreLoops(std::map<FuncInfo*, std::vector<SAPFOR::BasicBlock*>>* fullIR, const char* fileName);

src/CFGraph/IRSSAForm.cpp

@@ -0,0 +1,633 @@
+#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 "dvm.h"
+#include "IR.h"
+#include "CFGraph.h"
+
+using namespace std;
+using namespace SAPFOR;
+
+typedef SAPFOR::BasicBlock BBlock;
+typedef SAPFOR::Argument BArgument;
+
+static void printBlock(BBlock* block) {
+    cout << "block - " << block->getNumber() << endl;
+    cout << "next -";
+    for (auto i : block->getNext())
+    {
+        cout << " " << i->getNumber();
+    }
+    cout << endl << "prev -";
+    for (auto i : block->getPrev())
+    {
+        cout << " " << i->getNumber();
+    }
+    cout << endl;
+
+    for (auto i : block->getInstructions())
+    {
+        string resValue = "";
+        string arg1Value = "";
+        string arg2Value = "";
+        if (i->getInstruction()->getResult() != nullptr && i->getInstruction()->getResult()->getType() == CFG_ARG_TYPE::VAR) {
+            resValue = i->getInstruction()->getResult()->getValue();
+            i->getInstruction()->getResult()->setValue(i->getInstruction()->getResult()->getValue() + to_string(i->getInstruction()->getResult()->getNumber()));
+        } 
+        if (i->getInstruction()->getArg1() != nullptr && i->getInstruction()->getArg1()->getType() == CFG_ARG_TYPE::VAR) {
+            arg1Value = i->getInstruction()->getArg1()->getValue();
+            i->getInstruction()->getArg1()->setValue(i->getInstruction()->getArg1()->getValue() + to_string(i->getInstruction()->getArg1()->getNumber()));
+        }
+        if (i->getInstruction()->getArg2() != nullptr && i->getInstruction()->getArg2()->getType() == CFG_ARG_TYPE::VAR) {
+            arg2Value = i->getInstruction()->getArg2()->getValue();
+            i->getInstruction()->getArg2()->setValue(i->getInstruction()->getArg2()->getValue() + to_string(i->getInstruction()->getArg2()->getNumber()));
+        }
+
+        cout << i->getNumber() << " " << i->getInstruction()->dump() << endl;
+        
+        if (i->getInstruction()->getResult() != nullptr && i->getInstruction()->getResult()->getType() == CFG_ARG_TYPE::VAR) {
+            i->getInstruction()->getResult()->setValue(resValue);
+        }
+        if (i->getInstruction()->getArg1() != nullptr && i->getInstruction()->getArg1()->getType() == CFG_ARG_TYPE::VAR) {
+            i->getInstruction()->getArg1()->setValue(arg1Value);
+        }
+        if (i->getInstruction()->getArg2() != nullptr && i->getInstruction()->getArg2()->getType() == CFG_ARG_TYPE::VAR) {
+            i->getInstruction()->getArg2()->setValue(arg2Value);
+        }
+    }
+
+    cout << endl;
+}
+
+template <typename T>
+static bool compareVectors(const vector<T>* vec1, const vector<T>* vec2) {
+    if (vec1 == vec2) {
+        return true;
+    }
+
+    if (!vec1 || !vec2) {
+        return false;
+    }
+
+    vector<T> sortedVec1 = *vec1;
+    vector<T> sortedVec2 = *vec2;
+
+    sort(sortedVec1.begin(), sortedVec1.end());
+    sort(sortedVec2.begin(), sortedVec2.end());
+
+    return sortedVec1 == sortedVec2;
+}
+
+template <typename T>
+static vector<T>* getCommonElements(const vector<vector<T>>* vectors) {
+    if (!vectors || vectors->empty()) {
+        return new vector<T>(); // Return an empty vector if input is null or empty
+    }
+
+    // Start with the first vector
+    vector<T>* commonElements = new vector<T>((*vectors)[0]);
+
+    for (size_t i = 1; i < vectors->size(); ++i) {
+        vector<T> tempCommon;
+
+        // Sort the current vector and common result for intersection
+        vector<T> sortedVec = (*vectors)[i];
+        sort(commonElements->begin(), commonElements->end());
+        sort(sortedVec.begin(), sortedVec.end());
+
+        // Find the intersection
+        set_intersection(
+            commonElements->begin(), commonElements->end(),
+            sortedVec.begin(), sortedVec.end(),
+            back_inserter(tempCommon)
+        );
+
+        // Update common result
+        *commonElements = tempCommon;
+
+        // If no common elements left, break early
+        if (commonElements->empty()) {
+            break;
+        }
+    }
+
+    return commonElements;
+}
+
+
+static map<BBlock*, vector<BBlock*>> findDominators(vector<BBlock*> blocks) {
+    map<BBlock*, vector<BBlock*>> result;
+
+    bool changed = true;
+    while (changed) {
+        changed = false;
+
+        for (auto currentBlock : blocks) {
+            auto pred = currentBlock->getPrev();
+            auto prevDominators = new vector<vector<BBlock*>>();
+
+            for (auto predBlock : pred)
+                prevDominators->push_back(result.find(predBlock) != result.end() ? result[predBlock] : blocks);
+
+            auto currentBlockResult = getCommonElements(prevDominators);
+            currentBlockResult->push_back(currentBlock);
+
+            if (result.find(currentBlock) == result.end() || !compareVectors(currentBlockResult, &result[currentBlock])) {
+                result[currentBlock] = *currentBlockResult;
+                changed = true;
+            }
+        }
+    }
+
+    return result;
+}
+
+static void RenumberBlocks(BBlock* current, int* n, map<int, int>* res, set<BBlock*>* visited) {
+    if (visited->find(current) != visited->end()) {
+        return;
+    }
+
+    visited->insert(current);
+
+    vector<BBlock*> nextBlocks = current->getNext();
+
+    sort(nextBlocks.begin(), nextBlocks.end(), [](BBlock* a, BBlock* b) {
+        return a->getInstructions()[0]->getInstruction()->getOperator()->lineNumber() > b->getInstructions()[0]->getInstruction()->getOperator()->lineNumber();
+    });
+
+    for (auto i : nextBlocks) {
+        RenumberBlocks(i, n, res, visited);
+    }
+
+    (*res)[current->getNumber()] = *n;
+    *n -= 1;
+}
+
+static map<BBlock*, vector<BBlock*>> findDominatorBorders(vector<BBlock*>& blocks, map<BBlock*, BBlock*>& iDominators) {
+    map<BBlock*, vector<BBlock*>> result;
+
+    for (auto block : blocks) {
+        result[block] = *(new vector<BBlock*>());
+    }
+
+    for (auto block : blocks) {
+        if (block->getPrev().size() > 1) {
+            for (auto prev : block->getPrev()) {
+                auto tmpBlock = prev;
+                auto test = iDominators[block];
+                auto test2 = iDominators[prev];
+
+                while (tmpBlock != iDominators[block]) {
+                    result[tmpBlock].push_back(block);
+                    tmpBlock = iDominators[tmpBlock];
+                }
+            }
+        }
+    }
+
+    return result;
+}
+
+static BBlock* findImmediateDominatorsDfsHelper(BBlock* block, BBlock* currentBlock, BBlock* currentImmediateDominator, vector<BBlock*> &visited, map<BBlock*, vector<BBlock*>>& dominators) {
+    if (block == currentBlock) {
+        return currentImmediateDominator;
+    }
+    
+    if (find(visited.begin(), visited.end(), currentBlock) != visited.end()) {
+        return nullptr;
+    }
+    
+    visited.push_back(currentBlock);
+
+    if (find(dominators[block].begin(), dominators[block].end(), currentBlock) != dominators[block].end()) {
+        currentImmediateDominator = currentBlock;
+    }
+
+    for (auto nextBlock : currentBlock->getNext()) {
+        auto result = findImmediateDominatorsDfsHelper(block, nextBlock, currentImmediateDominator, visited, dominators);
+
+        if (result) {
+            return result;
+        }
+    }
+
+    return nullptr;
+}
+
+static map<BBlock*, BBlock*> findImmediateDominators1(const map<BBlock*, vector<BBlock*>>& dominators, BBlock* entry) {
+    map<BBlock*, BBlock*> iDom;
+
+    for (const auto& pair : dominators) {
+        BBlock* b = pair.first;
+
+        if (b == entry) continue;
+
+        const auto& doms = pair.second;
+
+        BBlock* candidate = nullptr;
+        for (auto d : doms) {
+            if (d == b) continue;
+            bool isImmediate = true;
+
+            for (auto other : doms) {
+                if (other == b || other == d) continue;
+                const auto& domsOfOther = dominators.at(other);
+                if (std::find(domsOfOther.begin(), domsOfOther.end(), d) != domsOfOther.end()) {
+                    isImmediate = false;
+                    break;
+                }
+            }
+
+            if (isImmediate) {
+                candidate = d;
+                break;
+            }
+        }
+
+        if (candidate) {
+            iDom[b] = candidate;
+        }
+    }
+
+    return iDom;
+}
+
+
+static map<BBlock*, BBlock*> findImmediateDominators(map<BBlock*, vector<BBlock*>>& dominators, BBlock* fistBlock) {
+    map<BBlock*, BBlock*> iDominators;
+
+    for (const auto& domPair : dominators) {
+        BBlock* block = domPair.first;
+        const vector<BBlock*>& domBlocks = domPair.second;
+        vector<BBlock*> visited;
+
+        if (block == fistBlock) {
+            continue;
+        }
+
+        iDominators[block] = findImmediateDominatorsDfsHelper(block, fistBlock, fistBlock, visited, dominators);
+    }
+
+    return iDominators;
+}
+
+static vector<BArgument*> getDefForBlock(const BBlock& block) {
+    vector<BArgument*> def;
+    const auto& instructions = block.getInstructions();
+
+    for (const auto& irBlock : instructions) {
+        if (irBlock) {
+            Instruction* instr = irBlock->getInstruction();
+
+            if (instr) {
+                BArgument* result = instr->getResult();
+                if (result) {
+                    def.push_back(result);
+                }
+            }
+        }
+    }
+
+    return def;
+}
+
+static pair<set<BArgument*>, map<BArgument*, set<BBlock*>>> getGlobalsAndVarBlocks(vector<BBlock*> blocks) {
+    set<BArgument*> globals;
+    map<BArgument*, set<BBlock*>> varBlocks;
+
+    for (auto block : blocks) {
+        set<BArgument*> def;
+        const auto& instructions = block->getInstructions();
+
+        for (const auto& irBlock : instructions) {
+            if (irBlock) {
+                Instruction* instr = irBlock->getInstruction();
+
+                if (instr) {
+                    auto arg1 = instr->getArg1();
+                    auto arg2 = instr->getArg2();
+                    auto res = instr->getResult();
+
+                    if (arg1 && arg1->getType() == CFG_ARG_TYPE::VAR && find(def.begin(), def.end(), arg1) == def.end()) {
+                        globals.insert(arg1);
+                    }
+                    if (arg2 && arg2->getType() == CFG_ARG_TYPE::VAR && find(def.begin(), def.end(), arg2) == def.end()) {
+                        globals.insert(arg2);
+                    }
+
+                    if (res && res->getType() == CFG_ARG_TYPE::VAR) {
+                        def.insert(res);
+                        varBlocks[res].insert(block);
+                    }
+                }
+            }
+        }
+    }
+
+    return make_pair(globals, varBlocks);
+}
+
+static void getBlocksWithFiFunctions(vector<BBlock*> blocks, set<BArgument*> globals, map<BArgument*, set<BBlock*>> varBlocks, map<BBlock*, vector<BBlock*>> dominatorBorders) {
+    vector<BBlock*> blocksWithFiFunctions;
+    auto fiFunc = new BArgument(CFG_ARG_TYPE::FUNC, CFG_MEM_TYPE::NONE_, "FI_FUNCTION");
+    auto paramCount = new BArgument(CFG_ARG_TYPE::CONST, CFG_MEM_TYPE::LOCAL_, "0");
+
+    for (auto var : globals) {
+        auto worklist = varBlocks[var];
+        set<BBlock*> hasFiFunction;
+
+        while (!worklist.empty()) {
+            auto block = *worklist.begin();
+            worklist.erase(block);
+
+            for (auto dfBlock : dominatorBorders[block]) {
+                if (hasFiFunction.find(dfBlock) == hasFiFunction.end()) {
+                    hasFiFunction.insert(dfBlock);
+
+                    Instruction* phiInstruction = new Instruction(CFG_OP::F_CALL, new BArgument(*fiFunc), new BArgument(*paramCount), var, dfBlock->getInstructions()[0]->getInstruction()->getOperator());
+
+                    IR_Block* phiBlock = new IR_Block(phiInstruction);
+                    dfBlock->addInstructionInFront(phiBlock);
+
+                    //blocksWithFiFunctions.push_back(dfBlock);
+                }
+            }
+        }
+    }
+   
+    //return blocksWithFiFunctions;
+}
+
+
+
+
+string ToString(CFG_ARG_TYPE type) {
+    switch (type) {
+    case CFG_ARG_TYPE::NONE: return "NONE";
+    case CFG_ARG_TYPE::REG: return "REG";
+    case CFG_ARG_TYPE::VAR: return "VAR";
+    case CFG_ARG_TYPE::ARRAY: return "ARRAY";
+    case CFG_ARG_TYPE::CONST: return "CONST";
+    case CFG_ARG_TYPE::FUNC: return "FUNC";
+    case CFG_ARG_TYPE::LAB: return "LAB";
+    case CFG_ARG_TYPE::INSTR: return "INSTR";
+    case CFG_ARG_TYPE::CONST_STR: return "CONST_STR";
+    case CFG_ARG_TYPE::RECORD: return "RECORD";
+    case CFG_ARG_TYPE::CONSTR_REF: return "CONSTR_REF";
+    default: return "UNKNOWN";
+    }
+}
+
+void restoreConnections(const vector<BBlock*>& originalBlocks, vector<BBlock*>& copiedBlocks) {
+    // Создаем отображение оригинальных блоков в их копии
+    map<BBlock*, BBlock*> blockMapping;
+    for (size_t i = 0; i < originalBlocks.size(); ++i) {
+        blockMapping[originalBlocks[i]] = copiedBlocks[i];
+    }
+
+    // Восстанавливаем связи между копиями
+    for (size_t i = 0; i < originalBlocks.size(); ++i) {
+        BBlock* originalBlock = originalBlocks[i];
+        BBlock* copiedBlock = copiedBlocks[i];
+
+        auto prevCopy = copiedBlock->getPrev();
+        for (auto j : prevCopy) {
+            copiedBlock->removePrev(j);
+        }
+
+        // Копируем, затем удаляем next связи
+        auto nextCopy = copiedBlock->getNext();
+        for (auto j : nextCopy) {
+            copiedBlock->removeNext(j);
+        }
+
+        // Восстанавливаем связи succ (следующих блоков)
+        for (auto* succ : originalBlock->getNext()) {
+            copiedBlock->addNext(blockMapping[succ]);
+        }
+
+        // Восстанавливаем связи prev (предыдущих блоков)
+        for (auto* prev : originalBlock->getPrev()) {
+            copiedBlock->addPrev(blockMapping[prev]);
+        }
+    }
+}
+
+
+BArgument* NewName(BArgument* var, map<string, int>& counter, map<string, stack<BArgument*>>& stack, int number) {
+    //int index = counter[var->getValue()];
+    counter[var->getValue()]++;
+
+    BArgument* newName = new BArgument(var->getType(), var->getMemType(), var->getValue(), number);
+    stack[var->getValue()].push(newName);
+    return newName;
+}
+
+void RenameFiFunctionResultVar(BBlock* block, map<string, int>& counter, map<string, stack<BArgument*>>& stack) {
+    for (auto irBlock : block->getInstructions()) {
+        auto instruction = irBlock->getInstruction();
+        if (instruction->getOperation() == CFG_OP::F_CALL && instruction->getArg1() != nullptr && instruction->getArg1()->getValue() == "FI_FUNCTION" && instruction->getResult() != nullptr) {
+            instruction->setResult(NewName(instruction->getResult(), counter, stack, instruction->getNumber()));
+        }
+    }
+}
+
+void RenameInstructionVars(BBlock* block, map<string, int>& counter, map<string, stack<BArgument*>>& stack) {
+    for (auto irBlock : block->getInstructions()) {
+        auto instruction = irBlock->getInstruction();
+
+        if (instruction->getArg1() != nullptr && instruction->getArg1()->getType() == CFG_ARG_TYPE::VAR) {
+            instruction->setArg1(stack[instruction->getArg1()->getValue()].top());
+        }
+
+        if (instruction->getArg2() != nullptr && instruction->getArg2()->getType() == CFG_ARG_TYPE::VAR) {
+            instruction->setArg2(stack[instruction->getArg2()->getValue()].top());
+        }
+
+        if (instruction->getResult() != nullptr && instruction->getResult()->getType() == CFG_ARG_TYPE::VAR) {
+            instruction->setResult(NewName(instruction->getResult(), counter, stack, instruction->getNumber()));
+        }
+    }
+}
+
+void RenameFiFunctionArgsVar(BBlock* block, map<string, stack<BArgument*>>& stack) {
+    auto size = block->getInstructions().size();
+    auto& instructions = block->getInstructions();
+    for (auto i = 0; i < size; i++) {
+        auto irBlock = instructions[i];
+        auto instruction = irBlock->getInstruction();
+        if (instruction->getOperation() == CFG_OP::F_CALL && instruction->getArg1() != nullptr && instruction->getArg1()->getValue() == "FI_FUNCTION" && instruction->getResult() != nullptr && instruction->getArg2() != nullptr) {
+
+            Instruction* paramInstruction;
+            
+            if (stack[instruction->getResult()->getValue()].size() > 0) {
+                BArgument* tmp = new BArgument(CFG_ARG_TYPE::CONST, CFG_MEM_TYPE::COMMON_, to_string(stack[instruction->getResult()->getValue()].top()->getNumber()));
+                paramInstruction = new Instruction(CFG_OP::PARAM, tmp);
+            }
+            else {
+                BArgument* tmp = new BArgument(CFG_ARG_TYPE::CONST, CFG_MEM_TYPE::COMMON_, "-1");
+                paramInstruction = new Instruction(CFG_OP::PARAM, tmp);
+            }
+
+            paramInstruction->setOperator(block->getInstructions()[0]->getInstruction()->getOperator());
+            block->addInstructionBeforeInstruction(new IR_Block(paramInstruction), instruction);
+
+            instruction->getArg2()->setValue(to_string(stoi(instruction->getArg2()->getValue()) + 1));
+            i++;
+        }
+    }
+}
+
+vector<BBlock*> findBlocksWithValue(map<BBlock*, BBlock*>& iDominators, BBlock* x) {
+    vector<BBlock*> result;
+
+    // Проходим по всем элементам map
+    for (auto& pair : iDominators) {
+        // Если значение равно x, добавляем ключ в результат
+        if (pair.second == x) {
+            result.push_back(pair.first);
+        }
+    }
+
+    return result;
+}
+
+void RenameIR(BBlock* block, map<BBlock*, BBlock*>& iDominators, map<string, int>& counter, map<string, stack<BArgument*>>& stack) {
+
+    RenameFiFunctionResultVar(block, counter, stack);
+
+    RenameInstructionVars(block, counter, stack);
+
+    for (auto* successor : block->getNext()) {
+        RenameFiFunctionArgsVar(successor, stack);
+    }
+
+    for (auto* child : findBlocksWithValue(iDominators, block)) {
+        RenameIR(child, iDominators, counter, stack);
+    }
+
+    for (auto& irBlock : block->getInstructions()) {
+        auto instruction = irBlock->getInstruction();
+        if (instruction->getResult() != nullptr && instruction->getResult()->getType() == CFG_ARG_TYPE::VAR) {
+            string varName = instruction->getResult()->getValue();
+            stack[varName].pop();
+        }
+    }
+
+    for (auto& irBlock : block->getInstructions()) {
+        auto instruction = irBlock->getInstruction();
+        if (instruction->getOperation() == CFG_OP::F_CALL && instruction->getArg1() != nullptr && instruction->getArg1()->getValue() == "FI_FUNCTION" && instruction->getResult() != nullptr) {
+            string varName = instruction->getResult()->getValue();
+            stack[varName].pop();
+        }
+    }
+}
+
+void buildIRSSAForm(map<FuncInfo*, vector<BBlock*>> fullIR, map<FuncInfo*, vector<BBlock*>>* result) {
+
+    for (auto item : fullIR) {
+
+        auto funcinfo = item.first;
+        auto funcIRConst = item.second;
+
+        cout << "Testing " << item.first->funcName << endl;
+
+
+
+        vector<BBlock*> funcIR;
+
+        for (auto i : funcIRConst) {
+            funcIR.push_back(new BBlock(*i));
+        }
+        restoreConnections(funcIRConst, funcIR);
+
+        for (auto i : funcIR) {
+            //printBlock(i);
+        }
+        auto dominators = findDominators(funcIR);
+
+        /*cout << endl << endl << endl << "DOMINATORS" << endl << endl << endl;
+
+        for (auto i : dominators) {
+            cout << "block - " << i.first->getNumber() << endl;
+            for (auto j : i.second) {
+                cout << "dominators - " << j->getNumber() << endl;
+            }
+
+            cout << endl;
+        }*/
+
+        auto iDominators = findImmediateDominators1(dominators, funcIR[0]);
+
+        /*for (auto i : iDominators) {
+            cout << "block - " << i.first->getNumber() << endl;
+            cout << "Idominators - " << i.second->getNumber() << endl;
+            cout << endl;
+        }
+        */
+        auto dominatorBorders = findDominatorBorders(funcIR, iDominators);
+        
+
+        /*for (auto i : dominatorBorders) {
+            cout << "block - " << i.first->getNumber() << endl;
+            for (auto j : i.second) {
+                cout << "border - " << j->getNumber() << endl;
+            }
+
+            cout << endl;
+        }*/
+
+
+        auto globalsAndVarBlocks = getGlobalsAndVarBlocks(funcIR);
+        auto globals = globalsAndVarBlocks.first;
+        auto varBlocks = globalsAndVarBlocks.second;
+
+        /*for (auto i : globals) {
+            cout << i->getValue() << " " << ToString(i->getType()) << " " << i->getNumber() << endl;
+
+        }
+        cout << endl;
+        for (auto i : varBlocks) {
+            cout << i.first->getValue() << " - ";
+            for (auto j : i.second) {
+                cout << j->getNumber() << ", ";
+            }
+            cout << endl;
+        }
+        cout << endl;
+        */
+
+        getBlocksWithFiFunctions(funcIR, globals, varBlocks, dominatorBorders);
+
+        map<string, int> count;
+        map<string, stack<BArgument*>> varStack;
+
+        for (auto var : globals) {
+            count[var->getValue()] = 0;
+
+            stack<BArgument*> tmp;
+            BArgument* tmpArgument = new BArgument(CFG_ARG_TYPE::CONST, CFG_MEM_TYPE::COMMON_, "-1");
+            tmp.push(tmpArgument);
+            varStack[var->getValue()] = tmp;
+        }
+
+        RenameIR(funcIR[0], iDominators, count, varStack);
+
+        for (auto i : funcIR) {
+            //printBlock(i);
+        }
+        //cout << endl << endl << endl << endl << endl;
+        //for (auto i : funcIRConst) {
+        //    printBlock(i);
+        //}
+
+        (*result)[funcinfo] = funcIR;
+    }
+}

src/CFGraph/IRSSAForm.h

@@ -0,0 +1,6 @@
+#pragma once
+
+#include "CFGraph.h"
+#include "IR.h"
+
+void buildIRSSAForm(std::map<FuncInfo*, std::vector<SAPFOR::BasicBlock*>> fullIR, std::map<FuncInfo*, std::vector<SAPFOR::BasicBlock*>>* result);

src/CFGraph/IR_domTree.cpp

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

src/CFGraph/IR_domTree.h

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

src/CFGraph/RD_subst.cpp

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

src/CFGraph/RD_subst.h

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

src/CFGraph/live_variable_analysis.h

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

src/CFGraph/private_variables_analysis.cpp

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

src/CFGraph/private_variables_analysis.h

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

src/CreateInterTree/CreateInterTree.cpp

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

src/CreateInterTree/CreateInterTree.h

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

src/DirectiveProcessing/directive_analyzer.cpp

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

src/DirectiveProcessing/directive_analyzer.h

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

src/DirectiveProcessing/directive_creator.cpp

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

src/DirectiveProcessing/directive_creator.h

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

src/DirectiveProcessing/directive_creator_base.cpp

@@ -1,4 +1,4 @@
-#include "leak_detector.h"
+#include "../Utils/leak_detector.h"
 
 #include <cstdio>
 #include <cstdlib>
@@ -10,9 +10,9 @@
 
 #include "../ParallelizationRegions/ParRegions.h"
 #include "../Distribution/Arrays.h"
-#include "LoopNesting/loop_transform.h"
+#include "../Transformations/loop_transform.h"
 
-#include "errors.h"
+#include "../Utils/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->isWhile()) // TODO: need to add all inductive variables!
+        if (!tmpL->isFor) // 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;
     }
 

src/DirectiveProcessing/directive_omp_parser.cpp

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

src/DirectiveProcessing/directive_omp_parser.h

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

src/DirectiveProcessing/directive_parser.cpp

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

src/DirectiveProcessing/directive_parser.h

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

src/DirectiveProcessing/insert_directive.cpp

@@ -1,4 +1,4 @@
-#include "leak_detector.h"
+#include "../Utils/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 "graph_loops_func.h"
+#include "../GraphLoop/graph_loops_func.h"
-#include "graph_calls_func.h"
+#include "../GraphCall/graph_calls_func.h"
 
-#include "errors.h"
+#include "../Utils/errors.h"
 #include "../LoopAnalyzer/loop_analyzer.h"
 #include "directive_parser.h"
-#include "SgUtils.h"
+#include "../Utils/SgUtils.h"
 #include "../Sapfor.h"
 #include "directive_creator.h"
 #include "insert_directive.h"

src/DirectiveProcessing/remote_access.cpp

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

src/DirectiveProcessing/remote_access_base.cpp

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

src/DirectiveProcessing/shadow.cpp

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

src/DirectiveProcessing/spf_directive_preproc.cpp

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

src/Distribution/Array.cpp

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

src/Distribution/Array.h

@@ -7,9 +7,9 @@
 #include <algorithm>
 #include <climits>
 #include "DvmhDirectiveBase.h"
-#include "utils.h"
+#include "../Utils/utils.h"
-#include "errors.h"
+#include "../Utils/errors.h"
-#include "json.hpp"
+#include "../Utils/json.hpp"
 
 class Symbol;
 class Expression;

src/Distribution/ArrayAnalysis.cpp

@@ -1,8 +1,8 @@
 #include "Array.h"
-#include "errors.h"
+#include "../Utils/errors.h"
-#include "utils.h"
+#include "../Utils/utils.h"
-#include "graph_calls.h"
+#include "../GraphCall/graph_calls.h"
-#include "SgUtils.h"
+#include "../Utils/SgUtils.h"
 #include "../DirectiveProcessing/directive_parser.h"
 #include "../DirectiveProcessing/directive_omp_parser.h"
 #include "../LoopAnalyzer/loop_analyzer.h"
@@ -241,15 +241,13 @@ 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 (deprecatedByIO.find(symb->identifier()) != deprecatedByIO.end())
+                else if (privates.find(symb->identifier()) != privates.end() || isarrayInModule)
-                    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)
@@ -276,6 +274,8 @@ static void findArrayRefs (SgExpression* ex, SgStatement* st, string fName, int
                     else
                         itNew->second.first->SetDistributeFlag(DIST::SPF_PRIV);
                 }
+                else if (deprecatedByIO.find(symb->identifier()) != deprecatedByIO.end())
+                    itNew->second.first->SetDistributeFlag(DIST::IO_PRIV);
                 else if (isSgConstantSymb(symb) || inDataStat)
                     itNew->second.first->SetDistributeFlag(DIST::SPF_PRIV);
                 else

src/Distribution/CreateDistributionDirs.cpp

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

src/Distribution/CreateDistributionDirs.h

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

src/Distribution/Cycle.cpp

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

src/Distribution/Cycle.h

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

src/Distribution/Distribution.cpp

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

src/Distribution/DvmhDirective.cpp

@@ -1,4 +1,4 @@
-#include "leak_detector.h"
+#include "../Utils/leak_detector.h"
 
 #include <stdio.h>
 #include <stdlib.h>
@@ -7,12 +7,12 @@
 #include <string>
 #include <algorithm>
 
-#include "types.h"
+#include "../Utils/types.h"
 #include "DvmhDirective.h"
-#include "errors.h"
+#include "../Utils/errors.h"
-#include "SgUtils.h"
+#include "../Utils/SgUtils.h"
 #include "../Sapfor.h"
-#include "graph_calls_func.h"
+#include "../GraphCall/graph_calls_func.h"
 
 #include "dvm.h"
 
@@ -45,10 +45,10 @@ static bool findArrayRefAndCheck(SgExpression *ex, const DIST::Array* currArray,
                 int countOfShadows = 0;
                 for (int i = 0; i < ref->numberOfSubscripts(); ++i)
                 {
-                    const vector<int*> &coeffs = getAttributes<SgExpression*, int*>(ref->subscript(i), set<int>{ INT_VAL });
+                    const vector<int*> &coefs = getAttributes<SgExpression*, int*>(ref->subscript(i), set<int>{ INT_VAL });
-                    if (coeffs.size() == 1)
+                    if (coefs.size() == 1)
                     {
-                        const pair<int, int> coef(coeffs[0][0], coeffs[0][1]);
+                        const pair<int, int> coef(coefs[0][0], coefs[0][1]);
                         auto it = shiftsByAccess[i].find(coef);
                         if (it != shiftsByAccess[i].end())
                             if (it->second != 0)
@@ -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;
                             }
                         }

src/Distribution/DvmhDirective.h

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

src/Distribution/DvmhDirectiveBase.cpp

@@ -1,4 +1,4 @@
-#include "leak_detector.h"
+#include "../Utils/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 "errors.h"
+#include "../Utils/errors.h"
-#include "utils.h"
+#include "../Utils/utils.h"
-#include "json.hpp"
+#include "../Utils/json.hpp"
 
-#include "graph_calls_func.h"
+#include "../GraphCall/graph_calls_func.h"
 
 using std::vector;
 using std::tuple;
@@ -364,11 +364,11 @@ static inline string calculateShifts(DIST::GraphCSR<int, double, attrType> &redu
             {
                 if (sharedMemoryParallelization)
                 {
-                    for (auto& coeffs : currReadOp->first[k].coefficients)
+                    for (auto& coefs : currReadOp->first[k].coefficients)
                     {
-                        auto currAccess = coeffs.first;
+                        auto currAccess = coefs.first;
 
-                        const int currShift = coeffs.first.second;
+                        const int currShift = coefs.first.second;
 
                         auto itFound = shiftsByAccess[k].find(currAccess);
                         if (itFound == shiftsByAccess[k].end())
@@ -393,9 +393,9 @@ static inline string calculateShifts(DIST::GraphCSR<int, double, attrType> &redu
                             int minShift = 9999999;
                             int maxShift = -9999999;
 
-                            for (auto &coeffs : currReadOp->first[k].coefficients)
+                            for (auto &coefs : currReadOp->first[k].coefficients)
                             {
-                                auto currAccess = coeffs.first;
+                                auto currAccess = coefs.first;
                                 auto result = DIST::Fx(currAccess, currRuleShadow);
 
                                 if (result.first == loopRule.first)
@@ -417,7 +417,7 @@ static inline string calculateShifts(DIST::GraphCSR<int, double, attrType> &redu
                                     auto it = remoteRegularReads.find(calcForArray);
                                     if (it == remoteRegularReads.end())
                                         it = remoteRegularReads.insert(it, make_pair(calcForArray, vector<ArrayOp>(calcForArray->GetDimSize())));
-                                    it->second[k].coefficients.insert(coeffs);
+                                    it->second[k].coefficients.insert(coefs);
                                 }
                             }
 

src/Distribution/DvmhDirectiveBase.h

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

src/Distribution/DvmhDirective_func.h

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

src/Distribution/GraphCSR.cpp

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

src/Distribution/GraphCSR.h

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

src/DvmhRegions/DvmhRegion.h

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

src/DvmhRegions/DvmhRegionInserter.cpp

@@ -11,9 +11,9 @@
 #include "DvmhRegionInserter.h"
 #include "DvmhRegions/RegionsMerger.h"
 #include "../VerificationCode/verifications.h"
+#include "../Transformations/function_purifying.h"
 #include "../LoopAnalyzer/loop_analyzer.h"
 #include "../DirectiveProcessing/directive_parser.h"
-#include "FunctionPurifying/function_purifying.h"
 
 using namespace std;
 
@@ -794,6 +794,154 @@ 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();
@@ -1024,7 +1172,7 @@ static bool isPure(SgStatement* func)
 
 void DvmhRegionInserter::createInterfaceBlockForOutCall(FuncInfo* func, FuncInfo* callFrom)
 {
-    insertInterface(func->funcPointer, callFrom);
+    insertInterface(func->funcPointer, getInterfaceBlock(callFrom->funcPointer->GetOriginal(), callFrom->funcParams), callFrom->funcName);
 }
 
 void DvmhRegionInserter::createInterfaceBlockForParallelFunctions(bool onlyRoutine)
@@ -1298,9 +1446,6 @@ 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)
@@ -1312,7 +1457,7 @@ static set<DIST::Array*>
                     }
                     else
                     {
-                        declStat = getFuncStat(declStat, { BLOCK_DATA });
+                        declStat = getFuncStat(declStat);
                         if (declStat != main)
                         {
                             declStat = NULL;

src/DvmhRegions/DvmhRegionInserter.h

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

src/DvmhRegions/LoopChecker.h

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

src/DvmhRegions/ReadWriteAnalyzer.h

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

src/DvmhRegions/TypedSymbol.h

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

src/DynamicAnalysis/createParallelRegions.cpp

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

src/DynamicAnalysis/createParallelRegions.h

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

src/DynamicAnalysis/gCov_parser.cpp

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

src/DynamicAnalysis/gCov_parser_func.h

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

src/DynamicAnalysis/gcov_info.cpp

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

src/DynamicAnalysis/gcov_info.h

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

src/ExpressionTransform/control_flow_graph_part.cpp

@@ -1,4 +1,4 @@
-#include "leak_detector.h"
+#include "../Utils/leak_detector.h"
 
 #include "dvm.h"
 #include "acc_analyzer.h"

src/ExpressionTransform/expr_transform.cpp

@@ -1,4 +1,4 @@
-#include "leak_detector.h"
+#include "../Utils/leak_detector.h"
 
 #if _WIN32 && NDEBUG && __SPF && __BOOST
 #include <boost/thread.hpp>
@@ -19,11 +19,11 @@ extern int passDone;
 
 #include "../ParallelizationRegions/ParRegions.h"
 #include "../ParallelizationRegions/ParRegions_func.h"
-#include "graph_loops.h"
+#include "../GraphLoop/graph_loops.h"
-#include "graph_calls.h"
+#include "../GraphCall/graph_calls.h"
-#include "graph_calls_func.h"
+#include "../GraphCall/graph_calls_func.h"
-#include "utils.h"
+#include "../Utils/utils.h"
-#include "SgUtils.h"
+#include "../Utils/SgUtils.h"
 #include "../Distribution/Distribution.h"
 #include "../VisualizerCalls/get_information.h"
 #include "expr_transform.h"
@@ -440,18 +440,15 @@ bool replaceConstantRec(SgExpression *&exp)
     if (exp->variant() == CONST_REF)
     {
         SgExpression *ret = ReplaceParameter_(exp);
-
         int sign = 1;
         SgExpression* toCalc = ret;
-        if (toCalc->variant() == UNARY_ADD_OP)
+        if (ret->variant() == UNARY_ADD_OP)
-            toCalc = toCalc->lhs();
+            toCalc = ret->lhs();
-
+        if (ret->variant() == MINUS_OP)
-        if (toCalc->variant() == MINUS_OP)
         {
-            toCalc = toCalc->lhs();
+            toCalc = ret->lhs();
             sign = -1;
         }
-
         if (toCalc->isInteger())
         {
             exp = new SgValueExp(sign * toCalc->valueInteger());

src/ExpressionTransform/expr_transform.h

@@ -5,10 +5,10 @@
 #include <string>
 #include "dvm.h"
 #include "../Distribution/Distribution.h"
-#include "graph_loops.h"
+#include "../GraphLoop/graph_loops.h"
 #include "../ParallelizationRegions/ParRegions.h"
-#include "graph_calls.h"
+#include "../GraphCall/graph_calls.h"
-#include "SgUtils.h"
+#include "../Utils/SgUtils.h"
 
 #include "acc_analyzer.h"
 

src/GraphCall/graph_calls.cpp

@@ -1,4 +1,4 @@
-#include "leak_detector.h"
+#include "../Utils/leak_detector.h"
 
 #include <cstdio>
 #include <cstdlib>
@@ -14,14 +14,14 @@
 #include "dvm.h"
 #include "graph_calls_func.h"
 
-#include "CFGraph/CFGraph.h"
+#include "../CFGraph/CFGraph.h"
-#include "graph_loops_func.h"
+#include "../GraphLoop/graph_loops_func.h"
 #include "../DirectiveProcessing/directive_parser.h"
-#include "SgUtils.h"
+#include "../Utils/SgUtils.h"
-#include "json.hpp"
+#include "../Utils/json.hpp"
 #include "../ParallelizationRegions/ParRegions_func.h"
 #include "../DynamicAnalysis/gCov_parser_func.h"
-#include "expr_transform.h"
+#include "../ExpressionTransform/expr_transform.h"
 #include "../LoopAnalyzer/loop_analyzer.h"
 #include "../VerificationCode/verifications.h"
 
@@ -779,20 +779,6 @@ 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)
@@ -813,12 +799,7 @@ static void fillInOut(FuncInfo *currF, SgStatement *start, SgStatement *last, co
         if (st->variant() == ENTRY_STAT)
             continue;
 
-        if (isSgExecutableStatement(st) == NULL) {
+        if (isSgExecutableStatement(st) == NULL || st->lineNumber() <= 0)
-            checkInTypeDescription(st->expr(0), currF, parNames);
-            continue;
-        }
-
-        if (st->lineNumber() <= 0)
             continue;
 
         if (activeOps.size() && activeOps.find(st) == activeOps.end())

src/GraphCall/graph_calls.h

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

src/GraphCall/graph_calls_base.cpp

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

src/GraphCall/graph_calls_func.h

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

src/GraphLoop/graph_loops.cpp

@@ -1,4 +1,4 @@
-#include "leak_detector.h"
+#include "../Utils/leak_detector.h"
 
 #include <cstdio>
 #include <cstdlib>
@@ -12,26 +12,26 @@
 
 #include "dvm.h"
 #include "../Sapfor.h"
-#include "graph_calls_func.h"
+#include "../GraphCall/graph_calls_func.h"
 #include "../ParallelizationRegions/ParRegions_func.h"
-#include "expr_transform.h"
+#include "../ExpressionTransform/expr_transform.h"
 
 #include "../Distribution/GraphCSR.h"
 #include "../Distribution/Arrays.h"
 #include "../Distribution/Distribution.h"
 
 #include "graph_loops.h"
-#include "utils.h"
+#include "../Utils/utils.h"
-#include "SgUtils.h"
+#include "../Utils/SgUtils.h"
 
-#include "errors.h"
+#include "../Utils/errors.h"
-#include "AstWrapper.h"
+#include "../Utils/AstWrapper.h"
-#include "json.hpp"
+#include "../Utils/json.hpp"
 
 #include "../DirectiveProcessing/directive_parser.h"
 #include "../DynamicAnalysis/gCov_parser_func.h"
 
-#include "VectorAssignToLoop/array_assign_to_loop.h"
+#include "../Transformations/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 (isArrayRef(exp))
+        if (exp->variant() == ARRAY_REF)
         {
             DIST::Array *arrayRef = NULL;
             SgSymbol *symbS = OriginalSymbol(exp->symbol());
@@ -699,12 +699,7 @@ 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 });
-                if (isSgForStmt(st))
+                newLoop->isFor = isSgForStmt(st) ? true : false;
-                    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);
 
@@ -782,7 +777,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->loopSymbols.addMainVar(st->symbol() ? st->symbol()->identifier() : "unknown");
+                newLoop->loopSymbol = st->symbol() ? st->symbol()->identifier() : "unknown";
                 findArrayRefs(newLoop);
 
                 SgStatement *lexPrev = st->lexPrev();

src/GraphLoop/graph_loops.h

@@ -5,8 +5,8 @@
 #include <map>
 #include <set>
 
-#include "errors.h"
+#include "../Utils/errors.h"
-#include "types.h"
+#include "../Utils/types.h"
 #include "../Distribution/DvmhDirective.h"
 #include "../Distribution/Distribution.h"
 
@@ -25,33 +25,6 @@ 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:
@@ -97,7 +70,7 @@ public:
         calculatedCountOfIters = 0;
         executionTimeInSec = -1.0;
         inDvmhRegion = 0;
-        loopType = LoopType::NONE;
+        isFor = false;
         inCanonicalFrom = false;
         hasAccessToSubArray = false;
         hasSubstringRefs = false;
@@ -140,24 +113,21 @@ 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));
@@ -198,7 +168,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())
@@ -423,14 +393,6 @@ 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;
@@ -445,7 +407,7 @@ public:
     int startVal, endVal, stepVal;
     std::tuple<Expression*, Expression*, Expression*> startEndStepVals;
 
-    InductiveVariables loopSymbols;
+    std::string loopSymbol;
     std::pair<Expression*, Expression*> startEndExpr;
 
     bool hasGoto;
@@ -486,7 +448,7 @@ public:
 
     bool hasSubstringRefs;
 
-    LoopType loopType;
+    bool isFor;
 
     bool inCanonicalFrom;
     

src/GraphLoop/graph_loops_base.cpp

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

src/Inliner/inliner.cpp

@@ -1,4 +1,4 @@
-#include "leak_detector.h"
+#include "../Utils/leak_detector.h"
 
 #include <stdlib.h>
 #include <stdio.h>
@@ -8,13 +8,13 @@
 #include <algorithm>
 
 #include "dvm.h"
-#include "errors.h"
+#include "../Utils/errors.h"
-#include "utils.h"
+#include "../Utils/utils.h"
-#include "SgUtils.h"
+#include "../Utils/SgUtils.h"
-#include "graph_calls_func.h"
+#include "../GraphCall/graph_calls_func.h"
 #include "inliner.h"
 #include "../VisualizerCalls/SendMessage.h"
-#include "expr_transform.h"
+#include "../ExpressionTransform/expr_transform.h"
 
 using std::set;
 using std::map;
@@ -1776,8 +1776,11 @@ static bool inliner(const string& fileName_in, const string& funcName, const int
         point.currCall = func->funcName;
 
         __spf_print(1, "  INLINE %s - ", func->funcName.c_str());
-        sendMessage_2lvl(6, func->funcName);
+#ifdef _WIN32
-
+        sendMessage_2lvl(wstring(L"ïîäñòàíîâêà ôóíêöèè '") + wstring(func->funcName.begin(), func->funcName.end()) + L"'");
+#else 
+        sendMessage_2lvl(wstring(L"inlinig of function '") + wstring(func->funcName.begin(), func->funcName.end()) + L"'");
+#endif
         //1 level
         bool isInlined = run_inliner(funcMap, toInsert, SPF_messages, fileName, func, newSymbsToDeclare, point, commonBlocks);
         __spf_print(1, "%s\n", isInlined ? "done" : "fault");

src/LoopAnalyzer/allocations_prepoc.cpp

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

src/LoopAnalyzer/dep_analyzer.cpp

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

src/LoopAnalyzer/loop_analyzer.cpp

@@ -18,7 +18,7 @@
 #include <tuple>
 #include <stack>
 
-#include "leak_detector.h"
+#include "../Utils/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 "errors.h"
+#include "../Utils/errors.h"
 #include "../DirectiveProcessing/directive_parser.h"
 #include "../DirectiveProcessing/directive_creator.h"
 
-#include "SgUtils.h"
+#include "../Utils/SgUtils.h"
-#include "AstWrapper.h"
+#include "../Utils/AstWrapper.h"
 
-#include "graph_calls_func.h"
+#include "../GraphCall/graph_calls_func.h"
-#include "graph_loops_func.h"
+#include "../GraphLoop/graph_loops_func.h"
 #include "../ParallelizationRegions/ParRegions_func.h"
 #include "../DynamicAnalysis/gCov_parser_func.h"
 
-#include "expr_transform.h"
+#include "../ExpressionTransform/expr_transform.h"
 #include "../SageAnalysisTool/depInterfaceExt.h"
 
 #include "../VisualizerCalls/get_information.h"
 #include "../VisualizerCalls/SendMessage.h"
 
-#include "LoopEndDoConverter/enddo_loop_converter.h"
+#include "../Transformations/enddo_loop_converter.h"
 
 #include "../DirectiveProcessing/remote_access.h"
 #include "../DirectiveProcessing/directive_omp_parser.h"
@@ -247,7 +247,7 @@ static vector<int> matchSubscriptToLoopSymbols(const vector<SgForStmt*> &parentL
         }
     }
 
-    pair<int, int> coeffs = pair<int, int>(0, 0);
+    pair<int, int> coefs = pair<int, int>(0, 0);
     // more than one loop symbol in subscription
     if (countOfSymbols > 1)
     {
@@ -326,16 +326,16 @@ static vector<int> matchSubscriptToLoopSymbols(const vector<SgForStmt*> &parentL
         {
             if (subscr->symbol()->id() == (parentLoops[position]->doName())->id())
             {
-                coeffs.first = 1;
+                coefs.first = 1;
                 needToCacl = false;
             }
         }
 
         if (needToCacl)
-            getCoefsOfSubscript(coeffs, subscr, parentLoops[position]->doName());
+            getCoefsOfSubscript(coefs, subscr, parentLoops[position]->doName());
-        __spf_print(PRINT_ARRAY_ARCS, " <%d %d> ", coeffs.first, coeffs.second);
+        __spf_print(PRINT_ARRAY_ARCS, " <%d %d> ", coefs.first, coefs.second);
 
-        if (coeffs.first == 0) // && coeffs.second == 0)
+        if (coefs.first == 0) // && coefs.second == 0)
         {
             if (currRegime == REMOTE_ACC)
             {
@@ -346,7 +346,7 @@ static vector<int> matchSubscriptToLoopSymbols(const vector<SgForStmt*> &parentL
             {                
                 const pair<bool, string> &arrayRefString = constructArrayRefForPrint(arrayRef, dimNum, origSubscr);
                 __spf_print(1, "WARN: can not calculate index expression for array ref '%s' at line %d\n", arrayRefString.second.c_str(), currLine);
-                addInfoToVectors(loopInfo, parentLoops[position], currOrigArrayS, dimNum, coeffs, UNREC_OP, numOfSubscriptions, currentW);
+                addInfoToVectors(loopInfo, parentLoops[position], currOrigArrayS, dimNum, coefs, UNREC_OP, numOfSubscriptions, currentW);
                 if (side == LEFT)
                     allPositions.clear();
 
@@ -371,19 +371,19 @@ static vector<int> matchSubscriptToLoopSymbols(const vector<SgForStmt*> &parentL
                         currOp.resize(numOfSubscriptions);
 
                     //add only uniq 
-                    auto itAdd = currOp[dimNum].coefficients.find(coeffs);
+                    auto itAdd = currOp[dimNum].coefficients.find(coefs);
                     if (itAdd == currOp[dimNum].coefficients.end())
-                        itAdd = currOp[dimNum].coefficients.insert(itAdd, make_pair(coeffs, currentW));
+                        itAdd = currOp[dimNum].coefficients.insert(itAdd, make_pair(coefs, currentW));
                 }
 
-                if (coeffs.first < 0)
+                if (coefs.first < 0)
                     addInfoToMap(loopInfo, parentLoops[position], currOrigArrayS, arrayRef, dimNum, REMOTE_TRUE, currLine, numOfSubscriptions);
                 else
                     //if we found regular access to array - set it false
                     addInfoToMap(loopInfo, parentLoops[position], currOrigArrayS, arrayRef, dimNum, REMOTE_FALSE, currLine, numOfSubscriptions);
             }
 
-            if (coeffs.first < 0 && sharedMemoryParallelization == 0)
+            if (coefs.first < 0 && sharedMemoryParallelization == 0)
             {
                 if (currRegime == DATA_DISTR)
                 {
@@ -402,15 +402,15 @@ static vector<int> matchSubscriptToLoopSymbols(const vector<SgForStmt*> &parentL
                     if (side == LEFT)
                         allPositions.clear();
                     else
-                        addInfoToVectors(loopInfo, parentLoops[position], currOrigArrayS, dimNum, coeffs, UNREC_OP, numOfSubscriptions, currentW);
+                        addInfoToVectors(loopInfo, parentLoops[position], currOrigArrayS, dimNum, coefs, UNREC_OP, numOfSubscriptions, currentW);
                 }
             }
             else
             {
                 if (side == LEFT)
-                    addInfoToVectors(loopInfo, parentLoops[position], currOrigArrayS, dimNum, coeffs, WRITE_OP, numOfSubscriptions, currentW);
+                    addInfoToVectors(loopInfo, parentLoops[position], currOrigArrayS, dimNum, coefs, WRITE_OP, numOfSubscriptions, currentW);
                 else
-                    addInfoToVectors(loopInfo, parentLoops[position], currOrigArrayS, dimNum, coeffs, READ_OP, numOfSubscriptions, currentW);
+                    addInfoToVectors(loopInfo, parentLoops[position], currOrigArrayS, dimNum, coefs, READ_OP, numOfSubscriptions, currentW);
             }
         }
     }
@@ -418,13 +418,13 @@ static vector<int> matchSubscriptToLoopSymbols(const vector<SgForStmt*> &parentL
     if (currRegime == ARRAY_ACC_CORNER)
     {
         int *valueSubs = new int[2];
-        valueSubs[0] = coeffs.first;
+        valueSubs[0] = coefs.first;
-        valueSubs[1] = coeffs.second;
+        valueSubs[1] = coefs.second;
 #ifdef __SPF
         addToCollection(__LINE__, __FILE__, valueSubs, 2);
 #endif
-        const vector<int*> &coeffs = getAttributes<SgExpression*, int*>(subscr, set<int>{ INT_VAL });
+        const vector<int*> &coefs = getAttributes<SgExpression*, int*>(subscr, set<int>{ INT_VAL });
-        if (coeffs.size() == 0)
+        if (coefs.size() == 0)
         {
             subscr->addAttribute(INT_VAL, valueSubs, sizeof(int*));
             if (position != -1 && allPositions.size() == 1 && position < parentLoops.size())
@@ -1633,7 +1633,17 @@ void loopAnalyzer(SgFile *file, vector<ParallelRegion*> &regions, map<tuple<int,
         createNeededException();
 
         string fName = file->functions(i)->symbol()->identifier();
-        sendMessage_2lvl(0, (file->functions(i)->variant() != MODULE_STMT), fName);
+#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
 
         set<SgSymbol*> delcsSymbViewed;
         set<SgStatement*> delcsStatViewed;
@@ -2178,8 +2188,11 @@ void loopAnalyzer(SgFile *file, vector<ParallelRegion*> &regions, map<tuple<int,
                 if (!skipDeps)
                 {
                     string fName = file->functions(i)->symbol()->identifier();
-                    sendMessage_2lvl(1, idx, (int)convertedLoopInfo.size());
+#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
                     tryToFindDependencies(loop.first, allLoops, funcWasInit, file, regions, currMessages, collection, funcByName, defUseByPlace);
                 }
             }
@@ -2199,7 +2212,7 @@ void loopAnalyzer(SgFile *file, vector<ParallelRegion*> &regions, map<tuple<int,
                             LoopGraph *tmpLoop = new LoopGraph();
 
                             tmpLoop->region = reg;
-                            tmpLoop->loopType = LoopType::FOR;
+                            tmpLoop->isFor = true;
 
                             tmpLoops.push_back(tmpLoop);
 
@@ -2327,7 +2340,7 @@ void loopAnalyzer(SgFile *file, vector<ParallelRegion*> &regions, map<tuple<int,
                 if (parallizeFreeLoops)
                     selectFreeLoopsForParallelization(loopsForFunction, funcName, (regime == DATA_DISTR), regions, messagesForFile);
             }
-            sendMessage_2lvl(2);
+            sendMessage_2lvl(L"");
         }
         else if (regime == COMP_DISTR)
         {

src/LoopAnalyzer/loop_analyzer.h

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

src/ParallelizationRegions/ParRegions.cpp

@@ -1,4 +1,4 @@
-#include "leak_detector.h"
+#include "../Utils/leak_detector.h"
 
 #include <stdio.h>
 #include <stdlib.h>
@@ -10,12 +10,12 @@
 
 #include "dvm.h"
 #include "ParRegions.h"
-#include "utils.h"
+#include "../Utils/utils.h"
-#include "SgUtils.h"
+#include "../Utils/SgUtils.h"
-#include "graph_calls_func.h"
+#include "../GraphCall/graph_calls_func.h"
-#include "graph_loops.h"
+#include "../GraphLoop/graph_loops.h"
 #include "../Distribution/Distribution.h"
-#include "expr_transform.h"
+#include "../ExpressionTransform/expr_transform.h"
 
 using std::vector;
 using std::string;

src/ParallelizationRegions/ParRegions.h

@@ -9,12 +9,12 @@
 #include "../Distribution/DvmhDirective.h"
 #include "../Distribution/GraphCSR.h"
 #include "../Distribution/Distribution.h"
-#include "AstWrapper.h"
+#include "../Utils/AstWrapper.h"
 
-#include "json.hpp"
+#include "../Utils/json.hpp"
 
 #if __SPF
-#include "SgUtils.h"
+#include "../Utils/SgUtils.h"
 #endif
 
 struct ParallelRegionLines

src/ParallelizationRegions/ParRegions_func.h

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

src/ParallelizationRegions/expand_extract_reg.cpp

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

src/ParallelizationRegions/expand_extract_reg.h

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

src/ParallelizationRegions/parse_merge_dirs.cpp

@@ -1,616 +0,0 @@
-#include "parse_merge_dirs.h"
-
-#include <unordered_set>
-
-using std::map;
-using std::pair;
-using std::string;
-using std::unordered_map;
-using std::unordered_set;
-using std::vector;
-
-static void parseMergeDirective(const char *comment,
-                                vector<pair<string, string>> &parsed_mapping)
-{
-    while (comment)
-    {
-        auto *line_end = strchr(comment, '\n');
-
-        static const char prefix[] = "!!SPF TRANSFORM(MERGE_ARRAYS(";
-        static const auto compare_chars = sizeof(prefix) - 1;
-
-        if (strncasecmp(comment, prefix, compare_chars) == 0)
-        {
-            auto *pair_start = comment + compare_chars;
-            auto *comma = strchr(pair_start, ',');
-            if (comma)
-            {
-                auto *close_br = strchr(comma + 1, ')');
-                if (close_br)
-                {
-                    parsed_mapping.emplace_back(
-                        string(pair_start, comma - pair_start),
-                        string(comma + 1, close_br - comma - 1));
-                }
-            }
-        }
-
-        comment = line_end;
-
-        if (comment)
-            comment++;
-    }
-}
-
-static string getNonDefaultRegion(DIST::Array *a)
-{
-    string result;
-
-    if (!a)
-        return result;
-
-    for (const auto &reg_name : a->GetRegionsName())
-    {
-        if (reg_name != "default")
-        {
-            if (!result.empty())
-                printInternalError(convertFileName(__FILE__).c_str(), __LINE__);
-
-            result = reg_name;
-        }
-    }
-
-    return result;
-}
-
-static bool hasSameSizes(DIST::Array *a, DIST::Array *b)
-{
-    for (auto *array : {a, b})
-    {
-        for (const auto &p : array->GetSizes())
-        {
-            if (p.first < 0 || p.second < 0)
-                return false;
-        }
-    }
-
-    return a->GetSizes() == b->GetSizes() && a->GetTypeSize() == b->GetTypeSize();
-}
-
-static bool checkSimilarTemplates(vector<ParallelRegion *> &regions,
-                                  const unordered_map<string, string> &new_region_mapping)
-{
-    // new region -> old regions
-    unordered_map<string, unordered_set<string>> new_region_inverse_mapping;
-    for (const auto &p : new_region_mapping)
-        new_region_inverse_mapping[p.second].insert(p.first);
-
-    for (const auto &new_reg : new_region_inverse_mapping)
-    {
-        DIST::Array *template_array = nullptr;
-        string first_reg_name;
-
-        for (const auto &old_region_name : new_reg.second)
-        {
-            auto *old_reg = getRegionByName(regions, old_region_name);
-
-            if (!old_reg)
-                printInternalError(convertFileName(__FILE__).c_str(), __LINE__);
-
-            const auto &distr_rules = old_reg->GetDataDir().GetDistrRules();
-            if (distr_rules.size() != 1)
-                printInternalError(convertFileName(__FILE__).c_str(), __LINE__);
-
-            auto *current_template = distr_rules.front().first;
-
-            if (template_array)
-            {
-                if (!hasSameSizes(template_array, current_template))
-                {
-                    __spf_print(1, "Templates of %s and %s has different sizes\n",
-                                first_reg_name.c_str(),
-                                old_region_name.c_str());
-
-                    return false;
-                }
-                // else everything OK
-            }
-            else
-            {
-                template_array = current_template;
-                first_reg_name = old_region_name;
-            }
-        }
-    }
-
-    return true;
-}
-
-static bool hasSameAlignment(const std::unordered_set<const AlignRule *> &align_a,
-                             const std::unordered_set<const AlignRule *> &align_b)
-{
-    if (align_a.size() != 1 || align_b.size() != 1)
-        return false;
-
-    const auto *rule_a = *align_a.begin();
-    const auto *rule_b = *align_b.begin();
-
-    if (rule_a->alignRule != rule_b->alignRule)
-        return false;
-
-    return true;
-}
-
-static void printExpr(SgExpression *e, string pad)
-{
-    if (!e)
-        return;
-
-    __spf_print(1, "%s%d: %s\n", pad.c_str(), e->variant(), e->unparse());
-
-    printExpr(e->lhs(), pad + "  ");
-    printExpr(e->rhs(), pad + "  ");
-}
-
-static pair<vector<SgStatement *>, SgSymbol *> generateDeclaration(const string &array_name, const string &common_block_name,
-                                                                   const vector<pair<int, int>> &sizes, SgType *type, SgStatement *scope)
-{
-    auto *array_symbol = new SgSymbol(VARIABLE_NAME, array_name.c_str(), new SgType(T_ARRAY), scope);
-
-    auto *decl = new SgDeclarationStatement(VAR_DECL);
-
-    decl->setExpression(1, new SgTypeExp(*type));
-
-    SgExpression *subs = new SgExprListExp();
-
-    auto *array_ref = new SgArrayRefExp(*array_symbol, *subs);
-
-    for (int i = 0; i < sizes.size(); i++)
-    {
-        const auto &p = sizes[i];
-        auto *d = new SgExpression(DDOT, new SgValueExp(p.first), new SgValueExp(p.second));
-        subs->setLhs(d);
-
-        if (i + 1 < sizes.size())
-        {
-            subs->setRhs(new SgExprListExp());
-            subs = subs->rhs();
-        }
-    }
-
-    decl->setExpression(0, array_ref);
-
-    auto comm = new SgStatement(COMM_STAT);
-
-    comm->setExpression(0, new SgExpression(COMM_LIST,
-                                            new SgVarRefExp(array_symbol),
-                                            NULL,
-                                            new SgSymbol(COMMON_NAME, common_block_name.c_str())));
-
-    return {{decl, comm}, array_symbol};
-}
-
-static SgExpression* findExprWithVariant(SgExpression* exp, int variant)
-{
-    if (exp)
-    {
-        if (exp->variant() == variant)
-            return exp;
-
-        auto *l = findExprWithVariant(exp->lhs(), variant);
-        if (l)
-            return l;
-
-        auto *r = findExprWithVariant(exp->rhs(), variant);
-        if (r)
-            return r;
-    }
-
-    return NULL;
-}
-
-SgType* GetArrayType(DIST::Array *array)
-{
-    if (!array)
-        return NULL;
-
-    for (const auto& decl_place : array->GetDeclInfo())
-    {
-        if (SgFile::switchToFile(decl_place.first) != -1)
-        {
-            auto* decl = SgStatement::getStatementByFileAndLine(decl_place.first, decl_place.second);
-            if (decl)
-            {
-                for (int i = 0; i < 3; i++)
-                {
-                    auto* found_type = isSgTypeExp(findExprWithVariant(decl->expr(i), TYPE_OP));
-                    if (found_type)
-                        return found_type->type();
-                }
-            }
-        }
-    }
-
-    return NULL;
-}
-
-SgSymbol *insertDeclIfNeeded(const string &array_name,
-                             const string &common_block_name,
-                             DIST::Array *example_array,
-                             FuncInfo *dest,
-                             unordered_map<FuncInfo *, unordered_map<string, SgSymbol *>> &inserted_arrays)
-{
-    auto *type = GetArrayType(example_array);
-
-    if (!type)
-        printInternalError(convertFileName(__FILE__).c_str(), __LINE__);
-
-    if (SgFile::switchToFile(dest->fileName) == -1)
-        printInternalError(convertFileName(__FILE__).c_str(), __LINE__);
-
-    auto &by_func = inserted_arrays[dest];
-    auto it = by_func.find(array_name);
-
-    if (it != by_func.end())
-        return it->second;
-
-    SgStatement *st = dest->funcPointer;
-
-    auto *end = st->lastNodeOfStmt();
-
-    st = st->lexNext();
-
-    while (st != end && !isSgExecutableStatement(st))
-    {
-        st = st->lexNext();
-    }
-
-    auto generated = generateDeclaration(array_name, common_block_name,
-                                         example_array->GetSizes(),
-                                         type, dest->funcPointer);
-    for (auto *new_stmt : generated.first)
-        st->insertStmtBefore(*new_stmt, *dest->funcPointer);
-
-    by_func[array_name] = generated.second;
-
-    return generated.second;
-}
-
-static pair<string, string> createNewArray(DIST::Array *example_array, const string &base_name,
-                                           const map<string, vector<FuncInfo *>> &allFuncInfo,
-                                           unordered_map<FuncInfo *, unordered_map<string, SgSymbol *>> &inserted_arrays)
-{
-    auto common_block_name = base_name + "_merge_cb";
-    auto array_name = base_name;
-
-    for (const auto &by_file : allFuncInfo)
-    {
-        for (auto *func_info : by_file.second)
-        {
-            if (func_info->isMain)
-            {
-                insertDeclIfNeeded(
-                    array_name,
-                    common_block_name,
-                    example_array,
-                    func_info,
-                    inserted_arrays);
-            }
-        }
-    }
-
-    return std::make_pair(array_name, common_block_name);
-}
-
-static void replaceArrayRec(SgExpression *e,
-                            const unordered_set<string> &arrays_to_replace,
-                            SgSymbol **func_symbol_hint,
-                            const pair<string, string> &replace_by,
-                            DIST::Array *example_array,
-                            FuncInfo *func,
-                            unordered_map<FuncInfo *, unordered_map<string, SgSymbol *>> &inserted_arrays)
-{
-    if (!e)
-        return;
-
-    if (isArrayRef(e) && arrays_to_replace.find(e->symbol()->identifier()) != arrays_to_replace.end())
-    {
-        if (!(*func_symbol_hint))
-        {
-            *func_symbol_hint = insertDeclIfNeeded(
-                replace_by.first, replace_by.second,
-                example_array,
-                func,
-                inserted_arrays);
-        }
-
-        e->setSymbol(*func_symbol_hint);
-    }
-
-    replaceArrayRec(
-        e->lhs(),
-        arrays_to_replace,
-        func_symbol_hint,
-        replace_by,
-        example_array,
-        func,
-        inserted_arrays);
-
-    replaceArrayRec(
-        e->rhs(),
-        arrays_to_replace,
-        func_symbol_hint,
-        replace_by,
-        example_array,
-        func,
-        inserted_arrays);
-}
-
-static void replaceRegion(SgStatement* st, const unordered_map<string, string> &new_region_mapping)
-{
-    if (!st)
-        return;
-
-    if(isSPF_stat(st) && st->variant() == SPF_PARALLEL_REG_DIR)
-    {
-        auto it = new_region_mapping.find(st->symbol()->identifier());
-
-        if (it != new_region_mapping.end())
-            st->setSymbol(*(new SgSymbol(CONST_NAME, it->second.c_str())));
-    }
-}
-
-void mergeCopyArrays(vector<ParallelRegion *> &regions, const map<string, vector<FuncInfo *>> &allFuncInfo)
-{
-    for (const auto *region : regions)
-    {
-        __spf_print(1, "region %s\n", region->GetName().c_str());
-
-        const auto &dirs = region->GetDataDir();
-
-        __spf_print(1, "  distr rules: %d\n", dirs.distrRules.size());
-
-        const auto &currentVariant = region->GetCurrentVariant();
-
-        int distr_idx = 0;
-        for (const auto &distr : dirs.distrRules)
-        {
-            const auto &dist_rule = distr.second.back().distRule;
-
-            string sizes;
-            for (const auto &p : distr.first->GetSizes())
-            {
-                if (!sizes.empty())
-                    sizes.push_back(',');
-
-                sizes += std::to_string(p.first) + ":" + std::to_string(p.second);
-            }
-
-            __spf_print(1, "      DIST %s(%s)", distr.first->GetName().c_str(), sizes.c_str());
-            for (const auto &dim : dist_rule)
-                __spf_print(1, " %c", dim == dist::BLOCK ? 'B' : '*');
-
-            __spf_print(1, "\n");
-            distr_idx++;
-        }
-
-        __spf_print(1, "  align rules: %d\n", dirs.alignRules.size());
-
-        for (const auto &align : dirs.alignRules)
-        {
-            string sub_a, sub_b;
-
-            int i = 0;
-            for (const auto coefs : align.alignRule)
-            {
-                if (!sub_a.empty())
-                    sub_a.push_back(',');
-
-                sub_a += std::to_string(coefs.first) + "*i" +
-                         std::to_string(i) + "+" + std::to_string(coefs.second);
-
-                i++;
-            }
-
-            for (const auto coefs : align.alignRuleWith)
-            {
-                if (!sub_b.empty())
-                    sub_b.push_back(',');
-
-                sub_b += std::to_string(coefs.second.first) + "*i" +
-                         std::to_string(coefs.first) + "+" + std::to_string(coefs.second.second);
-            }
-
-            __spf_print(1, "      ALIGN %s(%s) WITH %s(%s)\n",
-                        align.alignArray->GetName().c_str(), sub_a.c_str(),
-                        align.alignWith->GetName().c_str(), sub_b.c_str());
-        }
-    }
-
-    // parse directives
-
-    // new array name -> current arrays
-    unordered_map<string, unordered_set<DIST::Array *>> arrays_to_merge;
-    unordered_map<DIST::Array *, unordered_set<const AlignRule *>> array_alignment;
-
-    for (const auto &by_file : allFuncInfo)
-    {
-        const auto current_file_name = by_file.first;
-
-        if (SgFile::switchToFile(current_file_name) == -1)
-            printInternalError(convertFileName(__FILE__).c_str(), __LINE__);
-
-        for (auto *func_info : by_file.second)
-        {
-            SgStatement *curr_stmt = func_info->funcPointer;
-            if (!curr_stmt)
-                continue;
-
-            auto *stmt_end = curr_stmt->lastDeclaration();
-            if (!stmt_end)
-                continue;
-
-            stmt_end = stmt_end->lexNext();
-
-            for (; curr_stmt && curr_stmt != stmt_end; curr_stmt = curr_stmt->lexNext())
-            {
-                if (curr_stmt->comments())
-                {
-                    vector<pair<string, string>> parsed_mapping;
-                    parseMergeDirective(curr_stmt->comments(), parsed_mapping);
-
-                    for (const auto &p : parsed_mapping)
-                    {
-                        auto *found_array = getArrayFromDeclarated(curr_stmt, p.first);
-                        if (found_array)
-                        {
-                            arrays_to_merge[p.second].insert(found_array);
-                            array_alignment[found_array] = {};
-                        }
-                    }
-                }
-            }
-        }
-    }
-
-    // find alignment rules for array
-
-    for (const auto *region : regions)
-    {
-        const auto &dirs = region->GetDataDir();
-
-        for (const auto &align : dirs.alignRules)
-        {
-            auto it = array_alignment.find(align.alignArray);
-
-            if (it != array_alignment.end())
-                it->second.insert(&align);
-        }
-    }
-
-    // old region -> new region
-    unordered_map<string, string> new_region_mapping;
-
-    // new array -> new region
-    unordered_map<string, string> arrays_new_region_mapping;
-    vector<string> created_region_names;
-
-    for (const auto &by_new_array : arrays_to_merge)
-    {
-        string new_region_name;
-        for (auto *current_array : by_new_array.second)
-        {
-            auto current_array_region = getNonDefaultRegion(current_array);
-            auto it = new_region_mapping.find(current_array_region);
-            if (it != new_region_mapping.end())
-            {
-                if (new_region_name.empty())
-                    new_region_name = it->second;
-                else if (new_region_name != it->second)
-                    printInternalError(convertFileName(__FILE__).c_str(), __LINE__);
-            }
-        }
-
-        if (new_region_name.empty())
-        {
-            new_region_name = "merged_reg_" + std::to_string(created_region_names.size());
-            created_region_names.push_back(new_region_name);
-        }
-
-        for (auto *current_array : by_new_array.second)
-        {
-            auto current_array_region = getNonDefaultRegion(current_array);
-            new_region_mapping[current_array_region] = new_region_name;
-        }
-
-        arrays_new_region_mapping[by_new_array.first] = new_region_name;
-    }
-
-    if (!checkSimilarTemplates(regions, new_region_mapping))
-        printInternalError(convertFileName(__FILE__).c_str(), __LINE__);
-
-    unordered_map<FuncInfo *, unordered_map<string, SgSymbol *>> inserted_arrays;
-
-    for (const auto &by_dest_array : arrays_to_merge)
-    {
-        const auto &copy_arrays = by_dest_array.second;
-
-        if (copy_arrays.empty())
-            printInternalError(convertFileName(__FILE__).c_str(), __LINE__);
-
-        auto *first_element = *copy_arrays.begin();
-        auto first_elem_rules_it = array_alignment.find(first_element);
-
-        if (first_elem_rules_it == array_alignment.end())
-            continue;
-
-        const auto &first_elem_rules = first_elem_rules_it->second;
-
-        for (auto *array_to_merge : copy_arrays)
-        {
-            auto array_rules_it = array_alignment.find(array_to_merge);
-
-            if (array_rules_it == array_alignment.end())
-                printInternalError(convertFileName(__FILE__).c_str(), __LINE__);
-
-            const auto &array_rules = array_rules_it->second;
-
-            if (!hasSameSizes(array_to_merge, first_element) || !hasSameAlignment(first_elem_rules, array_rules))
-            {
-                __spf_print(1, "Arrays %s and %s has different sizes or align rules\n",
-                            array_to_merge->GetName().c_str(),
-                            first_element->GetName().c_str());
-
-                printInternalError(convertFileName(__FILE__).c_str(), __LINE__);
-            }
-        }
-
-        __spf_print(1, "merge into %s (%s):\n", by_dest_array.first.c_str(), arrays_new_region_mapping[by_dest_array.first].c_str());
-        for (auto *array_to_merge : copy_arrays)
-            __spf_print(1, "%s\n", array_to_merge->GetName().c_str());
-
-        auto created_array_info = createNewArray(first_element, by_dest_array.first, allFuncInfo, inserted_arrays);
-
-        unordered_set<string> arrays_to_replace;
-        for (auto *array_to_merge : copy_arrays)
-            arrays_to_replace.insert(array_to_merge->GetShortName());
-
-        for (const auto &by_file : allFuncInfo)
-        {
-            if (SgFile::switchToFile(by_file.first) == -1)
-                printInternalError(convertFileName(__FILE__).c_str(), __LINE__);
-
-            for (auto *func_info : by_file.second)
-            {
-                SgSymbol *func_symbol_hint = nullptr;
-                SgStatement *st = func_info->funcPointer;
-
-                auto *func_end = st->lastNodeOfStmt();
-
-                st = st->lexNext();
-
-                while (st && !isSgExecutableStatement(st) && st != func_end)
-                    st = st->lexNext();
-
-                while (st && st != func_end)
-                {
-                    for (int i = 0; i < 3; i++)
-                    {
-                        replaceArrayRec(
-                            st->expr(i),
-                            arrays_to_replace,
-                            &func_symbol_hint,
-                            created_array_info,
-                            first_element,
-                            func_info,
-                            inserted_arrays);
-                    }
-
-                    replaceRegion(st, new_region_mapping);
-
-                    st = st->lexNext();
-                }
-            }
-        }
-    }
-}

src/ParallelizationRegions/parse_merge_dirs.h

@@ -1,8 +0,0 @@
-#include "../GraphCall/graph_calls.h"
-#include "ParRegions.h"
-
-#include <string>
-#include <vector>
-#include <map>
-
-void mergeCopyArrays(std::vector<ParallelRegion*> &regions, const std::map<std::string, std::vector<FuncInfo*>> &allFuncInfo);

src/ParallelizationRegions/resolve_par_reg_conflicts.cpp

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

src/ParallelizationRegions/resolve_par_reg_conflicts.h

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

src/Predictor/PredictScheme.cpp

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

src/Predictor/PredictScheme.h

@@ -1,8 +1,8 @@
 #pragma once
 #include <vector>
 #include "dvm.h"
-#include "graph_calls.h"
+#include "../GraphCall/graph_calls.h"
-#include "json.hpp"
+#include "../Utils/json.hpp"
 
 class ParallelStats
 {

src/PrivateAnalyzer/private_analyzer.cpp

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

src/PrivateAnalyzer/private_analyzer.h

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

src/PrivateAnalyzer/private_arrays_search.cpp

@@ -9,42 +9,13 @@
 #include "private_arrays_search.h"
 #include "range_structures.h"
 #include "region.h"
-#include "SgUtils.h"
+#include "../Utils/SgUtils.h"
-#include "graph_loops.h"
+#include "../GraphLoop/graph_loops.h"
-#include "CFGraph/CFGraph.h"
+#include "../CFGraph/CFGraph.h"
-#include "utils.h"
 
 using namespace std;
 
-static void RemoveEmptyPoints(ArrayAccessingIndexes& container)
+void Collapse(Region* region)
-{
-    ArrayAccessingIndexes resultContainer;
-    unordered_set<string> toRemove;
-
-    for (auto& [arrayName, accessingSet] : container)
-    {
-        vector<vector<ArrayDimension>> points;
-        for (auto& arrayPoint : accessingSet.GetElements())
-        {
-            if (!arrayPoint.empty())
-                points.push_back(arrayPoint);
-        }
-
-        if (points.size() < accessingSet.GetElements().size() && !points.empty())
-            resultContainer[arrayName] = points;
-
-        if (points.empty())
-            toRemove.insert(arrayName);
-    }
-
-    for (const string& name : toRemove)
-        container.erase(name);
-
-    for (auto& [arrayName, accessingSet] : resultContainer)
-        container[arrayName] = accessingSet;
-}
-
-static void Collapse(Region* region)
 {
     if (region->getBasickBlocks().empty())
         return;
@@ -66,13 +37,13 @@ static void Collapse(Region* region)
             region->array_use[arrayName] = region->array_use[arrayName].Union(diff);
         }
     }
-
     ArrayAccessingIndexes useUnion;
     for (auto& byBlock : region->getBasickBlocks())
         for (auto& [arrayName, arrayRanges] : byBlock->array_use)
             useUnion[arrayName] = useUnion[arrayName].Union(byBlock->array_use[arrayName]);
 
-    region->array_priv = region->array_use;
+    for (auto& [arrayName, arrayRanges] : useUnion)
+        region->array_priv[arrayName] = useUnion[arrayName].Diff(region->array_use[arrayName]);
     
     for (Region* prevBlock : region->getHeader()->getPrevRegions()) 
         prevBlock->replaceInNextRegions(region, region->getHeader());
@@ -103,7 +74,6 @@ static void SolveDataFlowIteratively(Region* DFG)
                     newIn.clear();
                     continue;
                 }
-
                 for (const auto& [arrayName, accessSet] : prevBlock->array_out)
                 {
                     if (newIn.find(arrayName) != newIn.end())
@@ -116,7 +86,6 @@ static void SolveDataFlowIteratively(Region* DFG)
 
         b->array_in = move(newIn);
         ArrayAccessingIndexes newOut;
-
         if (b->array_def.empty())        
             newOut = b->array_in;
         else if (b->array_in.empty())
@@ -152,83 +121,21 @@ static void SolveDataFlow(Region* DFG)
     Collapse(DFG);
 }
 
-static void AddPrivateArraysToLoop(LoopGraph* loop, const ArrayAccessingIndexes& privates, set<SgStatement*>& insertedPrivates)
+map<LoopGraph*, ArrayAccessingIndexes>  FindPrivateArrays(map<string, vector<LoopGraph*>> &loopGraph, map<FuncInfo*, vector<SAPFOR::BasicBlock*>>& FullIR)
-{
-    SgStatement* spfStat = new SgStatement(SPF_ANALYSIS_DIR);
-    spfStat->setlineNumber(loop->loop->lineNumber());
-    spfStat->setFileName(loop->loop->fileName());
-    SgExpression* toAdd = new SgExpression(EXPR_LIST, new SgExpression(ACC_PRIVATE_OP), NULL, NULL);
-    set<SgSymbol*> arraysToInsert;
-    for (const auto& [_, accessingSet] : privates)
-    {
-        for (const auto& arrayElement : accessingSet.GetElements())
-        {
-            if (arrayElement.empty())
-                continue;
-            arraysToInsert.insert(arrayElement[0].array->symbol());
-        }
-    }
-
-    spfStat->setExpression(0, *toAdd);
-    toAdd = toAdd->lhs();
-    bool first = true;
-    for (auto& elem : arraysToInsert)
-    {
-        if (first)
-        {
-            toAdd->setLhs(new SgExpression(EXPR_LIST));
-            toAdd = toAdd->lhs();
-            first = false;
-        }
-        else
-        {
-            toAdd->setRhs(new SgExpression(EXPR_LIST));
-            toAdd = toAdd->rhs();
-        }
-        toAdd->setLhs(new SgVarRefExp(elem));
-    }
-    
-    if (arraysToInsert.size() == 0)
-        printInternalError(convertFileName(__FILE__).c_str(), __LINE__);
-
-    loop->loop->insertStmtBefore(*spfStat, *loop->loop->controlParent());
-    insertedPrivates.insert(spfStat);
-}
-
-void FindPrivateArrays(map<string, vector<LoopGraph*>> &loopGraph, map<FuncInfo*, vector<SAPFOR::BasicBlock*>>& FullIR, set<SgStatement*> &insertedPrivates)
 {  
     map<LoopGraph*, ArrayAccessingIndexes> result;
-    for (const auto& [fileName, loops] : loopGraph)
+    for (const auto& [loopName, loops] : loopGraph)
     {
-        SgFile::switchToFile(fileName);
         for (const auto& loop : loops)
         {
-            if (!loop->isFor())
-                continue;
-            SgStatement* search_func = loop->loop->GetOriginal();
-
-            while (search_func && (!isSgProgHedrStmt(search_func)))
-                search_func = search_func->controlParent();
-
             for (const auto& [funcInfo, blocks]: FullIR)
-            {   
-                if (funcInfo->fileName == fileName && funcInfo->funcPointer->GetOriginal() == search_func)
             {   
                 Region* loopRegion = new Region(loop, blocks);
-                    if (loopRegion->getBasickBlocks().size() <= 1)
-                    {
-                        delete(loopRegion);
-                        continue;
-                    }
                 SolveDataFlow(loopRegion);
-                    RemoveEmptyPoints(loopRegion->array_priv);
                 result[loop] = loopRegion->array_priv;
                 delete(loopRegion);
             }
         }
-
-            if (result.find(loop) != result.end() && !result[loop].empty())
-                AddPrivateArraysToLoop(loop, result[loop], insertedPrivates);
-        }
     }
+    return result;
 }

src/PrivateAnalyzer/private_arrays_search.h

@@ -2,12 +2,13 @@
 
 #include <vector>
 #include <map>
-#include <set>
 #include <unordered_set>
 
 #include "range_structures.h"
-#include "graph_loops.h"
+#include "region.h"
-#include "CFGraph/CFGraph.h"
+#include "../GraphLoop/graph_loops.h"
+#include "../CFGraph/CFGraph.h"
 
-void FindPrivateArrays(std::map<std::string, std::vector<LoopGraph*>>& loopGraph, std::map<FuncInfo*, std::vector<SAPFOR::BasicBlock*>>& FullIR, std::set<SgStatement*>& insertedPrivates);
+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);

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;
@@ -47,7 +47,7 @@ static ArrayDimension* DimensionIntersection(const ArrayDimension& dim1, const A
     
     uint64_t start3 = dim1.start + x0 * dim1.step;
     uint64_t step3 = c * dim1.step;
-    ArrayDimension* result = new(ArrayDimension){ start3, step3, tMax + 1 , dim1.array};
+    ArrayDimension* result = new(ArrayDimension){ start3, step3, tMax + 1 };
     return result;
 }
 
@@ -61,16 +61,21 @@ static vector<ArrayDimension> DimensionDifference(const ArrayDimension& dim1, co
     vector<ArrayDimension> result;
     /* add the part before intersection */
     if (dim1.start < intersection->start)    
-        result.push_back({ dim1.start, dim1.step, (intersection->start - dim1.start) / dim1.step, dim1.array});
+        result.push_back({ dim1.start, dim1.step, (intersection->start - dim1.start) / dim1.step });
     
     /* add the parts between intersection steps */
-    if (intersection->step > dim1.step)
-    {
     uint64_t start = (intersection->start - dim1.start) / dim1.step;
     uint64_t interValue = intersection->start;
-        for (int64_t i = start; interValue <= intersection->start + intersection->step * (intersection->tripCount - 1); i++)
+    for (int64_t i = start; dim1.start + i * dim1.step <= intersection->start + intersection->step * (intersection->tripCount - 1); i++)
     {
-            result.push_back({interValue + dim1.step, dim1.step, intersection->step / dim1.step, dim1.array});
+        uint64_t centerValue = dim1.start + i * dim1.step;
+        if (centerValue == interValue)
+        {
+            if (i - start > 1)
+            {
+                result.push_back({ dim1.start + (start + 1) * dim1.step, dim1.step, i - start - 1 });
+                start = i;
+            }
             interValue += intersection->step;
         }
     }
@@ -80,7 +85,7 @@ static vector<ArrayDimension> DimensionDifference(const ArrayDimension& dim1, co
         /* first value after intersection */
         uint64_t right_start = intersection->start + intersection->step * (intersection->tripCount - 1) + dim1.step;
         uint64_t tripCount = (dim1.start + dim1.step * dim1.tripCount - right_start) / dim1.step;
-        result.push_back({ right_start, dim1.step, tripCount, dim1.array });
+        result.push_back({ right_start, dim1.step, tripCount });
     }
     delete(intersection);
     return result;
@@ -179,8 +184,7 @@ void AccessingSet::FindUncovered(const vector<ArrayDimension>& element, vector<v
                 newTails.insert(newTails.end(), diff.begin(), diff.end());
             }
         }
-        result = newTails;
+        result = move(newTails);
-        newTails.clear();
     }
 }
 
@@ -211,10 +215,6 @@ void AccessingSet::Insert(const vector<ArrayDimension>& element)
 }
 
 AccessingSet AccessingSet::Union(const AccessingSet& source) {
-    if (source.GetElements().empty())
-        return *this;
-    if (allElements.empty())
-        return source;
     AccessingSet result;
     for (auto& element : source.GetElements())
         result.Insert(element);

src/PrivateAnalyzer/range_structures.h

@@ -6,12 +6,9 @@
 #include <string>
 #include <cstdint>
 
-#include "SgUtils.h"
-
 struct ArrayDimension
 {
     uint64_t start, step, tripCount;
-    SgArrayRefExp* array;
 };
 
 class AccessingSet {

src/PrivateAnalyzer/region.cpp

@@ -4,12 +4,11 @@
 #include<unordered_map>
 #include<string>
 #include <numeric>
-#include <iostream>
 
 #include "range_structures.h"
 #include "region.h"
 
-#include "SgUtils.h"
+#include "../Utils/SgUtils.h"
 
 using namespace std;
 
@@ -52,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)
@@ -105,33 +104,15 @@ static int GetDefUseArray(SAPFOR::BasicBlock* block, LoopGraph* loop, ArrayAcces
 
         auto operation = instruction->getInstruction()->getOperation();
         auto type = instruction->getInstruction()->getArg1()->getType();
-        if (operation == SAPFOR::CFG_OP::ASSIGN && instruction->getInstruction()->getResult()->getType() == SAPFOR::CFG_ARG_TYPE::ARRAY)
-        {
-            SgStatement* op = instruction->getInstruction()->getOperator();
-            if (op && op->expr(0) && isArrayRef(op->expr(0)) && op->expr(0)->symbol() && op->expr(0)->type())
-            {
-                if (isSgArrayType(op->expr(0)->symbol()->type()))
-                {
-                    SgArrayType* arrayType = (SgArrayType*)op->expr(0)->symbol()->type();
-                    int dimCount = ((SgArrayType*)op->expr(0)->symbol()->type())->dimension();
-                    vector<ArrayDimension> point;
-                    for (int i = 0; i < dimCount; i++)
-                    {
-                        string strDimLength = arrayType->sizeInDim(i)->unparse();
-                        if (arrayType->sizeInDim(i)->variant() == INT_VAL && strDimLength != "0")
-                            point.push_back({ 1ULL, 1ULL, (uint64_t)stoi(strDimLength), (SgArrayRefExp*)op->expr(0) });
-                    }
-
-                    if (point.size() == dimCount)
-                        def[instruction->getInstruction()->getResult()->getValue()] = AccessingSet({point});
-                }
-            }
-        }
         if ((operation == SAPFOR::CFG_OP::STORE || operation == SAPFOR::CFG_OP::LOAD) && type == SAPFOR::CFG_ARG_TYPE::ARRAY)
         {
             vector<SAPFOR::Argument*> index_vars;
             vector<int> refPos;
-            string array_name = instruction->getInstruction()->getArg1()->getValue();            
+            string array_name;
+            if (operation == SAPFOR::CFG_OP::STORE)
+                array_name = instruction->getInstruction()->getArg1()->getValue();            
+            else
+                array_name = instruction->getInstruction()->getArg2()->getValue();
 
             int j = i - 1;
             while (j >= 0 && instructions[j]->getInstruction()->getOperation() == SAPFOR::CFG_OP::REF)
@@ -146,15 +127,26 @@ static int GetDefUseArray(SAPFOR::BasicBlock* block, LoopGraph* loop, ArrayAcces
             vector<ArrayDimension> accessPoint(n);
 
             auto* ref = isSgArrayRefExp(instruction->getInstruction()->getExpression());
-            int fillCount = 0;
+            vector<pair<int, int>> coefsForDims;
+            for (int i = 0; ref && i < ref->numberOfSubscripts(); ++i)
+            {
+                const vector<int*>& coefs = getAttributes<SgExpression*, int*>(ref->subscript(i), set<int>{ INT_VAL });
+                if (coefs.size() == 1)
+                {
+                    const pair<int, int> coef(coefs[0][0], coefs[0][1]);
+                    coefsForDims.push_back(coef);
+                }
 
-            while (!index_vars.empty() && !refPos.empty())
+            }
+
+            while (!index_vars.empty())
             {
                 auto var = index_vars.back();
                 int currentVarPos = refPos.back();
+                pair currentCoefs = coefsForDims.back();
                 ArrayDimension current_dim;
                 if (var->getType() == SAPFOR::CFG_ARG_TYPE::CONST)
-                    current_dim = { stoul(var->getValue()), 1, 1, ref};
+                    current_dim = { stoul(var->getValue()), 1, 1 };
                 else
                 {
                     string name, full_name = var->getValue();
@@ -180,30 +172,23 @@ static int GetDefUseArray(SAPFOR::BasicBlock* block, LoopGraph* loop, ArrayAcces
                             return -1;
                     }
 
-                    uint64_t start = currentLoop->startVal;
+                    uint64_t start = currentLoop->startVal * currentCoefs.first + currentCoefs.second;
-                    uint64_t step = currentLoop->stepVal;
+                    uint64_t step = currentCoefs.first;
-                    uint64_t iters = currentLoop->calculatedCountOfIters;
+                    current_dim = { start, step, (uint64_t)currentLoop->calculatedCountOfIters };
-                    current_dim = { start, step, iters, ref };
                 }
 
-                if (current_dim.start != 0 && current_dim.step != 0 && current_dim.tripCount != 0)
-                {
                 accessPoint[n - index_vars.size()] = current_dim;
-                    fillCount++;
-                }
                 index_vars.pop_back();
                 refPos.pop_back();
+                coefsForDims.pop_back();
             }
 
-            if (fillCount == accessPoint.size())
-            {
             if (operation == SAPFOR::CFG_OP::STORE)            
                 def[array_name].Insert(accessPoint);
             else
                 use[array_name].Insert(accessPoint);
         }
     }
-    }
     return 0;
 
 }
@@ -229,21 +214,16 @@ static Region* CreateSubRegion(LoopGraph* loop, const vector<SAPFOR::BasicBlock*
     if (bbToRegion.find(header) != bbToRegion.end())
         region->setHeader(bbToRegion.at(header));    
     else
-    {
-        printInternalError(convertFileName(__FILE__).c_str(), __LINE__);
         return NULL;
-    }
     
     for (SAPFOR::BasicBlock* block : blockSet)
         if (bbToRegion.find(block) != bbToRegion.end())
             region->addBasickBlocks(bbToRegion.at(block));
 
     for (LoopGraph* childLoop : loop->children)
-    {
-        if (!childLoop->isFor())
-            continue;
         region->addSubRegions(CreateSubRegion(childLoop, Blocks, bbToRegion));
-    }
+
+    cout << header << endl;
     return region;
 }
 
@@ -262,9 +242,5 @@ Region::Region(LoopGraph* loop, const vector<SAPFOR::BasicBlock*>& Blocks)
     SetConnections(bbToRegion, blockSet);
     //create subRegions
     for (LoopGraph* childLoop : loop->children)
-    {
-        if (!childLoop->isFor())
-            continue;
         subRegions.insert(CreateSubRegion(childLoop, Blocks, bbToRegion));
-    }
 }