some loop analysis done

.gitignore

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

src/SwapOperators/swapOperators.cpp

@@ -62,26 +62,80 @@ map<SgForStmt*, vector<SAPFOR::BasicBlock*>> findAndAnalyzeLoops(SgStatement *st
             SgStatement *loopBody = forSt -> body();
             SgStatement *lastLoopNode = st->lastNodeOfStmt();
             // part with find blocks and instructions of loops
+            unordered_set<int> blocks_nums;
             while (loopBody && loopBody != lastLoopNode)
             {
                 SAPFOR::IR_Block* IR = findInstructionsFromOperator(loopBody, blocks).front();
-                result[forSt].push_back(IR -> getBasicBlock());     // change this part for taking only unique blocks to vector
+                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;
 }
 
-vector<pair<int, int>> AnalyzeLoop(SgForStmt* forStatement, vector<SAPFOR::BasicBlock*> loopBlocks)
+map<SgStatement*, unordered_set<SgStatement*>> AnalyzeLoopAndFindDeps(SgForStmt* forStatement, vector<SAPFOR::BasicBlock*> loopBlocks, map<FuncInfo*, vector<SAPFOR::BasicBlock*>>& FullIR)
 {
-    vector<pair<int, int>> result;
+    map<SgStatement*, unordered_set<SgStatement*>> result;
-    // Analyze loop and create rules for moving operators in loops
+    for (SAPFOR::BasicBlock* bb: loopBlocks) {
-    // Return vector with moving rules (from line to line for operators)
+        std::map<SAPFOR::Argument*, std::set<int>> blockReachingDefinitions = bb -> getRD_In();
+        vector<SAPFOR::IR_Block*> instructions = bb -> getInstructions();
+        for (SAPFOR::IR_Block* irBlock: instructions) {
+            SAPFOR::Instruction* instr = irBlock -> getInstruction();
+            // take Argument 1 and it's RD and push operators to final set
+            if (instr -> getArg1() != NULL) {
+                SAPFOR::Argument* arg = instr -> getArg1();
+                set<int> prevInstructionsNumbers = blockReachingDefinitions[arg];
+                for (int i: prevInstructionsNumbers) {
+                    SAPFOR::Instruction* foundInstruction = getInstructionAndBlockByNumber(FullIR, i).first;
+                    if (foundInstruction != NULL) {
+                        SgStatement* prevOp = foundInstruction -> getOperator();
+                        if (prevOp != forStatement && instr -> getOperator() != forStatement && instr -> getOperator() -> lineNumber() > prevOp -> lineNumber())
+                            result[instr -> getOperator()].insert(prevOp);
+                    }
+                }
+            }
+            // take Argument 2 (if exists) and it's RD and push operators to final set
+            if (instr -> getArg2() != NULL) {
+                SAPFOR::Argument* arg = instr -> getArg2();
+                set<int> prevInstructionsNumbers = blockReachingDefinitions[arg];
+                for (int i: prevInstructionsNumbers) {
+                    SAPFOR::Instruction* foundInstruction = getInstructionAndBlockByNumber(FullIR, i).first;
+                    if (foundInstruction != NULL) {
+                        SgStatement* prevOp = foundInstruction -> getOperator();
+                        if (prevOp != forStatement && instr -> getOperator() != forStatement && instr -> getOperator() -> lineNumber() > prevOp -> lineNumber())
+                            result[instr -> getOperator()].insert(prevOp);
+                    }
+                }
+            }
+            // update RD
+            if (instr -> getResult() != NULL)
+                blockReachingDefinitions[instr -> getResult()] = {instr -> getNumber()};
+        }
+    }
     return result;
 }
 
+int RebuildLoop(int firstLine, int lastLine, map<SgStatement*, unordered_set<SgStatement*>> moveRules) {
+    // only cout done yet ((
+    cout << "LOOP ANALYZE FROM " << firstLine << " TO " << lastLine << " RES\n" << endl;
+    for (auto r: moveRules) {
+        cout << "OPERATOR: " << endl;
+        cout << r.first -> lineNumber() << r.first -> sunparse();
+        cout << "DEPENDS FROM NEXT: " << endl;
+        for (SgStatement* st: r.second)
+            cout << st -> lineNumber() << endl;
+    }
+    cout << "\n\n\n";
+    return 0;
+}
+
 void runSwapOperators(SgFile *file, std::map<std::string, std::vector<LoopGraph*>>& loopGraph, std::map<FuncInfo*, std::vector<SAPFOR::BasicBlock*>>& FullIR, int& countOfTransform)
 {
     std::cout << "SWAP_OPERATORS Pass" << std::endl;    // to remove
@@ -95,7 +149,12 @@ void runSwapOperators(SgFile *file, std::map<std::string, std::vector<LoopGraph*
         map<SgForStmt*, vector<SAPFOR::BasicBlock*>> loopsMapping = findAndAnalyzeLoops(st, blocks);
         for (pair<SgForStmt*, vector<SAPFOR::BasicBlock*>> loopForAnalyze: loopsMapping)
         {
-            vector<pair<int, int>> moveRules = AnalyzeLoop(loopForAnalyze.first, loopForAnalyze.second);
+            map<SgStatement*, unordered_set<SgStatement*>> moveRules = AnalyzeLoopAndFindDeps(loopForAnalyze.first, loopForAnalyze.second, FullIR);
+            if (moveRules.size() != 0) {
+                int firstLine = loopForAnalyze.first -> lineNumber();
+                int lastLine = loopForAnalyze.first -> lastNodeOfStmt() -> lineNumber();
+                countOfTransform += RebuildLoop(firstLine, lastLine, moveRules);
+            }
         }
     }