moved to transformations

.gitignore

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

CMakeLists.txt

@@ -33,6 +33,7 @@ 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})
@@ -202,6 +203,8 @@ 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}
@@ -224,8 +227,9 @@ 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
         src/CFGraph/IR_domTree.cpp
@@ -238,14 +242,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)
@@ -321,9 +325,7 @@ 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/implicit_loops_analyzer.cpp
-        src/LoopAnalyzer/implicit_loops_analyzer.h)
+        src/LoopAnalyzer/loop_analyzer.h)
 
 set(MAIN src/Sapfor.cpp
         src/Sapfor.h
@@ -459,6 +461,7 @@ 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})

src/CFGraph/CFGraph.cpp

@@ -50,30 +50,12 @@ BBlock::BasicBlock(const BBlock& copyFrom)
     prev = copyFrom.prev;
 }
 
-void BBlock::addInstruction(IR_Block* item, bool pushFront)
+void BBlock::addInstruction(IR_Block* item)
 {
-    if (pushFront)
-        instructions.insert(instructions.begin(), item);
-    else
-        instructions.push_back(item);
+    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);
@@ -530,7 +512,7 @@ static int buildReachingDefs(const vector<BBlock*>& CFG, const FuncInfo* currF,
     return iter;
 }
 
-//Kosaraju-Sharir algorithm
+//Kosaraju<EFBFBD>Sharir algorithm
 static vector<int> getStronglyConnectedComps(vector<vector<int>>& g) {
     // 1. For each vertex u of the graph, mark u as unvisited. Let l be empty.
     auto size = g.size();

src/CFGraph/CFGraph.h

@@ -6,10 +6,6 @@
 #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
@@ -45,8 +41,7 @@ namespace SAPFOR
         BasicBlock(IR_Block* item);
         BasicBlock(const BasicBlock& copyFrom);
 
-        void addInstructionBefore(IR_Block* item, Instruction* istruction);
-        void addInstruction(IR_Block* item, bool pushFront = false);
+        void addInstruction(IR_Block* item);
         void addPrev(BasicBlock* prev_) { prev.push_back(prev_); }
         void addNext(BasicBlock* next_) { next.push_back(next_); }
         void setDom(BasicBlock* dom) { directDominator = dom; }

src/CFGraph/IR.h

@@ -42,7 +42,6 @@ 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 &&
@@ -51,9 +50,6 @@ 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

@@ -1,386 +0,0 @@
-#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;
-
-static const SAPFOR::Argument CONST_UNDEFINED_ARG(CFG_ARG_TYPE::CONST, CFG_MEM_TYPE::COMMON_, "-1");
-
-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>();
-    
-    vector<T>* commonElements = new vector<T>((*vectors)[0]);
-
-    for (size_t i = 1; i < vectors->size(); ++i) 
-    {
-        vector<T> tempCommon;
-
-        vector<T> sortedVec = (*vectors)[i];
-        sort(commonElements->begin(), commonElements->end());
-        sort(sortedVec.begin(), sortedVec.end());
-
-        set_intersection(
-            commonElements->begin(), commonElements->end(),
-            sortedVec.begin(), sortedVec.end(),
-            back_inserter(tempCommon)
-        );
-
-        *commonElements = tempCommon;
-
-        if (commonElements->empty())
-            break;
-    }
-
-    return commonElements;
-}
-
-
-static map<SAPFOR::BasicBlock*, vector<SAPFOR::BasicBlock*>> findDominators(const vector<SAPFOR::BasicBlock*>& blocks) 
-{
-    map<SAPFOR::BasicBlock*, vector<SAPFOR::BasicBlock*>> result;
-
-    bool changed = true;
-    while (changed)
-    {
-        changed = false;
-
-        for (auto& currentBlock : blocks) 
-        {
-            auto pred = currentBlock->getPrev();
-            auto prevDominators = new vector<vector<SAPFOR::BasicBlock*>>();
-
-            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 map<SAPFOR::BasicBlock*, vector<SAPFOR::BasicBlock*>> findDominatorBorders(const vector<SAPFOR::BasicBlock*>& blocks)
-{
-    map<SAPFOR::BasicBlock*, vector<SAPFOR::BasicBlock*>> result;
-
-    for (auto& block : blocks)
-        result[block] = *(new vector<SAPFOR::BasicBlock*>());
-
-    for (auto& block : blocks) 
-    {
-        if (block->getPrev().size() > 1) 
-        {
-            for (auto prev : block->getPrev()) 
-            {
-                auto tmpBlock = prev;
-
-                while (tmpBlock != block->getDom())
-                {
-                    result[tmpBlock].push_back(block);
-                    tmpBlock = tmpBlock->getDom();
-                }
-            }
-        }
-    }
-
-    return result;
-}
-
-static pair<set<SAPFOR::Argument*>, map<SAPFOR::Argument*, set<SAPFOR::BasicBlock*>>> getGlobalsAndVarBlocks(const vector<SAPFOR::BasicBlock*>& blocks)
-{
-    set<SAPFOR::Argument*> globals;
-    map<SAPFOR::Argument*, set<SAPFOR::BasicBlock*>> varBlocks;
-
-    for (auto& block : blocks) 
-    {
-        set<SAPFOR::Argument*> 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<SAPFOR::BasicBlock*> blocks, set<SAPFOR::Argument*>& globals, 
-                                     map<SAPFOR::Argument*, set<SAPFOR::BasicBlock*>>& varBlocks, 
-                                     map<SAPFOR::BasicBlock*, vector<SAPFOR::BasicBlock*>>& dominatorBorders) 
-{
-    vector<SAPFOR::BasicBlock*> blocksWithFiFunctions;
-    auto fiFunc = new SAPFOR::Argument(CFG_ARG_TYPE::FUNC, CFG_MEM_TYPE::NONE_, "FI_FUNCTION");
-    auto paramCount = new SAPFOR::Argument(CFG_ARG_TYPE::CONST, CFG_MEM_TYPE::LOCAL_, "0");
-
-    for (auto& var : globals)
-    {
-        auto worklist = varBlocks[var];
-        set<SAPFOR::BasicBlock*> 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 SAPFOR::Argument(*fiFunc), new SAPFOR::Argument(*paramCount), var, dfBlock->getInstructions()[0]->getInstruction()->getOperator());
-
-                    IR_Block* phiBlock = new IR_Block(phiInstruction);
-                    dfBlock->addInstruction(phiBlock, true);
-                }
-            }
-        }
-    }
-}
-
-static void restoreConnections(const vector<SAPFOR::BasicBlock*>& originalBlocks, vector<SAPFOR::BasicBlock*>& copiedBlocks) 
-{
-    map<SAPFOR::BasicBlock*, SAPFOR::BasicBlock*> blockMapping;
-    for (size_t i = 0; i < originalBlocks.size(); ++i)
-        blockMapping[originalBlocks[i]] = copiedBlocks[i];
-
-    for (size_t i = 0; i < originalBlocks.size(); ++i) 
-    {
-        SAPFOR::BasicBlock* originalBlock = originalBlocks[i];
-        SAPFOR::BasicBlock* copiedBlock = copiedBlocks[i];
-
-        auto prevCopy = copiedBlock->getPrev();
-        for (auto j : prevCopy)
-            copiedBlock->removePrev(j);
-        
-        auto nextCopy = copiedBlock->getNext();
-        for (auto j : nextCopy)
-            copiedBlock->removeNext(j);
-        
-        for (auto* succ : originalBlock->getNext())
-            copiedBlock->addNext(blockMapping[succ]);
-        
-        for (auto* prev : originalBlock->getPrev())
-            copiedBlock->addPrev(blockMapping[prev]);
-    }
-}
-
-
-static SAPFOR::Argument* newName(SAPFOR::Argument* var, map<string, int>& counter, map<string, stack<SAPFOR::Argument*>>& stack, int number) {
-    counter[var->getValue()]++;
-
-    SAPFOR::Argument* newName = new SAPFOR::Argument(var->getType(), var->getMemType(), var->getValue(), number);
-    stack[var->getValue()].push(newName);
-    return newName;
-}
-
-static void renameFiFunctionResultVar(SAPFOR::BasicBlock* block, map<string, int>& counter, map<string, stack<SAPFOR::Argument*>>& 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(SAPFOR::BasicBlock* block, map<string, int>& counter, map<string, stack<SAPFOR::Argument*>>& 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(SAPFOR::BasicBlock* block, map<string, stack<SAPFOR::Argument*>>& stack) 
-{
-    auto size = block->getInstructions().size();
-    auto& instructions = block->getInstructions();
-
-    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) 
-        {
-            Instruction* paramInstruction;
-            
-            if (stack[instruction->getResult()->getValue()].size() > 0) 
-            {
-                SAPFOR::Argument* tmp = new SAPFOR::Argument(CFG_ARG_TYPE::CONST, CFG_MEM_TYPE::COMMON_, to_string(stack[instruction->getResult()->getValue()].top()->getNumber()));
-                paramInstruction = new Instruction(CFG_OP::PARAM, tmp);
-            }
-            else 
-            {
-                SAPFOR::Argument* tmp = new SAPFOR::Argument(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<SAPFOR::BasicBlock*> findBlocksWithValue(vector<SAPFOR::BasicBlock*>& blocks, SAPFOR::BasicBlock* x) 
-{
-    vector<SAPFOR::BasicBlock*> result;
-
-    for (auto& block : blocks)
-        if (block->getDom() == x)
-            result.push_back(block);
-
-    return result;
-}
-
-static void renameIR(SAPFOR::BasicBlock* block, vector<SAPFOR::BasicBlock*>& blocks, map<string, int>& counter, map<string, stack<SAPFOR::Argument*>>& stack)
-{
-    renameFiFunctionResultVar(block, counter, stack);
-    renameInstructionVars(block, counter, stack);
-
-    for (auto& successor : block->getNext())
-        renameFiFunctionArgsVar(successor, stack);
-    
-    for (auto& child : findBlocksWithValue(blocks, block))
-        renameIR(child, blocks, 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();
-        }
-    }
-}
-
-void buildFuncIRSSAForm(FuncInfo* funcInfo, const std::vector<SAPFOR::BasicBlock*>& funcIRConst, std::map<FuncInfo*, std::vector<SAPFOR::BasicBlock*>>& result)
-{
-    vector<SAPFOR::BasicBlock*> funcIR;
-
-    for (auto& i : funcIRConst)
-        funcIR.push_back(new SAPFOR::BasicBlock(*i));
-
-    restoreConnections(funcIRConst, funcIR);
-
-    SAPFOR::buildDominatorTree(funcIR);
-
-    auto dominatorBorders = findDominatorBorders(funcIR);
-
-    auto globalsAndVarBlocks = getGlobalsAndVarBlocks(funcIR);
-    auto globals = globalsAndVarBlocks.first;
-    auto varBlocks = globalsAndVarBlocks.second;
-
-    getBlocksWithFiFunctions(funcIR, globals, varBlocks, dominatorBorders);
-
-    map<string, int> count;
-    map<string, stack<SAPFOR::Argument*>> varStack;
-
-    for (auto& var : globals)
-    {
-        count[var->getValue()] = 0;
-
-        stack<SAPFOR::Argument*> tmp;
-        tmp.push(new SAPFOR::Argument(CONST_UNDEFINED_ARG));
-        varStack[var->getValue()] = tmp;
-    }
-
-    renameIR(funcIR[0], funcIR, count, varStack);
-
-    result[funcInfo] = funcIR;
-}
-
-FuncInfo* getIRByFilename(const std::map<FuncInfo*, std::vector<SAPFOR::BasicBlock*>>& fullIR, const char* filename)
-{
-    for (auto ir : fullIR)
-        if (ir.first->fileName == filename)
-            return ir.first;
-
-    return nullptr;
-}

src/CFGraph/IR_SSAForm.h

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

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/DirectiveProcessing/directive_creator.cpp

@@ -22,7 +22,7 @@
 #include "SgUtils.h"
 #include "../Sapfor.h"
 #include "graph_loops_func.h"
-#include "../Transformations/LoopNesting/loop_transform.h"
+#include "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 "../Transformations/LoopNesting/loop_transform.h"
+#include "LoopNesting/loop_transform.h"
 
 #include "errors.h"
 #include "directive_parser.h"

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

src/GraphCall/graph_calls.cpp

@@ -779,6 +779,20 @@ static void checkSpecList(SgExpression *spec, FuncInfo* currF, const map<string,
     }
 }
 
+static void checkInTypeDescription(SgExpression *ex, FuncInfo* currF, const map<string, int>& parNames)
+{
+    if (ex)
+    {
+        if (ex->variant() == ARRAY_REF)
+            fillIn(currF, ex->lhs(), parNames, false);
+        else
+        {
+            checkInTypeDescription(ex->lhs(), currF, parNames);
+            checkInTypeDescription(ex->rhs(), currF, parNames);
+        }
+    }
+}
+
 static void fillInOut(FuncInfo *currF, SgStatement *start, SgStatement *last, const set<SgStatement*>& activeOps)
 {
     if (currF->funcParams.countOfPars == 0)
@@ -798,8 +812,13 @@ static void fillInOut(FuncInfo *currF, SgStatement *start, SgStatement *last, co
 
         if (st->variant() == ENTRY_STAT)
             continue;
+        
+        if (isSgExecutableStatement(st) == NULL) {
+            checkInTypeDescription(st->expr(0), currF, parNames);
+            continue;
+        }
 
-        if (isSgExecutableStatement(st) == NULL || st->lineNumber() <= 0)
+        if (st->lineNumber() <= 0)
             continue;
 
         if (activeOps.size() && activeOps.find(st) == activeOps.end())

src/GraphLoop/graph_loops.cpp

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

src/LoopAnalyzer/implicit_loops_analyzer.cpp

@@ -1,281 +0,0 @@
-#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);
-        return;
-    }
-
-    if (visit[id] == VISITED)
-        return;
-
-    visit[id] = VISITING;
-
-    for (auto next : block->getNext())
-        dfs(next, visit, startAndEnd, block);
-
-    visit[id] = VISITED;
-}
-
-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;
-}
-
-void findImplicitLoops(const std::vector<SAPFOR::BasicBlock*>& irSSA, const std::vector<LoopGraph*> loopGraph)
-{
-    map<int, int> visited;
-    for (auto i : irSSA)
-        visited[i->getNumber()] = UNVISITED;
-
-    vector<pair<SAPFOR::BasicBlock*, SAPFOR::BasicBlock*>> startAndEnd;
-    dfs(irSSA[0], visited, startAndEnd, NULL);
-
-    vector<LoopGraph*> loops;
-
-    for (auto& [tail, header] : startAndEnd)
-    {
-        set<SAPFOR::BasicBlock*> loopExits;
-
-        for (auto succ : tail->getNext())
-            if (succ != header)
-                loopExits.insert(succ);
-
-        vector<SAPFOR::BasicBlock*> loopBody;
-        getLoopBody(header, loopExits, loopBody);
-
-        findInductiveVars(loopBody, irSSA);
-
-        Instruction* instructionAfterLoop = findInstructionAfterLoop(loopBody);
-
-        if (instructionAfterLoop == NULL)
-        {
-            cout << "Warning: instruction after loop not found!" << endl;
-            continue;
-        }
-
-        auto firstInstruction = header->getInstructions()[0]->getInstruction();
-        auto lastInstruction = tail->getInstructions().back()->getInstruction();
-        auto tmpLoop = new LoopGraph();
-        tmpLoop->lineNum = firstInstruction->getOperator()->lineNumber();
-        tmpLoop->lineNumAfterLoop = instructionAfterLoop->getOperator()->lineNumber();
-
-
-        if (firstInstruction->getOperator()->variant() == FOR_NODE) 
-        {
-            SgForStmt* stmt = isSgForStmt(firstInstruction->getOperator());
-
-            cout << "for loop" << endl;
-        }
-        else if (firstInstruction->getOperator()->variant() == WHILE_NODE) 
-        {
-            SgWhileStmt* stmt = isSgWhileStmt(firstInstruction->getOperator());
-
-            cout << (stmt->conditional() == NULL ? "infinit" : "") << "while loop" << endl;
-        }
-        else if (firstInstruction->getOperator()->variant() == DO_WHILE_NODE) 
-        {
-            SgWhileStmt* stmt = isSgDoWhileStmt(firstInstruction->getOperator());
-
-            cout << "do while loop" << endl;
-        }
-        else if (firstInstruction->getOperator()->variant() == LOOP_NODE) 
-        {
-            cout << "not known loop" << endl;
-        }
-        else
-        {
-            cout << "goto loop" << 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

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

src/LoopAnalyzer/loop_analyzer.cpp

@@ -48,7 +48,7 @@ extern int passDone;
 #include "../VisualizerCalls/get_information.h"
 #include "../VisualizerCalls/SendMessage.h"
 
-#include "../Transformations/LoopEndDoConverter/enddo_loop_converter.h"
+#include "LoopEndDoConverter/enddo_loop_converter.h"
 
 #include "../DirectiveProcessing/remote_access.h"
 #include "../DirectiveProcessing/directive_omp_parser.h"

src/ParallelizationRegions/resolve_par_reg_conflicts.cpp

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

src/PrivateAnalyzer/private_arrays_search.cpp

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

@@ -10,5 +10,5 @@
 #include "../CFGraph/CFGraph.h"
 
 void Collapse(Region* region);
-std::map<LoopGraph*, ArrayAccessingIndexes> findPrivateArrays(std::map<std::string, std::vector<LoopGraph*>>& loopGraph, std::map<FuncInfo*, std::vector<SAPFOR::BasicBlock*>>& FullIR);
+std::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/Sapfor.cpp

@@ -40,7 +40,6 @@
 #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"
@@ -90,13 +89,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"
@@ -941,6 +940,8 @@ static bool runAnalysis(SgProject &project, const int curr_regime, const bool ne
                     internalExit = err;
             }
         }
+        else if (curr_regime == SWAP_OPERATORS)        
+            runSwapOperators(file, loopGraph, fullIR, countOfTransform);        
         else if (curr_regime == PRIVATE_REMOVING_ANALYSIS)
         {
             auto itFound = loopGraph.find(file->filename());
@@ -1021,19 +1022,8 @@ 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)
-        {
-            auto irFound = getIRByFilename(fullIR, file_name);
-            buildFuncIRSSAForm(irFound, fullIR[irFound], fullIR_SSA);
-        }
-        else if (curr_regime == FIND_IMPLICIT_LOOPS)
-        {
-            auto itFound = loopGraph.find(file_name);
-            auto irFound = getIRByFilename(fullIR_SSA, file_name);
-            findImplicitLoops(fullIR_SSA[irFound], itFound->second);
-        }         
         else if (curr_regime == FIND_PRIVATE_ARRAYS)
-            findPrivateArrays(loopGraph, fullIR);
+            FindPrivateArrays(loopGraph, fullIR);
         else if (curr_regime == TEST_PASS)
         {
         //test pass
@@ -1050,7 +1040,8 @@ 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())
     {
@@ -1294,7 +1285,6 @@ static bool runAnalysis(SgProject &project, const int curr_regime, const bool ne
         detectCopies(allFuncInfo);
         fillInterfaceBlock(allFuncInfo);
         intentInsertToInterfaces(allFuncInfo);
-        createInterfacesForAssumedSize(allFuncInfo);
 
         //this call is only for testing
         //setPureStatus(allFuncInfo);
@@ -2344,6 +2334,7 @@ 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:
@@ -2645,7 +2636,10 @@ int main(int argc, char **argv)
         }
 
         if (curr_regime == INSERT_PARALLEL_DIRS_NODIST)
+        {
             ignoreArrayDistributeState = true;
+            sharedMemoryParallelization = 1;
+        }
 
         if (runAsClient)
         {

src/Sapfor.h

@@ -122,6 +122,8 @@ enum passes {
     CREATE_INTER_TREE,
     INSERT_INTER_TREE,
 
+    SWAP_OPERATORS,
+
     SHADOW_GROUPING,
     INLINE_PROCEDURES,
     FILL_PARALLEL_REG_IR,
@@ -182,8 +184,6 @@ enum passes {
 
     SET_IMPLICIT_NONE,
     RENAME_INLCUDES,
-    FIND_IMPLICIT_LOOPS,
-    BUILD_IR_SSA_FORM,
 
     FIND_PRIVATE_ARRAYS,
 
@@ -319,6 +319,7 @@ 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";
@@ -371,8 +372,6 @@ 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[TEST_PASS] = "TEST_PASS";

src/SapforData.h

@@ -181,7 +181,3 @@ 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/FunctionPurifying/function_purifying.cpp

@@ -210,7 +210,8 @@ static vector<FuncInfo*> sortByName(const T &funcs)
     return funcList;
 }
 
-void createInterfacesForAssumedSize(const map<string, vector<FuncInfo*>>& allFuncInfo)
+//XXX: incorrect!!
+/*void createInterfacesForAssumedSize(const map<string, vector<FuncInfo*>>& allFuncInfo)
 {
     set<FuncInfo*> hasAssumedSizeArrays;
 
@@ -295,7 +296,7 @@ void createInterfacesForAssumedSize(const map<string, vector<FuncInfo*>>& allFun
                 removeExternalStat(prog, addedInterfaceFor);
         }       
     }
-}
+}*/
 
 static void setPureStatus(FuncInfo* func)
 {
@@ -1388,6 +1389,37 @@ 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();
@@ -1395,22 +1427,21 @@ 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> ident(pars.identificators.begin(), pars.identificators.end());
+    const set<string> idents(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)
             {
-                SgStatement* next = st->lexNext();
-                st->extractStmt();
-                st = next;
+                toExtract.push_back(st);
+                st = st->lexNext();
             }
             else
                 st = st->lexNext();
@@ -1431,31 +1462,20 @@ static string getInterfaceBlock(SgStatement* func, const FuncParam& pars)
     st = copy->lexNext();
     while (st != last)
     {
-        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();
-            }
+        const int var = st->variant();
 
-            if (newList.size() == 0)
+        if (var == VAR_DECL || var == VAR_DECL_90 || var == DIM_STAT ||
+            var == INTENT_STMT || var == EXTERN_STAT)
+        {
+            bool empty = filterFromList(st, idents);
+            if (empty)
             {
-                SgStatement* next = st->lexNext();
                 toExtract.push_back(st);
-                st = next;
+                st = st->lexNext();
                 continue;
             }
-            else
-                st->setExpression(0, makeExprList(newList));
         }
-        else
+        else if (!isDVM_stat(st) && !isSPF_stat(st))
             toExtract.push_back(st);
 
         if (st->variant() == CONTAINS_STMT)
@@ -1466,16 +1486,56 @@ static string getInterfaceBlock(SgStatement* func, const FuncParam& pars)
     for (auto& elem : toExtract)
         elem->extractStmt();
 
-    string retVal = copy->unparse();
+    string codeString = 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;
 }
 
-static void insertInterface(SgStatement* func, const string& iface)
+void insertInterface(SgStatement* func, const FuncInfo *callFrom)
 {
+    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__);
@@ -1484,6 +1544,18 @@ static void insertInterface(SgStatement* func, const string& iface)
     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();
@@ -1491,7 +1563,7 @@ static void insertInterface(SgStatement* func, const string& iface)
     SgStatement* ifaceBlock = new SgStatement(INTERFACE_STMT);
     addControlEndToStmt(ifaceBlock->thebif);
 
-    ifaceBlock->setlineNumber(st->lineNumber());
+    ifaceBlock->setlineNumber(getNextNegativeLineNumber());
     ifaceBlock->setFileName(st->fileName());
     st->insertStmtBefore(*ifaceBlock, *st->controlParent());
     ifaceBlock->lastNodeOfStmt()->addComment(iface.c_str());
@@ -1507,7 +1579,7 @@ static void createInterfaceBlockForToCalls(FuncInfo* func)
         if (callTo->interfaceBlocks.find(func->funcName) == callTo->interfaceBlocks.end())
         {
             callTo->interfaceBlocks[func->funcName] = func;
-            insertInterface(callTo->funcPointer, getInterfaceBlock(func->funcPointer->GetOriginal(), func->funcParams));
+            insertInterface(callTo->funcPointer, func);
         }
     }
 }

src/Transformations/FunctionPurifying/function_purifying.h

@@ -6,11 +6,12 @@ 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);
 
 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 moduleTransfer(const std::map<std::string, std::vector<FuncInfo*>>& allFuncInfo);
+
+void insertInterface(SgStatement* func, const FuncInfo* callFrom);

src/Transformations/SwapOperators/swap_operators.cpp

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

src/Transformations/SwapOperators/swap_operators.h

@@ -0,0 +1,6 @@
+#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,6 +212,8 @@ 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);
 
@@ -316,9 +318,7 @@ void InitPassesDependencies(map<passes, vector<passes>> &passDepsIn, set<passes>
 
     list({ VERIFY_INCLUDES, CORRECT_VAR_DECL }) <= Pass(SET_IMPLICIT_NONE);
 
-    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);
+    list({ CALL_GRAPH2, CALL_GRAPH, BUILD_IR, LOOP_GRAPH, 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/version.h

@@ -1,3 +1,3 @@
 #pragma once
 
-#define VERSION_SPF "2432"
+#define VERSION_SPF "2436"