WIP change logic of inductive variables

.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/)
@@ -34,7 +33,6 @@ 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})
@@ -204,8 +202,6 @@ set(TR_INLINER src/Transformations/FunctionInlining/inliner.cpp
         src/Transformations/FunctionInlining/inliner.h)
 set(TR_RENAME_SYMBOLS  src/Transformations/RenameSymbols/rename_symbols.cpp
                     src/Transformations/RenameSymbols/rename_symbols.h)
-SET(TR_SWAP_OPERATORS src/Transformations/SwapOperators/swap_operators.cpp
-        src/Transformations/SwapOperators/swap_operators.h)
 
 set(TRANSFORMS 
         ${TR_DEAD_CODE}
@@ -228,8 +224,7 @@ set(TRANSFORMS
         ${TR_REPLACE_ARRAYS_IN_IO}
         ${TR_EXPR_TRANSFORM}
         ${TR_INLINER}
-        ${TR_RENAME_SYMBOLS}
+        ${TR_RENAME_SYMBOLS})
-        ${TR_SWAP_OPERATORS})
 
 set(CFG src/CFGraph/IR.cpp
         src/CFGraph/IR.h
@@ -243,14 +238,14 @@ 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/IR_SSAForm.cpp
+        src/CFGraph/IR_SSAForm.h)
         
 set(DATA_FLOW
         src/CFGraph/DataFlow/data_flow.h
         src/CFGraph/DataFlow/data_flow_impl.h
         src/CFGraph/DataFlow/backward_data_flow.h
-        src/CFGraph/DataFlow/backward_data_flow_impl.h
+        src/CFGraph/DataFlow/backward_data_flow_impl.h)
-        )
 
 set(CREATE_INTER_T  src/CreateInterTree/CreateInterTree.cpp
         src/CreateInterTree/CreateInterTree.h)
@@ -326,7 +321,9 @@ set(GR_LOOP src/GraphLoop/graph_loops_base.cpp
 set(LOOP_ANALYZER  src/LoopAnalyzer/allocations_prepoc.cpp
         src/LoopAnalyzer/dep_analyzer.cpp        
         src/LoopAnalyzer/loop_analyzer.cpp
-        src/LoopAnalyzer/loop_analyzer.h)
+        src/LoopAnalyzer/loop_analyzer.h
+        src/LoopAnalyzer/implicit_loops_analyzer.cpp
+        src/LoopAnalyzer/implicit_loops_analyzer.h)
 
 set(MAIN src/Sapfor.cpp
         src/Sapfor.h
@@ -462,7 +459,6 @@ source_group (Transformations\\GlobalVariables FILES ${TR_GV})
 source_group (Transformations\\ConvertToC FILES ${TR_CONV})
 source_group (Transformations\\SetImplicitNone FILES ${TR_IMPLICIT_NONE})
 source_group (Transformations\\ReplaceArraysInIO FILES ${TR_REPLACE_ARRAYS_IN_IO})
-source_group (Transformations\\SwapOperators FILES ${TR_SWAP_OPERATORS})
 
 
 source_group (CreateIntervals FILES ${CREATE_INTER_T})
@@ -500,9 +496,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/CFGraph/CFGraph.cpp

@@ -50,12 +50,30 @@ BBlock::BasicBlock(const BBlock& copyFrom)
     prev = copyFrom.prev;
 }
 
-void BBlock::addInstruction(IR_Block* item)
+void BBlock::addInstruction(IR_Block* item, bool pushFront)
 {
+    if (pushFront)
+        instructions.insert(instructions.begin(), item);
+    else
         instructions.push_back(item);
     item->setBasicBlock(this);
 }
 
+void BBlock::addInstructionBefore(IR_Block* item, Instruction* before)
+{
+    checkNull(before, convertFileName(__FILE__).c_str(), __LINE__);
+    checkNull(item, convertFileName(__FILE__).c_str(), __LINE__);
+
+    for (auto it = instructions.begin(); it != instructions.end(); ++it) {
+        if ((*it)->getInstruction() == before) {
+            instructions.insert(it, item);
+            item->setBasicBlock(this);
+            return;
+        }
+    }
+    printInternalError(convertFileName(__FILE__).c_str(), __LINE__);
+}
+
 int BBlock::removePrev(BBlock* removed)
 {
     auto it = std::remove(prev.begin(), prev.end(), removed);
@@ -512,7 +530,7 @@ static int buildReachingDefs(const vector<BBlock*>& CFG, const FuncInfo* currF,
     return iter;
 }
 
-//Kosaraju<EFBFBD>Sharir algorithm
+//Kosaraju-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();
@@ -1162,9 +1180,6 @@ map<FuncInfo*, vector<BBlock*>> buildCFG(const map<string, CommonBlock*>& common
     if (SgFile::switchToFile(oldFile) == -1)
         printInternalError(convertFileName(__FILE__).c_str(), __LINE__);
 
-    for (auto& [func, blocks] : result)
-        removedUnreachableBlocks(blocks);
-
     return result;
 }
 

src/CFGraph/CFGraph.h

@@ -6,6 +6,10 @@
 #include <vector>
 
 #include "IR.h"
+#include "../Utils/errors.h"
+#include "../Utils/utils.h"
+#include "../Utils/CommonBlock.h"
+#include "../GraphCall/graph_calls.h"
 #include "IR_domTree.h"
 
 namespace SAPFOR
@@ -41,7 +45,8 @@ namespace SAPFOR
         BasicBlock(IR_Block* item);
         BasicBlock(const BasicBlock& copyFrom);
 
-        void addInstruction(IR_Block* item);
+        void addInstructionBefore(IR_Block* item, Instruction* istruction);
+        void addInstruction(IR_Block* item, bool pushFront = false);
         void addPrev(BasicBlock* prev_) { prev.push_back(prev_); }
         void addNext(BasicBlock* next_) { next.push_back(next_); }
         void setDom(BasicBlock* dom) { directDominator = dom; }

src/CFGraph/IR.h

@@ -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,9 @@ 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; }

src/CFGraph/IR_SSAForm.cpp

@@ -0,0 +1,678 @@
+#include <stdlib.h>
+#include <stdio.h>
+#include <vector>
+#include <set>
+
+#include "../Utils/SgUtils.h"
+#include "../Utils/CommonBlock.h"
+#include "../GraphCall/graph_calls.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() != NULL && 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() != NULL && 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() != NULL && 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() != NULL && i->getInstruction()->getResult()->getType() == CFG_ARG_TYPE::VAR)
+            i->getInstruction()->getResult()->setValue(resValue);
+
+        if (i->getInstruction()->getArg1() != NULL && i->getInstruction()->getArg1()->getType() == CFG_ARG_TYPE::VAR)
+            i->getInstruction()->getArg1()->setValue(arg1Value);
+
+        if (i->getInstruction()->getArg2() != NULL && 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(const 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(const 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 NULL;
+    
+    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 NULL;
+}
+
+bool checkoDom(vector<BBlock*> a, vector<BBlock*> b, BBlock* c) {
+    if (a.size() != b.size() + 1) {
+        return false;
+    }
+
+    for (auto i : a)
+    {
+        if (i != c && find(b.begin(), b.end(), i) == b.end()) {
+            return false;
+        }
+    }
+
+    return true;
+}
+
+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;
+
+        // candidates = all dominators of b except itself
+        bool found = false;
+        for (auto& d : doms) {
+            if (d == b) continue;
+
+            if (checkoDom(doms, dominators.at(d), b)) {
+                iDom[b] = d;
+                found = true;
+                break;
+            }
+        }
+
+        if (!found) {
+            cout << "ERRORERRORERROR   " << b->getNumber() << endl;
+        }
+    }
+
+    return iDom;
+}
+
+static map<BBlock*, BBlock*> findImmediateDominators(map<BBlock*, vector<BBlock*>>& dominators, BBlock* fistBlock) 
+{
+    map<BBlock*, BBlock*> iDominators;
+
+    for (const auto& [block, domBlocks] : dominators) {
+        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(const 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(const 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->addInstruction(phiBlock, true);
+
+                    //blocksWithFiFunctions.push_back(dfBlock);
+                }
+            }
+        }
+    }
+   
+    //return blocksWithFiFunctions;
+}
+
+static 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";
+    }
+}
+
+static 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]);
+    }
+}
+
+
+static 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;
+}
+
+static 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() != NULL &&
+            instruction->getArg1()->getValue() == "FI_FUNCTION" && instruction->getResult() != NULL)
+        {
+            instruction->setResult(newName(instruction->getResult(), counter, stack, instruction->getNumber()));
+        }
+    }
+}
+
+static 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() != NULL && instruction->getArg1()->getType() == CFG_ARG_TYPE::VAR)
+            instruction->setArg1(stack[instruction->getArg1()->getValue()].top());
+
+        if (instruction->getArg2() != NULL && instruction->getArg2()->getType() == CFG_ARG_TYPE::VAR)
+            instruction->setArg2(stack[instruction->getArg2()->getValue()].top());
+
+        if (instruction->getResult() != NULL && instruction->getResult()->getType() == CFG_ARG_TYPE::VAR)
+            instruction->setResult(newName(instruction->getResult(), counter, stack, instruction->getNumber()));
+    }
+}
+
+static void renameFiFunctionArgsVar(BBlock* block, map<string, stack<BArgument*>>& stack) 
+{
+    auto size = block->getInstructions().size();
+    auto& instructions = block->getInstructions();
+
+    //cout << "try to insert Phi to block - " << block->getNumber() << endl;
+
+    for (size_t i = 0; i < size; ++i) 
+    {
+        auto irBlock = instructions[i];
+        auto instruction = irBlock->getInstruction();
+        if (instruction->getOperation() == CFG_OP::F_CALL && instruction->getArg1() != NULL && 
+            instruction->getArg1()->getValue() == "FI_FUNCTION" && instruction->getResult() != NULL && 
+            instruction->getArg2() != NULL) 
+        {
+            //cout << "Insert Phi to block - " << block->getNumber() << endl;
+            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->addInstructionBefore(new IR_Block(paramInstruction), instruction);
+
+            instruction->getArg2()->setValue(to_string(stoi(instruction->getArg2()->getValue()) + 1));
+            i++;
+        }
+    }
+}
+
+static vector<BBlock*> findBlocksWithValue(map<BBlock*, BBlock*>& iDominators, BBlock* x) 
+{
+    vector<BBlock*> result;
+
+    // Проходим по всем элементам map
+    for (auto& pair : iDominators)
+        if (pair.second == x) // Если значение равно x, добавляем ключ в результат
+            result.push_back(pair.first);
+
+    return result;
+}
+
+static void renameIR(BBlock* block, map<BBlock*, BBlock*>& iDominators, map<string, int>& counter, map<string, stack<BArgument*>>& stack) {
+
+    //cout << "renameIR for block " << block->getNumber() << endl;
+
+    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() != NULL && 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() != NULL && 
+            instruction->getArg1()->getValue() == "FI_FUNCTION" && instruction->getResult() != NULL) 
+        {
+            string varName = instruction->getResult()->getValue();
+            stack[varName].pop();
+        }
+    }
+}
+
+bool isEqual1(const char* cstr, const std::string& str) {
+    return str == cstr;
+}
+
+void buildIRSSAForm(const map<FuncInfo*, vector<BBlock*>>& fullIR, 
+                    map<FuncInfo*, vector<BBlock*>>& result) {
+
+    for (auto& [funcinfo, funcIRConst]: fullIR) {
+        if (isEqual1("csol.for", funcinfo->fileName) || isEqual1("reblns.for", funcinfo->fileName) || isEqual1("adjont.for", funcinfo->fileName)
+            || isEqual1("beginf.for", funcinfo->fileName) || isEqual1("dsnp1.for", funcinfo->fileName) || isEqual1("dsnpnm.for", funcinfo->fileName)
+            || isEqual1("decod3.for", funcinfo->fileName))
+            continue;
+
+        cout << "Testing " << funcinfo->funcName << endl;
+
+        vector<BBlock*> funcIR;
+
+       /* for (auto& i : funcIRConst) {
+            printBlock(i);
+        }*/
+
+        for (auto& i : funcIRConst)
+            funcIR.push_back(new BBlock(*i));
+
+        restoreConnections(funcIRConst, funcIR);
+
+        /*for (auto& i : funcIR) {
+            printBlock(i);
+        }*/
+        for (auto& [func, bblocks] : result)
+            SAPFOR::buildDominatorTree(bblocks);
+        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;
+        }
+
+        /*for (auto& i : funcIR) {
+            printBlock(i);
+        }*/
+
+        renameIR(funcIR[0], iDominators, count, varStack);
+
+        //cout << endl << endl << "___________________" << endl << endl;
+
+        /*for (auto& i : funcIR) {
+            printBlock(i);
+        }*/
+        //cout << endl << endl << endl << endl << endl;
+        //for (auto i : funcIRConst) {
+        //    printBlock(i);
+        //}
+
+        result[funcinfo] = funcIR;
+    }
+}

src/CFGraph/IR_SSAForm.h

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

src/CFGraph/IR_domTree.h

@@ -7,7 +7,7 @@
 #include "CFGraph.h"
 
 // Lengauer, Thomas. A fast algorithm for finding dominators in a flowgraph / Thomas Lengauer, Robert Endre Tarjan 
-// ACM Transactions on Programming Languages and Systems (TOPLAS). <20> 1979. <20> Vol. 1, no. 1. <20> Pp. 121<32>141.
+// ACM Transactions on Programming Languages and Systems (TOPLAS). <20> 1979. <20> Vol. 1, no. 1. <20> Pp. 121<32>141.
 
 namespace SAPFOR {
 

src/CFGraph/private_variables_analysis.cpp

@@ -250,7 +250,7 @@ static set<SAPFOR::BasicBlock*> analyzeLoop(LoopGraph* loop, const set<SAPFOR::B
                                             const map<string, SgSymbol*>& commonArgs, FuncInfo* func,
                                             map<string, vector<Messages>>& messages)
 {
-    if (!loop->isFor())
+    if (!loop->isFor)
         printInternalError(convertFileName(__FILE__).c_str(), __LINE__); //should be called only with FOR loops
 
     SgStatement* loop_operator = loop->loop->GetOriginal();
@@ -450,7 +450,7 @@ static void recAnalyzeLoop(LoopGraph* loop, const set<SAPFOR::BasicBlock*>& bloc
                            const map<string, SgSymbol*>& commonArgs,
                            FuncInfo* func, map<string, vector<Messages>>& messages)
 {
-    const auto& loop_body = loop->isFor() ? analyzeLoop(loop, blocks, commonVars, commonArgs, func, messages) : blocks;
+    const auto& loop_body = loop->isFor ? analyzeLoop(loop, blocks, commonVars, commonArgs, func, messages) : blocks;
     
     for (const auto& inner_loop : loop->children)
         recAnalyzeLoop(inner_loop, loop_body, commonVars, commonArgs, func, messages);

src/DirectiveProcessing/directive_creator.cpp

@@ -22,7 +22,7 @@
 #include "SgUtils.h"
 #include "../Sapfor.h"
 #include "graph_loops_func.h"
-#include "LoopNesting/loop_transform.h"
+#include "../Transformations/LoopNesting/loop_transform.h"
 #include "expr_transform.h"
 #include "graph_calls_func.h"
 

src/DirectiveProcessing/directive_creator_base.cpp

@@ -10,7 +10,7 @@
 
 #include "../ParallelizationRegions/ParRegions.h"
 #include "../Distribution/Arrays.h"
-#include "LoopNesting/loop_transform.h"
+#include "../Transformations/LoopNesting/loop_transform.h"
 
 #include "errors.h"
 #include "directive_parser.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/shadow.cpp

@@ -15,7 +15,7 @@
 #include "SgUtils.h"
 #include "expr_transform.h"
 
-#include "CFGraph/CFGraph.h"
+#include "../CFGraph/CFGraph.h"
 
 #include "shadow.h"
 #include "dvm.h"

src/Distribution/ArrayAnalysis.cpp

@@ -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/DvmhDirective.cpp

@@ -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/DvmhRegions/DvmhRegionInserter.cpp

@@ -11,9 +11,9 @@
 #include "DvmhRegionInserter.h"
 #include "DvmhRegions/RegionsMerger.h"
 #include "../VerificationCode/verifications.h"
+#include "../Transformations/FunctionPurifying/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/GraphCall/graph_calls.cpp

@@ -14,7 +14,7 @@
 #include "dvm.h"
 #include "graph_calls_func.h"
 
-#include "CFGraph/CFGraph.h"
+#include "../CFGraph/CFGraph.h"
 #include "graph_loops_func.h"
 #include "../DirectiveProcessing/directive_parser.h"
 #include "SgUtils.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/GraphLoop/graph_loops.cpp

@@ -31,7 +31,7 @@
 #include "../DirectiveProcessing/directive_parser.h"
 #include "../DynamicAnalysis/gCov_parser_func.h"
 
-#include "VectorAssignToLoop/array_assign_to_loop.h"
+#include "../Transformations/VectorAssignToLoop/array_assign_to_loop.h"
 
 using std::vector;
 using std::map;
@@ -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

@@ -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

@@ -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", 

src/LoopAnalyzer/implicit_loops_analyzer.cpp

@@ -0,0 +1,370 @@
+#include <map>
+#include <set>
+#include <vector>
+#include <string>
+#include <iostream>
+#include <stack>
+
+#include "../CFGraph/IR.h"
+#include "GraphCall/graph_calls.h"
+#include "implicit_loops_analyzer.h"
+
+using namespace std;
+using namespace SAPFOR;
+
+using std::map;
+using std::set;
+using std::vector;
+using std::pair;
+using std::string;
+using std::cout;
+using std::endl;
+using std::make_pair;
+using std::to_string;
+
+enum VisitState { UNVISITED = 0, VISITING = 1, VISITED = 2 };
+
+void dfs(SAPFOR::BasicBlock* block,
+    std::map<int, int>& visit,
+    std::vector<std::pair<SAPFOR::BasicBlock*, SAPFOR::BasicBlock*>>& startAndEnd,
+    SAPFOR::BasicBlock* prev) {
+    if (!block) return;
+
+    int id = block->getNumber();
+
+    if (visit[id] == VISITING) {
+        // Обратное ребро — фиксируем цикл
+        startAndEnd.emplace_back(prev, block);
+        //std::cout << "Back edge detected: " << prev->getNumber() << " -> " << id << std::endl;
+        return;
+    }
+
+    if (visit[id] == VISITED) {
+        return;
+    }
+
+    visit[id] = VISITING;
+
+    for (auto next : block->getNext()) {
+        dfs(next, visit, startAndEnd, block);
+    }
+
+    visit[id] = VISITED;
+}
+
+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);
+        }
+    }
+}
+
+SAPFOR::Instruction* findDef(const SAPFOR::Argument* arg,
+    const std::vector<SAPFOR::BasicBlock*>& blocks) {
+    if (!arg) return nullptr;
+    std::string argName = arg->getValue();
+
+    for (auto block : blocks) {
+        for (auto instrWrapper : block->getInstructions()) {
+            auto instr = instrWrapper->getInstruction();
+            if (!instr) continue;
+
+            auto res = instr->getResult();
+            if (!res) continue;
+
+            if (res->getValue() == argName) {
+                return instr;
+            }
+        }
+    }
+
+    return nullptr;
+}
+
+const SAPFOR::Argument* getBaseSource(const SAPFOR::Argument* arg, const std::vector<SAPFOR::BasicBlock*>& blocks) {
+    while (arg && arg->getType() == CFG_ARG_TYPE::REG) {
+        auto defInstr = findDef(arg, blocks);
+        if (!defInstr) break;
+        auto defOp = defInstr->getOperation();
+
+        if (defOp == CFG_OP::ASSIGN) {
+            arg = defInstr->getArg1();
+        }
+        else {
+            break;
+        }
+    }
+    return arg;
+}
+
+void findInductiveVars(const std::vector<SAPFOR::BasicBlock*>& Loopblocks, const std::vector<SAPFOR::BasicBlock*>& blocks) {
+    std::set<std::string> inductiveVars;
+
+    for (auto block : Loopblocks) {
+        for (auto instrWrapper : block->getInstructions()) {
+            auto instr = instrWrapper->getInstruction();
+            if (!instr) continue;
+
+            auto res = instr->getResult();
+            if (!res || res->getType() != SAPFOR::CFG_ARG_TYPE::VAR) continue;
+
+            while (instr && instr->getOperation() == CFG_OP::ASSIGN) {
+                instr = findDef(instr->getArg1(), blocks);
+            }
+
+            if (!instr || instr->getOperation() != CFG_OP::ADD && instr->getOperation() != CFG_OP::SUBT) continue;
+
+            auto arg1 = getBaseSource(instr->getArg1(), blocks);
+            auto arg2 = getBaseSource(instr->getArg2(), blocks);
+
+            bool ok = false;
+            if (res->getValue() == arg1->getValue() &&
+                arg2->getType() == CFG_ARG_TYPE::CONST) {
+                ok = true;
+            }
+            else if (res->getValue() == arg2->getValue() &&
+                arg1->getType() == CFG_ARG_TYPE::CONST) {
+                ok = true;
+            }
+
+            if (ok) {
+                inductiveVars.insert(res->getValue());
+            }
+        }
+    }
+
+    if (inductiveVars.empty()) {
+        std::cout << "No inductive variables found." << std::endl;
+    }
+    else {
+        for (const auto& var : inductiveVars) {
+            std::cout << "Inductive variable: " << var << 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();
+                if (instructions.empty()) {
+                    std::cout << "Exit block has no instructions." << std::endl;
+                }
+                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 findImplicitLoops(const std::map<FuncInfo*, std::vector<SAPFOR::BasicBlock*>>& fullIR_SSA, const char* fileName) {
+    for (auto& i : fullIR_SSA)
+    {
+        //for (auto j : i.second)
+        //    printblock(j);
+
+        if (!isEqual(fileName, i.first->fileName))
+            continue;
+
+        if (isEqual("csol.for", i.first->fileName) || isEqual("reblns.for", i.first->fileName) || isEqual("adjont.for", i.first->fileName)
+            || isEqual("beginf.for", i.first->fileName) || isEqual("dsnp1.for", i.first->fileName) || isEqual("dsnpnm.for", i.first->fileName)
+            || isEqual("decod3.for", i.first->fileName))
+            continue;
+
+        //if (!isEqual("iter3.for", i.first->fileName))
+        //    continue;
+
+        map<int, int> visited;
+        for (auto i : i.second)
+            visited[i->getNumber()] = UNVISITED;
+
+        //for (auto j : i.second)
+        //    printBlock(j);
+
+        //continue;
+
+            //vector<int> visited(i.second.size(), UNVISITED);
+        vector<pair<SAPFOR::BasicBlock*, SAPFOR::BasicBlock*>> startAndEnd;
+        dfs(i.second[0], visited, startAndEnd, NULL);
+
+        //continue;
+
+        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(loopBody, i.second);
+
+            continue;
+
+
+            Instruction* instructionAfterLoop = findInstructionAfterLoop(loopBody);
+
+            if (instructionAfterLoop == NULL) {
+                cout << "Warning: instruction after loop not found!" << endl;
+                cout << i.first->fileName << 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();
+
+            //continue;
+
+            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/LoopAnalyzer/implicit_loops_analyzer.h

@@ -0,0 +1,7 @@
+#pragma once
+
+#include <map>
+#include "../CFGraph/CFGraph.h"
+#include "../GraphCall/graph_calls.h"
+
+void findImplicitLoops(const std::map<FuncInfo*, std::vector<SAPFOR::BasicBlock*>>& fullIR_SSA, const char* fileName);

src/LoopAnalyzer/loop_analyzer.cpp

@@ -48,7 +48,7 @@ extern int passDone;
 #include "../VisualizerCalls/get_information.h"
 #include "../VisualizerCalls/SendMessage.h"
 
-#include "LoopEndDoConverter/enddo_loop_converter.h"
+#include "../Transformations/LoopEndDoConverter/enddo_loop_converter.h"
 
 #include "../DirectiveProcessing/remote_access.h"
 #include "../DirectiveProcessing/directive_omp_parser.h"
@@ -2199,7 +2199,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);
 

src/ParallelizationRegions/resolve_par_reg_conflicts.cpp

@@ -18,7 +18,7 @@
 #include "../DirectiveProcessing/insert_directive.h"
 #include "SgUtils.h"
 #include "expr_transform.h"
-#include "FunctionPurifying/function_purifying.h"
+#include "../Transformations/FunctionPurifying/function_purifying.h"
 
 using std::map;
 using std::pair;

src/Predictor/PredictScheme.cpp

@@ -22,7 +22,7 @@
 #include "graph_loops_func.h"
 #include "expr_transform.h"
 #include "../LoopAnalyzer/loop_analyzer.h"
-#include "CFGraph/CFGraph.h"
+#include "../CFGraph/CFGraph.h"
 
 #include "json.hpp"
 

src/PrivateAnalyzer/private_analyzer.cpp

@@ -12,7 +12,7 @@
 #include "graph_calls.h"
 #include "private_analyzer.h"
 #include "dvm.h"
-#include "CFGraph/CFGraph.h"
+#include "../CFGraph/CFGraph.h"
 
 using std::vector;
 

src/PrivateAnalyzer/private_arrays_search.cpp

@@ -11,11 +11,11 @@
 #include "region.h"
 #include "SgUtils.h"
 #include "graph_loops.h"
-#include "CFGraph/CFGraph.h"
+#include "../CFGraph/CFGraph.h"
 
 using namespace std;
 
-static void Collapse(Region* region)
+void Collapse(Region* region)
 {
     if (region->getBasickBlocks().empty())
         return;
@@ -121,7 +121,7 @@ static void SolveDataFlow(Region* DFG)
     Collapse(DFG);
 }
 
-map<LoopGraph*, ArrayAccessingIndexes>  FindPrivateArrays(map<string, vector<LoopGraph*>> &loopGraph, map<FuncInfo*, vector<SAPFOR::BasicBlock*>>& FullIR)
+map<LoopGraph*, ArrayAccessingIndexes>  findPrivateArrays(map<string, vector<LoopGraph*>> &loopGraph, map<FuncInfo*, vector<SAPFOR::BasicBlock*>>& FullIR)
 {  
     map<LoopGraph*, ArrayAccessingIndexes> result;
     for (const auto& [loopName, loops] : loopGraph)

src/PrivateAnalyzer/private_arrays_search.h

@@ -5,8 +5,10 @@
 #include <unordered_set>
 
 #include "range_structures.h"
+#include "region.h"
 #include "graph_loops.h"
-#include "CFGraph/CFGraph.h"
+#include "../CFGraph/CFGraph.h"
 
-std::map<LoopGraph*, ArrayAccessingIndexes> FindPrivateArrays(std::map<std::string, std::vector<LoopGraph*>>& loopGraph, std::map<FuncInfo*, std::vector<SAPFOR::BasicBlock*>>& FullIR);
+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/region.cpp

@@ -51,7 +51,7 @@ pair<SAPFOR::BasicBlock*, unordered_set<SAPFOR::BasicBlock*>> GetBasicBlocksForL
 }
 
 static void BuildLoopIndex(map<string, LoopGraph*>& loopForIndex, LoopGraph* loop) {
-    string index = loop->loopSymbol();
+    string index = loop->loopSymbol;
     loopForIndex[index] = loop;
 
     for (const auto& childLoop : loop->children)

src/PrivateAnalyzer/region.h

@@ -6,7 +6,7 @@
 #include <string>
 
 #include "graph_loops.h"
-#include "CFGraph/CFGraph.h"
+#include "../CFGraph/CFGraph.h"
 
 class Region : public SAPFOR::BasicBlock {
 public:

src/ProjectManipulation/ConvertFiles.cpp

@@ -403,7 +403,7 @@ static int convertFile(int argc, char* argv[], const set<string>& filesInProj, c
             fprintf(stderr, "<<<<<  Unparsing   %s  >>>>>\n", fout_name);
 
         if (mod_gpu) /*ACC*/
-            UnparseTo_CufAndCu_Files(file, fout_cuf, fout_C_cu, fout_info, fout_name);
+            UnparseTo_CufAndCu_Files(file, fout_cuf, fout_C_cu, fout_info);
 
         const string fileN = file->filename();
         set<SgStatement*> toRemove;

src/Sapfor.cpp

@@ -40,6 +40,7 @@
 #include "ProjectManipulation/ConvertFiles.h"
 
 #include "LoopAnalyzer/loop_analyzer.h"
+#include "LoopAnalyzer/implicit_loops_analyzer.h"
 
 #include "GraphCall/graph_calls_func.h"
 #include "GraphLoop/graph_loops_func.h"
@@ -89,13 +90,13 @@
 #include "Transformations/DeadCodeRemoving/dead_code.h"
 #include "Transformations/RenameSymbols/rename_symbols.h"
 #include "Transformations/FunctionInlining/inliner.h"
-#include "Transformations/SwapOperators/swap_operators.h"
 
 #include "ProjectParameters/projectParameters.h"
 
 #include "CFGraph/IR.h"
 #include "CFGraph/RD_subst.h"
 #include "CFGraph/CFGraph.h"
+#include "CFGraph/IR_SSAForm.h"
 
 #include "CFGraph/live_variable_analysis.h"
 #include "CFGraph/private_variables_analysis.h"
@@ -940,8 +941,6 @@ static bool runAnalysis(SgProject &project, const int curr_regime, const bool ne
                     internalExit = err;
             }
         }
-        else if (curr_regime == SWAP_OPERATORS)        
-            runSwapOperators(file, loopGraph, fullIR, countOfTransform);        
         else if (curr_regime == PRIVATE_REMOVING_ANALYSIS)
         {
             auto itFound = loopGraph.find(file->filename());
@@ -1022,8 +1021,15 @@ static bool runAnalysis(SgProject &project, const int curr_regime, const bool ne
                 if(func->funcPointer->variant() != ENTRY_STAT)
                     countOfTransform += removeDeadCode(func->funcPointer, allFuncInfo, commonBlocks);
         }
+        else if (curr_regime == BUILD_IR_SSA_FORM)
+        {
+            if (fullIR_SSA.size() == 0)
+                buildIRSSAForm(fullIR, fullIR_SSA);
+        }
+        else if (curr_regime == FIND_IMPLICIT_LOOPS)        
+            findImplicitLoops(fullIR_SSA, file_name);            
         else if (curr_regime == FIND_PRIVATE_ARRAYS)
-            FindPrivateArrays(loopGraph, fullIR);
+            findPrivateArrays(loopGraph, fullIR);
         else if (curr_regime == TEST_PASS)
         {
         //test pass
@@ -1040,8 +1046,7 @@ static bool runAnalysis(SgProject &project, const int curr_regime, const bool ne
                           PRIVATE_REMOVING,
                           PRIVATE_ARRAYS_EXPANSION, 
                           PRIVATE_ARRAYS_SHRINKING,
-                          REMOVE_DEAD_CODE,
+                          REMOVE_DEAD_CODE };
-                          SWAP_OPERATORS };
 
     if ((countOfTransform == 0 || internalExit > 0) && applyFor.find(curr_regime) != applyFor.end())
     {
@@ -1285,6 +1290,7 @@ static bool runAnalysis(SgProject &project, const int curr_regime, const bool ne
         detectCopies(allFuncInfo);
         fillInterfaceBlock(allFuncInfo);
         intentInsertToInterfaces(allFuncInfo);
+        createInterfacesForAssumedSize(allFuncInfo);
 
         //this call is only for testing
         //setPureStatus(allFuncInfo);
@@ -1918,8 +1924,6 @@ static bool runAnalysis(SgProject &project, const int curr_regime, const bool ne
         calculateStatsForPredictor(allFuncInfo, gCovInfo);
         parseDvmDirForPredictor(declaredArrays, commonBlocks, allFuncInfo, gCovInfo);
     }
-    else if (curr_regime == TRANSFORM_ASSUMED_SIZE_PARAMETERS)
-        transformAssumedSizeParameters(allFuncInfo);
 
     const float elapsed = duration_cast<milliseconds>(high_resolution_clock::now() - timeForPass).count() / 1000.;
     const float elapsedGlobal = duration_cast<milliseconds>(high_resolution_clock::now() - globalTime).count() / 1000.;
@@ -2155,8 +2159,6 @@ void runPass(const int curr_regime, const char *proj_name, const char *folderNam
         runAnalysis(*project, REMOVE_COPIES, false);
         runAnalysis(*project, SWAP_LOOPS, false);
 
-        runPass(TRANSFORM_ASSUMED_SIZE_PARAMETERS, proj_name, folderName);
-
         if (folderName || consoleMode)
             runAnalysis(*project, UNPARSE_FILE, true, additionalName.c_str(), folderName);
     }
@@ -2338,7 +2340,6 @@ void runPass(const int curr_regime, const char *proj_name, const char *folderNam
     case INSERT_NO_DISTR_FLAGS_FROM_GUI:
     case PRIVATE_REMOVING:
     case RENAME_INLCUDES:
-    case SWAP_OPERATORS:
         runAnalysis(*project, curr_regime, true, "", folderName);
         break;
     case INLINE_PROCEDURES:
@@ -2640,10 +2641,7 @@ int main(int argc, char **argv)
         }
 
         if (curr_regime == INSERT_PARALLEL_DIRS_NODIST)
-        {
             ignoreArrayDistributeState = true;
-            sharedMemoryParallelization = 1;
-        }
 
         if (runAsClient)
         {

src/Sapfor.h

@@ -122,8 +122,6 @@ enum passes {
     CREATE_INTER_TREE,
     INSERT_INTER_TREE,
 
-    SWAP_OPERATORS,
-
     SHADOW_GROUPING,
     INLINE_PROCEDURES,
     FILL_PARALLEL_REG_IR,
@@ -184,11 +182,11 @@ enum passes {
 
     SET_IMPLICIT_NONE,
     RENAME_INLCUDES,
+    FIND_IMPLICIT_LOOPS,
+    BUILD_IR_SSA_FORM,
 
     FIND_PRIVATE_ARRAYS,
 
-    TRANSFORM_ASSUMED_SIZE_PARAMETERS,
-
     TEST_PASS,
     EMPTY_PASS
 };
@@ -321,7 +319,6 @@ static void setPassValues()
     passNames[CHECK_PAR_REG_DIR] = "CHECK_PAR_REG_DIR";
     passNames[CREATE_INTER_TREE] = "CREATE_INTER_TREE";
     passNames[INSERT_INTER_TREE] = "INSERT_INTER_TREE";
-    passNames[SWAP_OPERATORS] = "SWAP_OPERATORS";
     passNames[CREATE_PARALLEL_REGIONS] = "CREATE_PARALLEL_REGIONS";
     passNames[PRIVATE_REMOVING_ANALYSIS] = "PRIVATE_REMOVING_ANALYSIS";
     passNames[PRIVATE_REMOVING] = "PRIVATE_REMOVING";
@@ -374,10 +371,10 @@ static void setPassValues()
     passNames[SET_IMPLICIT_NONE] = "SET_IMPLICIT_NONE";
     passNames[RENAME_INLCUDES] = "RENAME_INLCUDES";
     passNames[INSERT_NO_DISTR_FLAGS_FROM_GUI] = "INSERT_NO_DISTR_FLAGS_FROM_GUI";
+    passNames[FIND_IMPLICIT_LOOPS] = "FIND_IMPLICIT_LOOPS";
+    passNames[BUILD_IR_SSA_FORM] = "BUILD_IR_SSA_FORM";
     passNames[FIND_PRIVATE_ARRAYS] = "FIND_PRIVATE_ARRAYS";
 
-    passNames[TRANSFORM_ASSUMED_SIZE_PARAMETERS] = "TRANSFORM_ASSUMED_SIZE_PARAMETERS";
-
     passNames[TEST_PASS] = "TEST_PASS";
 }
 

src/SapforData.h

@@ -181,3 +181,7 @@ bool passNamesWasInit = false;
 
 std::map<PTR_BFND, std::pair<std::string, int>> sgStats;
 std::map<PTR_LLND, std::pair<std::string, int>> sgExprs;
+
+//for FIND_IMPLICIT_LOOPS and BUILD_IR_SSA_FORM
+map<FuncInfo*, vector<SAPFOR::BasicBlock*>> fullIR_SSA;
+//

src/Transformations/DeadCodeRemoving/dead_code.cpp

@@ -6,7 +6,7 @@
 #include <set>
 #include <algorithm>
 
-#include "../CFGraph/CFGraph.h"
+#include "../../CFGraph/CFGraph.h"
 
 using std::map;
 using std::string;

src/Transformations/DeadCodeRemoving/dead_code.h

@@ -4,10 +4,10 @@
 #include<vector>
 
 #include "SgUtils.h"
-#include "CFGraph/CFGraph.h"
+#include "../CFGraph/CFGraph.h"
-#include "CFGraph/live_variable_analysis.h"
+#include "../CFGraph/live_variable_analysis.h"
-#include "CFGraph/DataFlow/data_flow.h"
+#include "../CFGraph/DataFlow/data_flow.h"
-#include "CFGraph/DataFlow/backward_data_flow.h"
+#include "../CFGraph/DataFlow/backward_data_flow.h"
 
 int removeDeadCode(SgStatement* func, 
                    const std::map<std::string, std::vector<FuncInfo*>>&allFuncs,

src/Transformations/ExpressionSubstitution/expr_transform.cpp

@@ -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/Transformations/FunctionPurifying/function_purifying.cpp

@@ -103,7 +103,7 @@ void insertIntrinsicStat(const vector<FuncInfo*>& allFuncInfo)
             if (line <= 0)
                 printInternalError(convertFileName(__FILE__).c_str(), __LINE__);
 
-            intr->setlineNumber(getNextNegativeLineNumber());
+            intr->setlineNumber(line);
             st->insertStmtBefore(*intr, *func->funcPointer);
         }
         else
@@ -136,41 +136,33 @@ void createInterfacesForOutCalls(FuncInfo* func)
     }
 }
 
-static bool changeIfHasStarRange(SgExpression* arrayDecl, SgStatement* scope, vector<SgSymbol*>& parNames)
+static bool changeIfHasStarRange(SgExpression* arrayDecl, bool doReplace = false)
 {
     SgExpression* list = arrayDecl->lhs();
-    string varN = arrayDecl->symbol()->identifier() + string("_sz");
+    bool has = doReplace;
-    bool has = false;
     
-    SgExpression* allDimsBefore = NULL;
     while (list)
     {
         const int var = list->lhs()->variant();
         if (var == STAR_RANGE)
-        {
             has = true;
-
-            parNames.push_back(new SgSymbol(VARIABLE_NAME, varN.c_str(), SgTypeInt(), scope));
-            SgExpression* par = allDimsBefore ? &(*new SgVarRefExp(parNames.back()) / *allDimsBefore) : (new SgVarRefExp(parNames.back()));
-
-            list->setLhs(par);
-            break;
-        }
-        else
-        {
-            if (allDimsBefore == NULL)
-                allDimsBefore = list->lhs();
-            else
-                allDimsBefore = &(*allDimsBefore * *list->lhs()->copyPtr());
-        }
-
         list = list->rhs();
     }
 
+    if (has)
+    {
+        list = arrayDecl->lhs();
+        while (list)
+        {
+            list->setLhs(new SgExpression(DDOT));
+            list = list->rhs();
+        }
+    }
+
     return has;
 }
 
-/*static void removeExternalStat(SgStatement* func, const set<string>& addedInterfaceFor)
+static void removeExternalStat(SgStatement* func, const set<string>& addedInterfaceFor)
 {
     vector<SgStatement*> toRem;
     for (auto st = func; st != func->lastNodeOfStmt(); st = st->lexNext())
@@ -205,7 +197,7 @@ static bool changeIfHasStarRange(SgExpression* arrayDecl, SgStatement* scope, ve
 
     for (auto& rem : toRem)
         rem->deleteStmt();
-}*/
+}
 
 template<typename T>
 static vector<FuncInfo*> sortByName(const T &funcs)
@@ -218,25 +210,9 @@ static vector<FuncInfo*> sortByName(const T &funcs)
     return funcList;
 }
 
-static bool hasDvmParallel(SgStatement *func)
+void createInterfacesForAssumedSize(const map<string, vector<FuncInfo*>>& allFuncInfo)
 {
-    for (auto st = func; st != func->lastNodeOfStmt(); st = st->lexNext())
+    set<FuncInfo*> hasAssumedSizeArrays;
-    {
-        const int var = st->variant();
-        if (var == DVM_PARALLEL_ON_DIR || var == ACC_REGION_DIR ||
-            var == ACC_ACTUAL_DIR || var == ACC_GET_ACTUAL_DIR)
-            return true;
-
-        if (st->variant() == CONTAINS_STMT)
-            break;
-    }
-
-    return false;
-}
-
-void transformAssumedSizeParameters(const map<string, vector<FuncInfo*>>& allFuncInfo)
-{
-    map<string, vector<int>> assumedSizeArraysByFunc;
 
     for (auto& funcByFile : allFuncInfo)
     {
@@ -249,12 +225,6 @@ void transformAssumedSizeParameters(const map<string, vector<FuncInfo*>>& allFun
             if (prog == NULL)
                 continue;
 
-            if (!hasDvmParallel(prog))
-                continue;
-
-            vector<SgSymbol*> parNames;
-            SgStatement* scope = prog->getScopeForDeclare();
-
             vector<SgExpression*> arrayRefs;
             bool hasRefs = false;
             for (int z = 0; z < func->funcParams.countOfPars; ++z)
@@ -274,8 +244,13 @@ void transformAssumedSizeParameters(const map<string, vector<FuncInfo*>>& allFun
                         {
                             if (list->lhs() && list->lhs()->symbol()->identifier() == name)
                             {
-                                if (changeIfHasStarRange(list->lhs(), scope, parNames))
+                                if (changeIfHasStarRange(list->lhs()))
-                                    assumedSizeArraysByFunc[func->funcName].push_back(z);
+                                {
+                                    hasRefs = true;
+                                    hasAssumedSizeArrays.insert(func);
+                                }
+                                else
+                                    arrayRefs.push_back(list->lhs());
                                 break;
                             }
                             list = list->rhs();
@@ -284,20 +259,13 @@ void transformAssumedSizeParameters(const map<string, vector<FuncInfo*>>& allFun
                 }
             }
 
-            if (parNames.size())
+            if (hasRefs)
-            {
+                for (auto& ref : arrayRefs)
-                SgProcHedrStmt* proc = isSgProcHedrStmt(func->funcPointer->GetOriginal());
+                    changeIfHasStarRange(ref, true);
-                checkNull(proc, convertFileName(__FILE__).c_str(), __LINE__);
-
-                //makeDeclaration(parNames, scope);
-
-                for (auto& newPar : parNames)
-                    proc->AddArg(*new SgVarRefExp(newPar));
-            }
         }
     }
 
-    if (assumedSizeArraysByFunc.size() == 0)
+    if (hasAssumedSizeArrays.size() == 0)
         return;
 
     for (auto& funcByFile : allFuncInfo)
@@ -305,60 +273,26 @@ void transformAssumedSizeParameters(const map<string, vector<FuncInfo*>>& allFun
         if (SgFile::switchToFile(funcByFile.first) == -1)
             printInternalError(convertFileName(__FILE__).c_str(), __LINE__);
 
-        SgSymbol* funcSize = new SgSymbol(FUNCTION_NAME, "size");
-
         for (auto& func : sortByName(funcByFile.second))
         {
             SgProgHedrStmt* prog = isSgProgHedrStmt(func->funcPointer->GetOriginal());
             if (prog == NULL)
                 continue;
 
-            for (auto& detailedCall : func->callsFromDetailed)
+            set<string> addedInterfaceFor;
+            for (auto& elem : sortByName(func->callsFromV))
             {
-                auto it = assumedSizeArraysByFunc.find(detailedCall.detailCallsFrom.first);
+                auto it = hasAssumedSizeArrays.find(elem);
-                if (it != assumedSizeArraysByFunc.end())
+                if (it != hasAssumedSizeArrays.end())
                 {
-                    auto pointer = detailedCall.pointerDetailCallsFrom;
+                    auto callFrom = *it;
-
+                    DvmhRegionInserter::createInterfaceBlockForOutCall(func, callFrom);
-                    SgExpression* list = NULL;
+                    addedInterfaceFor.insert(callFrom->funcName);
-                    if (pointer.second == FUNC_CALL)
-                    {
-                        SgExpression* p = (SgExpression*)pointer.first;
-                        list = p->lhs();
-                    }
-                    else
-                    {
-                        SgStatement* p = (SgStatement*)pointer.first;
-                        list = p->expr(0);
-                    }
-
-                    SgExpression* last = list;
-                    vector<SgExpression*> pars;
-                    while (list)
-                    {
-                        last = list;
-                        pars.push_back(list->lhs());
-                        list = list->rhs();
-                    }
-
-                    for (int z = 0; z < it->second.size(); ++z)
-                    {
-                        int parNum = it->second[z];
-                        if (parNum >= pars.size())
-                            printInternalError(convertFileName(__FILE__).c_str(), __LINE__);
-
-                        //TODO: need to do it better
-                        SgExpression* parArray = pars[parNum]->copyPtr();
-                        parArray->setLhs(NULL);
-                        parArray->setRhs(NULL);
-
-                        SgFunctionCallExp* call = new SgFunctionCallExp(*funcSize, *parArray);
-
-                        last->setRhs(new SgExpression(EXPR_LIST, call));
-                        last = last->rhs();
-                    }
                 }
             }
+
+            if (addedInterfaceFor.size())
+                removeExternalStat(prog, addedInterfaceFor);
         }       
     }
 }
@@ -525,7 +459,7 @@ static void insertIntents(set<string>& identificators, SgStatement* header, cons
     if (args.size())
     {
         SgIntentStmt* intent = new SgIntentStmt(*makeExprList(args), *attr);
-        intent->setlineNumber(getNextNegativeLineNumber());
+        intent->setlineNumber(lastDecl->lineNumber());
 
         lastDecl->insertStmtAfter(*intent, (header == lastDecl) ? *header : *lastDecl->controlParent());
     }
@@ -1454,37 +1388,6 @@ static string makeName(SgSymbol* var, map<SgSymbol*, set< SgSymbol*>>& modVarsTo
     return name;
 }
 
-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();
@@ -1492,21 +1395,22 @@ static string getInterfaceBlock(SgStatement* func, const FuncParam& pars)
         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());
+
+    const set<string> ident(pars.identificators.begin(), pars.identificators.end());
 
     //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);
+                SgStatement* next = st->lexNext();
-                st = st->lexNext();
+                st->extractStmt();
+                st = next;
             }
             else
                 st = st->lexNext();
@@ -1527,20 +1431,31 @@ static string getInterfaceBlock(SgStatement* func, const FuncParam& pars)
     st = copy->lexNext();
     while (st != last)
     {
-        const int var = st->variant();
+        if (st->variant() == VAR_DECL
+            || st->variant() == VAR_DECL_90
+            || st->variant() == DIM_STAT
+            || st->variant() == INTENT_STMT)
+        {
+            SgExpression* list = st->expr(0);
+            vector<SgExpression*> newList;
+            while (list)
+            {
+                if (ident.find(list->lhs()->symbol()->identifier()) != ident.end())
+                    newList.push_back(list->lhs());
+                list = list->rhs();
+            }
 
-        if (var == VAR_DECL || var == VAR_DECL_90 || var == DIM_STAT ||
+            if (newList.size() == 0)
-            var == INTENT_STMT || var == EXTERN_STAT)
-        {
-            bool empty = filterFromList(st, idents);
-            if (empty)
             {
+                SgStatement* next = st->lexNext();
                 toExtract.push_back(st);
-                st = st->lexNext();
+                st = next;
                 continue;
             }
+            else
+                st->setExpression(0, makeExprList(newList));
         }
-        else if (!isDVM_stat(st) && !isSPF_stat(st))
+        else
             toExtract.push_back(st);
 
         if (st->variant() == CONTAINS_STMT)
@@ -1551,56 +1466,16 @@ static string getInterfaceBlock(SgStatement* func, const FuncParam& pars)
     for (auto& elem : toExtract)
         elem->extractStmt();
 
-    string codeString = copy->unparse();
+    string retVal = copy->unparse();
 
     if (SgFile::switchToFile(oldFile) == -1)
         printInternalError(convertFileName(__FILE__).c_str(), __LINE__);
 
-    //insert tabs
-    const string tab = "    ";
-    const int countEnds = std::count(codeString.begin(), codeString.end(), '\n');
-
-    string retVal = "  ";
-    retVal.reserve(retVal.size() + codeString.size() + countEnds * tab.size());
-
-    for (int z = 0, ends = 0; z < codeString.size(); ++z)
-    {
-        retVal += codeString[z];
-        if (codeString[z] == '\n')
-        {
-            ends++;
-            if (ends == countEnds)
-                continue;
-
-            int p = z + 1;
-            while (codeString[p] == ' ' && p < codeString.size())
-                ++p;
-
-            auto start = p;
-            auto end = string::npos;
-            auto sub = codeString.find("subroutine", p);
-            auto func = codeString.find("function", p);
-            auto end_sub = codeString.find("end subroutine", p);
-            auto end_func = codeString.find("end function", p);
-
-            if (sub != end && sub == start || end_sub != end && end_sub == start ||
-                func != end && func == start || end_func != end && end_func == start)
-            {
-                retVal += "  ";
-            }
-            else
-                retVal += tab;
-        }
-    }
-
     return retVal;
 }
 
-void insertInterface(SgStatement* func, const FuncInfo *callFrom)
+static void insertInterface(SgStatement* func, const string& iface)
 {
-    const string& iface = getInterfaceBlock(callFrom->funcPointer->GetOriginal(), callFrom->funcParams);
-    const string& fName = callFrom->funcName;
-
     string oldFile = current_file->filename();
     if (!func->switchToFile())
         printInternalError(convertFileName(__FILE__).c_str(), __LINE__);
@@ -1609,18 +1484,6 @@ void insertInterface(SgStatement* func, const FuncInfo *callFrom)
     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();
@@ -1628,7 +1491,7 @@ void insertInterface(SgStatement* func, const FuncInfo *callFrom)
     SgStatement* ifaceBlock = new SgStatement(INTERFACE_STMT);
     addControlEndToStmt(ifaceBlock->thebif);
 
-    ifaceBlock->setlineNumber(getNextNegativeLineNumber());
+    ifaceBlock->setlineNumber(st->lineNumber());
     ifaceBlock->setFileName(st->fileName());
     st->insertStmtBefore(*ifaceBlock, *st->controlParent());
     ifaceBlock->lastNodeOfStmt()->addComment(iface.c_str());
@@ -1644,7 +1507,7 @@ static void createInterfaceBlockForToCalls(FuncInfo* func)
         if (callTo->interfaceBlocks.find(func->funcName) == callTo->interfaceBlocks.end())
         {
             callTo->interfaceBlocks[func->funcName] = func;
-            insertInterface(callTo->funcPointer, func);
+            insertInterface(callTo->funcPointer, getInterfaceBlock(func->funcPointer->GetOriginal(), func->funcParams));
         }
     }
 }

src/Transformations/FunctionPurifying/function_purifying.h

@@ -6,6 +6,7 @@ bool checkOutCalls(const std::set<std::string>& outCalls);
 std::map<SgStatement*, std::set<std::string>> fillFromIntent(SgStatement* header);
 void intentInsert(const std::vector<FuncInfo*>& allFuncInfo);
 void intentInsertToInterfaces(const std::map<std::string, std::vector<FuncInfo*>>& allFuncInfo);
+void createInterfacesForAssumedSize(const std::map<std::string, std::vector<FuncInfo*>>& allFuncInfo);
 void createInterfacesForOutCalls(FuncInfo* func);
 void setPureStatus(const std::set<FuncInfo*>& funcInfo);
 void setPureStatus(const std::map<std::string, std::vector<FuncInfo*>>& allFuncInfo);
@@ -13,7 +14,3 @@ void setPureStatus(const std::map<std::string, std::vector<FuncInfo*>>& allFuncI
 void commonTransfer(const std::map<std::string, std::vector<FuncInfo*>>& allFuncInfo, const std::map<std::string, CommonBlock*>& commonBlocks);
 void saveTransfer(const std::map<std::string, std::vector<FuncInfo*>>& allFuncInfo);
 void moduleTransfer(const std::map<std::string, std::vector<FuncInfo*>>& allFuncInfo);
-
-void insertInterface(SgStatement* func, const FuncInfo* callFrom);
-
-void transformAssumedSizeParameters(const std::map<std::string, std::vector<FuncInfo*>>& allFuncInfo);

src/Transformations/LoopCombining/loops_combiner.cpp

@@ -20,7 +20,7 @@ using std::wstring;
 
 static SgSymbol* getLoopSymbol(const LoopGraph* loop)
 {
-    if (!loop || !loop->isFor())
+    if (!loop || !loop->isFor)
         return NULL;
 
     SgForStmt* stmt = (SgForStmt*)loop->loop->GetOriginal();
@@ -667,12 +667,12 @@ static void renameIterationVariables(LoopGraph* loop, const map<SgSymbol*, SgSym
 {
     if (loop)
     {
-        const string& loopName = loop->loopSymbol();
+        string& loopName = loop->loopSymbol;
-        for (auto& [from, to] : symbols)
+        for (auto& pair : symbols)
         {
-            if (from->identifier() == loopName)
+            if (pair.first->identifier() == loopName)
             {
-                loop->loopSymbols.replaceMainVar(to->identifier());
+                loop->loopSymbol = (string)pair.second->identifier();
                 break;
             }
         }
@@ -691,9 +691,9 @@ static void renameVariablesInLoop(LoopGraph* loop, const map<SgSymbol*, SgSymbol
         if (st->variant() == FOR_NODE)
         {
             SgForStmt* for_st = (SgForStmt*)st;
-            for (auto& [from, to] : symbols)
+            for (auto& pair : symbols)
-                if (isEqSymbols(from, for_st->symbol()))
+                if (isEqSymbols(pair.first, for_st->symbol()))
-                    for_st->setDoName(*to);
+                    for_st->setDoName(*pair.second);
         }
 
         for (int i = 0; i < 3; ++i)
@@ -710,12 +710,12 @@ static void renamePrivatesInMap(LoopGraph* loop, const map<SgSymbol*, SgSymbol*>
         for (auto& priv : privates->second)
         {
             bool found = false;
-            for (auto& [from, to] : symbols)
+            for (auto& pair : symbols)
             {
-                if (isEqSymbols(priv, from))
+                if (isEqSymbols(priv, pair.first))
                 {
                     found = true;
-                    newList.insert(to);
+                    newList.insert(pair.second);
                     break;
                 }
             }
@@ -1590,7 +1590,7 @@ static bool combine(LoopGraph* firstLoop, const vector<LoopGraph*>& nextLoops, s
     bool wasCombine = false;
     for (LoopGraph* loop : nextLoops)
     {
-        if (!loop->isFor())
+        if (!loop->isFor)
             return wasCombine;
 
         int perfectLoop = std::min(firstLoop->perfectLoop, loop->perfectLoop);
@@ -1723,7 +1723,7 @@ static bool tryToCombine(vector<LoopGraph*>& loopGraphs, map<LoopGraph*, set<SgS
     {
         LoopGraph* loop = loops[z];
         newloopGraphs.push_back(loop);
-        if (!loop->isFor())
+        if (!loop->isFor)
             continue;
 
         vector<LoopGraph*> nextLoops = getNextLoops(loop, loopGraphs, -1);

src/Transformations/LoopSplitting/loops_splitter.cpp

@@ -6,7 +6,7 @@
 #include "../LoopAnalyzer/loop_analyzer.h"
 #include "expr_transform.h"
 #include "errors.h"
-#include "CFGraph/CFGraph.h"
+#include "../CFGraph/CFGraph.h"
 #include "../SageAnalysisTool/OmegaForSage/include/lang-interf.h"
 #include "../DirectiveProcessing/directive_parser.h"
 #include "../DirectiveProcessing/directive_omp_parser.h"
@@ -1035,7 +1035,7 @@ int splitLoops(SgFile *file, vector<LoopGraph*> &loopGraphs, vector<Messages> &m
 
     for (auto &loopPair : mapLoopGraph)
     {
-        if (!loopPair.second->isFor())
+        if (!loopPair.second->isFor)
             continue;
 
         LoopGraph *loop = loopPair.second;

src/Transformations/PrivateArrayRemoving/private_removing.cpp

@@ -2257,7 +2257,7 @@ void removePrivatesAnalysis(string filename,
 {
     for (LoopGraph* loop : loopGraphs)
     {
-        if (!loop->isFor())
+        if (!loop->isFor)
             continue;
 
         SgForStmt* loopStmt = (SgForStmt*)loop->loop->GetOriginal();

src/Transformations/PrivateArrayRemoving/private_removing.h

@@ -2,8 +2,8 @@
 
 #include "dvm.h"
 #include "../DirectiveProcessing/directive_parser.h"
-#include "CFGraph/CFGraph.h"
+#include "../CFGraph/CFGraph.h"
-#include "CFGraph/RD_subst.h"
+#include "../CFGraph/RD_subst.h"
 
 // Regime defines the regime of private removing
 enum class Regime { DEFLT = 1, REGULAR_INDEXES };

src/Transformations/PrivateArrayResizing/private_arrays_resizing.cpp

@@ -74,7 +74,7 @@ static void fillIterationVariables(const LoopGraph* loop, set<string>& vars, int
 {
     if (dimensions == -1)
     {
-        vars.insert(loop->loopSymbol());
+        vars.insert(loop->loopSymbol);
         for (LoopGraph* child : loop->children)
             fillIterationVariables(child, vars);
     }
@@ -82,7 +82,7 @@ static void fillIterationVariables(const LoopGraph* loop, set<string>& vars, int
     {
         for (int i = 0; i < dimensions; ++i)
         {
-            vars.insert(loop->loopSymbol());
+            vars.insert(loop->loopSymbol);
             if (i != dimensions - 1)
                 loop = loop->children[0];
         }

src/Transformations/ReplaceArraysInIO/replace_dist_arrays_in_io.cpp

@@ -17,157 +17,6 @@ using std::pair;
 
 #define DEBUG_TRACE 0
 
-static bool hasArrayRef(SgExpression* ex)
-{
-    if (ex)
-        return isArrayRef(ex) || hasArrayRef(ex->lhs()) || hasArrayRef(ex->rhs());
-
-    return false;
-}
-
-static inline bool isArrayDeclaration(SgStatement* st)
-{
-    return isSgDeclarationStatement(st) || isSgVarListDeclStmt(st) || isSgNestedVarListDeclStmt(st);
-}
-
-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;
-}
-
-static bool switchToDeclarationFile(DIST::Array* array_p, 
-                                    pair<string, int>& decl_place, 
-                                    const string &current_file_name,
-                                    FuncInfo *current_func)
-{
-    if (!array_p)
-        return false;
-
-    // try to find declaration from current function
-    for (const auto &p : array_p->GetDeclInfo())
-    {
-        if (p.first == current_file_name && 
-            current_func->linesNum.first <= p.second && 
-            p.second <= current_func->linesNum.second)
-        {
-            decl_place = p;
-            return true;
-        }
-    }
-
-    for (const auto &p : array_p->GetDeclInfo())
-    {
-        if (SgFile::switchToFile(p.first) != -1)
-        {
-            decl_place = p;
-            return true;
-        }
-    }
-
-    return false;
-}
-
-static bool checkAssumedShape(SgStatement* decl, const string& array_name)
-{
-    SgExpression* list = decl->expr(0);
-    SgExpression* dim_list = NULL;
-
-    while (list)
-    {
-        auto *arr_ref = list->lhs();
-
-        if (arr_ref && 
-            arr_ref->symbol() && 
-            arr_ref->symbol()->identifier() && 
-            arr_ref->symbol()->identifier() == array_name)
-        {
-            dim_list = arr_ref->lhs();
-            break;
-        }
-
-        list = list->rhs();
-    }
-
-    if (!dim_list)
-    {
-        auto *dim_expr = findExprWithVariant(decl->expr(2), DIMENSION_OP);
-        if (dim_expr)
-            dim_list = dim_expr->lhs();
-    }
-
-    while (dim_list)
-    {
-        auto *lhs = dim_list->lhs();
-
-        if (lhs && lhs->variant() == DDOT && (!lhs->lhs() || !lhs->rhs()))
-            return true;
-
-        dim_list = dim_list->rhs();
-    }
-
-    return false;
-}
-
-static bool checkAssumedSize(const string &array_name, DIST::Array* array_p, const string &current_file_name, FuncInfo *current_func)
-{
-    if (!array_p)
-        return true; // raise true to prevent array from copying
-
-    bool found = false;
-
-    pair<string, int> decl_place;
-
-    if (!switchToDeclarationFile(array_p, decl_place, current_file_name, current_func))
-        return true;
-
-    auto *st = SgStatement::getStatementByFileAndLine(decl_place.first, decl_place.second);
-    checkNull(st, convertFileName(__FILE__).c_str(), __LINE__);
-    
-    SgExpression* list = st->expr(0);    
-    while (list)
-    {
-        if (list->lhs() && 
-            list->lhs()->symbol() && 
-            list->lhs()->symbol()->identifier() && 
-            list->lhs()->symbol()->identifier() == array_name
-        )
-        {
-            if(findExprWithVariant(list->lhs(), STAR_RANGE))
-                found = true;
-
-            break;
-        }
-
-        list = list->rhs();
-    }
-
-    if (!found)
-    {
-        auto *dim_expr = findExprWithVariant(st->expr(2), DIMENSION_OP);
-        if (dim_expr && findExprWithVariant(dim_expr, STAR_RANGE))
-            found = true;
-    }
-
-    if (SgFile::switchToFile(current_file_name) == -1)
-        printInternalError(convertFileName(__FILE__).c_str(), __LINE__); // can't switch back to file with array usage
-
-    return found;
-}
-
 static void findArrays(SgExpression* exp, set<SgSymbol*>& arrays)
 {
     if (exp)
@@ -180,15 +29,12 @@ static void findArrays(SgExpression* exp, set<SgSymbol*>& arrays)
     }
 }
 
-static bool populateDistributedIoArrays(map<SgSymbol*, set<SgStatement*>>& arrays, 
+static void populateDistributedIoArrays(map<SgSymbol*, set<SgStatement*>>& arrays, SgStatement* stat)
-                                        SgStatement* stat, 
-                                        const string& current_file_name,
-                                        FuncInfo *current_func)
 {
     auto var = stat->variant();
 
     if (var != READ_STAT && var != PRINT_STAT && var != WRITE_STAT)
-        return false;
+        return;
 
     // check if such IO allowed in dvm: 
     // list should consist only of single array and format string should be *
@@ -198,28 +44,24 @@ static bool populateDistributedIoArrays(map<SgSymbol*, set<SgStatement*>>& array
     SgExpression* ioList = stat->expr(0);
 
     if (!ioList)
-        return false;
+        return;
 
     if (ioList->variant() != EXPR_LIST)
-        return false;
+        return;
 
     if (ioList->rhs() == NULL)
     {
         SgExpression* arg = ioList->lhs();
         if (!arg)
-            return false;
+            return;
 
-        if (hasArrayRef(arg))
+        if (!isArrayRef(arg))
-        {
+            return;
-            if (isArrayRef(arg) && arg->lhs())
+
+        if (arg->lhs())
             need_replace = true;
     }
     else
-        {
-            return false;
-        }
-    }
-    else
     {
         need_replace = true;
     }
@@ -232,11 +74,15 @@ static bool populateDistributedIoArrays(map<SgSymbol*, set<SgStatement*>>& array
         {
             SgExpression* fmt = stat->expr(1);
             if (!fmt || fmt->variant() != SPEC_PAIR || fmt->lhs()->variant() != KEYWORD_VAL)
+            {
                 printInternalError(convertFileName(__FILE__).c_str(), __LINE__);
+                return;
+            }
 
             if (fmt->rhs()->variant() != KEYWORD_VAL || fmt->rhs()->sunparse() != "*")
                 need_replace = true;
 
+
             break;
         }
         case READ_STAT:
@@ -258,7 +104,10 @@ static bool populateDistributedIoArrays(map<SgSymbol*, set<SgStatement*>>& array
                 {
                     auto *kv = spec->lhs();
                     if (!kv || kv->variant() != SPEC_PAIR || !kv->rhs())
+                    {
                         printInternalError(convertFileName(__FILE__).c_str(), __LINE__);
+                        return;
+                    }
 
                     if (kv->rhs()->variant() != KEYWORD_VAL || kv->rhs()->sunparse() != "*")
                     {
@@ -269,7 +118,6 @@ static bool populateDistributedIoArrays(map<SgSymbol*, set<SgStatement*>>& array
                     spec = spec->rhs();
                 }
             }
-            break;
         }
         default:
             break;
@@ -277,9 +125,7 @@ static bool populateDistributedIoArrays(map<SgSymbol*, set<SgStatement*>>& array
     }
 
     if (!need_replace)
-        return false;
+        return;
-
-    bool ret = false;
 
     set<SgSymbol*> found_arrays;
 
@@ -290,21 +136,11 @@ static bool populateDistributedIoArrays(map<SgSymbol*, set<SgStatement*>>& array
     {
         string array_name = string(by_symb->identifier());
         DIST::Array* array_p = getArrayFromDeclarated(declaratedInStmt(by_symb), array_name);
-        if (array_p && 
+        if (array_p && array_p->GetDistributeFlagVal() == Distribution::distFlag::IO_PRIV && arrays[by_symb].insert(stat).second)
-            array_p->GetDistributeFlagVal() == Distribution::distFlag::IO_PRIV && 
+            __spf_print(DEBUG_TRACE, "[%d]: add array %s\n", stat->lineNumber(), array_p->GetName().c_str());
-            !checkAssumedSize(array_name, array_p, current_file_name, current_func))
-        {
-            auto inserted = arrays[by_symb].insert(stat).second;
-
-            if (inserted)
-                __spf_print(DEBUG_TRACE, "[%d]: add array %s %p\n", stat->lineNumber(), array_p->GetName().c_str(), by_symb);
-
-            ret = true;
-        }
     }
 
     __spf_print(DEBUG_TRACE, "[replace]\n");
-    return ret;
 }
 
 static void replaceArrayRec(SgSymbol* arr, SgSymbol* replace_by, SgExpression* exp, bool& has_read, bool& has_write, bool from_read, bool from_write)
@@ -374,12 +210,7 @@ static void replaceArrayRec(SgSymbol* arr, SgSymbol* replace_by, SgStatement* st
     }
 }
 
-static void copyArrayBetweenStatements(SgSymbol* replace_symb, 
+static void copyArrayBetweenStatements(SgSymbol* replace_symb, SgSymbol* replace_by, SgStatement* start, SgStatement* last, bool start_is_scope)
-                                       SgSymbol* replace_by,
-                                       SgStatement* start, 
-                                       SgStatement* last, 
-                                       bool start_is_scope,
-                                       FuncInfo *func_info)
 {
     while (start->lexNext() && !isSgExecutableStatement(start->lexNext()))
         start = start->lexNext();
@@ -398,23 +229,10 @@ static void copyArrayBetweenStatements(SgSymbol* replace_symb,
         auto* parent = start_is_scope ? start : start->controlParent();
         if (parent && parent->lastNodeOfStmt() == start)
             parent = parent->controlParent();
-        checkNull(parent, convertFileName(__FILE__).c_str(), __LINE__);
 
         start->insertStmtAfter(*assign, *parent);
     }
 
-    if (has_write)
-    {
-        for (int i = 0; i < func_info->funcParams.identificators.size(); i++)
-        {
-            if (func_info->funcParams.identificators[i] == replace_symb->identifier())
-            {
-                has_write &= func_info->funcParams.isArgOut(i);
-                break;
-            }
-        }
-    }
-
     if (has_write)
     {
         // A = A_reg
@@ -425,14 +243,9 @@ static void copyArrayBetweenStatements(SgSymbol* replace_symb,
     }
 }
 
-static void replaceArrayInFragment(SgSymbol* replace_symb, 
+static void replaceArrayInFragment(SgSymbol* replace_symb, const set<SgStatement*> usages, SgSymbol* replace_by, SgStatement* start, SgStatement* last, const string& filename)
-                                   const set<SgStatement*> usages, 
-                                   SgSymbol* replace_by, 
-                                   SgStatement* start, 
-                                   SgStatement* last, 
-                                   FuncInfo *func_info)
 {
-    while (start->lexNext() && (!isSgExecutableStatement(start->lexNext()) || start->lexNext()->variant() == ALLOCATE_STMT))
+    while (start->lexNext() && !isSgExecutableStatement(start->lexNext()))
         start = start->lexNext();
 
     set<SgStatement*> not_opened, not_closed, copied;
@@ -499,7 +312,7 @@ static void replaceArrayInFragment(SgSymbol* replace_symb,
         }
 
         __spf_print(DEBUG_TRACE, "[copy %s] [%d, %d]\n", replace_symb->identifier(), scope_start->lineNumber(), scope_end->lineNumber());
-        copyArrayBetweenStatements(replace_symb, replace_by, scope_start, scope_end, copy_scope == scope_start, func_info);
+        copyArrayBetweenStatements(replace_symb, replace_by, scope_start, scope_end, copy_scope == scope_start);
         copied.insert(copy_scope);
     }
 }
@@ -522,16 +335,12 @@ static bool ioReginBorder(SgStatement* stat, SgStatement* last_io_bound)
         STOP_STAT,
         STOP_NODE,
         EXIT_STMT,
-        EXIT_NODE,
+        EXIT_NODE
-        GOTO_NODE
     };
 
     if (border_stats.find(var) != border_stats.end())
         return true;
 
-    if (stat->hasLabel())
-        return true;
-
     if (last_io_bound && last_io_bound->lastNodeOfStmt() && last_io_bound->lastNodeOfStmt() == stat)
         return true;
 
@@ -555,29 +364,26 @@ void replaceDistributedArraysInIO(vector<ParallelRegion*>& regions,
     {
         __spf_print(DEBUG_TRACE, "[%s]: enter region\n", region->GetName().c_str());
 
-        for (auto& lines_by_file : region->GetAllLinesToModify())
+        for (auto& linesByFile : region->GetAllLinesToModify())
         {
-            const auto& current_file_name = lines_by_file.first;
+            const auto& filename = linesByFile.first;
 
-            if (SgFile::switchToFile(current_file_name) == -1)
+            if (SgFile::switchToFile(filename) < 0)
-                printInternalError(convertFileName(__FILE__).c_str(), __LINE__);
-
-            auto func_info_it = allFuncInfo.find(current_file_name);
-            if (func_info_it == allFuncInfo.end())
-                printInternalError(convertFileName(__FILE__).c_str(), __LINE__);
-
-            auto *lbound_symb = new SgSymbol(FUNCTION_NAME, "lbound");
-            auto *ubound_symb = new SgSymbol(FUNCTION_NAME, "ubound");
-
-            for (auto& lines : lines_by_file.second)
             {
-                __spf_print(DEBUG_TRACE, "[fragment] %s: %d:%d %d\n", current_file_name.c_str(), lines.lines.first,
+                printInternalError(convertFileName(__FILE__).c_str(), __LINE__);
+                return;
+            }
+
+            for (auto& lines : linesByFile.second)
+            {
+                __spf_print(DEBUG_TRACE, "[fragment] %s: %d:%d %d\n", filename.c_str(), lines.lines.first,
                     lines.lines.second, lines.isImplicit());
 
                 SgStatement* curr_stmt, * end;
 
                 if (lines.isImplicit())
                 {
+
                     curr_stmt = current_file->SgStatementAtLine(lines.lines.first);
                     end = current_file->SgStatementAtLine(lines.lines.second);
 
@@ -593,7 +399,6 @@ void replaceDistributedArraysInIO(vector<ParallelRegion*>& regions,
                 map<SgSymbol*, set<SgStatement*>> need_replace;
                 SgStatement* last_io_bound = NULL;
 
-                FuncInfo *current_func_info = NULL;
 
                 while (curr_stmt != end)
                 {
@@ -602,21 +407,9 @@ void replaceDistributedArraysInIO(vector<ParallelRegion*>& regions,
 
                     auto var = curr_stmt->variant();
 
+
                     if (var == PROC_HEDR || var == PROG_HEDR || var == FUNC_HEDR)
                     {
-                        current_func_info = NULL;
-                        for (auto *func_info : func_info_it->second)
-                        {
-                            if (func_info->funcName == curr_stmt->symbol()->identifier())
-                            {
-                                current_func_info = func_info;
-                                break;
-                            }
-                        }
-
-                        if (!current_func_info)
-                            printInternalError(convertFileName(__FILE__).c_str(), __LINE__);
-
                         curr_stmt = curr_stmt->lexNext();
                         while (curr_stmt && !isSgExecutableStatement(curr_stmt))
                         {
@@ -640,192 +433,77 @@ void replaceDistributedArraysInIO(vector<ParallelRegion*>& regions,
                                 string array_name = string(array_to_copy->identifier());
                                 DIST::Array* array_p = getArrayFromDeclarated(declaratedInStmt(array_to_copy), array_name);
 
-                                // at this point all considered arrays must have DIST::Array* references
+                                bool fromModule = (array_p->GetLocation().first == DIST::l_MODULE);
-                                if (!array_p)
+                                const string locationName = array_p->GetLocation().second;
-                                    printInternalError(convertFileName(__FILE__).c_str(), __LINE__);
-
-                                // ... and be declared in switchable files (not in headers)
-                                pair<string, int> decl_place;
-                                if (!switchToDeclarationFile(array_p, decl_place, current_file_name, current_func_info))
-                                    printInternalError(convertFileName(__FILE__).c_str(), __LINE__);
 
+                                auto place = *array_p->GetDeclInfo().begin();
+                                string fileName = place.first;
                                 string suffix = "_io_l";
 
-                                switch (array_p->GetLocation().first)
+                                if (fromModule)
-                                {
-                                    case DIST::l_MODULE:
                                     suffix = "_io_m";
-                                        break;
-                                    case DIST::l_COMMON:
-                                        suffix = "_io_c";
-                                        break;
-                                }
 
-                                auto copied_symbol = copyArray(decl_place, 
+                                pair<SgSymbol*, SgSymbol*> copied;
-                                                               array_p, 
+                                copied.first = array_to_copy;
-                                                               lines_by_file.second, 
-                                                               suffix + to_string(region->GetId()), 
-                                                               decl_place.first, 
-                                                               newDeclsToInclude, 
-                                                               copied_syms);
 
-                                // original declaration statement
+                                if (SgFile::switchToFile(fileName) == -1)
-                                auto *decl_stmt = SgStatement::getStatementByFileAndLine(decl_place.first, decl_place.second);
-
-                                if (!decl_stmt || !isArrayDeclaration(decl_stmt))
-                                    printInternalError(convertFileName(__FILE__).c_str(), __LINE__);
-
-                                auto dynamic_array = checkAssumedShape(decl_stmt, array_name);  
-
-                                while (decl_stmt && !isSgExecutableStatement(decl_stmt))
                                 {
-                                    if (isArrayDeclaration(decl_stmt) &&
+                                    auto* func_stmt = curr_stmt->getScopeForDeclare();
-                                        decl_stmt->expr(0) &&
+
-                                        decl_stmt->expr(0)->lhs() &&
+                                    SgStatement* insertPlace = NULL;
-                                        decl_stmt->expr(0)->lhs()->symbol() == copied_symbol.second)
+                                    for (auto iterator = func_stmt->lexNext();
+                                        !isSgExecutableStatement(iterator) || isSPF_stat(iterator) &&
+                                        !(iterator->variant() == SPF_PARALLEL_REG_DIR || iterator->variant() == SPF_END_PARALLEL_REG_DIR);
+                                        iterator = iterator->lexNext())
                                     {
-                                        break;
+                                        insertPlace = iterator;
                                     }
 
-                                    decl_stmt = decl_stmt->lexNext();
+                                    //NULL - no decl stats in function!
+                                    if (!insertPlace)
+                                        insertPlace = func_stmt;
+
+                                    auto st = insertPlace->controlParent();
+                                    if (st->variant() == GLOBAL)
+                                        st = insertPlace;
+
+                                    auto& copied_symb = array_to_copy->copy();
+                                    copied.second = &copied_symb;
+
+                                    auto new_name = string(array_to_copy->identifier()) + "_io_c";
+                                    copied_symb.changeName(new_name.c_str());
+
+                                    auto stat = array_to_copy->makeVarDeclStmt();
+                                    auto res = CalculateInteger(stat->expr(0)->copyPtr());
+                                    res->lhs()->setSymbol(copied_symb);
+                                    stat->setExpression(0, res);
+
+                                    insertPlace->insertStmtAfter(*stat, *st);
+                                }
+                                else
+                                {
+                                    copied = copyArray(place, array_p, linesByFile.second, suffix + to_string(region->GetId()), fileName, newDeclsToInclude, copied_syms);
                                 }
 
-                                // created declaration statement
+                                SgStatement* decl = SgStatement::getStatementByFileAndLine(place.first, place.second);
-                                if (!decl_stmt || !isArrayDeclaration(decl_stmt))
-                                    printInternalError(convertFileName(__FILE__).c_str(), __LINE__);
 
-                                // insert !$SPF ANALYSIS(PROCESS_PRIVATE(array)) directive before declaration statement
+                                if (decl)
+                                    decl = decl->lexNext();
 
+                                if (decl)
+                                {
                                     string dir_str;
-                                if (decl_stmt->comments())
+                                    if (decl->comments())
                                     {
-                                    auto str_comment = string(decl_stmt->comments());
+                                        string str_comment = string(decl->comments());
                                         if (str_comment.size() && str_comment.back() != '\n')
                                             dir_str += "\n";
                                     }
 
-                                dir_str += "!$SPF ANALYSIS(PROCESS_PRIVATE(" + string(copied_symbol.second->identifier()) + "))\n";
+                                    dir_str += "!$SPF ANALYSIS(PROCESS_PRIVATE(" + string(copied.second->identifier()) + "))\n";
-                                decl_stmt->addComment(dir_str.c_str());
+                                    decl->addComment(dir_str.c_str());
-                            
-                                created_copies.insert({ array_to_copy, copied_symbol.second });
-
-                                // make array copy allocatable in case of assumed-shape array
-                                if(dynamic_array)
-                                {
-                                    // insert allocatable keyword in declaration
-                                    auto *kword_list = decl_stmt->expr(2);
-                                    if (!findExprWithVariant(kword_list, ALLOCATABLE_OP))
-                                    {
-                                        if (!kword_list)
-                                        {
-                                            kword_list = new SgExprListExp();
-                                            decl_stmt->setExpression(2, *kword_list);
                                 }
-                                        
+                                created_copies.insert({ array_to_copy, copied.second });
-                                        while (kword_list->rhs())
-                                            kword_list = kword_list->rhs();
-                                        
-                                        if (kword_list->lhs())
-                                        {
-                                            kword_list->setRhs(new SgExprListExp());
-                                            kword_list = kword_list->rhs();
-                                        }
-
-                                        kword_list->setLhs(new SgExpression(ALLOCATABLE_OP));
-                                    }
-
-                                    // can't switch back to file with array usage
-                                    if (SgFile::switchToFile(current_file_name) == -1)
-                                        printInternalError(convertFileName(__FILE__).c_str(), __LINE__); 
-                                        
-                                    // insert allocate(a_l(lbound(a, 1):ubound(a,1),...)) statement
-                                    SgStatement* allocate_stmt_place = NULL;
-
-                                    auto* func_stmt = curr_stmt->getScopeForDeclare();
-                                    for (auto iterator = func_stmt->lexNext();
-                                        iterator && !isSgExecutableStatement(iterator);
-                                        iterator = iterator->lexNext())
-                                    {
-                                            allocate_stmt_place = iterator;
-                                    }
-
-                                    //NULL - no decl stats in function!
-                                    if (!allocate_stmt_place)
-                                        allocate_stmt_place = func_stmt;
-
-                                    auto *allocate_stmt_parent = allocate_stmt_place->controlParent();
-                                    if (allocate_stmt_parent->variant() == GLOBAL)
-                                        allocate_stmt_parent = allocate_stmt_place;
-                                    
-                                    auto *created_array_ref = new SgArrayRefExp(*copied_symbol.second);
-
-                                    auto* dim_list = new SgExprListExp();
-                                    created_array_ref->setLhs(dim_list);
-                                    
-                                    int dim_len = array_p->GetSizes().size();
-                                    for (int i = 1; i <= dim_len; i++)
-                                    {
-                                        auto *lcall = new SgFunctionCallExp(*lbound_symb);
-                                        auto *rcall = new SgFunctionCallExp(*ubound_symb);
-                                        
-                                        for (auto *call : {lcall, rcall})
-                                        {
-                                            call->setLhs(new SgExprListExp());
-
-                                            call->lhs()->setLhs(new SgArrayRefExp(*array_to_copy));
-                                            call->lhs()->setRhs(new SgValueExp(i));
-                                        }
-                                        
-                                        auto *dot_expr = new SgExpression(DDOT);
-                                        dot_expr->setLhs(lcall);
-                                        dot_expr->setRhs(rcall);
-
-                                        dim_list->setLhs(dot_expr);
-
-                                        if (i < dim_len)
-                                        {
-                                            auto *next = new SgExprListExp();
-                                            dim_list->setRhs(next);
-                                            dim_list = next;
-                                        }
-                                    }
-
-                                    auto *allocate_stmt = new SgStatement(ALLOCATE_STMT);
-                                    allocate_stmt->setExpression(0, created_array_ref);
-
-                                    allocate_stmt_place->insertStmtAfter(*allocate_stmt, *allocate_stmt_parent);
-
-                                    // insert deallocate statemens before all returns
-                                    auto *find_return_stmt = func_stmt;
-                                    while (find_return_stmt != func_stmt->lastNodeOfStmt())
-                                    {
-                                        auto *next = find_return_stmt->lexNext();
-                                        if (next && (isSgReturnStmt(next) || next == func_stmt->lastNodeOfStmt()))
-                                        {
-                                            if (next->hasLabel())
-                                            {
-                                                moveLabelBefore(next);
-                                                find_return_stmt = next->lexPrev();
-                                            }
-                                            
-                                            auto *dealloc_stmt = new SgStatement(DEALLOCATE_STMT);
-
-                                            dealloc_stmt->setExpression(0, new SgExprListExp());
-                                            dealloc_stmt->expr(0)->setLhs(new SgArrayRefExp(*copied_symbol.second));
-
-                                            find_return_stmt->insertStmtAfter(*dealloc_stmt, *next->controlParent());
-
-                                            if (next == curr_stmt)
-                                                curr_stmt = dealloc_stmt;
-                                        }
-
-                                        find_return_stmt = next;
-                                    }
-                                }
-
-                                // can't switch back to file with array usage
-                                if (SgFile::switchToFile(current_file_name) == -1)
-                                    printInternalError(convertFileName(__FILE__).c_str(), __LINE__); 
                             }
                         }
 
@@ -837,9 +515,12 @@ void replaceDistributedArraysInIO(vector<ParallelRegion*>& regions,
                             {
                                 auto it = created_copies.find(p.first);
                                 if (it != created_copies.end())
-                                    replaceArrayInFragment(p.first, p.second, it->second, last_io_bound, curr_stmt, current_func_info);
+                                    replaceArrayInFragment(p.first, p.second, it->second, last_io_bound, curr_stmt, filename);
                                 else
+                                {
                                     printInternalError(convertFileName(__FILE__).c_str(), __LINE__);
+                                    return;
+                                }
                             }
                         }
 
@@ -857,17 +538,7 @@ void replaceDistributedArraysInIO(vector<ParallelRegion*>& regions,
                         }
                     }
 
-                    auto need_fix_io = populateDistributedIoArrays(need_replace, curr_stmt, current_file_name, current_func_info);
+                    populateDistributedIoArrays(need_replace, curr_stmt);
-                    
-                    // incorrect IO statement with label
-                    // move label to dummy statement and insert copy statements between dummy statement and IO
-                    if (need_fix_io && curr_stmt->hasLabel())
-                    {
-                        moveLabelBefore(curr_stmt);
-                        if (last_io_bound == curr_stmt) // always true
-                            last_io_bound = curr_stmt->lexPrev();
-                    }
-
                     curr_stmt = curr_stmt->lexNext();
                 }
             }

src/Transformations/SwapOperators/swap_operators.cpp

@@ -1,299 +0,0 @@
-#include <map>
-#include <unordered_set>
-#include <vector>
-#include <queue>
-#include <iostream>
-#include <algorithm>
-
-#include "../../Utils/errors.h"
-#include "../../Utils/SgUtils.h"
-#include "../../GraphCall/graph_calls.h"
-#include "../../GraphCall/graph_calls_func.h"
-#include "../../CFGraph/CFGraph.h"
-#include "../../CFGraph/IR.h"
-#include "../../GraphLoop/graph_loops.h"
-#include "swap_operators.h"
-
-using namespace std;
-
-string getNameByArg(SAPFOR::Argument* arg);
-SgSymbol* getSybolByArg(SAPFOR::Argument* arg);
-
-static vector<SAPFOR::IR_Block*> findInstructionsFromOperator(SgStatement* st, vector<SAPFOR::BasicBlock*> Blocks) {
-    vector<SAPFOR::IR_Block*> result;
-    string filename = st->fileName();
-    
-    for (auto& block: Blocks) {
-        vector<SAPFOR::IR_Block*> instructionsInBlock = block->getInstructions();
-        for (auto& instruction: instructionsInBlock) {
-            SgStatement* curOperator = instruction->getInstruction()->getOperator();
-            // Match by line number to find corresponding IR instruction
-            if (curOperator->lineNumber() == st->lineNumber()) {
-                result.push_back(instruction);
-            }
-        }
-    }
-    return result;
-}
-
-unordered_set<int> loop_tags = {FOR_NODE};
-unordered_set<int> control_tags = {IF_NODE, ELSEIF_NODE, DO_WHILE_NODE, WHILE_NODE};
-unordered_set<int> control_end_tags = {CONTROL_END};
-
-struct OperatorInfo {
-    SgStatement* stmt;
-    set<string> usedVars;
-    set<string> definedVars;
-    int lineNumber;
-    bool isMovable;
-    OperatorInfo(SgStatement* s) : stmt(s), lineNumber(s->lineNumber()), isMovable(true) {}
-};
-
-static vector<OperatorInfo> analyzeOperatorsInLoop(SgForStmt* loop, vector<SAPFOR::BasicBlock*> blocks, map<FuncInfo*, vector<SAPFOR::BasicBlock*>>& FullIR) {
-    vector<OperatorInfo> operators;
-    SgStatement* loopStart = loop->lexNext();
-    SgStatement* loopEnd = loop->lastNodeOfStmt();
-    
-    SgStatement* current = loopStart;
-    while (current && current != loopEnd) {
-        if (isSgExecutableStatement(current)) {
-            OperatorInfo opInfo(current);
-            
-            vector<SAPFOR::IR_Block*> irBlocks = findInstructionsFromOperator(current, blocks);
-            for (auto irBlock : irBlocks) {
-                SAPFOR::Instruction* instr = irBlock->getInstruction();
-                
-                if (instr->getArg1()) {
-                    string varName = getNameByArg(instr->getArg1());
-                    if (!varName.empty()) {
-                        opInfo.usedVars.insert(varName);
-                    }
-                }
-                if (instr->getArg2()) {
-                    string varName = getNameByArg(instr->getArg2());
-                    if (!varName.empty()) {
-                        opInfo.usedVars.insert(varName);
-                    }
-                }
-                if (instr->getResult()) {
-                    string varName = getNameByArg(instr->getResult());
-                    if (!varName.empty()) {
-                        opInfo.definedVars.insert(varName);
-                    }
-                }
-            }
-            
-            if (control_tags.find(current->variant()) != control_tags.end()) {
-                opInfo.isMovable = false;
-            }
-            
-            operators.push_back(opInfo);
-        }
-        current = current->lexNext();
-    }
-    
-    return operators;
-}
-
-static map<string, vector<SgStatement*>> findVariableDefinitions(SgForStmt* loop, vector<OperatorInfo>& operators) {
-    map<string, vector<SgStatement*>> varDefinitions;
-    
-    for (auto& op : operators) {
-        for (const string& var : op.definedVars) {
-            varDefinitions[var].push_back(op.stmt);
-        }
-    }
-    
-    return varDefinitions;
-}
-
-static int calculateDistance(SgStatement* from, SgStatement* to) {
-    if (!from || !to) return INT_MAX;
-    return abs(to->lineNumber() - from->lineNumber());
-}
-
-static SgStatement* findBestPosition(SgStatement* operatorStmt, vector<OperatorInfo>& operators, map<string, vector<SgStatement*>>& varDefinitions) {
-    OperatorInfo* opInfo = nullptr;
-    for (auto& op : operators) {
-        if (op.stmt == operatorStmt) {
-            opInfo = &op;
-            break;
-        }
-    }
-    
-    if (!opInfo || !opInfo->isMovable) return nullptr;
-    
-    SgStatement* bestPos = nullptr;
-    int minDistance = INT_MAX;
-    
-    for (const string& usedVar : opInfo->usedVars) {
-        if (varDefinitions.find(usedVar) != varDefinitions.end()) {
-            for (SgStatement* defStmt : varDefinitions[usedVar]) {
-                int distance = calculateDistance(operatorStmt, defStmt);
-                if (distance < minDistance) {
-                    minDistance = distance;
-                    bestPos = defStmt;
-                }
-            }
-        }
-    }
-    
-    return bestPos;
-}
-
-static bool canMoveTo(SgStatement* from, SgStatement* to, SgForStmt* loop) {
-    if (!from || !to || from == to) return false;
-    
-    SgStatement* loopStart = loop->lexNext();
-    SgStatement* loopEnd = loop->lastNodeOfStmt();
-    
-    if (to->lineNumber() < loopStart->lineNumber() || to->lineNumber() > loopEnd->lineNumber()) {
-        return false;
-    }
-    
-    SgStatement* current = from;
-    while (current && current != loopEnd) {
-        if (control_tags.find(current->variant()) != control_tags.end()) {
-            return false;
-        }
-        if (current == to) break;
-        current = current->lexNext();
-    }
-    
-    return true;
-}
-
-static vector<SgStatement*> optimizeOperatorOrder(SgForStmt* loop, vector<OperatorInfo>& operators, map<string, vector<SgStatement*>>& varDefinitions) {
-    vector<SgStatement*> newOrder;
-    vector<bool> moved(operators.size(), false);
-    
-    for (size_t i = 0; i < operators.size(); i++) {
-        if (moved[i] || !operators[i].isMovable) {
-            newOrder.push_back(operators[i].stmt);
-            moved[i] = true;
-            continue;
-        }
-        
-        SgStatement* bestPos = findBestPosition(operators[i].stmt, operators, varDefinitions);
-        
-        if (bestPos && canMoveTo(operators[i].stmt, bestPos, loop)) {
-            bool inserted = false;
-            for (size_t j = 0; j < newOrder.size(); j++) {
-                if (newOrder[j] == bestPos) {
-                    newOrder.insert(newOrder.begin() + j + 1, operators[i].stmt);
-                    inserted = true;
-                    break;
-                }
-            }
-            if (!inserted) {
-                newOrder.push_back(operators[i].stmt);
-            }
-        } else {
-            newOrder.push_back(operators[i].stmt);
-        }
-        moved[i] = true;
-    }
-    
-    return newOrder;
-}
-
-static bool applyOperatorReordering(SgForStmt* loop, vector<SgStatement*>& newOrder) {
-    if (!loop || newOrder.empty()) return false;
-    
-    SgStatement* loopStart = loop->lexNext();
-    SgStatement* loopEnd = loop->lastNodeOfStmt();
-    
-    vector<SgStatement*> extractedStatements;
-    vector<char*> savedComments;
-    
-    for (SgStatement* stmt : newOrder) {
-        if (stmt && stmt != loop && stmt != loopEnd) {
-            savedComments.push_back(stmt->comments() ? strdup(stmt->comments()) : nullptr);
-            SgStatement* extracted = stmt->extractStmt();
-            if (extracted) {
-                extractedStatements.push_back(extracted);
-            }
-        }
-    }
-    
-    SgStatement* currentPos = loop;
-    int lineCounter = loop->lineNumber() + 1;
-    
-    for (size_t i = 0; i < extractedStatements.size(); i++) {
-        SgStatement* stmt = extractedStatements[i];
-        if (stmt) {
-            if (i < savedComments.size() && savedComments[i]) {
-                stmt->setComments(savedComments[i]);
-            }
-            stmt->setlineNumber(lineCounter++);
-            currentPos->insertStmtAfter(*stmt, *loop);
-            currentPos = stmt;
-        }
-    }
-    
-    for (char* comment : savedComments) {
-        if (comment) {
-            free(comment);
-        }
-    }
-    
-    if (currentPos && currentPos->lexNext() != loopEnd) {
-        currentPos->setLexNext(*loopEnd);
-    }
-    
-    return true;
-}
-
-vector<SAPFOR::BasicBlock*> findFuncBlocksByFuncStatement(SgStatement *st, map<FuncInfo*, vector<SAPFOR::BasicBlock*>>& FullIR) {
-    vector<SAPFOR::BasicBlock*> result;
-    Statement* forSt = (Statement*)st;
-    for (auto& func: FullIR) {
-        if (func.first -> funcPointer -> getCurrProcessFile() == forSt -> getCurrProcessFile()
-            && func.first -> funcPointer -> lineNumber() == forSt -> lineNumber())
-            result = func.second;
-    }
-    return result;
-}
-
-map<SgForStmt*, vector<SAPFOR::BasicBlock*>> findAndAnalyzeLoops(SgStatement *st, vector<SAPFOR::BasicBlock*> blocks) {
-    map<SgForStmt*, vector<SAPFOR::BasicBlock*>> result;
-    SgStatement *lastNode = st->lastNodeOfStmt();
-    while (st && st != lastNode) {
-        if (loop_tags.find(st -> variant()) != loop_tags.end()) {
-            SgForStmt *forSt = (SgForStmt*)st;
-            SgStatement *loopBody = forSt -> body();
-            SgStatement *lastLoopNode = st->lastNodeOfStmt();
-            unordered_set<int> blocks_nums;
-            while (loopBody && loopBody != lastLoopNode) {
-                SAPFOR::IR_Block* IR = findInstructionsFromOperator(loopBody, blocks).front();
-                if (blocks_nums.find(IR -> getBasicBlock() -> getNumber()) == blocks_nums.end()) {
-                    result[forSt].push_back(IR -> getBasicBlock());
-                    blocks_nums.insert(IR -> getBasicBlock() -> getNumber());
-                }
-                loopBody = loopBody -> lexNext();
-            }
-            std::sort(result[forSt].begin(), result[forSt].end());
-        }
-        st = st -> lexNext();
-    }
-    return result;
-}
-
-void runSwapOperators(SgFile *file, std::map<std::string, std::vector<LoopGraph*>>& loopGraph, std::map<FuncInfo*, std::vector<SAPFOR::BasicBlock*>>& FullIR, int& countOfTransform) {
-    countOfTransform += 1;
-
-    const int funcNum = file -> numberOfFunctions();
-    for (int i = 0; i < funcNum; ++i) {
-        SgStatement *st = file -> functions(i);
-        vector<SAPFOR::BasicBlock*> blocks = findFuncBlocksByFuncStatement(st, FullIR);
-        map<SgForStmt*, vector<SAPFOR::BasicBlock*>> loopsMapping = findAndAnalyzeLoops(st, blocks);
-        
-        for (pair<SgForStmt*, vector<SAPFOR::BasicBlock*>> loopForAnalyze: loopsMapping) {
-            vector<OperatorInfo> operators = analyzeOperatorsInLoop(loopForAnalyze.first, loopForAnalyze.second, FullIR);
-            map<string, vector<SgStatement*>> varDefinitions = findVariableDefinitions(loopForAnalyze.first, operators);
-            
-            vector<SgStatement*> newOrder = optimizeOperatorOrder(loopForAnalyze.first, operators, varDefinitions);
-            applyOperatorReordering(loopForAnalyze.first, newOrder);
-        }
-    }
-}

src/Transformations/SwapOperators/swap_operators.h

@@ -1,6 +0,0 @@
-#pragma once
-
-#include "../../GraphLoop/graph_loops.h"
-#include "../../CFGraph/CFGraph.h"
-
-void runSwapOperators(SgFile *file, std::map<std::string, std::vector<LoopGraph*>>& loopGraph, std::map<FuncInfo*, std::vector<SAPFOR::BasicBlock*>>& FullIR, int& countOfTransform);

src/Utils/PassManager.h

@@ -212,8 +212,6 @@ void InitPassesDependencies(map<passes, vector<passes>> &passDepsIn, set<passes>
 
     Pass(BUILD_IR) <= Pass(SUBST_EXPR_RD) <= Pass(SUBST_EXPR_RD_AND_UNPARSE);
 
-    list({BUILD_IR, CALL_GRAPH2}) <= Pass(SWAP_OPERATORS);
-
     list({ LOOP_ANALYZER_DATA_DIST_S1, SUBST_EXPR_RD } ) <= Pass(PRIVATE_REMOVING_ANALYSIS);
     list({ PRIVATE_REMOVING_ANALYSIS, REVERT_SUBST_EXPR_RD }) <= Pass(PRIVATE_REMOVING);
 
@@ -318,7 +316,9 @@ void InitPassesDependencies(map<passes, vector<passes>> &passDepsIn, set<passes>
 
     list({ VERIFY_INCLUDES, CORRECT_VAR_DECL }) <= Pass(SET_IMPLICIT_NONE);
 
-    list({ CALL_GRAPH2, CALL_GRAPH, BUILD_IR, LOOP_GRAPH, LOOP_ANALYZER_DATA_DIST_S2 }) <= Pass(FIND_PRIVATE_ARRAYS);
+    list({ CALL_GRAPH, LOOP_GRAPH, CALL_GRAPH2, BUILD_IR }) <= Pass(BUILD_IR_SSA_FORM) <= Pass(FIND_IMPLICIT_LOOPS);
+
+    list({ CALL_GRAPH, LOOP_GRAPH, CALL_GRAPH2, BUILD_IR, LOOP_ANALYZER_DATA_DIST_S2 }) <= Pass(FIND_PRIVATE_ARRAYS);
 
     passesIgnoreStateDone.insert({ CREATE_PARALLEL_DIRS, INSERT_PARALLEL_DIRS, INSERT_SHADOW_DIRS, EXTRACT_PARALLEL_DIRS, 
                                    EXTRACT_SHADOW_DIRS, CREATE_REMOTES, UNPARSE_FILE, REMOVE_AND_CALC_SHADOW,

src/Utils/utils.cpp

@@ -390,14 +390,31 @@ void clearGlobalBuffer() { globalOutputBuffer = ""; }
 const string& getGlobalBuffer() { return globalOutputBuffer; }
 
 set<short*> allocated;
+set<int*> allocatedInt;
+static void convertGlobalBuffer(short *&result, int *&resultSize)
+{
+    const unsigned len = (unsigned)globalOutputBuffer.size();
+    result = new short[len + 1];
+    allocated.insert(result);
+
+    result[len] = '\0';
+    for (unsigned i = 0; i < len; ++i)
+        result[i] = globalOutputBuffer[i];
+
+    resultSize = new int[1];
+    resultSize[0] = (int)len;
+}
+
 extern map<string, vector<Messages>> SPF_messages; //file ->messages
 void clearGlobalMessagesBuffer()
 {
     //clear allocated memory
     for (auto& elem : allocated)
         delete[]elem;
+    for (auto& elem : allocatedInt)
+        delete[]elem;
     allocated.clear();
-    
+    allocatedInt.clear();
 
     SPF_messages.clear();
 }
@@ -434,7 +451,7 @@ static map<string, vector<Messages>> removeCopies(map<string, vector<Messages>>
     return out;
 }
 
-static string convertGlobalMessagesBuffer()
+static void convertGlobalMessagesBuffer(short *&result, int *&resultSize)
 {
     auto copySPF_messages = removeCopies(SPF_messages);
     for (auto &byFile : copySPF_messages)
@@ -472,13 +489,21 @@ static string convertGlobalMessagesBuffer()
     json all;
     all["allMessages"] = allMessages;
 
-    return all.dump();    
+    const string str = all.dump();    
+    const unsigned len = (unsigned)str.size();
+
+    copyStringToShort(result, str);
+    allocated.insert(result);
+
+    resultSize = new int[1];
+    resultSize[0] = (int)len;
 }
 
-void convertBuffers(string &resultM, string &result)
+
+void convertBuffers(short*& resultM, int*& resultSizeM, short*& result, int*& resultSize)
 {
-    resultM = convertGlobalMessagesBuffer();
+    convertGlobalMessagesBuffer(resultM, resultSizeM);
-    result = getGlobalBuffer();
+    convertGlobalBuffer(result, resultSize);
 }
 
 bool isSPF_comment(const string &bufStr)

src/Utils/utils.h

@@ -33,7 +33,7 @@ void addToGlobalBufferAndPrint(const std::string &toPrint);
 void clearGlobalBuffer();
 const std::string& getGlobalBuffer();
 std::wstring to_wstring(const std::string);
-void convertBuffers(std::string& resultM, std::string& result);
+void convertBuffers(short*& resultM, int*& resultSizeM, short*& result, int*& resultSize);
 void clearGlobalMessagesBuffer();
 std::string renameInclude(const std::string& inc);
 void copyIncludes(const std::set<std::string> &allIncludeFiles, const std::map<std::string, std::map<int, std::set<std::string>>> &commentsToInclude, const std::map<std::string, std::map<int, std::set<std::string>>>& newCopyDeclToIncl, const char *folderName, bool keepSpfDirs, bool isFreeStyle, bool isRename, int removeDirs = 0);

src/Utils/version.h

@@ -1,3 +1,3 @@
 #pragma once
 
-#define VERSION_SPF "2446"
+#define VERSION_SPF "2430"