REMOVE_DIST_ARRAYS_FROM_IO: fix type, add TODO

CMakeLists.txt

@@ -208,8 +208,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
+SET(TR_MOVE_OPERATORS src/Transformations/MoveOperators/move_operators.cpp
-        src/Transformations/SwapOperators/swap_operators.h)
+        src/Transformations/MoveOperators/move_operators.h)
 
 set(TRANSFORMS 
         ${TR_DEAD_CODE}
@@ -233,7 +233,7 @@ set(TRANSFORMS
         ${TR_EXPR_TRANSFORM}
         ${TR_INLINER}
         ${TR_RENAME_SYMBOLS}
-        ${TR_SWAP_OPERATORS})
+        ${TR_MOVE_OPERATORS})
         
 set(CFG src/CFGraph/IR.cpp
         src/CFGraph/IR.h
@@ -467,7 +467,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 (Transformations\\MoveOperators FILES ${TR_MOVE_OPERATORS})
 
 
 source_group (CreateIntervals FILES ${CREATE_INTER_T})

src/CFGraph/private_variables_analysis.cpp

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

src/Sapfor.cpp

@@ -90,7 +90,7 @@
 #include "Transformations/DeadCodeRemoving/dead_code.h"
 #include "Transformations/RenameSymbols/rename_symbols.h"
 #include "Transformations/FunctionInlining/inliner.h"
-#include "Transformations/SwapOperators/swap_operators.h"
+#include "Transformations/MoveOperators/move_operators.h"
 
 #include "ProjectParameters/projectParameters.h"
 
@@ -942,8 +942,8 @@ static bool runAnalysis(SgProject &project, const int curr_regime, const bool ne
                     internalExit = err;
             }
         }
-        else if (curr_regime == SWAP_OPERATORS)        
+        else if (curr_regime == MOVE_OPERATORS)        
-            runSwapOperators(file, loopGraph, fullIR, countOfTransform);        
+            moveOperators(file, loopGraph, fullIR, countOfTransform);        
         else if (curr_regime == PRIVATE_REMOVING_ANALYSIS)
         {
             auto itFound = loopGraph.find(file->filename());
@@ -1041,7 +1041,7 @@ static bool runAnalysis(SgProject &project, const int curr_regime, const bool ne
                           PRIVATE_ARRAYS_EXPANSION, 
                           PRIVATE_ARRAYS_SHRINKING,
                           REMOVE_DEAD_CODE,
-                          SWAP_OPERATORS };
+                          MOVE_OPERATORS };
 
     if ((countOfTransform == 0 || internalExit > 0) && applyFor.find(curr_regime) != applyFor.end())
     {
@@ -2343,7 +2343,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:
+    case MOVE_OPERATORS:
         runAnalysis(*project, curr_regime, true, "", folderName);
         break;
     case INLINE_PROCEDURES:

src/Sapfor.h

@@ -122,7 +122,7 @@ enum passes {
     CREATE_INTER_TREE,
     INSERT_INTER_TREE,
 
-    SWAP_OPERATORS,
+    MOVE_OPERATORS,
 
     SHADOW_GROUPING,
     INLINE_PROCEDURES,
@@ -323,7 +323,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[MOVE_OPERATORS] = "MOVE_OPERATORS";
     passNames[CREATE_PARALLEL_REGIONS] = "CREATE_PARALLEL_REGIONS";
     passNames[PRIVATE_REMOVING_ANALYSIS] = "PRIVATE_REMOVING_ANALYSIS";
     passNames[PRIVATE_REMOVING] = "PRIVATE_REMOVING";

src/Transformations/MoveOperators/move_operators.cpp

@@ -12,31 +12,29 @@
 #include "../../CFGraph/CFGraph.h"
 #include "../../CFGraph/IR.h"
 #include "../../GraphLoop/graph_loops.h"
-#include "swap_operators.h"
+#include "move_operators.h"
 
 using namespace std;
 
-string getNameByArg(SAPFOR::Argument* arg);
+static vector<SAPFOR::IR_Block*> findInstructionsFromOperator(SgStatement* st, const vector<SAPFOR::BasicBlock*>& Blocks) {
-
-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();
-            if (curOperator->lineNumber() == st->lineNumber()) {
+            if (curOperator->lineNumber() == st->lineNumber())
                 result.push_back(instruction);
         }
     }
-    }
     return result;
 }
 
-unordered_set<int> loop_tags = {FOR_NODE};
+const unordered_set<int> loop_tags = { FOR_NODE };
-unordered_set<int> control_tags = {IF_NODE, ELSEIF_NODE, DO_WHILE_NODE, WHILE_NODE, LOGIF_NODE};
+const unordered_set<int> control_tags = { IF_NODE, ELSEIF_NODE, DO_WHILE_NODE, WHILE_NODE, LOGIF_NODE };
-unordered_set<int> control_end_tags = {CONTROL_END};
+const unordered_set<int> control_end_tags = { CONTROL_END };
 
 struct OperatorInfo {
     SgStatement* stmt;
@@ -45,58 +43,58 @@ struct OperatorInfo {
     int lineNumber;
     bool isMovable;
     
-    OperatorInfo(SgStatement* s) : stmt(s), lineNumber(s->lineNumber()), isMovable(true) {}
+    OperatorInfo(SgStatement* s) : stmt(s), lineNumber(s->lineNumber()), isMovable(true) { }
 };
 
 static bool isStatementEmbedded(SgStatement* stmt, SgStatement* parent) {
-    if (!stmt || !parent || stmt == parent) return false;
+    if (!stmt || !parent || stmt == parent)
+        return false;
     
     if (parent->variant() == LOGIF_NODE) {
-        if (stmt->lineNumber() == parent->lineNumber()) {
+        if (stmt->lineNumber() == parent->lineNumber())
             return true;
-        }
         
         SgStatement* current = parent;
         SgStatement* lastNode = parent->lastNodeOfStmt();
 
         while (current && current != lastNode) {
-            if (current == stmt) {
+            if (current == stmt)
                 return true;
-            }
+
-            if (current->isIncludedInStmt(*stmt)) {
+            if (current->isIncludedInStmt(*stmt))
                 return true;
-            }
+
             current = current->lexNext();
         }
     }
     
-    if (parent->isIncludedInStmt(*stmt)) {
+    if (parent->isIncludedInStmt(*stmt))
         return true;
-    }
     
     return false;
 }
 
 static bool isLoopBoundary(SgStatement* stmt) {
-    if (!stmt) return false;
+    if (!stmt)
+        return false;
     
-    if (stmt->variant() == FOR_NODE || stmt->variant() == CONTROL_END) {
+    if (stmt->variant() == FOR_NODE || stmt->variant() == CONTROL_END)
         return true;
-    }
     
     return false;
 }
 
 static bool isPartOfNestedLoop(SgStatement* stmt, SgForStmt* loop) {
-    if (!stmt || !loop) return false;
+    if (!stmt || !loop)
+        return false;
     
     SgStatement* loopStart = loop->lexNext();
     SgStatement* loopEnd = loop->lastNodeOfStmt();
-    if (!loopStart || !loopEnd) return false;
+    if (!loopStart || !loopEnd)
-    
+        return false;
-    if (stmt->lineNumber() < loopStart->lineNumber() || stmt->lineNumber() > loopEnd->lineNumber()) {
+    
+    if (stmt->lineNumber() < loopStart->lineNumber() || stmt->lineNumber() > loopEnd->lineNumber())
         return false;
-    }
     
     SgStatement* current = loopStart;
     
@@ -121,60 +119,58 @@ static bool isPartOfNestedLoop(SgStatement* stmt, SgForStmt* loop) {
 }
 
 static bool canSafelyExtract(SgStatement* stmt, SgForStmt* loop) {
-    if (!stmt || !loop) return false;
+    if (!stmt || !loop)
-    
-    if (isLoopBoundary(stmt)) {
         return false;
-    }
     
-    if (control_tags.find(stmt->variant()) != control_tags.end()) {
+    if (isLoopBoundary(stmt))
         return false;
-    }
     
-    if (isPartOfNestedLoop(stmt, loop)) {
+    if (control_tags.find(stmt->variant()) != control_tags.end())
+        return false;
+    
+    if (isPartOfNestedLoop(stmt, loop))
         return false;
-    }
     
     SgStatement* loopStart = loop->lexNext();
     SgStatement* loopEnd = loop->lastNodeOfStmt();
-    if (!loopStart || !loopEnd) return false;
+    if (!loopStart || !loopEnd) 
+        return false;
     
     SgStatement* current = loopStart;
     
     while (current && current != loopEnd) {
-        if (current->variant() == LOGIF_NODE && current->lineNumber() == stmt->lineNumber()) {
+        if (current->variant() == LOGIF_NODE && current->lineNumber() == stmt->lineNumber())
             return false;
-        }
 
-        if (control_tags.find(current->variant()) != control_tags.end()) {
+        if (control_tags.find(current->variant()) != control_tags.end())
-            if (isStatementEmbedded(stmt, current)) {
+            if (isStatementEmbedded(stmt, current))
                 return false;
-            }
+
-        }
+        if (current == stmt) 
-        if (current == stmt) break;
+            break;
         current = current->lexNext();
     }
     
     return true;
 }
 
-static vector<OperatorInfo> analyzeOperatorsInLoop(SgForStmt* loop, vector<SAPFOR::BasicBlock*> blocks, map<FuncInfo*, vector<SAPFOR::BasicBlock*>>& FullIR) {
+static vector<OperatorInfo> analyzeOperatorsInLoop(SgForStmt* loop, const vector<SAPFOR::BasicBlock*>& blocks, 
+                                                   const map<FuncInfo*, vector<SAPFOR::BasicBlock*>>& FullIR) {
     vector<OperatorInfo> operators;
     SgStatement* loopStart = loop->lexNext();
     SgStatement* loopEnd = loop->lastNodeOfStmt();
     
-    if (!loopStart || !loopEnd) {
+    if (!loopStart || !loopEnd)
         return operators;
-    }
     
     SgStatement* current = loopStart;
     unordered_set<SgStatement*> visited;
     
     while (current && current != loopEnd) {
         
-        if (visited.find(current) != visited.end()) {
+        if (visited.find(current) != visited.end())
             break;
-        }
+
         visited.insert(current);
         
         if (isLoopBoundary(current)) {
@@ -184,11 +180,10 @@ static vector<OperatorInfo> analyzeOperatorsInLoop(SgForStmt* loop, vector<SAPFO
         
         if (current->variant() == FOR_NODE && current != loop) {
             SgStatement* nestedEnd = current->lastNodeOfStmt();
-            if (nestedEnd) {
+            if (nestedEnd)
                 current = nestedEnd->lexNext();
-            } else {
+            else
                 current = current->lexNext();
-            }
             continue;
         }
         
@@ -197,6 +192,7 @@ static vector<OperatorInfo> analyzeOperatorsInLoop(SgForStmt* loop, vector<SAPFO
                 current = current->lexNext();
                 continue;
             }
+
             if (current->variant() != ASSIGN_STAT) {
                 current = current->lexNext();
                 continue;
@@ -206,29 +202,28 @@ static vector<OperatorInfo> analyzeOperatorsInLoop(SgForStmt* loop, vector<SAPFO
             
             vector<SAPFOR::IR_Block*> irBlocks = findInstructionsFromOperator(current, blocks);
             for (auto irBlock : irBlocks) {
-                if (!irBlock || !irBlock->getInstruction()) continue;
+                if (!irBlock || !irBlock->getInstruction()) 
-                
+                    continue;
-                SAPFOR::Instruction* instr = irBlock->getInstruction();
                 
+                const SAPFOR::Instruction* instr = irBlock->getInstruction();
                 if (instr->getArg1()) {
                     string varName = getNameByArg(instr->getArg1());
-                    if (!varName.empty()) {
+                    if (!varName.empty())
                         opInfo.usedVars.insert(varName);
                 }
-                }
+
                 if (instr->getArg2()) {
                     string varName = getNameByArg(instr->getArg2());
-                    if (!varName.empty()) {
+                    if (!varName.empty())
                         opInfo.usedVars.insert(varName);
                 }
-                }
+
                 if (instr->getResult()) {
                     string varName = getNameByArg(instr->getResult());
-                    if (!varName.empty()) {
+                    if (!varName.empty())
                         opInfo.definedVars.insert(varName);
                 }
             }
-            }
             
             operators.push_back(opInfo);
         }
@@ -240,21 +235,23 @@ static vector<OperatorInfo> analyzeOperatorsInLoop(SgForStmt* loop, vector<SAPFO
 
 static map<string, vector<SgStatement*>> findVariableDefinitions(SgForStmt* loop, vector<OperatorInfo>& operators) {
     map<string, vector<SgStatement*>> varDefinitions;
-    for (auto& op : operators) {
+    for (auto& op : operators)
-        for (const string& var : op.definedVars) {
+        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;
+    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, SgForStmt* loop) {
+static SgStatement* findBestPosition(SgStatement* operatorStmt, const vector<OperatorInfo>& operators, 
-    OperatorInfo* opInfo = nullptr;
+                                     const map<string, vector<SgStatement*>>& varDefinitions, SgForStmt* loop) {
+    const OperatorInfo* opInfo = nullptr;
     for (auto& op : operators) {
         if (op.stmt == operatorStmt) {
             opInfo = &op;
@@ -262,16 +259,15 @@ static SgStatement* findBestPosition(SgStatement* operatorStmt, vector<OperatorI
         }
     }
 
-    if (!opInfo || !opInfo->isMovable) {
+    if (!opInfo || !opInfo->isMovable)
         return nullptr;
-    }
     
     SgStatement* bestPos = nullptr;
     int bestLine = -1;
     
     for (const string& usedVar : opInfo->usedVars) {
         if (varDefinitions.find(usedVar) != varDefinitions.end()) {
-            for (SgStatement* defStmt : varDefinitions[usedVar]) {
+            for (SgStatement* defStmt : varDefinitions.at(usedVar)) {
                 if (defStmt->lineNumber() < operatorStmt->lineNumber()) {
                     if (defStmt->controlParent() == operatorStmt->controlParent()) {
                         if (defStmt->lineNumber() > bestLine) {
@@ -290,13 +286,11 @@ static SgStatement* findBestPosition(SgStatement* operatorStmt, vector<OperatorI
         
         for (const string& usedVar : opInfo->usedVars) {
             if (varDefinitions.find(usedVar) != varDefinitions.end()) {
-                for (SgStatement* defStmt : varDefinitions[usedVar]) {
+                for (SgStatement* defStmt : varDefinitions.at(usedVar)) {
-                    if (defStmt == operatorStmt) {
+                    if (defStmt == operatorStmt)
                         continue;
-                    }
                     
                     hasAnyDefinition = true;
-                    
                     if (defStmt->lineNumber() < operatorStmt->lineNumber() &&
                         defStmt->controlParent() == operatorStmt->controlParent()) {
                         allLoopCarried = false;
@@ -304,7 +298,9 @@ static SgStatement* findBestPosition(SgStatement* operatorStmt, vector<OperatorI
                     }
                 }
             }
-            if (!allLoopCarried) break;
+
+            if (!allLoopCarried) 
+                break;
         }
         
         if (allLoopCarried || (!hasAnyDefinition && !opInfo->usedVars.empty())) {
@@ -317,12 +313,14 @@ static SgStatement* findBestPosition(SgStatement* operatorStmt, vector<OperatorI
 }
 
 static bool canMoveTo(SgStatement* from, SgStatement* to, SgForStmt* loop) {
-    if (!from || !to || from == to) return false;
+    if (!from || !to || from == to)
+        return false;
     
     SgStatement* loopStart = loop->lexNext();
     SgStatement* loopEnd = loop->lastNodeOfStmt();
     
-    if (!loopStart || !loopEnd) return false;
+    if (!loopStart || !loopEnd) 
+        return false;
     
     if (to == loopStart) {
         SgStatement* fromControlParent = from->controlParent();
@@ -330,20 +328,17 @@ static bool canMoveTo(SgStatement* from, SgStatement* to, SgForStmt* loop) {
         return fromControlParent == loop || fromControlParent == loopStart->controlParent();
     }
     
-    if (from->lineNumber() < loopStart->lineNumber() || from->lineNumber() > loopEnd->lineNumber()) {
+    if (from->lineNumber() < loopStart->lineNumber() || from->lineNumber() > loopEnd->lineNumber())
         return false;
-    }
-    if (to->lineNumber() < loopStart->lineNumber() || to->lineNumber() > loopEnd->lineNumber()) {
-        return false;
-    }
 
-    if (to->lineNumber() >= from->lineNumber()) {
+    if (to->lineNumber() < loopStart->lineNumber() || to->lineNumber() > loopEnd->lineNumber())
         return false;
-    }
     
-    if (from->controlParent() != to->controlParent()) {
+    if (to->lineNumber() >= from->lineNumber())
+        return false;
+    
+    if (from->controlParent() != to->controlParent())
         return false;
-    }
     
     SgStatement* current = to->lexNext();
     while (current && current != from && current != loopEnd) {
@@ -361,31 +356,31 @@ static bool canMoveTo(SgStatement* from, SgStatement* to, SgForStmt* loop) {
     return true;
 }
 
-static vector<SgStatement*> optimizeOperatorOrder(SgForStmt* loop, vector<OperatorInfo>& operators, map<string, vector<SgStatement*>>& varDefinitions) {
+static vector<SgStatement*> optimizeOperatorOrder(SgForStmt* loop, 
+                                                  const vector<OperatorInfo>& operators, 
+                                                  const map<string, vector<SgStatement*>>& varDefinitions) {
     vector<SgStatement*> newOrder;
-    for (auto& op : operators) {
+    for (auto& op : operators)
         newOrder.push_back(op.stmt);
-    }
     
-    map<SgStatement*, OperatorInfo*> stmtToOpInfo;
+    map<SgStatement*, const OperatorInfo*> stmtToOpInfo;
-    for (auto& op : operators) {
+    for (auto& op : operators) 
         stmtToOpInfo[op.stmt] = &op;
-    }
     
     bool changed = true;
-    int iterations = 0;
-    const int MAX_ITERATIONS = 50;
     
-    while (changed && iterations < MAX_ITERATIONS) {
+    while (changed) {
         changed = false;
-        iterations++;
         
         for (int i = operators.size() - 1; i >= 0; i--) {
-            if (!operators[i].isMovable) continue;
+            if (!operators[i].isMovable) 
+                continue;
             
             SgStatement* stmt = operators[i].stmt;
-            OperatorInfo* opInfo = stmtToOpInfo[stmt];
+            const OperatorInfo* opInfo = stmtToOpInfo[stmt];
-            if (!opInfo) continue;
+
+            if (!opInfo)
+                continue;
             
             size_t currentPos = 0;
             for (size_t j = 0; j < newOrder.size(); j++) {
@@ -401,7 +396,7 @@ static vector<SgStatement*> optimizeOperatorOrder(SgForStmt* loop, vector<Operat
                 bool hasDependents = false;
                 for (size_t j = currentPos + 1; j < newOrder.size(); j++) {
                     SgStatement* candidate = newOrder[j];
-                    OperatorInfo* candidateOpInfo = stmtToOpInfo[candidate];
+                    const OperatorInfo* candidateOpInfo = stmtToOpInfo[candidate];
                     if (candidateOpInfo) {
                         for (const string& definedVar : opInfo->definedVars) {
                             if (candidateOpInfo->usedVars.find(definedVar) != candidateOpInfo->usedVars.end()) {
@@ -409,7 +404,9 @@ static vector<SgStatement*> optimizeOperatorOrder(SgForStmt* loop, vector<Operat
                                 break;
                             }
                         }
-                        if (hasDependents) break;
+
+                        if (hasDependents) 
+                            break;
                     }
                 }
                 
@@ -424,7 +421,7 @@ static vector<SgStatement*> optimizeOperatorOrder(SgForStmt* loop, vector<Operat
                 
                 for (size_t j = 0; j < currentPos && j < newOrder.size(); j++) {
                     SgStatement* candidate = newOrder[j];
-                    OperatorInfo* candidateOpInfo = stmtToOpInfo[candidate];
+                    const OperatorInfo* candidateOpInfo = stmtToOpInfo[candidate];
                     if (candidateOpInfo) {
                         bool usesDefinedVar = false;
                         for (const string& definedVar : opInfo->definedVars) {
@@ -433,6 +430,7 @@ static vector<SgStatement*> optimizeOperatorOrder(SgForStmt* loop, vector<Operat
                                 break;
                             }
                         }
+
                         if (usesDefinedVar) {
                             targetPos = j;
                             break;
@@ -463,7 +461,7 @@ static vector<SgStatement*> optimizeOperatorOrder(SgForStmt* loop, vector<Operat
                     
                     for (size_t j = bestPosIdx + 1; j < currentPos && j < newOrder.size(); j++) {
                         SgStatement* candidate = newOrder[j];
-                        OperatorInfo* candidateOpInfo = stmtToOpInfo[candidate];
+                        const OperatorInfo* candidateOpInfo = stmtToOpInfo[candidate];
                         if (candidateOpInfo) {
                             bool definesUsedVar = false;
                             for (const string& usedVar : opInfo->usedVars) {
@@ -472,16 +470,15 @@ static vector<SgStatement*> optimizeOperatorOrder(SgForStmt* loop, vector<Operat
                                     break;
                                 }
                             }
-                            if (definesUsedVar) {
+                            if (definesUsedVar)
                                 targetPos = j + 1;
                         }
                     }
-                    }
                     
                     bool wouldBreakDependency = false;
                     for (size_t j = targetPos; j < currentPos && j < newOrder.size(); j++) {
                         SgStatement* candidate = newOrder[j];
-                        OperatorInfo* candidateOpInfo = stmtToOpInfo[candidate];
+                        const OperatorInfo* candidateOpInfo = stmtToOpInfo[candidate];
                         if (candidateOpInfo) {
                             for (const string& definedVar : opInfo->definedVars) {
                                 if (candidateOpInfo->usedVars.find(definedVar) != candidateOpInfo->usedVars.end()) {
@@ -489,7 +486,9 @@ static vector<SgStatement*> optimizeOperatorOrder(SgForStmt* loop, vector<Operat
                                     break;
                                 }
                             }
-                            if (wouldBreakDependency) break;
+
+                            if (wouldBreakDependency) 
+                                break;
                         }
                     }
                     
@@ -512,18 +511,19 @@ static vector<SgStatement*> optimizeOperatorOrder(SgForStmt* loop, vector<Operat
         
         for (size_t i = 0; i < newOrder.size(); i++) {
             SgStatement* stmt = newOrder[i];
-            OperatorInfo* opInfo = stmtToOpInfo[stmt];
+            const OperatorInfo* opInfo = stmtToOpInfo[stmt];
-            if (!opInfo) continue;
+            if (!opInfo) 
+                continue;
             
             for (size_t j = 0; j < i; j++) {
                 SgStatement* prevStmt = newOrder[j];
-                OperatorInfo* prevOpInfo = stmtToOpInfo[prevStmt];
+                const OperatorInfo* prevOpInfo = stmtToOpInfo[prevStmt];
-                if (!prevOpInfo) continue;
+                if (!prevOpInfo)
+                    continue;
                 
                 pair<SgStatement*, SgStatement*> key = make_pair(stmt, prevStmt);
-                if (triedPairs.find(key) != triedPairs.end()) {
+                if (triedPairs.find(key) != triedPairs.end())
                     continue;
-                }
                 
                 bool violation = false;
                 for (const string& definedVar : opInfo->definedVars) {
@@ -539,8 +539,10 @@ static vector<SgStatement*> optimizeOperatorOrder(SgForStmt* loop, vector<Operat
                     bool wouldCreateViolation = false;
                     for (size_t k = j; k < i; k++) {
                         SgStatement* betweenStmt = newOrder[k];
-                        OperatorInfo* betweenOpInfo = stmtToOpInfo[betweenStmt];
+                        const OperatorInfo* betweenOpInfo = stmtToOpInfo[betweenStmt];
-                        if (!betweenOpInfo) continue;
+
+                        if (!betweenOpInfo)
+                            continue;
                         
                         for (const string& usedVar : opInfo->usedVars) {
                             if (betweenOpInfo->definedVars.find(usedVar) != betweenOpInfo->definedVars.end()) {
@@ -548,7 +550,9 @@ static vector<SgStatement*> optimizeOperatorOrder(SgForStmt* loop, vector<Operat
                                 break;
                             }
                         }
-                        if (wouldCreateViolation) break;
+
+                        if (wouldCreateViolation)
+                            break;
                     }
                     
                     if (!wouldCreateViolation) {
@@ -559,27 +563,31 @@ static vector<SgStatement*> optimizeOperatorOrder(SgForStmt* loop, vector<Operat
                     }
                 }
             }
-            if (dependencyViolation) break;
+
+            if (dependencyViolation)
+                break;
         }
     }
     
     return newOrder;
 }
 
-static bool applyOperatorReordering(SgForStmt* loop, vector<SgStatement*>& newOrder) {
+static bool applyOperatorReordering(SgForStmt* loop, const vector<SgStatement*>& newOrder) {
-    if (!loop || newOrder.empty()) return false;
+    if (!loop || newOrder.empty()) 
+        return false;
     
     SgStatement* loopStart = loop->lexNext();
     SgStatement* loopEnd = loop->lastNodeOfStmt();
     
-    if (!loopStart || !loopEnd) return false;
+    if (!loopStart || !loopEnd) 
+        return false;
     
     vector<SgStatement*> originalOrder;
     SgStatement* current = loopStart;
     while (current && current != loopEnd) {
-        if (isSgExecutableStatement(current) && current->variant() == ASSIGN_STAT) {
+        if (isSgExecutableStatement(current) && current->variant() == ASSIGN_STAT)
             originalOrder.push_back(current);
-        }
+
         current = current->lexNext();
     }
     
@@ -591,13 +599,12 @@ static bool applyOperatorReordering(SgForStmt* loop, vector<SgStatement*>& newOr
                 break;
             }
         }
-    } else {
+    } 
+    else
         orderChanged = true;
-    }
     
-    if (!orderChanged) {
+    if (!orderChanged)
         return false;
-    }
 
     vector<SgStatement*> extractedStatements;
     vector<char*> savedComments;
@@ -607,13 +614,11 @@ static bool applyOperatorReordering(SgForStmt* loop, vector<SgStatement*>& newOr
     
     for (SgStatement* stmt : newOrder) {
         if (stmt && stmt != loop && stmt != loopEnd && extractedSet.find(stmt) == extractedSet.end()) {
-            if (control_tags.find(stmt->variant()) != control_tags.end()) {
+            if (control_tags.find(stmt->variant()) != control_tags.end())
                 continue;
-            }
             
-            if (!canSafelyExtract(stmt, loop)) {
+            if (!canSafelyExtract(stmt, loop))
                 continue;
-            }
             
             bool isMoving = false;
             for (size_t i = 0; i < originalOrder.size(); i++) {
@@ -628,9 +633,8 @@ static bool applyOperatorReordering(SgForStmt* loop, vector<SgStatement*>& newOr
                 }
             }
             
-            if (!isMoving) {
+            if (!isMoving)
                 continue;
-            }
             
             originalLineNumbers[stmt] = stmt->lineNumber();
             savedComments.push_back(stmt->comments() ? strdup(stmt->comments()) : nullptr);
@@ -650,7 +654,9 @@ static bool applyOperatorReordering(SgForStmt* loop, vector<SgStatement*>& newOr
         
         if (extractedSet.find(stmt) != extractedSet.end()) {
             SgStatement* stmtToInsert = stmtToExtracted[stmt];
-            if (!stmtToInsert) continue;
+
+            if (!stmtToInsert) 
+                continue;
             
             SgStatement* insertAfter = loop;
             
@@ -696,16 +702,15 @@ static bool applyOperatorReordering(SgForStmt* loop, vector<SgStatement*>& newOr
                 }
             }
             
-            if (commentIdx < savedComments.size() && savedComments[commentIdx]) {
+            if (commentIdx < savedComments.size() && savedComments[commentIdx])
                 stmtToInsert->setComments(savedComments[commentIdx]);
-            }
             
-            if (originalLineNumbers.find(stmt) != originalLineNumbers.end()) {
+            if (originalLineNumbers.find(stmt) != originalLineNumbers.end())
                 stmtToInsert->setlineNumber(originalLineNumbers[stmt]);
-            }
             
             SgStatement* controlParent = stmt->controlParent();
-            if (!controlParent) controlParent = loop;
+            if (!controlParent)
+                controlParent = loop;
             
             insertAfter->insertStmtAfter(*stmtToInsert, *controlParent);
             insertedStatements[stmt] = stmtToInsert;
@@ -713,26 +718,28 @@ static bool applyOperatorReordering(SgForStmt* loop, vector<SgStatement*>& newOr
     }
     
     for (char* comment : savedComments) {
-        if (comment) {
+        if (comment)
             free(comment);
     }
-    }
     
     return true;
 }
 
-vector<SAPFOR::BasicBlock*> findFuncBlocksByFuncStatement(SgStatement *st, map<FuncInfo*, vector<SAPFOR::BasicBlock*>>& FullIR) {
+vector<SAPFOR::BasicBlock*> findFuncBlocksByFuncStatement(SgStatement *st, const 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()
+        if (func.first->funcPointer->getCurrProcessFile() == forSt->getCurrProcessFile()
-            && func.first -> funcPointer -> lineNumber() == forSt -> lineNumber())
+            && 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*>> findAndAnalyzeLoops(SgStatement *st, const vector<SAPFOR::BasicBlock*>& blocks) {
     map<SgForStmt*, vector<SAPFOR::BasicBlock*>> result;
     SgStatement *lastNode = st->lastNodeOfStmt();
     
@@ -756,15 +763,17 @@ map<SgForStmt*, vector<SAPFOR::BasicBlock*>> findAndAnalyzeLoops(SgStatement *st
                 }
                 loopBody = loopBody -> lexNext();
             }
-            std::sort(result[forSt].begin(), result[forSt].end());
+            sort(result[forSt].begin(), result[forSt].end());
         }
         st = st -> lexNext();
     }
     return result;
 }
 
-static void processLoopRecursively(SgForStmt* loop, vector<SAPFOR::BasicBlock*> blocks, map<FuncInfo*, vector<SAPFOR::BasicBlock*>>& FullIR) {
+static void processLoopRecursively(SgForStmt* loop, const vector<SAPFOR::BasicBlock*>& blocks, 
-    if (!loop) return;
+                                   const map<FuncInfo*, vector<SAPFOR::BasicBlock*>>& FullIR) {
+    if (!loop) 
+        return;
     
     SgStatement* loopStart = loop->lexNext();
     SgStatement* loopEnd = loop->lastNodeOfStmt();
@@ -775,16 +784,16 @@ static void processLoopRecursively(SgForStmt* loop, vector<SAPFOR::BasicBlock*>
                 SgForStmt* nestedLoop = (SgForStmt*)current;
                 processLoopRecursively(nestedLoop, blocks, FullIR);
                 SgStatement* nestedEnd = nestedLoop->lastNodeOfStmt();
-                if (nestedEnd) {
+
+                if (nestedEnd)
                     current = nestedEnd->lexNext();
-                } else {
+                else
                     current = current->lexNext();
             } 
-            } else {
+            else
                 current = current->lexNext();
         }
     }
-    }
     
     vector<OperatorInfo> operators = analyzeOperatorsInLoop(loop, blocks, FullIR);
     if (!operators.empty()) {
@@ -794,10 +803,12 @@ static void processLoopRecursively(SgForStmt* loop, vector<SAPFOR::BasicBlock*>
     }
 }
 
-void runSwapOperators(SgFile *file, std::map<std::string, std::vector<LoopGraph*>>& loopGraph, std::map<FuncInfo*, std::vector<SAPFOR::BasicBlock*>>& FullIR, int& countOfTransform) {
+void moveOperators(SgFile *file, map<string, vector<LoopGraph*>>& loopGraph, 
+                   const map<FuncInfo*, vector<SAPFOR::BasicBlock*>>& FullIR, 
+                   int& countOfTransform) {
     countOfTransform += 1;
     
-    std::cout << "SWAP_OPERATORS Pass Started" << std::endl;
+    //cout << "MOVE_OPERATORS Pass Started" << endl;
 
     const int funcNum = file -> numberOfFunctions();
     
@@ -805,13 +816,11 @@ void runSwapOperators(SgFile *file, std::map<std::string, std::vector<LoopGraph*
         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) {
+        for (auto& loopForAnalyze: loopsMapping)
             processLoopRecursively(loopForAnalyze.first, loopForAnalyze.second, FullIR);
     }
-    }
     
-    std::cout << "SWAP_OPERATORS Pass Completed" << std::endl;
+    //cout << "MOVE_OPERATORS Pass Completed" << endl;
 }

src/Transformations/MoveOperators/move_operators.h

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

src/Transformations/ReplaceArraysInIO/replace_dist_arrays_in_io.cpp

@@ -504,7 +504,7 @@ static void replaceArrayInFragment(SgSymbol* replace_symb,
     }
 }
 
-static bool ioReginBorder(SgStatement* stat, SgStatement* last_io_bound)
+static bool ioRegionBorder(SgStatement* stat, SgStatement* last_io_bound)
 {
     auto var = stat->variant();
 
@@ -535,8 +535,6 @@ static bool ioReginBorder(SgStatement* stat, SgStatement* last_io_bound)
     if (last_io_bound && last_io_bound->lastNodeOfStmt() && last_io_bound->lastNodeOfStmt() == stat)
         return true;
 
-    int parent_var;
-
     if (var == CONTROL_END && border_stats.find(stat->controlParent()->variant()) != border_stats.end())
         return true;
 
@@ -602,6 +600,7 @@ void replaceDistributedArraysInIO(vector<ParallelRegion*>& regions,
 
                     auto var = curr_stmt->variant();
 
+                    // TODO: does not work with user regions
                     if (var == PROC_HEDR || var == PROG_HEDR || var == FUNC_HEDR)
                     {
                         current_func_info = NULL;
@@ -628,7 +627,7 @@ void replaceDistributedArraysInIO(vector<ParallelRegion*>& regions,
                             break;
                     }
 
-                    if (ioReginBorder(curr_stmt, last_io_bound))
+                    if (ioRegionBorder(curr_stmt, last_io_bound))
                     {
                         for (const auto& by_array_to_copy : need_replace)
                         {

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);
 
@@ -321,6 +319,8 @@ void InitPassesDependencies(map<passes, vector<passes>> &passDepsIn, set<passes>
     list({ CALL_GRAPH2, CALL_GRAPH, BUILD_IR, LOOP_GRAPH, LOOP_ANALYZER_DATA_DIST_S2 }) <= Pass(FIND_PRIVATE_ARRAYS_ANALYSIS);
     list({ FIND_PRIVATE_ARRAYS_ANALYSIS, CONVERT_LOOP_TO_ASSIGN, RESTORE_LOOP_FROM_ASSIGN, REVERT_SUBST_EXPR_RD }) <= Pass(FIND_PRIVATE_ARRAYS);
 
+    list({ BUILD_IR, CALL_GRAPH2, RESTORE_LOOP_FROM_ASSIGN, REVERT_SUBST_EXPR_RD }) <= Pass(MOVE_OPERATORS);
+
     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,
                                    REVERSE_CREATED_NESTED_LOOPS, PREDICT_SCHEME, CALCULATE_STATS_SCHEME, REVERT_SPF_DIRS, CLEAR_SPF_DIRS, TRANSFORM_SHADOW_IF_FULL,

src/Utils/version.h

@@ -1,3 +1,3 @@
 #pragma once
 
-#define VERSION_SPF "2450"
+#define VERSION_SPF "2453"

src/VisualizerCalls/get_information.cpp

@@ -1802,6 +1802,13 @@ int SPF_InsertPrivateArrayDirectives(void*& context, int winHandler, short* opti
     return simpleTransformPass(FIND_PRIVATE_ARRAYS, options, projName, folderName, output, outputMessage);
 }
 
+int SPF_MoveOperators(void*& context, int winHandler, short* options, short* projName, short* folderName, string& output, string& outputMessage)
+{
+    MessageManager::clearCache();
+    MessageManager::setWinHandler(winHandler);
+    return simpleTransformPass(MOVE_OPERATORS, options, projName, folderName, output, outputMessage);
+}
+
 static inline void convertBackSlash(char *str, int strL)
 {
     for (int z = 0; z < strL; ++z)
@@ -2510,6 +2517,8 @@ const wstring Sapfor_RunTransformation(const char* transformName_c, const char*
         retCode = SPF_RenameIncludes(context, winHandler, optSh, projSh, fold, output, outputMessage);
     else if (whichRun == "SPF_InsertPrivateArrayDirectives")
         retCode = SPF_InsertPrivateArrayDirectives(context, winHandler, optSh, projSh, fold, output, outputMessage);
+    else if (whichRun == "SPF_MoveOperators")
+        retCode = SPF_MoveOperators(context, winHandler, optSh, projSh, fold, output, outputMessage);
     else if (whichRun == "SPF_CreateParallelVariant")
     {
         vector<string> splited;