fixes & improvements

.gitignore

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

CMakeLists.txt

@@ -208,6 +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
+        src/Transformations/SwapOperators/swap_operators.h)
 
 set(TRANSFORMS 
         ${TR_DEAD_CODE}
@@ -230,7 +232,8 @@ 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
@@ -464,6 +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 (CreateIntervals FILES ${CREATE_INTER_T})

src/Sapfor.cpp

@@ -90,6 +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 "ProjectParameters/projectParameters.h"
 
@@ -941,6 +942,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());
@@ -1037,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())
     {
@@ -2339,6 +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:
         runAnalysis(*project, curr_regime, true, "", folderName);
         break;
     case INLINE_PROCEDURES:

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,
@@ -321,6 +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[CREATE_PARALLEL_REGIONS] = "CREATE_PARALLEL_REGIONS";
     passNames[PRIVATE_REMOVING_ANALYSIS] = "PRIVATE_REMOVING_ANALYSIS";
     passNames[PRIVATE_REMOVING] = "PRIVATE_REMOVING";

src/Transformations/SwapOperators/swap_operators.cpp

@@ -0,0 +1,817 @@
+#include <map>
+#include <unordered_set>
+#include <vector>
+#include <queue>
+#include <iostream>
+#include <algorithm>
+
+#include "../../Utils/errors.h"
+#include "../../Utils/SgUtils.h"
+#include "../../GraphCall/graph_calls.h"
+#include "../../GraphCall/graph_calls_func.h"
+#include "../../CFGraph/CFGraph.h"
+#include "../../CFGraph/IR.h"
+#include "../../GraphLoop/graph_loops.h"
+#include "swap_operators.h"
+
+using namespace std;
+
+string getNameByArg(SAPFOR::Argument* arg);
+
+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()) {
+                result.push_back(instruction);
+            }
+        }
+    }
+    return result;
+}
+
+unordered_set<int> loop_tags = {FOR_NODE};
+unordered_set<int> control_tags = {IF_NODE, ELSEIF_NODE, DO_WHILE_NODE, WHILE_NODE, LOGIF_NODE};
+unordered_set<int> control_end_tags = {CONTROL_END};
+
+struct OperatorInfo {
+    SgStatement* stmt;
+    set<string> usedVars;
+    set<string> definedVars;
+    int lineNumber;
+    bool isMovable;
+    
+    OperatorInfo(SgStatement* s) : stmt(s), lineNumber(s->lineNumber()), isMovable(true) {}
+};
+
+static bool isStatementEmbedded(SgStatement* stmt, SgStatement* parent) {
+    if (!stmt || !parent || stmt == parent) return false;
+    
+    if (parent->variant() == LOGIF_NODE) {
+        if (stmt->lineNumber() == parent->lineNumber()) {
+            return true;
+        }
+        
+        SgStatement* current = parent;
+        SgStatement* lastNode = parent->lastNodeOfStmt();
+
+        while (current && current != lastNode) {
+            if (current == stmt) {
+                return true;
+            }
+            if (current->isIncludedInStmt(*stmt)) {
+                return true;
+            }
+            current = current->lexNext();
+        }
+    }
+    
+    if (parent->isIncludedInStmt(*stmt)) {
+        return true;
+    }
+    
+    return false;
+}
+
+static bool isLoopBoundary(SgStatement* stmt) {
+    if (!stmt) return false;
+    
+    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;
+    
+    SgStatement* loopStart = loop->lexNext();
+    SgStatement* loopEnd = loop->lastNodeOfStmt();
+    if (!loopStart || !loopEnd) return false;
+    
+    if (stmt->lineNumber() < loopStart->lineNumber() || stmt->lineNumber() > loopEnd->lineNumber()) {
+        return false;
+    }
+    
+    SgStatement* current = loopStart;
+    
+    while (current && current != loopEnd) {
+        
+        if (current->variant() == FOR_NODE && current != loop) {
+            SgForStmt* nestedLoop = (SgForStmt*)current;
+            SgStatement* nestedStart = nestedLoop->lexNext();
+            SgStatement* nestedEnd = nestedLoop->lastNodeOfStmt();
+            
+            if (nestedStart && nestedEnd && 
+                stmt->lineNumber() >= nestedStart->lineNumber() && 
+                stmt->lineNumber() <= nestedEnd->lineNumber()) {
+                return true;
+            }
+        }
+        
+        current = current->lexNext();
+    }
+    
+    return false;
+}
+
+static bool canSafelyExtract(SgStatement* stmt, SgForStmt* loop) {
+    if (!stmt || !loop) return false;
+    
+    if (isLoopBoundary(stmt)) {
+        return false;
+    }
+    
+    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;
+    
+    SgStatement* current = loopStart;
+    
+    while (current && current != loopEnd) {
+        if (current->variant() == LOGIF_NODE && current->lineNumber() == stmt->lineNumber()) {
+            return false;
+        }
+
+        if (control_tags.find(current->variant()) != control_tags.end()) {
+            if (isStatementEmbedded(stmt, current)) {
+                return false;
+            }
+        }
+        if (current == stmt) break;
+        current = current->lexNext();
+    }
+    
+    return true;
+}
+
+static vector<OperatorInfo> analyzeOperatorsInLoop(SgForStmt* loop, vector<SAPFOR::BasicBlock*> blocks, map<FuncInfo*, vector<SAPFOR::BasicBlock*>>& FullIR) {
+    vector<OperatorInfo> operators;
+    SgStatement* loopStart = loop->lexNext();
+    SgStatement* loopEnd = loop->lastNodeOfStmt();
+    
+    if (!loopStart || !loopEnd) {
+        return operators;
+    }
+    
+    SgStatement* current = loopStart;
+    unordered_set<SgStatement*> visited;
+    
+    while (current && current != loopEnd) {
+        
+        if (visited.find(current) != visited.end()) {
+            break;
+        }
+        visited.insert(current);
+        
+        if (isLoopBoundary(current)) {
+            current = current->lexNext();
+            continue;
+        }
+        
+        if (current->variant() == FOR_NODE && current != loop) {
+            SgStatement* nestedEnd = current->lastNodeOfStmt();
+            if (nestedEnd) {
+                current = nestedEnd->lexNext();
+            } else {
+                current = current->lexNext();
+            }
+            continue;
+        }
+        
+        if (isSgExecutableStatement(current)) {
+            if (control_tags.find(current->variant()) != control_tags.end()) {
+                current = current->lexNext();
+                continue;
+            }
+            if (current->variant() != ASSIGN_STAT) {
+                current = current->lexNext();
+                continue;
+            }
+            
+            OperatorInfo opInfo(current);
+            
+            vector<SAPFOR::IR_Block*> irBlocks = findInstructionsFromOperator(current, blocks);
+            for (auto irBlock : irBlocks) {
+                if (!irBlock || !irBlock->getInstruction()) continue;
+                
+                SAPFOR::Instruction* instr = irBlock->getInstruction();
+                
+                if (instr->getArg1()) {
+                    string varName = getNameByArg(instr->getArg1());
+                    if (!varName.empty()) {
+                        opInfo.usedVars.insert(varName);
+                    }
+                }
+                if (instr->getArg2()) {
+                    string varName = getNameByArg(instr->getArg2());
+                    if (!varName.empty()) {
+                        opInfo.usedVars.insert(varName);
+                    }
+                }
+                if (instr->getResult()) {
+                    string varName = getNameByArg(instr->getResult());
+                    if (!varName.empty()) {
+                        opInfo.definedVars.insert(varName);
+                    }
+                }
+            }
+            
+            operators.push_back(opInfo);
+        }
+        current = current->lexNext();
+    }
+    
+    return operators;
+}
+
+static map<string, vector<SgStatement*>> findVariableDefinitions(SgForStmt* loop, vector<OperatorInfo>& operators) {
+    map<string, vector<SgStatement*>> varDefinitions;
+    for (auto& op : operators) {
+        for (const string& var : op.definedVars) {
+            varDefinitions[var].push_back(op.stmt);
+        }
+    }
+    return varDefinitions;
+}
+
+static int calculateDistance(SgStatement* from, SgStatement* to) {
+    if (!from || !to) return INT_MAX;
+    return abs(to->lineNumber() - from->lineNumber());
+}
+
+static SgStatement* findBestPosition(SgStatement* operatorStmt, vector<OperatorInfo>& operators, map<string, vector<SgStatement*>>& varDefinitions, SgForStmt* loop) {
+    OperatorInfo* opInfo = nullptr;
+    for (auto& op : operators) {
+        if (op.stmt == operatorStmt) {
+            opInfo = &op;
+            break;
+        }
+    }
+    
+    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]) {
+                if (defStmt->lineNumber() < operatorStmt->lineNumber()) {
+                    if (defStmt->controlParent() == operatorStmt->controlParent()) {
+                        if (defStmt->lineNumber() > bestLine) {
+                            bestLine = defStmt->lineNumber();
+                            bestPos = defStmt;
+                        }
+                    }
+                }
+            }
+        }
+    }
+    
+    if (!bestPos) {
+        bool allLoopCarried = true;
+        bool hasAnyDefinition = false;
+        
+        for (const string& usedVar : opInfo->usedVars) {
+            if (varDefinitions.find(usedVar) != varDefinitions.end()) {
+                for (SgStatement* defStmt : varDefinitions[usedVar]) {
+                    if (defStmt == operatorStmt) {
+                        continue;
+                    }
+                    
+                    hasAnyDefinition = true;
+                    
+                    if (defStmt->lineNumber() < operatorStmt->lineNumber() &&
+                        defStmt->controlParent() == operatorStmt->controlParent()) {
+                        allLoopCarried = false;
+                        break;
+                    }
+                }
+            }
+            if (!allLoopCarried) break;
+        }
+        
+        if (allLoopCarried || (!hasAnyDefinition && !opInfo->usedVars.empty())) {
+            SgStatement* loopStart = loop->lexNext();
+            return loopStart;
+        }
+    }
+    
+    return bestPos;
+}
+
+static bool canMoveTo(SgStatement* from, SgStatement* to, SgForStmt* loop) {
+    if (!from || !to || from == to) return false;
+    
+    SgStatement* loopStart = loop->lexNext();
+    SgStatement* loopEnd = loop->lastNodeOfStmt();
+    
+    if (!loopStart || !loopEnd) return false;
+    
+    if (to == loopStart) {
+        SgStatement* fromControlParent = from->controlParent();
+        if (!fromControlParent) fromControlParent = loop;
+        return fromControlParent == loop || fromControlParent == loopStart->controlParent();
+    }
+    
+    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()) {
+        return false;
+    }
+    
+    if (from->controlParent() != to->controlParent()) {
+        return false;
+    }
+    
+    SgStatement* current = to->lexNext();
+    while (current && current != from && current != loopEnd) {
+        if (control_tags.find(current->variant()) != control_tags.end()) {
+            SgStatement* controlEnd = current->lastNodeOfStmt();
+            if (controlEnd && from->lineNumber() <= controlEnd->lineNumber()) {
+                if (from->controlParent() == current && to->controlParent() != current) {
+                    return false;
+                }
+            }
+        }
+        current = current->lexNext();
+    }
+    
+    return true;
+}
+
+static vector<SgStatement*> optimizeOperatorOrder(SgForStmt* loop, vector<OperatorInfo>& operators, map<string, vector<SgStatement*>>& varDefinitions) {
+    vector<SgStatement*> newOrder;
+    for (auto& op : operators) {
+        newOrder.push_back(op.stmt);
+    }
+    
+    map<SgStatement*, OperatorInfo*> stmtToOpInfo;
+    for (auto& op : operators) {
+        stmtToOpInfo[op.stmt] = &op;
+    }
+    
+    bool changed = true;
+    int iterations = 0;
+    const int MAX_ITERATIONS = 50;
+    
+    while (changed && iterations < MAX_ITERATIONS) {
+        changed = false;
+        iterations++;
+        
+        for (int i = operators.size() - 1; i >= 0; i--) {
+            if (!operators[i].isMovable) continue;
+            
+            SgStatement* stmt = operators[i].stmt;
+            OperatorInfo* opInfo = stmtToOpInfo[stmt];
+            if (!opInfo) continue;
+            
+            size_t currentPos = 0;
+            for (size_t j = 0; j < newOrder.size(); j++) {
+                if (newOrder[j] == stmt) {
+                    currentPos = j;
+                    break;
+                }
+            }
+            
+            SgStatement* bestPos = findBestPosition(stmt, operators, varDefinitions, loop);
+            
+            if (!bestPos) {
+                bool hasDependents = false;
+                for (size_t j = currentPos + 1; j < newOrder.size(); j++) {
+                    SgStatement* candidate = newOrder[j];
+                    OperatorInfo* candidateOpInfo = stmtToOpInfo[candidate];
+                    if (candidateOpInfo) {
+                        for (const string& definedVar : opInfo->definedVars) {
+                            if (candidateOpInfo->usedVars.find(definedVar) != candidateOpInfo->usedVars.end()) {
+                                hasDependents = true;
+                                break;
+                            }
+                        }
+                        if (hasDependents) break;
+                    }
+                }
+                
+                continue;
+            }
+            
+            size_t targetPos = 0;
+            bool foundTarget = false;
+            
+            if (bestPos == loop->lexNext()) {
+                targetPos = 0;
+                
+                for (size_t j = 0; j < currentPos && j < newOrder.size(); j++) {
+                    SgStatement* candidate = newOrder[j];
+                    OperatorInfo* candidateOpInfo = stmtToOpInfo[candidate];
+                    if (candidateOpInfo) {
+                        bool usesDefinedVar = false;
+                        for (const string& definedVar : opInfo->definedVars) {
+                            if (candidateOpInfo->usedVars.find(definedVar) != candidateOpInfo->usedVars.end()) {
+                                usesDefinedVar = true;
+                                break;
+                            }
+                        }
+                        if (usesDefinedVar) {
+                            targetPos = j;
+                            break;
+                        }
+                    }
+                }
+                
+                foundTarget = true;
+                
+                if (currentPos != targetPos && canMoveTo(stmt, bestPos, loop)) {
+                    newOrder.erase(newOrder.begin() + currentPos);
+                    newOrder.insert(newOrder.begin() + targetPos, stmt);
+                    changed = true;
+                }
+            } else {
+                size_t bestPosIdx = 0;
+                bool foundBestPos = false;
+                for (size_t j = 0; j < newOrder.size(); j++) {
+                    if (newOrder[j] == bestPos) {
+                        bestPosIdx = j;
+                        foundBestPos = true;
+                        break;
+                    }
+                }
+                
+                if (foundBestPos) {
+                    targetPos = bestPosIdx + 1;
+                    
+                    for (size_t j = bestPosIdx + 1; j < currentPos && j < newOrder.size(); j++) {
+                        SgStatement* candidate = newOrder[j];
+                        OperatorInfo* candidateOpInfo = stmtToOpInfo[candidate];
+                        if (candidateOpInfo) {
+                            bool definesUsedVar = false;
+                            for (const string& usedVar : opInfo->usedVars) {
+                                if (candidateOpInfo->definedVars.find(usedVar) != candidateOpInfo->definedVars.end()) {
+                                    definesUsedVar = true;
+                                    break;
+                                }
+                            }
+                            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];
+                        if (candidateOpInfo) {
+                            for (const string& definedVar : opInfo->definedVars) {
+                                if (candidateOpInfo->usedVars.find(definedVar) != candidateOpInfo->usedVars.end()) {
+                                    wouldBreakDependency = true;
+                                    break;
+                                }
+                            }
+                            if (wouldBreakDependency) break;
+                        }
+                    }
+                    
+                    if (!wouldBreakDependency && currentPos > targetPos && canMoveTo(stmt, bestPos, loop)) {
+                        newOrder.erase(newOrder.begin() + currentPos);
+                        newOrder.insert(newOrder.begin() + targetPos, stmt);
+                        changed = true;
+                    }
+                }
+            }
+        }
+    }
+    
+    bool dependencyViolation = true;
+    set<pair<SgStatement*, SgStatement*>> triedPairs;
+    
+    while (dependencyViolation) {
+        dependencyViolation = false;
+        triedPairs.clear();
+        
+        for (size_t i = 0; i < newOrder.size(); i++) {
+            SgStatement* stmt = newOrder[i];
+            OperatorInfo* opInfo = stmtToOpInfo[stmt];
+            if (!opInfo) continue;
+            
+            for (size_t j = 0; j < i; j++) {
+                SgStatement* prevStmt = newOrder[j];
+                OperatorInfo* prevOpInfo = stmtToOpInfo[prevStmt];
+                if (!prevOpInfo) continue;
+                
+                pair<SgStatement*, SgStatement*> key = make_pair(stmt, prevStmt);
+                if (triedPairs.find(key) != triedPairs.end()) {
+                    continue;
+                }
+                
+                bool violation = false;
+                for (const string& definedVar : opInfo->definedVars) {
+                    if (prevOpInfo->usedVars.find(definedVar) != prevOpInfo->usedVars.end()) {
+                        violation = true;
+                        break;
+                    }
+                }
+                
+                if (violation) {
+                    triedPairs.insert(key);
+                    
+                    bool wouldCreateViolation = false;
+                    for (size_t k = j; k < i; k++) {
+                        SgStatement* betweenStmt = newOrder[k];
+                        OperatorInfo* betweenOpInfo = stmtToOpInfo[betweenStmt];
+                        if (!betweenOpInfo) continue;
+                        
+                        for (const string& usedVar : opInfo->usedVars) {
+                            if (betweenOpInfo->definedVars.find(usedVar) != betweenOpInfo->definedVars.end()) {
+                                wouldCreateViolation = true;
+                                break;
+                            }
+                        }
+                        if (wouldCreateViolation) break;
+                    }
+                    
+                    if (!wouldCreateViolation) {
+                        newOrder.erase(newOrder.begin() + i);
+                        newOrder.insert(newOrder.begin() + j, stmt);
+                        dependencyViolation = true;
+                        break;
+                    }
+                }
+            }
+            if (dependencyViolation) break;
+        }
+    }
+    
+    return newOrder;
+}
+
+static bool applyOperatorReordering(SgForStmt* loop, vector<SgStatement*>& newOrder) {
+    if (!loop || newOrder.empty()) return false;
+    
+    SgStatement* loopStart = loop->lexNext();
+    SgStatement* loopEnd = loop->lastNodeOfStmt();
+    
+    if (!loopStart || !loopEnd) return false;
+    
+    vector<SgStatement*> originalOrder;
+    SgStatement* current = loopStart;
+    while (current && current != loopEnd) {
+        if (isSgExecutableStatement(current) && current->variant() == ASSIGN_STAT) {
+            originalOrder.push_back(current);
+        }
+        current = current->lexNext();
+    }
+    
+    bool orderChanged = false;
+    if (originalOrder.size() == newOrder.size()) {
+        for (size_t i = 0; i < originalOrder.size(); i++) {
+            if (originalOrder[i] != newOrder[i]) {
+                orderChanged = true;
+                break;
+            }
+        }
+    } else {
+        orderChanged = true;
+    }
+    
+    if (!orderChanged) {
+        return false;
+    }
+    
+    vector<SgStatement*> extractedStatements;
+    vector<char*> savedComments;
+    unordered_set<SgStatement*> extractedSet;
+    map<SgStatement*, int> originalLineNumbers;
+    map<SgStatement*, SgStatement*> stmtToExtracted;
+    
+    for (SgStatement* stmt : newOrder) {
+        if (stmt && stmt != loop && stmt != loopEnd && extractedSet.find(stmt) == extractedSet.end()) {
+            if (control_tags.find(stmt->variant()) != control_tags.end()) {
+                continue;
+            }
+            
+            if (!canSafelyExtract(stmt, loop)) {
+                continue;
+            }
+            
+            bool isMoving = false;
+            for (size_t i = 0; i < originalOrder.size(); i++) {
+                if (originalOrder[i] == stmt) {
+                    for (size_t j = 0; j < newOrder.size(); j++) {
+                        if (newOrder[j] == stmt && i != j) {
+                            isMoving = true;
+                            break;
+                        }
+                    }
+                    break;
+                }
+            }
+            
+            if (!isMoving) {
+                continue;
+            }
+            
+            originalLineNumbers[stmt] = stmt->lineNumber();
+            savedComments.push_back(stmt->comments() ? strdup(stmt->comments()) : nullptr);
+            SgStatement* extracted = stmt->extractStmt();
+            if (extracted) {
+                extractedStatements.push_back(extracted);
+                extractedSet.insert(stmt);
+                stmtToExtracted[stmt] = extracted;
+            }
+        }
+    }
+    
+    map<SgStatement*, SgStatement*> insertedStatements;
+    
+    for (size_t idx = 0; idx < newOrder.size(); idx++) {
+        SgStatement* stmt = newOrder[idx];
+        
+        if (extractedSet.find(stmt) != extractedSet.end()) {
+            SgStatement* stmtToInsert = stmtToExtracted[stmt];
+            if (!stmtToInsert) continue;
+            
+            SgStatement* insertAfter = loop;
+            
+            for (int i = idx - 1; i >= 0; i--) {
+                SgStatement* prevStmt = newOrder[i];
+                
+                if (extractedSet.find(prevStmt) != extractedSet.end()) {
+                    if (insertedStatements.find(prevStmt) != insertedStatements.end()) {
+                        insertAfter = insertedStatements[prevStmt];
+                        break;
+                    }
+                } else {
+                    SgStatement* search = loop->lexNext();
+                    while (search && search != loopEnd) {
+                        bool skip = false;
+                        for (size_t j = idx; j < newOrder.size(); j++) {
+                            if (extractedSet.find(newOrder[j]) != extractedSet.end() && 
+                                search == newOrder[j]) {
+                                skip = true;
+                                break;
+                            }
+                        }
+                        if (skip) {
+                            search = search->lexNext();
+                            continue;
+                        }
+                        
+                        if (search == prevStmt) {
+                            insertAfter = search;
+                            break;
+                        }
+                        search = search->lexNext();
+                    }
+                    if (insertAfter != loop) break;
+                }
+            }
+            
+            size_t commentIdx = 0;
+            for (size_t i = 0; i < extractedStatements.size(); i++) {
+                if (extractedStatements[i] == stmtToInsert) {
+                    commentIdx = i;
+                    break;
+                }
+            }
+            
+            if (commentIdx < savedComments.size() && savedComments[commentIdx]) {
+                stmtToInsert->setComments(savedComments[commentIdx]);
+            }
+            
+            if (originalLineNumbers.find(stmt) != originalLineNumbers.end()) {
+                stmtToInsert->setlineNumber(originalLineNumbers[stmt]);
+            }
+            
+            SgStatement* controlParent = stmt->controlParent();
+            if (!controlParent) controlParent = loop;
+            
+            insertAfter->insertStmtAfter(*stmtToInsert, *controlParent);
+            insertedStatements[stmt] = stmtToInsert;
+        }
+    }
+    
+    for (char* comment : savedComments) {
+        if (comment) {
+            free(comment);
+        }
+    }
+    
+    return true;
+}
+
+vector<SAPFOR::BasicBlock*> findFuncBlocksByFuncStatement(SgStatement *st, map<FuncInfo*, vector<SAPFOR::BasicBlock*>>& FullIR) {
+    vector<SAPFOR::BasicBlock*> result;
+    Statement* forSt = (Statement*)st;
+    for (auto& func: FullIR) {
+        if (func.first -> funcPointer -> getCurrProcessFile() == forSt -> getCurrProcessFile()
+            && func.first -> funcPointer -> lineNumber() == forSt -> lineNumber())
+            result = func.second;
+    }
+    return result;
+}
+
+map<SgForStmt*, vector<SAPFOR::BasicBlock*>> findAndAnalyzeLoops(SgStatement *st, vector<SAPFOR::BasicBlock*> blocks) {
+    map<SgForStmt*, vector<SAPFOR::BasicBlock*>> result;
+    SgStatement *lastNode = st->lastNodeOfStmt();
+    
+    while (st && st != lastNode) {
+        if (loop_tags.find(st -> variant()) != loop_tags.end()) {
+            SgForStmt *forSt = (SgForStmt*)st;
+            SgStatement *loopBody = forSt -> body();
+            SgStatement *lastLoopNode = st->lastNodeOfStmt();
+            unordered_set<int> blocks_nums;
+            
+            while (loopBody && loopBody != lastLoopNode) {
+                vector<SAPFOR::IR_Block*> irBlocks = findInstructionsFromOperator(loopBody, blocks);
+                if (!irBlocks.empty()) {
+                    SAPFOR::IR_Block* IR = irBlocks.front();
+                    if (IR && IR->getBasicBlock()) {
+                        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;
+}
+
+static void processLoopRecursively(SgForStmt* loop, vector<SAPFOR::BasicBlock*> blocks, map<FuncInfo*, vector<SAPFOR::BasicBlock*>>& FullIR) {
+    if (!loop) return;
+    
+    SgStatement* loopStart = loop->lexNext();
+    SgStatement* loopEnd = loop->lastNodeOfStmt();
+    if (loopStart && loopEnd) {
+        SgStatement* current = loopStart;
+        while (current && current != loopEnd) {
+            if (current->variant() == FOR_NODE && current != loop) {
+                SgForStmt* nestedLoop = (SgForStmt*)current;
+                processLoopRecursively(nestedLoop, blocks, FullIR);
+                SgStatement* nestedEnd = nestedLoop->lastNodeOfStmt();
+                if (nestedEnd) {
+                    current = nestedEnd->lexNext();
+                } else {
+                    current = current->lexNext();
+                }
+            } else {
+                current = current->lexNext();
+            }
+        }
+    }
+    
+    vector<OperatorInfo> operators = analyzeOperatorsInLoop(loop, blocks, FullIR);
+    if (!operators.empty()) {
+        map<string, vector<SgStatement*>> varDefinitions = findVariableDefinitions(loop, operators);
+        vector<SgStatement*> newOrder = optimizeOperatorOrder(loop, operators, varDefinitions);
+        applyOperatorReordering(loop, newOrder);
+    }
+}
+
+void runSwapOperators(SgFile *file, std::map<std::string, std::vector<LoopGraph*>>& loopGraph, std::map<FuncInfo*, std::vector<SAPFOR::BasicBlock*>>& FullIR, int& countOfTransform) {
+    countOfTransform += 1;
+    
+    std::cout << "SWAP_OPERATORS Pass Started" << std::endl;
+
+    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) {
+            processLoopRecursively(loopForAnalyze.first, loopForAnalyze.second, FullIR);
+        }
+    }
+    
+    std::cout << "SWAP_OPERATORS Pass Completed" << std::endl;
+}

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