Make pass correct

.gitignore

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

CMakeLists.txt

@@ -204,6 +204,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}
@@ -226,7 +228,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
@@ -459,6 +462,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/PrivateAnalyzer/private_arrays_search.cpp

@@ -124,30 +124,16 @@ static void SolveDataFlow(Region* DFG)
 map<LoopGraph*, ArrayAccessingIndexes>  FindPrivateArrays(map<string, vector<LoopGraph*>> &loopGraph, map<FuncInfo*, vector<SAPFOR::BasicBlock*>>& FullIR)
 {  
     map<LoopGraph*, ArrayAccessingIndexes> result;
-    for (const auto& [fileName, loops] : loopGraph)
+    for (const auto& [loopName, loops] : loopGraph)
     {
-        SgFile::switchToFile(fileName);
         for (const auto& loop : loops)
         {
-            SgStatement* search_func = loop->loop->GetOriginal();
-
-            while (search_func && (!isSgProgHedrStmt(search_func)))
-                search_func = search_func->controlParent();
-
             for (const auto& [funcInfo, blocks]: FullIR)
             {   
-                if (funcInfo->fileName == fileName && funcInfo->funcPointer->GetOriginal() == search_func)
-                {
-                    Region* loopRegion = new Region(loop, blocks);
-                    if (loopRegion->getBasickBlocks().size() <= 1)
-                    {
-                        delete(loopRegion);
-                        continue;
-                    }
-                    SolveDataFlow(loopRegion);
-                    result[loop] = loopRegion->array_priv;
-                    delete(loopRegion);
-                }
+                Region* loopRegion = new Region(loop, blocks);
+                SolveDataFlow(loopRegion);
+                result[loop] = loopRegion->array_priv;
+                delete(loopRegion);
             }
         }
     }

src/Sapfor.cpp

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

src/Transformations/SwapOperators/swap_operators.h

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

src/Utils/version.h

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

src/VisualizerCalls/get_information.cpp

@@ -1793,13 +1793,6 @@ int SPF_RenameIncludes(void*& context, int winHandler, short* options, short* pr
     return simpleTransformPass(RENAME_INLCUDES, options, projName, folderName, output, outputMessage);
 }
 
-int SPF_InsertPrivateArrayDirectives(void*& context, int winHandler, short* options, short* projName, short* folderName, string& output, string& outputMessage)
-{
-    MessageManager::clearCache();
-    MessageManager::setWinHandler(winHandler);
-    return simpleTransformPass(FIND_PRIVATE_ARRAYS, options, projName, folderName, output, outputMessage);
-}
-
 static inline void convertBackSlash(char *str, int strL)
 {
     for (int z = 0; z < strL; ++z)
@@ -2506,8 +2499,6 @@ const wstring Sapfor_RunTransformation(const char* transformName_c, const char*
         retCode = SPF_InsertImplicitNone(context, winHandler, optSh, projSh, fold, output, outputMessage);
     else if (whichRun == "SPF_RenameIncludes")
         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_CreateParallelVariant")
     {
         vector<string> splited;