WIP: merge master

CMakeLists.txt

@@ -197,17 +197,19 @@ set(TRANSFORMS
         ${TR_PRIV_DEL}
         ${TR_IMPLICIT_NONE}
         ${TR_REPLACE_ARRAYS_IN_IO})
-        
+
-set(CFG src/CFGraph/IR.cpp
+set(CFG _src/CFGraph/IR.cpp
-        src/CFGraph/IR.h
+        _src/CFGraph/IR.h
-        src/CFGraph/CFGraph.cpp
+        _src/CFGraph/CFGraph.cpp
-        src/CFGraph/CFGraph.h
+        _src/CFGraph/CFGraph.h
-        src/CFGraph/RD_subst.cpp
+        _src/CFGraph/RD_subst.cpp
-        src/CFGraph/RD_subst.h
+        _src/CFGraph/RD_subst.h
-        src/CFGraph/live_variable_analysis.cpp
+        _src/CFGraph/live_variable_analysis.cpp
-        src/CFGraph/live_variable_analysis.h
+        _src/CFGraph/live_variable_analysis.h
-        src/CFGraph/private_variables_analysis.cpp
+        _src/CFGraph/private_variables_analysis.cpp
-        src/CFGraph/private_variables_analysis.h
+        _src/CFGraph/private_variables_analysis.h
+	_src/CFGraph/IRSSAForm.cpp
+	_src/CFGraph/IRSSAForm.h
         )
         
 set(DATA_FLOW

src/CFGraph/CFGraph.cpp

@@ -56,6 +56,23 @@ void BBlock::addInstruction(IR_Block* item)
     item->setBasicBlock(this);
 }
 
+void BBlock::addInstructionInFront(IR_Block* item)
+{
+    instructions.insert(instructions.begin(), item);
+    item->setBasicBlock(this);
+}
+
+void BBlock::addInstructionBeforeInstruction(IR_Block* item, Instruction* instruction)
+{
+    for (auto it = instructions.begin(); it != instructions.end(); ++it) {
+        if ((*it)->getInstruction() == instruction) {
+            instructions.insert(instructions.begin(), item);
+            item->setBasicBlock(this);
+            return;
+        }
+    }
+}
+
 int BBlock::removePrev(BBlock* removed)
 {
     auto it = std::remove(prev.begin(), prev.end(), removed);
@@ -512,7 +529,7 @@ static int buildReachingDefs(const vector<BBlock*>& CFG, const FuncInfo* currF,
     return iter;
 }
 
-//Kosaraju<6A>Sharir algorithm
+//Kosaraju<6A>Sharir algorithm
 static vector<int> getStronglyConnectedComps(vector<vector<int>>& g) {
     // 1. For each vertex u of the graph, mark u as unvisited. Let l be empty.
     auto size = g.size();

src/CFGraph/CFGraph.h

@@ -39,6 +39,8 @@ namespace SAPFOR
         BasicBlock(IR_Block* item);
         BasicBlock(const BasicBlock& copyFrom);
 
+        void addInstructionBeforeInstruction(IR_Block* item, Instruction* istruction);
+        void addInstructionInFront(IR_Block* item);
         void addInstruction(IR_Block* item);
         void addPrev(BasicBlock* prev_) { prev.push_back(prev_); }
         void addNext(BasicBlock* next_) { next.push_back(next_); }

src/CFGraph/IR.cpp

@@ -395,7 +395,7 @@ static SAPFOR::Argument* processExpression(SgExpression* ex, vector<IR_Block*>&
     if (ex)
     {
         const int var = ex->variant();
-        if ((var == VAR_REF || var == CONST_REF || var == LABEL_REF) && !ex->lhs() && !ex->rhs()) // <EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD> <20> <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>
+        if ((var == VAR_REF || var == CONST_REF || var == LABEL_REF) && !ex->lhs() && !ex->rhs()) // обращение к переменной
         {
             if (var == CONST_REF)
             {
@@ -1572,7 +1572,7 @@ vector<IR_Block*> buildIR(SgStatement* function, const FuncInfo* func, const vec
     else
         findReturn(0, blocks.size(), blocks, blocks.back()->getNumber());
 
-    // <EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD> <20><> GOTO <20> <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>
+    // добавление связей по GOTO и переходам
     for (int z = 0; z < blocks.size(); ++z)
     {
         auto op = blocks[z]->getInstruction()->getOperation();
@@ -1592,7 +1592,7 @@ vector<IR_Block*> buildIR(SgStatement* function, const FuncInfo* func, const vec
 
                 blocks[z]->setJump(it->second);
 
-                // <EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD><EFBFBD> <20><> <20><><EFBFBD><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>
+                // заменим метку на номер инструкции
                 arg->setValue(to_string(it->second->getNumber())); 
                 arg->setType(CFG_ARG_TYPE::INSTR);
             }
@@ -1613,3 +1613,140 @@ vector<IR_Block*> buildIR(SgStatement* function, const FuncInfo* func, const vec
 
     return blocks;
 }
+
+void dfs(SAPFOR::BasicBlock* block, vector<int>& visit, vector<pair<SAPFOR::BasicBlock*, SAPFOR::BasicBlock*>>& startAndEnd, SAPFOR::BasicBlock* prev) {
+    if (visit[block->getNumber()] == 2) {
+        cout << "error";
+        return;
+    }
+
+    if (visit[block->getNumber()] == 1) {
+        visit[block->getNumber()] = 2;
+        startAndEnd.push_back(make_pair(prev, block));
+        return;
+    }
+
+    visit[block->getNumber()] = 1;
+    for (auto i : block->getNext()) {
+        dfs(i, visit, startAndEnd, block);
+    }
+}
+
+void printBlock(SAPFOR::BasicBlock* block) {
+    cout << "block - " << block->getNumber() << endl;
+    cout << "next -";
+    for (auto i : block->getNext())
+    {
+        cout << " " << i->getNumber();
+    }
+    cout << endl << "prev -";
+    for (auto i : block->getPrev())
+    {
+        cout << " " << i->getNumber();
+    }
+    cout << endl;
+    
+    for (auto i : block->getInstructions())
+    {
+        cout << i->getNumber() << " " << i->getInstruction()->dump() << endl;
+    }
+
+    cout << endl;
+}
+
+void testIR(map<FuncInfo*, vector<SAPFOR::BasicBlock*>> fullIR) {
+    for (auto& i : fullIR)
+    {
+        for (auto j : i.second)
+            printBlock(j);
+
+        vector<IR_Block*> all;
+        for (auto j : i.second)
+            for (auto k : j->getInstructions())
+                all.push_back(k);
+
+        vector<int> visited(i.second.size(), 0);
+        vector<pair<SAPFOR::BasicBlock*, SAPFOR::BasicBlock*>> startAndEnd;
+        dfs(i.second[0], visited, startAndEnd, NULL);
+
+
+        vector<LoopGraph*> loops;
+        for (auto j : startAndEnd)
+        {
+            auto firstInstruction = j.second->getInstructions()[0]->getInstruction();
+            auto lastInstruction = j.first->getInstructions().back()->getInstruction();
+            Instruction* instructionAfterLoop;
+            for (auto a : fullIR)
+                for(auto b : a.second)
+                    for (auto c : b->getInstructions())
+                        if (c->getInstruction()->getNumber() == lastInstruction->getNumber() + 1)
+                        {
+                            instructionAfterLoop = c->getInstruction();
+                            break;
+                        }
+
+            //auto instructionAfterLoop = getInstructionByNumber(all, lastInstruction->getNumber() + 1);
+            cout << "first - " << firstInstruction->getNumber() << " last - " << lastInstruction->getNumber() << " after - " << instructionAfterLoop->getNumber() << endl;
+
+            if (firstInstruction->getOperator()->variant() == FOR_NODE) {
+                SgForStmt* stmt = isSgForStmt(firstInstruction->getOperator());
+
+                auto tmpLoop = new LoopGraph();
+                tmpLoop->isFor = true;
+                tmpLoop->lineNum = firstInstruction->getOperator()->lineNumber();
+                tmpLoop->lineNumAfterLoop = instructionAfterLoop->getOperator()->lineNumber();
+
+                cout << "for" << endl << stmt->sunparse() << endl;
+                cout << "loop start line " << tmpLoop->lineNum << endl;
+                cout << "after loop line " << tmpLoop->lineNumAfterLoop << endl << endl;
+                loops.push_back(tmpLoop);
+            } else if (firstInstruction->getOperator()->variant() == WHILE_NODE) {
+                SgWhileStmt* stmt = isSgWhileStmt(firstInstruction->getOperator());
+
+                auto tmpLoop = new LoopGraph();
+                tmpLoop->lineNum = firstInstruction->getOperator()->lineNumber();
+                tmpLoop->lineNumAfterLoop = instructionAfterLoop->getOperator()->lineNumber();
+
+                if (stmt->conditional() == NULL)
+                {
+                    //infinit loop
+                    cout << "infinit loop " << endl << stmt->sunparse() << endl;
+                }
+                else
+                {
+                    //while
+                    cout << "while " << endl << stmt->sunparse();
+                }
+
+                cout << "loop start line " << tmpLoop->lineNum << endl;
+                cout << "after loop line " << tmpLoop->lineNumAfterLoop << endl << endl;
+
+                loops.push_back(tmpLoop);
+            } else if (firstInstruction->getOperator()->variant() == LOOP_NODE) {
+                cout << "not known loop" << endl << firstInstruction->getOperator()->sunparse() << endl;
+            }
+            else { 
+                cout << "goto loop - " << firstInstruction->getOperator()->sunparse() << endl;
+            }
+        }
+
+
+        /*for (auto j : i.second) {
+            cout << j->getNumber() << endl << "in" << endl;
+            for (auto k : j->getRD_In()) {
+                cout << k.first->getMemTypeStr() << " - ";
+                for (auto h : k.second) {
+                    cout << h << " ";
+                }
+                cout << endl;
+            }
+            cout << "out" << endl;
+            for (auto k : j->getRD_Out()) {
+                cout << k.first->getMemTypeStr() << " - ";
+                for (auto h : k.second) {
+                    cout << h << " ";
+                }
+                cout << endl;
+            }*/        
+    }
+}

src/CFGraph/IR.h

@@ -42,6 +42,7 @@ namespace SAPFOR
         Argument() : number(lastNumArg++), type(CFG_ARG_TYPE::NONE), value(""), mType(CFG_MEM_TYPE::NONE_) { }
         Argument(CFG_ARG_TYPE type, CFG_MEM_TYPE mType) : number(lastNumArg++), type(type), mType(mType), value("") { }
         Argument(CFG_ARG_TYPE type, CFG_MEM_TYPE mType, const std::string& value) : number(lastNumArg++), type(type), mType(mType), value(value) { }
+        Argument(CFG_ARG_TYPE type, CFG_MEM_TYPE mType, const std::string& value, int num) : number(num), type(type), mType(mType), value(value) { }
         Argument(CFG_ARG_TYPE type, const std::string& value) : number(lastNumArg++), type(type), mType(CFG_MEM_TYPE::NONE_), value(value) 
         {
             if (type != CFG_ARG_TYPE::INSTR && type == CFG_ARG_TYPE::LAB &&
@@ -130,7 +131,7 @@ namespace SAPFOR
         {
             if (arg == NULL)
                 return "";
-            return arg->getValue();
+            return arg->getValue(); 
         }
     public:
 
@@ -198,7 +199,7 @@ namespace SAPFOR
         {
             std::string res = "";
 
-            std::string resultVal = getArgValue(result);
+            std::string resultVal = getArgValue(result); 
             std::string arg1Val = getArgValue(arg1);
             std::string arg2Val = getArgValue(arg2);
 
@@ -343,4 +344,6 @@ std::vector<SAPFOR::IR_Block*> buildIR(SgStatement* function, const FuncInfo* fu
 SAPFOR::Instruction* getInstructionByNumber(const std::vector<SAPFOR::IR_Block*>& blocks, int num);
 std::pair<SAPFOR::Instruction*, SAPFOR::BasicBlock*> getInstructionAndBlockByNumber(const std::map<FuncInfo*, std::vector<SAPFOR::BasicBlock*>>& CFGraph, int num);
 std::pair<SAPFOR::Instruction*, SAPFOR::BasicBlock*> getInstructionAndBlockByStatement(const std::map<FuncInfo*, std::vector<SAPFOR::BasicBlock*>>& CFGraph, SgStatement* stmt);
-int getParamIndex(SAPFOR::Argument* func_param, int max_index);
+int getParamIndex(SAPFOR::Argument* func_param, int max_index);
+
+void testIR(std::map<FuncInfo*, std::vector<SAPFOR::BasicBlock*>> fullIR);

src/CFGraph/IRSSAForm.cpp

@@ -0,0 +1,588 @@
+#include <stdlib.h>
+#include <stdio.h>
+#include <vector>
+#include <set>
+
+#include "../Utils/SgUtils.h"
+#include "../Utils/CommonBlock.h"
+#include "../GraphCall/graph_calls.h"
+#include "../ExpressionTransform/expr_transform.h"
+
+#include "dvm.h"
+#include "IR.h"
+#include "CFGraph.h"
+
+using namespace std;
+using namespace SAPFOR;
+
+typedef SAPFOR::BasicBlock BBlock;
+typedef SAPFOR::Argument BArgument;
+
+static void printBlock(BBlock* block) {
+    cout << "block - " << block->getNumber() << endl;
+    cout << "next -";
+    for (auto i : block->getNext())
+    {
+        cout << " " << i->getNumber();
+    }
+    cout << endl << "prev -";
+    for (auto i : block->getPrev())
+    {
+        cout << " " << i->getNumber();
+    }
+    cout << endl;
+
+    for (auto i : block->getInstructions())
+    {
+        string resValue = "";
+        string arg1Value = "";
+        string arg2Value = "";
+        if (i->getInstruction()->getResult() != nullptr && i->getInstruction()->getResult()->getType() == CFG_ARG_TYPE::VAR) {
+            resValue = i->getInstruction()->getResult()->getValue();
+            i->getInstruction()->getResult()->setValue(i->getInstruction()->getResult()->getValue() + to_string(i->getInstruction()->getResult()->getNumber()));
+        } 
+        if (i->getInstruction()->getArg1() != nullptr && i->getInstruction()->getArg1()->getType() == CFG_ARG_TYPE::VAR) {
+            arg1Value = i->getInstruction()->getArg1()->getValue();
+            i->getInstruction()->getArg1()->setValue(i->getInstruction()->getArg1()->getValue() + to_string(i->getInstruction()->getArg1()->getNumber()));
+        }
+        if (i->getInstruction()->getArg2() != nullptr && i->getInstruction()->getArg2()->getType() == CFG_ARG_TYPE::VAR) {
+            arg2Value = i->getInstruction()->getArg2()->getValue();
+            i->getInstruction()->getArg2()->setValue(i->getInstruction()->getArg2()->getValue() + to_string(i->getInstruction()->getArg2()->getNumber()));
+        }
+
+        cout << i->getNumber() << " " << i->getInstruction()->dump() << endl;// << (i->getInstruction()->getResult() != nullptr ? "   1 " : "   0 ") << (i->getInstruction()->getArg1() != nullptr ? "1 " : "0 ") << (i->getInstruction()->getArg2() != nullptr ? "1 " : "0 ") << endl;
+
+        /*if (i->getInstruction()->getResult() != nullptr) {
+            cout << "num - " << i->getInstruction()->getResult()->getNumber() << endl;
+        })*/
+
+        /*if (i->getInstruction()->getOperation() == CFG_OP::F_CALL) {
+            cout << endl;
+            cout << "arg1 - " << (i->getInstruction()->getArg1()->getType() == CFG_ARG_TYPE::FUNC ? "1" : "0") << "arg2 - " << (i->getInstruction()->getArg2()->getType() == CFG_ARG_TYPE::CONST ? "1" : "0") << "res - " << i->getInstruction()->getResult() << endl;
+        }*/
+        
+        if (i->getInstruction()->getResult() != nullptr && i->getInstruction()->getResult()->getType() == CFG_ARG_TYPE::VAR) {
+            i->getInstruction()->getResult()->setValue(resValue);
+        }
+        if (i->getInstruction()->getArg1() != nullptr && i->getInstruction()->getArg1()->getType() == CFG_ARG_TYPE::VAR) {
+            i->getInstruction()->getArg1()->setValue(arg1Value);
+        }
+        if (i->getInstruction()->getArg2() != nullptr && i->getInstruction()->getArg2()->getType() == CFG_ARG_TYPE::VAR) {
+            i->getInstruction()->getArg2()->setValue(arg2Value);
+        }
+    }
+
+    cout << endl;
+}
+template <typename T>
+static bool compareVectors(const vector<T>* vec1, const vector<T>* vec2) {
+    if (vec1 == vec2) {
+        return true;
+    }
+
+    if (!vec1 || !vec2) {
+        return false;
+    }
+
+    vector<T> sortedVec1 = *vec1;
+    vector<T> sortedVec2 = *vec2;
+
+    sort(sortedVec1.begin(), sortedVec1.end());
+    sort(sortedVec2.begin(), sortedVec2.end());
+
+    return sortedVec1 == sortedVec2;
+}
+
+template <typename T>
+static vector<T>* getCommonElements(const vector<vector<T>>* vectors) {
+    if (!vectors || vectors->empty()) {
+        return new vector<T>(); // Return an empty vector if input is null or empty
+    }
+
+    // Start with the first vector
+    vector<T>* commonElements = new vector<T>((*vectors)[0]);
+
+    for (size_t i = 1; i < vectors->size(); ++i) {
+        vector<T> tempCommon;
+
+        // Sort the current vector and common result for intersection
+        vector<T> sortedVec = (*vectors)[i];
+        sort(commonElements->begin(), commonElements->end());
+        sort(sortedVec.begin(), sortedVec.end());
+
+        // Find the intersection
+        set_intersection(
+            commonElements->begin(), commonElements->end(),
+            sortedVec.begin(), sortedVec.end(),
+            back_inserter(tempCommon)
+        );
+
+        // Update common result
+        *commonElements = tempCommon;
+
+        // If no common elements left, break early
+        if (commonElements->empty()) {
+            break;
+        }
+    }
+
+    return commonElements;
+}
+
+
+static map<BBlock*, vector<BBlock*>> findDominators(vector<BBlock*> blocks) {
+    map<BBlock*, vector<BBlock*>> result;
+
+    bool changed = true;
+    while (changed) {
+        changed = false;
+
+        for (auto currentBlock : blocks) {
+            auto pred = currentBlock->getPrev();
+            auto prevDominators = new vector<vector<BBlock*>>();
+
+            for (auto predBlock : pred)
+                prevDominators->push_back(result.find(predBlock) != result.end() ? result[predBlock] : blocks);
+
+            auto currentBlockResult = getCommonElements(prevDominators);
+            currentBlockResult->push_back(currentBlock);
+
+            if (result.find(currentBlock) == result.end() || !compareVectors(currentBlockResult, &result[currentBlock])) {
+                result[currentBlock] = *currentBlockResult;
+                changed = true;
+            }
+        }
+    }
+
+    return result;
+}
+
+static void RenumberBlocks(BBlock* current, int* n, map<int, int>* res, set<BBlock*>* visited) {
+    if (visited->find(current) != visited->end()) {
+        return;
+    }
+
+    visited->insert(current);
+
+    vector<BBlock*> nextBlocks = current->getNext();
+
+    sort(nextBlocks.begin(), nextBlocks.end(), [](BBlock* a, BBlock* b) {
+        return a->getInstructions()[0]->getInstruction()->getOperator()->lineNumber() > b->getInstructions()[0]->getInstruction()->getOperator()->lineNumber();
+    });
+
+    for (auto i : nextBlocks) {
+        RenumberBlocks(i, n, res, visited);
+    }
+
+    (*res)[current->getNumber()] = *n;
+    *n -= 1;
+}
+
+static map<BBlock*, vector<BBlock*>> findDominatorBorders(vector<BBlock*>& blocks, map<BBlock*, BBlock*>& iDominators) {
+    map<BBlock*, vector<BBlock*>> result;
+
+    for (auto block : blocks) {
+        result[block] = *(new vector<BBlock*>());
+    }
+
+    for (auto block : blocks) {
+        if (block->getPrev().size() > 1) {
+            for (auto prev : block->getPrev()) {
+                auto tmpBlock = prev;
+
+                while (tmpBlock != iDominators[block]) {
+                    result[tmpBlock].push_back(block);
+                    tmpBlock = iDominators[tmpBlock];
+                }
+            }
+        }
+    }
+
+    return result;
+}
+
+static BBlock* findImmediateDominatorsDfsHelper(BBlock* block, BBlock* currentBlock, BBlock* currentImmediateDominator, vector<BBlock*> &visited, map<BBlock*, vector<BBlock*>>& dominators) {
+    if (block == currentBlock) {
+        return currentImmediateDominator;
+    }
+    
+    if (find(visited.begin(), visited.end(), currentBlock) != visited.end()) {
+        return nullptr;
+    }
+    
+    visited.push_back(currentBlock);
+
+    if (find(dominators[block].begin(), dominators[block].end(), currentBlock) != dominators[block].end()) {
+        currentImmediateDominator = currentBlock;
+    }
+
+    for (auto nextBlock : currentBlock->getNext()) {
+        auto result = findImmediateDominatorsDfsHelper(block, nextBlock, currentImmediateDominator, visited, dominators);
+
+        if (result) {
+            return result;
+        }
+    }
+
+    return nullptr;
+}
+
+static map<BBlock*, BBlock*> findImmediateDominators(map<BBlock*, vector<BBlock*>>& dominators, BBlock* fistBlock) {
+    map<BBlock*, BBlock*> iDominators;
+
+    for (const auto& domPair : dominators) {
+        BBlock* block = domPair.first;
+        const vector<BBlock*>& domBlocks = domPair.second;
+        vector<BBlock*> visited;
+
+        if (block == fistBlock) {
+            continue;
+        }
+
+        iDominators[block] = findImmediateDominatorsDfsHelper(block, fistBlock, fistBlock, visited, dominators);
+    }
+
+    return iDominators;
+}
+
+static vector<BArgument*> getDefForBlock(const BBlock& block) {
+    vector<BArgument*> def;
+    const auto& instructions = block.getInstructions();
+
+    for (const auto& irBlock : instructions) {
+        if (irBlock) {
+            Instruction* instr = irBlock->getInstruction();
+
+            if (instr) {
+                BArgument* result = instr->getResult();
+                if (result) {
+                    def.push_back(result);
+                }
+            }
+        }
+    }
+
+    return def;
+}
+
+static pair<set<BArgument*>, map<BArgument*, set<BBlock*>>> getGlobalsAndVarBlocks(vector<BBlock*> blocks) {
+    set<BArgument*> globals;
+    map<BArgument*, set<BBlock*>> varBlocks;
+
+    for (auto block : blocks) {
+        set<BArgument*> def;
+        const auto& instructions = block->getInstructions();
+
+        for (const auto& irBlock : instructions) {
+            if (irBlock) {
+                Instruction* instr = irBlock->getInstruction();
+
+                if (instr) {
+                    auto arg1 = instr->getArg1();
+                    auto arg2 = instr->getArg2();
+                    auto res = instr->getResult();
+
+                    if (arg1 && arg1->getType() == CFG_ARG_TYPE::VAR && find(def.begin(), def.end(), arg1) == def.end()) {
+                        globals.insert(arg1);
+                    }
+                    if (arg2 && arg2->getType() == CFG_ARG_TYPE::VAR && find(def.begin(), def.end(), arg2) == def.end()) {
+                        globals.insert(arg2);
+                    }
+
+                    if (res && res->getType() == CFG_ARG_TYPE::VAR) {
+                        def.insert(res);
+                        varBlocks[res].insert(block);
+                    }
+                }
+            }
+        }
+    }
+
+    return make_pair(globals, varBlocks);
+}
+
+static vector<BBlock*> getBlocksWithFiFunctions(vector<BBlock*> blocks, set<BArgument*> globals, map<BArgument*, set<BBlock*>> varBlocks, map<BBlock*, vector<BBlock*>> dominatorBorders) {
+    vector<BBlock*> blocksWithFiFunctions;
+    auto fiFunc = new BArgument(CFG_ARG_TYPE::FUNC, CFG_MEM_TYPE::NONE_, "FI_FUNCTION");
+    auto paramCount = new BArgument(CFG_ARG_TYPE::CONST, CFG_MEM_TYPE::LOCAL_, "0");
+
+    for (auto var : globals) {
+        auto worklist = varBlocks[var];
+        set<BBlock*> hasFiFunction;
+
+        while (!worklist.empty()) {
+            auto block = *worklist.begin();
+            worklist.erase(block);
+
+            for (auto dfBlock : dominatorBorders[block]) {
+                if (hasFiFunction.find(dfBlock) == hasFiFunction.end()) {
+                    hasFiFunction.insert(dfBlock);
+
+                    Instruction* phiInstruction = new Instruction(CFG_OP::F_CALL, fiFunc, paramCount, var);
+
+                    //cout << "insert fi functio9n in " << dfBlock->getNumber() << " with var " << var->getValue() << endl;
+
+                    IR_Block* phiBlock = new IR_Block(phiInstruction);
+                    dfBlock->addInstructionInFront(phiBlock);
+
+                    blocksWithFiFunctions.push_back(dfBlock);
+                }
+            }
+        }
+    }
+
+    return blocksWithFiFunctions;
+}
+
+
+
+
+string ToString(CFG_ARG_TYPE type) {
+    switch (type) {
+    case CFG_ARG_TYPE::NONE: return "NONE";
+    case CFG_ARG_TYPE::REG: return "REG";
+    case CFG_ARG_TYPE::VAR: return "VAR";
+    case CFG_ARG_TYPE::ARRAY: return "ARRAY";
+    case CFG_ARG_TYPE::CONST: return "CONST";
+    case CFG_ARG_TYPE::FUNC: return "FUNC";
+    case CFG_ARG_TYPE::LAB: return "LAB";
+    case CFG_ARG_TYPE::INSTR: return "INSTR";
+    case CFG_ARG_TYPE::CONST_STR: return "CONST_STR";
+    case CFG_ARG_TYPE::RECORD: return "RECORD";
+    case CFG_ARG_TYPE::CONSTR_REF: return "CONSTR_REF";
+    default: return "UNKNOWN";
+    }
+}
+
+void restoreConnections(const vector<BBlock*>& originalBlocks, vector<BBlock*>& copiedBlocks) {
+    // Создаем отображение оригинальных блоков в их копии
+    map<BBlock*, BBlock*> blockMapping;
+    for (size_t i = 0; i < originalBlocks.size(); ++i) {
+        blockMapping[originalBlocks[i]] = copiedBlocks[i];
+    }
+
+    // Восстанавливаем связи между копиями
+    for (size_t i = 0; i < originalBlocks.size(); ++i) {
+        BBlock* originalBlock = originalBlocks[i];
+        BBlock* copiedBlock = copiedBlocks[i];
+
+        for (auto j : copiedBlock->getPrev()) {
+            copiedBlock->removePrev(j);
+        }
+        for (auto j : copiedBlock->getNext()) {
+            copiedBlock->removeNext(j);
+        }
+
+        // Восстанавливаем связи succ (следующих блоков)
+        for (auto* succ : originalBlock->getNext()) {
+            copiedBlock->addNext(blockMapping[succ]);
+        }
+
+        // Восстанавливаем связи prev (предыдущих блоков)
+        for (auto* prev : originalBlock->getPrev()) {
+            copiedBlock->addPrev(blockMapping[prev]);
+        }
+    }
+}
+
+
+BArgument* NewName(BArgument* var, map<string, int>& counter, map<string, stack<BArgument*>>& stack) {
+    int index = counter[var->getValue()];
+    counter[var->getValue()]++;
+
+    BArgument* newName = new BArgument(var->getType(), var->getMemType(), var->getValue(), index + 1);
+    stack[var->getValue()].push(newName);
+    return newName;
+}
+
+void RenameFiFunctionResultVar(BBlock* block, map<string, int>& counter, map<string, stack<BArgument*>>& stack) {
+    for (auto irBlock : block->getInstructions()) {
+        auto instruction = irBlock->getInstruction();
+        if (instruction->getOperation() == CFG_OP::F_CALL && instruction->getArg1() != nullptr && instruction->getArg1()->getValue() == "FI_FUNCTION" && instruction->getResult() != nullptr) {
+            instruction->setResult(NewName(instruction->getResult(), counter, stack));
+        }
+    }
+}
+
+void RenameInstructionVars(BBlock* block, map<string, int>& counter, map<string, stack<BArgument*>>& stack) {
+    for (auto irBlock : block->getInstructions()) {
+        auto instruction = irBlock->getInstruction();
+
+        if (instruction->getArg1() != nullptr && instruction->getArg1()->getType() == CFG_ARG_TYPE::VAR) {
+            instruction->setArg1(stack[instruction->getArg1()->getValue()].top());
+        }
+
+        if (instruction->getArg2() != nullptr && instruction->getArg2()->getType() == CFG_ARG_TYPE::VAR) {
+            instruction->setArg2(stack[instruction->getArg2()->getValue()].top());
+        }
+
+        if (instruction->getResult() != nullptr && instruction->getResult()->getType() == CFG_ARG_TYPE::VAR) {
+            instruction->setResult(NewName(instruction->getResult(), counter, stack));
+        }
+    }
+}
+
+void RenameFiFunctionArgsVar(BBlock* block, map<string, stack<BArgument*>>& stack) {
+    cout << "test" << endl;
+    auto size = block->getInstructions().size();
+    for (auto i = 0; i < size; i++) {
+        auto irBlock = block->getInstructions()[i];
+        auto instruction = irBlock->getInstruction();
+        if (instruction->getOperation() == CFG_OP::F_CALL && instruction->getArg1() != nullptr && instruction->getArg1()->getValue() == "FI_FUNCTION" && instruction->getResult() != nullptr) {
+            //cout << "test" << endl;
+
+            auto paramInstruction = new Instruction(CFG_OP::PARAM, stack[instruction->getResult()->getValue()].top());
+            block->addInstructionBeforeInstruction(new IR_Block(paramInstruction), instruction);
+
+            i++;
+        }
+    }
+}
+
+vector<BBlock*> findBlocksWithValue(map<BBlock*, BBlock*>& iDominators, BBlock* x) {
+    vector<BBlock*> result;
+
+    // Проходим по всем элементам map
+    for (auto& pair : iDominators) {
+        // Если значение равно x, добавляем ключ в результат
+        if (pair.second == x) {
+            result.push_back(pair.first);
+        }
+    }
+
+    return result;
+}
+
+void RenameIR(BBlock* block, map<BBlock*, BBlock*>& iDominators, map<string, int>& counter, map<string, stack<BArgument*>>& stack) {
+
+    RenameFiFunctionResultVar(block, counter, stack);
+
+    RenameInstructionVars(block, counter, stack);
+
+    for (auto* successor : block->getNext()) {
+        RenameFiFunctionArgsVar(successor, stack);
+    }
+
+    for (auto* child : findBlocksWithValue(iDominators, block)) {
+        cout << "sec" << endl;
+        RenameIR(child, iDominators, counter, stack);
+    }
+
+    for (auto& irBlock : block->getInstructions()) {
+        auto instruction = irBlock->getInstruction();
+        if (instruction->getResult() != nullptr && instruction->getResult()->getType() == CFG_ARG_TYPE::VAR) {
+            string varName = instruction->getResult()->getValue();
+            stack[varName].pop();
+        }
+    }
+
+    for (auto& irBlock : block->getInstructions()) {
+        auto instruction = irBlock->getInstruction();
+        if (instruction->getOperation() == CFG_OP::F_CALL && instruction->getArg1() != nullptr && instruction->getArg1()->getValue() == "FI_FUNCTION" && instruction->getResult() != nullptr) {
+            string varName = instruction->getResult()->getValue();
+            stack[varName].pop();
+        }
+    }
+}
+
+map<FuncInfo*, vector<BBlock*>> buildIRSSAForm(map<FuncInfo*, vector<BBlock*>> fullIR) {
+
+    map<FuncInfo*, vector<BBlock*>> result;
+
+    for (auto item : fullIR) {
+        auto funcinfo = item.first;
+        auto funcIRConst = item.second;
+
+        vector<BBlock*> funcIR;
+        vector<BBlock*> funcResult;
+
+        for (auto i : funcIRConst) {
+            funcIR.push_back(new BBlock(*i));
+        }
+        restoreConnections(funcIRConst, funcIR);
+
+        for (auto i : funcIR) {
+            //printBlock(i);
+        }
+
+        auto dominators = findDominators(funcIR);
+
+        /*cout << endl << endl << endl << "DOMINATORS" << endl << endl << endl;
+
+        for (auto i : dominators) {
+            cout << "block - " << i.first->getNumber() << endl;
+            for (auto j : i.second) {
+                cout << "dominators - " << j->getNumber() << endl;
+            }
+
+            cout << endl;
+        }*/
+
+        auto iDominators = findImmediateDominators(dominators, funcIR[0]);
+
+        /*for (auto i : iDominators) {
+            cout << "block - " << i.first->getNumber() << endl;
+            cout << "Idominators - " << i.second->getNumber() << endl;
+            cout << endl;
+        }
+        */
+        auto dominatorBorders = findDominatorBorders(funcIR, iDominators);
+        
+
+        /*for (auto i : dominatorBorders) {
+            cout << "block - " << i.first->getNumber() << endl;
+            for (auto j : i.second) {
+                cout << "border - " << j->getNumber() << endl;
+            }
+
+            cout << endl;
+        }*/
+
+
+        auto globalsAndVarBlocks = getGlobalsAndVarBlocks(funcIR);
+        auto globals = globalsAndVarBlocks.first;
+        auto varBlocks = globalsAndVarBlocks.second;
+
+        /*for (auto i : globals) {
+            cout << i->getValue() << " " << ToString(i->getType()) << " " << i->getNumber() << endl;
+
+        }
+        cout << endl;
+        for (auto i : varBlocks) {
+            cout << i.first->getValue() << " - ";
+            for (auto j : i.second) {
+                cout << j->getNumber() << ", ";
+            }
+            cout << endl;
+        }
+        cout << endl;
+        */
+
+        funcResult = getBlocksWithFiFunctions(funcIR, globals, varBlocks, dominatorBorders);
+
+        map<string, int> count;
+        map<string, stack<BArgument*>> varStack;
+
+        for (auto var : globals) {
+            count[var->getValue()] = 0;
+
+            stack<BArgument*> tmp;
+            varStack[var->getValue()] = tmp;
+        }
+
+        RenameIR(funcIR[0], iDominators, count, varStack);
+
+        for (auto i : funcIR) {
+            printBlock(i);
+        }
+        cout << endl << endl << endl << endl << endl;
+        for (auto i : funcIRConst) {
+            printBlock(i);
+        }
+
+
+        result[funcinfo] = funcResult;
+    }
+
+    return result;
+}

src/CFGraph/IRSSAForm.h

@@ -0,0 +1,6 @@
+#pragma once
+
+#include "CFGraph.h"
+#include "IR.h"
+
+std::map<FuncInfo*, std::vector<SAPFOR::BasicBlock*>> buildIRSSAForm(std::map<FuncInfo*, std::vector<SAPFOR::BasicBlock*>> fullIR);

src/LoopAnalyzer/loop_analyzer.cpp

@@ -1635,9 +1635,9 @@ void loopAnalyzer(SgFile *file, vector<ParallelRegion*> &regions, map<tuple<int,
         string fName = file->functions(i)->symbol()->identifier();
 #if _WIN32
         if (file->functions(i)->variant() != MODULE_STMT)
-            sendMessage_2lvl(wstring(L"<EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD> '") + wstring(fName.begin(), fName.end()) + L"'");
+            sendMessage_2lvl(wstring(L"<EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD> '") + wstring(fName.begin(), fName.end()) + L"'");
         else
-            sendMessage_2lvl(wstring(L"<EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD> '") + wstring(fName.begin(), fName.end()) + L"'");
+            sendMessage_2lvl(wstring(L"<EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD> '") + wstring(fName.begin(), fName.end()) + L"'");
 #else
         if (file->functions(i)->variant() != MODULE_STMT)
             sendMessage_2lvl(wstring(L"processing function '") + wstring(fName.begin(), fName.end()) + L"'");
@@ -2168,7 +2168,7 @@ void loopAnalyzer(SgFile *file, vector<ParallelRegion*> &regions, map<tuple<int,
                 {
                     string fName = file->functions(i)->symbol()->identifier();
 #ifdef _WIN32
-                    sendMessage_2lvl(wstring(L"<EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD><EFBFBD> ") + std::to_wstring(idx) + L"/" + std::to_wstring(convertedLoopInfo.size()));
+                    sendMessage_2lvl(wstring(L"<EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD><EFBFBD> ") + std::to_wstring(idx) + L"/" + std::to_wstring(convertedLoopInfo.size()));
 #else
                     sendMessage_2lvl(wstring(L"processing loop ") + std::to_wstring(idx) + L"/" + std::to_wstring(convertedLoopInfo.size()));
 #endif

src/Sapfor.cpp

@@ -93,6 +93,7 @@
 #include "CFGraph/IR.h"
 #include "CFGraph/RD_subst.h"
 #include "CFGraph/CFGraph.h"
+#include "CFGraph/IRSSAForm.h"
 
 #include "CFGraph/live_variable_analysis.h"
 #include "CFGraph/private_variables_analysis.h"
@@ -1018,6 +1019,10 @@ 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 == EXPLORE_IR_LOOPS)
+            testIR(fullIR);
+        else if (curr_regime == BUILD_IR_SSA_FORM)
+            buildIRSSAForm(fullIR);
         else if (curr_regime == TEST_PASS)
         {
         //test pass

src/Sapfor.h

@@ -182,6 +182,8 @@ enum passes {
 
     SET_IMPLICIT_NONE,
     RENAME_INLCUDES,
+    EXPLORE_IR_LOOPS,
+    BUILD_IR_SSA_FORM,
 
     TEST_PASS,
     EMPTY_PASS
@@ -367,6 +369,8 @@ static void setPassValues()
     passNames[SET_IMPLICIT_NONE] = "SET_IMPLICIT_NONE";
     passNames[RENAME_INLCUDES] = "RENAME_INLCUDES";
     passNames[INSERT_NO_DISTR_FLAGS_FROM_GUI] = "INSERT_NO_DISTR_FLAGS_FROM_GUI";
+    passNames[EXPLORE_IR_LOOPS] = "EXPLORE_IR_LOOPS";
+    passNames[BUILD_IR_SSA_FORM] = "BUILD_IR_SSA_FORM";
 
     passNames[TEST_PASS] = "TEST_PASS";
 }

src/Utils/PassManager.h

@@ -314,6 +314,9 @@ void InitPassesDependencies(map<passes, vector<passes>> &passDepsIn, set<passes>
 
     list({ VERIFY_INCLUDES, CORRECT_VAR_DECL }) <= Pass(SET_IMPLICIT_NONE);
 
+    list({ CALL_GRAPH, LOOP_GRAPH, CALL_GRAPH2 }) <= Pass(EXPLORE_IR_LOOPS);
+    list({ CALL_GRAPH, LOOP_GRAPH, CALL_GRAPH2 }) <= Pass(BUILD_IR_SSA_FORM);
+
     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,