fixed code style

CMakeLists.txt

@@ -219,14 +219,14 @@ set(CFG src/CFGraph/IR.cpp
         src/CFGraph/live_variable_analysis.h
         src/CFGraph/private_variables_analysis.cpp
         src/CFGraph/private_variables_analysis.h
-        )
+        src/CFGraph/IR_SSAForm.cpp
+        src/CFGraph/IR_SSAForm.h)
         
 set(DATA_FLOW
         src/CFGraph/DataFlow/data_flow.h
         src/CFGraph/DataFlow/data_flow_impl.h
         src/CFGraph/DataFlow/backward_data_flow.h
-        src/CFGraph/DataFlow/backward_data_flow_impl.h
-        )
+        src/CFGraph/DataFlow/backward_data_flow_impl.h)
 
 set(CREATE_INTER_T  src/CreateInterTree/CreateInterTree.cpp
         src/CreateInterTree/CreateInterTree.h)
@@ -309,7 +309,9 @@ set(INLINER src/Inliner/inliner.cpp
 set(LOOP_ANALYZER  src/LoopAnalyzer/allocations_prepoc.cpp
         src/LoopAnalyzer/dep_analyzer.cpp        
         src/LoopAnalyzer/loop_analyzer.cpp
-        src/LoopAnalyzer/loop_analyzer.h)
+        src/LoopAnalyzer/loop_analyzer.h
+        src/LoopAnalyzer/implicit_loops_analyzer.cpp
+        src/LoopAnalyzer/implicit_loops_analyzer.h)
 
 set(RENAME_SYMBOLS  src/RenameSymbols/rename_symbols.cpp
                     src/RenameSymbols/rename_symbols.h)

src/CFGraph/CFGraph.cpp

@@ -50,12 +50,30 @@ BBlock::BasicBlock(const BBlock& copyFrom)
     prev = copyFrom.prev;
 }
 
-void BBlock::addInstruction(IR_Block* item)
+void BBlock::addInstruction(IR_Block* item, bool pushFront)
 {
-    instructions.push_back(item);
+    if (pushFront)
+        instructions.insert(instructions.begin(), item);
+    else
+        instructions.push_back(item);
     item->setBasicBlock(this);
 }
 
+void BBlock::addInstructionBefore(IR_Block* item, Instruction* before)
+{
+    checkNull(before, convertFileName(__FILE__).c_str(), __LINE__);
+    checkNull(item, convertFileName(__FILE__).c_str(), __LINE__);
+
+    for (auto it = instructions.begin(); it != instructions.end(); ++it) {
+        if ((*it)->getInstruction() == before) {
+            instructions.insert(it, item);
+            item->setBasicBlock(this);
+            return;
+        }
+    }
+    printInternalError(convertFileName(__FILE__).c_str(), __LINE__);
+}
+
 int BBlock::removePrev(BBlock* removed)
 {
     auto it = std::remove(prev.begin(), prev.end(), removed);
@@ -512,7 +530,7 @@ static int buildReachingDefs(const vector<BBlock*>& CFG, const FuncInfo* currF,
     return iter;
 }
 
-//Kosaraju<EFBFBD>Sharir algorithm
+//Kosaraju-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

@@ -6,6 +6,10 @@
 #include <vector>
 
 #include "IR.h"
+#include "../Utils/errors.h"
+#include "../Utils/utils.h"
+#include "../Utils/CommonBlock.h"
+#include "../GraphCall/graph_calls.h"
 
 namespace SAPFOR
 {
@@ -39,7 +43,8 @@ namespace SAPFOR
         BasicBlock(IR_Block* item);
         BasicBlock(const BasicBlock& copyFrom);
 
-        void addInstruction(IR_Block* item);
+        void addInstructionBefore(IR_Block* item, Instruction* istruction);
+        void addInstruction(IR_Block* item, bool pushFront = false);
         void addPrev(BasicBlock* prev_) { prev.push_back(prev_); }
         void addNext(BasicBlock* next_) { next.push_back(next_); }
 

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 &&
@@ -50,6 +51,9 @@ namespace SAPFOR
                 printInternalError(convertFileName(__FILE__).c_str(), __LINE__);
             }
         }
+        Argument(const Argument& other)
+            : number(other.number), type(other.type), mType(other.mType), value(other.value)
+        { }
 
         void setType(CFG_ARG_TYPE newType) { type = newType; }
         CFG_ARG_TYPE getType() const { return type; }

src/CFGraph/IR_SSAForm.cpp

@@ -0,0 +1,655 @@
+#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() != NULL && 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() != NULL && 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() != NULL && 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;
+        
+        if (i->getInstruction()->getResult() != NULL && i->getInstruction()->getResult()->getType() == CFG_ARG_TYPE::VAR)
+            i->getInstruction()->getResult()->setValue(resValue);
+
+        if (i->getInstruction()->getArg1() != NULL && i->getInstruction()->getArg1()->getType() == CFG_ARG_TYPE::VAR)
+            i->getInstruction()->getArg1()->setValue(arg1Value);
+
+        if (i->getInstruction()->getArg2() != NULL && 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(const 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(const 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;
+                auto test = iDominators[block];
+                auto test2 = iDominators[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 NULL;
+    
+    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 NULL;
+}
+
+static map<BBlock*, BBlock*> findImmediateDominators1(const map<BBlock*, vector<BBlock*>>& dominators, BBlock* entry)
+{
+    map<BBlock*, BBlock*> iDom;
+
+    for (const auto& pair : dominators) 
+    {
+        BBlock* b = pair.first;
+
+        if (b == entry) 
+            continue;
+
+        const auto& doms = pair.second;
+
+        BBlock* candidate = NULL;
+        for (auto& d : doms) 
+        {
+            if (d == b) 
+                continue;
+
+            bool isImmediate = true;
+            for (auto& other : doms) 
+            {
+                if (other == b || other == d) 
+                    continue;
+
+                const auto& domsOfOther = dominators.at(other);
+                if (std::find(domsOfOther.begin(), domsOfOther.end(), d) != domsOfOther.end()) 
+                {
+                    isImmediate = false;
+                    break;
+                }
+            }
+
+            if (isImmediate) 
+            {
+                candidate = d;
+                break;
+            }
+        }
+
+        if (candidate)
+            iDom[b] = candidate;
+    }
+
+    return iDom;
+}
+
+
+static map<BBlock*, BBlock*> findImmediateDominators(map<BBlock*, vector<BBlock*>>& dominators, BBlock* fistBlock) 
+{
+    map<BBlock*, BBlock*> iDominators;
+
+    for (const auto& [block, domBlocks] : dominators) {
+        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(const 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 void getBlocksWithFiFunctions(const 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, new BArgument(*fiFunc), new BArgument(*paramCount), var, dfBlock->getInstructions()[0]->getInstruction()->getOperator());
+
+                    IR_Block* phiBlock = new IR_Block(phiInstruction);
+                    dfBlock->addInstruction(phiBlock, true);
+
+                    //blocksWithFiFunctions.push_back(dfBlock);
+                }
+            }
+        }
+    }
+   
+    //return blocksWithFiFunctions;
+}
+
+static 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";
+    }
+}
+
+static 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];
+
+        auto prevCopy = copiedBlock->getPrev();
+        for (auto j : prevCopy)
+            copiedBlock->removePrev(j);
+        
+        // Копируем, затем удаляем next связи
+        auto nextCopy = copiedBlock->getNext();
+        for (auto j : nextCopy)
+            copiedBlock->removeNext(j);
+        
+        // Восстанавливаем связи succ (следующих блоков)
+        for (auto* succ : originalBlock->getNext())
+            copiedBlock->addNext(blockMapping[succ]);
+        
+        // Восстанавливаем связи prev (предыдущих блоков)
+        for (auto* prev : originalBlock->getPrev())
+            copiedBlock->addPrev(blockMapping[prev]);
+    }
+}
+
+
+static BArgument* newName(BArgument* var, map<string, int>& counter, map<string, stack<BArgument*>>& stack, int number) {
+    //int index = counter[var->getValue()];
+    counter[var->getValue()]++;
+
+    BArgument* newName = new BArgument(var->getType(), var->getMemType(), var->getValue(), number);
+    stack[var->getValue()].push(newName);
+    return newName;
+}
+
+static 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() != NULL &&
+            instruction->getArg1()->getValue() == "FI_FUNCTION" && instruction->getResult() != NULL)
+        {
+            instruction->setResult(newName(instruction->getResult(), counter, stack, instruction->getNumber()));
+        }
+    }
+}
+
+static 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() != NULL && instruction->getArg1()->getType() == CFG_ARG_TYPE::VAR)
+            instruction->setArg1(stack[instruction->getArg1()->getValue()].top());
+
+        if (instruction->getArg2() != NULL && instruction->getArg2()->getType() == CFG_ARG_TYPE::VAR)
+            instruction->setArg2(stack[instruction->getArg2()->getValue()].top());
+
+        if (instruction->getResult() != NULL && instruction->getResult()->getType() == CFG_ARG_TYPE::VAR)
+            instruction->setResult(newName(instruction->getResult(), counter, stack, instruction->getNumber()));
+    }
+}
+
+static void renameFiFunctionArgsVar(BBlock* block, map<string, stack<BArgument*>>& stack) 
+{
+    auto size = block->getInstructions().size();
+    auto& instructions = block->getInstructions();
+
+    for (size_t i = 0; i < size; ++i) 
+    {
+        auto irBlock = instructions[i];
+        auto instruction = irBlock->getInstruction();
+        if (instruction->getOperation() == CFG_OP::F_CALL && instruction->getArg1() != NULL && 
+            instruction->getArg1()->getValue() == "FI_FUNCTION" && instruction->getResult() != NULL && 
+            instruction->getArg2() != NULL) 
+        {
+            Instruction* paramInstruction;
+            
+            if (stack[instruction->getResult()->getValue()].size() > 0) 
+            {
+                BArgument* tmp = new BArgument(CFG_ARG_TYPE::CONST, CFG_MEM_TYPE::COMMON_, to_string(stack[instruction->getResult()->getValue()].top()->getNumber()));
+                paramInstruction = new Instruction(CFG_OP::PARAM, tmp);
+            }
+            else 
+            {
+                BArgument* tmp = new BArgument(CFG_ARG_TYPE::CONST, CFG_MEM_TYPE::COMMON_, "-1");
+                paramInstruction = new Instruction(CFG_OP::PARAM, tmp);
+            }
+
+            paramInstruction->setOperator(block->getInstructions()[0]->getInstruction()->getOperator());
+            block->addInstructionBefore(new IR_Block(paramInstruction), instruction);
+
+            instruction->getArg2()->setValue(to_string(stoi(instruction->getArg2()->getValue()) + 1));
+            i++;
+        }
+    }
+}
+
+static vector<BBlock*> findBlocksWithValue(map<BBlock*, BBlock*>& iDominators, BBlock* x) 
+{
+    vector<BBlock*> result;
+
+    // Проходим по всем элементам map
+    for (auto& pair : iDominators)
+        if (pair.second == x) // Если значение равно x, добавляем ключ в результат
+            result.push_back(pair.first);
+
+    return result;
+}
+
+static 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))
+        renameIR(child, iDominators, counter, stack);
+
+    for (auto& irBlock : block->getInstructions())
+    {
+        auto instruction = irBlock->getInstruction();
+        if (instruction->getResult() != NULL && 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() != NULL && 
+            instruction->getArg1()->getValue() == "FI_FUNCTION" && instruction->getResult() != NULL) 
+        {
+            string varName = instruction->getResult()->getValue();
+            stack[varName].pop();
+        }
+    }
+}
+
+void buildIRSSAForm(const map<FuncInfo*, vector<BBlock*>>& fullIR, 
+                    map<FuncInfo*, vector<BBlock*>>& result) {
+
+    for (auto& [funcinfo, funcIRConst]: fullIR) {
+        cout << "Testing " << funcinfo->funcName << endl;
+
+        vector<BBlock*> funcIR;
+
+        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 = findImmediateDominators1(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;
+        */
+
+        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;
+            BArgument* tmpArgument = new BArgument(CFG_ARG_TYPE::CONST, CFG_MEM_TYPE::COMMON_, "-1");
+            tmp.push(tmpArgument);
+            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] = funcIR;
+    }
+}

src/CFGraph/IR_SSAForm.h

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

src/LoopAnalyzer/implicit_loops_analyzer.cpp

@@ -0,0 +1,467 @@
+#include <map>
+#include <set>
+#include <vector>
+#include <string>
+#include <iostream>
+#include <stack>
+
+#include "../CFGraph/IR.h"
+#include "GraphCall/graph_calls.h"
+#include "implicit_loops_analyzer.h"
+
+using std::map;
+using std::set;
+using std::vector;
+using std::pair;
+using std::string;
+using std::cout;
+using std::endl;
+using std::make_pair;
+using std::to_string;
+
+enum VisitState { UNVISITED = 0, VISITING = 1, VISITED = 2 };
+
+static void dfs(SAPFOR::BasicBlock* block, map<int, int>& visit, vector<pair<SAPFOR::BasicBlock*, SAPFOR::BasicBlock*>>& startAndEnd, SAPFOR::BasicBlock* prev) {
+    if (!block) 
+        return;
+
+    if (visit[block->getNumber()] == VISITED) 
+    {
+        cout << "error";
+        return;
+    }
+
+    if (visit[block->getNumber()] == VISITING) 
+    {
+        visit[block->getNumber()] = VISITED;
+        startAndEnd.push_back(make_pair(prev, block));
+        return;
+    }
+
+    visit[block->getNumber()] = VISITING;
+    for (auto i : block->getNext())
+        dfs(i, visit, startAndEnd, block);
+}
+
+static 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())
+    {
+        string resValue = "";
+        string arg1Value = "";
+        string arg2Value = "";
+        if (i->getInstruction()->getResult() != NULL && i->getInstruction()->getResult()->getType() == SAPFOR::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() != NULL && i->getInstruction()->getArg1()->getType() == SAPFOR::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() != NULL && i->getInstruction()->getArg2()->getType() == SAPFOR::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;
+
+        if (i->getInstruction()->getResult() != NULL && i->getInstruction()->getResult()->getType() == SAPFOR::CFG_ARG_TYPE::VAR) 
+            i->getInstruction()->getResult()->setValue(resValue);        
+
+        if (i->getInstruction()->getArg1() != NULL && i->getInstruction()->getArg1()->getType() == SAPFOR::CFG_ARG_TYPE::VAR)
+            i->getInstruction()->getArg1()->setValue(arg1Value);
+
+        if (i->getInstruction()->getArg2() != NULL && i->getInstruction()->getArg2()->getType() == SAPFOR::CFG_ARG_TYPE::VAR)
+            i->getInstruction()->getArg2()->setValue(arg2Value);
+    }
+
+    cout << endl;
+}
+
+static void getLoopBody(SAPFOR::BasicBlock* loopHeader, const set<SAPFOR::BasicBlock*>& loopExits, std::vector<SAPFOR::BasicBlock*>& loopBody) 
+{
+    set<SAPFOR::BasicBlock*> visited;
+    std::stack<SAPFOR::BasicBlock*> stack;
+
+    stack.push(loopHeader);
+
+    while (!stack.empty()) 
+    {
+        auto block = stack.top();
+        stack.pop();
+
+        if (visited.count(block)) 
+            continue;
+        visited.insert(block);
+
+        for (auto& succ : block->getNext()) 
+        {
+            if (loopExits.count(succ)) 
+                continue;
+
+            if (!visited.count(succ))
+                stack.push(succ);            
+        }
+    }
+
+    set<SAPFOR::BasicBlock*> backReachable;
+    std::stack<SAPFOR::BasicBlock*> reverseStack;
+    reverseStack.push(loopHeader);
+
+    while (!reverseStack.empty()) 
+    {
+        auto block = reverseStack.top();
+        reverseStack.pop();
+
+        if (backReachable.count(block)) 
+            continue;
+        backReachable.insert(block);
+
+        for (auto& pred : block->getPrev())
+            if (visited.count(pred) && !backReachable.count(pred)) 
+                reverseStack.push(pred);
+    }
+
+    for (auto& block : visited) 
+        if (backReachable.count(block))
+            loopBody.push_back(block);
+}
+
+
+static set<SAPFOR::Argument*> findRegisterSourceVariables(const std::vector<SAPFOR::BasicBlock*>& blocks, SAPFOR::Argument* var)
+{
+    set<SAPFOR::Argument*> result;
+    set<SAPFOR::Argument*> visited;
+    std::stack<SAPFOR::Argument*> workStack;
+    workStack.push(var);
+
+    auto isBinaryOp = [](SAPFOR::CFG_OP op) {
+        return op == SAPFOR::CFG_OP::ADD || op == SAPFOR::CFG_OP::SUBT ||
+            op == SAPFOR::CFG_OP::MULT || op == SAPFOR::CFG_OP::DIV ||
+            op == SAPFOR::CFG_OP::POW ||
+            op == SAPFOR::CFG_OP::GE || op == SAPFOR::CFG_OP::LE ||
+            op == SAPFOR::CFG_OP::GT || op == SAPFOR::CFG_OP::LT ||
+            op == SAPFOR::CFG_OP::EQ || op == SAPFOR::CFG_OP::NEQV ||
+            op == SAPFOR::CFG_OP::EQV || op == SAPFOR::CFG_OP::EMPTY ||
+            op == SAPFOR::CFG_OP::OR || op == SAPFOR::CFG_OP::AND;
+        };
+
+    auto isUnaryOp = [](SAPFOR::CFG_OP op) {
+        return op == SAPFOR::CFG_OP::UN_ADD || op == SAPFOR::CFG_OP::UN_MINUS ||
+            op == SAPFOR::CFG_OP::NOT || op == SAPFOR::CFG_OP::ASSIGN;
+        };
+
+    while (!workStack.empty()) 
+    {
+        auto variable = workStack.top();
+        workStack.pop();
+        if (!variable || visited.count(variable))
+            continue;
+
+        visited.insert(variable);
+
+        for (auto& block : blocks) 
+        {
+            for (auto& instrWrapper : block->getInstructions()) 
+            {
+                auto instr = instrWrapper->getInstruction();
+                if (!instr || instr->getResult() != variable)
+                    continue;
+
+                auto op = instr->getOperation();
+                auto arg1 = instr->getArg1();
+                auto arg2 = instr->getArg2();
+
+                if (isBinaryOp(op) && arg1 && arg2) 
+                {
+                    if (arg1->getType() == SAPFOR::CFG_ARG_TYPE::VAR)
+                        result.insert(arg1);
+                    else if (arg1->getType() == SAPFOR::CFG_ARG_TYPE::REG)
+                        workStack.push(arg1);
+
+                    if (arg2->getType() == SAPFOR::CFG_ARG_TYPE::VAR)
+                        result.insert(arg2);
+                    else if (arg2->getType() == SAPFOR::CFG_ARG_TYPE::REG)
+                        workStack.push(arg2);
+                }
+                else if (isUnaryOp(op) && arg1) 
+                {
+                    if (arg1->getType() == SAPFOR::CFG_ARG_TYPE::VAR)
+                        result.insert(arg1);
+                    else if (arg1->getType() == SAPFOR::CFG_ARG_TYPE::REG)
+                        workStack.push(arg1);
+                }
+            }
+        }
+    }
+
+    return result;
+}
+
+static std::vector<SAPFOR::Instruction*> getPhiArguments(SAPFOR::BasicBlock* block, SAPFOR::Instruction* phiInstr) 
+{
+    std::vector<SAPFOR::Instruction*> result;
+
+    auto& instructions = block->getInstructions();
+    bool collecting = false;
+    for (int i = instructions.size() - 1; i >= 0; --i) {
+        auto instr = instructions[i]->getInstruction();
+
+        if (collecting) 
+        {
+            if (instr->getOperation() == SAPFOR::CFG_OP::PARAM) 
+            {
+                auto arg = instr->getArg1();
+                if (arg)
+                    result.push_back(instr);                
+            }
+            else 
+                break;            
+        }
+
+        if (!instr)
+            continue;
+
+        if (instr == phiInstr) 
+        {
+            collecting = true;
+            continue;
+        }
+    }
+
+    std::reverse(result.begin(), result.end());
+    return result;
+}
+
+SAPFOR::BasicBlock* findInstructionBlock(SAPFOR::Instruction* targetInstr, const std::vector<SAPFOR::BasicBlock*>& blocks)
+{
+    for (auto& block : blocks) 
+    {
+        for (auto& instrWrapper : block->getInstructions()) 
+        {
+            auto instr = instrWrapper->getInstruction();
+            if (instr == targetInstr)
+                return block;
+        }
+    }
+    return NULL;
+}
+
+static SAPFOR::BasicBlock* findInstructionBlockByNumber(int number, const std::vector<SAPFOR::BasicBlock*>& blocks)
+{
+    for (auto& block : blocks) 
+    {
+        for (auto& instrWrapper : block->getInstructions()) 
+        {
+            auto instr = instrWrapper->getInstruction();
+            if (instr->getNumber() == number)
+                return block;
+        }
+    }
+    return NULL;
+}
+
+static void findInductiveVars(const std::vector<SAPFOR::BasicBlock*>& blocks, 
+                              const std::vector<SAPFOR::BasicBlock*>& Loopblocks, SAPFOR::BasicBlock* loopHeader, 
+                              const set<SAPFOR::BasicBlock*>& loopExits) 
+{
+    set<string> inductiveVars;
+    set<SAPFOR::BasicBlock*> relevantBlocks = { loopHeader };
+
+    for (auto& block : relevantBlocks) 
+    {
+        for (auto& instrWrapper : block->getInstructions()) 
+        {
+            auto instr = instrWrapper->getInstruction();
+            if (!instr) 
+                continue;
+
+            auto op = instr->getOperation();
+            auto res = instr->getResult();
+            auto arg1 = instr->getArg1();
+            auto arg2 = instr->getArg2();
+
+            if (op == SAPFOR::CFG_OP::JUMP_IF) 
+            {
+                if (arg1 && arg1->getType() == SAPFOR::CFG_ARG_TYPE::VAR) 
+                    inductiveVars.insert(arg1->getValue());
+                
+                if (arg1 && arg1->getType() == SAPFOR::CFG_ARG_TYPE::REG) 
+                {
+                    auto foundVariables = findRegisterSourceVariables(blocks, arg1);
+                    for (auto& var : foundVariables)
+                        inductiveVars.insert(var->getValue());
+                }
+            }
+        }
+    }
+
+    set<string> finalInductiveVars;
+
+    for (auto& instrWrapper : loopHeader->getInstructions()) 
+    {
+        auto instr = instrWrapper->getInstruction();
+        if (!instr || instr->getOperation() != SAPFOR::CFG_OP::F_CALL || !instr->getArg1() || instr->getArg1()->getValue() != "FI_FUNCTION") 
+            continue;
+
+        auto phiRes = instr->getResult();
+        if (!phiRes || !inductiveVars.count(phiRes->getValue()))
+            continue;
+
+        auto currentBlock = findInstructionBlock(instr, blocks);
+        if (!currentBlock)
+            continue;
+
+        auto phiArgs = getPhiArguments(currentBlock, instr);
+        bool hasInLoopDefinition = false;
+
+        for (const auto& argInstr : phiArgs) 
+        {
+            if (!argInstr) 
+                continue;
+
+            int definitionInstrNumber = stoi(argInstr->getArg1()->getValue());
+            if (definitionInstrNumber == -1)
+                continue;
+
+            auto phiBlock = findInstructionBlockByNumber(definitionInstrNumber, blocks);
+            if (!phiBlock)
+                continue;
+
+            if (std::find(Loopblocks.begin(), Loopblocks.end(), phiBlock) != Loopblocks.end())
+                hasInLoopDefinition = true;
+        }
+
+        if (hasInLoopDefinition)
+            finalInductiveVars.insert(phiRes->getValue());
+    }
+
+    for (auto& i : finalInductiveVars)
+        cout << "Confirmed inductive variable: " << i << endl;
+
+    if (finalInductiveVars.empty())
+        cout << "No confirmed inductive variables found." << endl;
+}
+
+static SAPFOR::Instruction* findInstructionAfterLoop(const std::vector<SAPFOR::BasicBlock*>& loopBody) 
+{
+    set<SAPFOR::BasicBlock*> loopSet(loopBody.begin(), loopBody.end());
+
+    for (auto& block : loopBody) 
+    {
+        for (auto& succ : block->getNext()) 
+        {
+            if (!loopSet.count(succ)) 
+            {
+                // <20><><EFBFBD><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD><EFBFBD> <20><> <20><><EFBFBD><EFBFBD><EFBFBD> <20> <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>
+                auto instructions = succ->getInstructions();
+                for (auto& wrapper : instructions)
+                    if (auto instr = wrapper->getInstruction())
+                        return instr;
+            }
+        }
+    }
+
+    return NULL; // <20><> <20><><EFBFBD><EFBFBD><EFBFBD>
+}
+
+void findImplicitLoops(const map<FuncInfo*, vector<SAPFOR::BasicBlock*>>& fullIR_SSA, const char* fileName)
+{
+    for (auto& i : fullIR_SSA)
+    {
+        //for (auto& j : i.second)
+        //    printblock(j);
+
+        if (fileName != i.first->fileName)
+            continue;
+
+        map<int, int> visited;
+        for (auto& i : i.second)
+            visited[i->getNumber()] = UNVISITED;
+
+        //vector<int> visited(i.second.size(), UNVISITED);
+        vector<pair<SAPFOR::BasicBlock*, SAPFOR::BasicBlock*>> startAndEnd;
+        dfs(i.second[0], visited, startAndEnd, NULL);
+
+        vector<LoopGraph*> loops;
+
+        for (auto& [tail, header] : startAndEnd) {
+            set<SAPFOR::BasicBlock*> loopExits;
+
+            for (auto& succ : tail->getNext())
+                if (succ != header)
+                    loopExits.insert(succ);
+
+            vector<SAPFOR::BasicBlock*> loopBody;
+            getLoopBody(header, loopExits, loopBody);
+
+            cout << "LOOP DETECTED:" << endl;
+            cout << "  Header: " << header->getNumber() << endl;
+            cout << "  Tail: " << tail->getNumber() << endl;
+            cout << "  Body blocks: ";
+            for (auto& block : loopBody)
+                cout << block->getNumber() << " ";
+            cout << endl;
+
+            findInductiveVars(i.second, loopBody, header, loopExits);
+            SAPFOR::Instruction* instructionAfterLoop = findInstructionAfterLoop(loopBody);
+
+            if (instructionAfterLoop == NULL) 
+            {
+                cout << "Warning: instruction after loop not found!" << endl;
+                continue;
+            }
+
+            auto firstInstruction = header->getInstructions()[0]->getInstruction();
+            auto lastInstruction = tail->getInstructions().back()->getInstruction();
+
+            cout << "first - " << firstInstruction->getNumber() << " last - " << lastInstruction->getNumber() << " after - " << instructionAfterLoop->getNumber() << endl;
+            auto x = firstInstruction->getOperator();
+
+            auto tmpLoop = new LoopGraph();
+            tmpLoop->isFor = true;
+            tmpLoop->lineNum = firstInstruction->getOperator()->lineNumber();
+            tmpLoop->lineNumAfterLoop = instructionAfterLoop->getOperator()->lineNumber();
+
+            if (firstInstruction->getOperator()->variant() == FOR_NODE) 
+            {
+                SgForStmt* stmt = isSgForStmt(firstInstruction->getOperator());
+                cout << "for loop" << endl;// << stmt->sunparse() << endl;
+            }
+            else if (firstInstruction->getOperator()->variant() == WHILE_NODE) 
+            {
+                SgWhileStmt* stmt = isSgWhileStmt(firstInstruction->getOperator());
+                cout << (stmt->conditional() == NULL ? "infinit" : "") << "while loop" << endl;//<< stmt->sunparse() << endl;
+            }
+            else if (firstInstruction->getOperator()->variant() == DO_WHILE_NODE) 
+            {
+                SgWhileStmt* stmt = isSgDoWhileStmt(firstInstruction->getOperator());
+                cout << "do while loop" << endl;// << stmt->sunparse() << endl;
+            }
+            else if (firstInstruction->getOperator()->variant() == LOOP_NODE)
+                cout << "not known loop" << endl;// << firstInstruction->getOperator()->sunparse() << endl;
+            else
+                cout << "goto loop" << endl;// firstInstruction->getOperator()->sunparse() << endl;
+
+            cout << "loop start line " << tmpLoop->lineNum << endl;
+            cout << "after loop line " << tmpLoop->lineNumAfterLoop << endl << endl;
+
+            loops.push_back(tmpLoop);
+        }
+    }
+}

src/LoopAnalyzer/implicit_loops_analyzer.h

@@ -0,0 +1,7 @@
+#pragma once
+
+#include <map>
+#include "../CFGraph/CFGraph.h"
+#include "../GraphCall/graph_calls.h"
+
+void findImplicitLoops(const std::map<FuncInfo*, std::vector<SAPFOR::BasicBlock*>>& fullIR_SSA, const char* fileName);

src/PrivateAnalyzer/private_arrays_search.cpp

@@ -121,7 +121,7 @@ static void SolveDataFlow(Region* DFG)
     Collapse(DFG);
 }
 
-map<LoopGraph*, ArrayAccessingIndexes>  FindPrivateArrays(map<string, vector<LoopGraph*>> &loopGraph, map<FuncInfo*, vector<SAPFOR::BasicBlock*>>& FullIR)
+map<LoopGraph*, ArrayAccessingIndexes>  findPrivateArrays(map<string, vector<LoopGraph*>> &loopGraph, map<FuncInfo*, vector<SAPFOR::BasicBlock*>>& FullIR)
 {  
     map<LoopGraph*, ArrayAccessingIndexes> result;
     for (const auto& [loopName, loops] : loopGraph)

src/PrivateAnalyzer/private_arrays_search.h

@@ -10,5 +10,5 @@
 #include "../CFGraph/CFGraph.h"
 
 void Collapse(Region* region);
-std::map<LoopGraph*, ArrayAccessingIndexes> FindPrivateArrays(std::map<std::string, std::vector<LoopGraph*>>& loopGraph, std::map<FuncInfo*, std::vector<SAPFOR::BasicBlock*>>& FullIR);
+std::map<LoopGraph*, ArrayAccessingIndexes> findPrivateArrays(std::map<std::string, std::vector<LoopGraph*>>& loopGraph, std::map<FuncInfo*, std::vector<SAPFOR::BasicBlock*>>& FullIR);
 std::pair<SAPFOR::BasicBlock*, std::unordered_set<SAPFOR::BasicBlock*>> GetBasicBlocksForLoop(const LoopGraph* loop, const std::vector<SAPFOR::BasicBlock*> blocks);

src/Sapfor.cpp

@@ -42,6 +42,7 @@
 #include "ProjectManipulation/ConvertFiles.h"
 
 #include "LoopAnalyzer/loop_analyzer.h"
+#include "LoopAnalyzer/implicit_loops_analyzer.h"
 
 #include "GraphCall/graph_calls_func.h"
 #include "GraphLoop/graph_loops_func.h"
@@ -95,6 +96,7 @@
 #include "CFGraph/IR.h"
 #include "CFGraph/RD_subst.h"
 #include "CFGraph/CFGraph.h"
+#include "CFGraph/IR_SSAForm.h"
 
 #include "CFGraph/live_variable_analysis.h"
 #include "CFGraph/private_variables_analysis.h"
@@ -1029,8 +1031,12 @@ 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 == BUILD_IR_SSA_FORM)
+            buildIRSSAForm(fullIR, fullIR_SSA);
+        else if (curr_regime == FIND_IMPLICIT_LOOPS)        
+            findImplicitLoops(fullIR_SSA, file_name);            
         else if (curr_regime == FIND_PRIVATE_ARRAYS)
-            FindPrivateArrays(loopGraph, fullIR);
+            findPrivateArrays(loopGraph, fullIR);
         else if (curr_regime == TEST_PASS)
         {
         //test pass

src/Sapfor.h

@@ -182,6 +182,8 @@ enum passes {
 
     SET_IMPLICIT_NONE,
     RENAME_INLCUDES,
+    FIND_IMPLICIT_LOOPS,
+    BUILD_IR_SSA_FORM,
 
     FIND_PRIVATE_ARRAYS,
 
@@ -369,6 +371,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[FIND_IMPLICIT_LOOPS] = "FIND_IMPLICIT_LOOPS";
+    passNames[BUILD_IR_SSA_FORM] = "BUILD_IR_SSA_FORM";
     passNames[FIND_PRIVATE_ARRAYS] = "FIND_PRIVATE_ARRAYS";
 
     passNames[TEST_PASS] = "TEST_PASS";

src/SapforData.h

@@ -180,3 +180,7 @@ bool passNamesWasInit = false;
 
 std::map<PTR_BFND, std::pair<std::string, int>> sgStats;
 std::map<PTR_LLND, std::pair<std::string, int>> sgExprs;
+
+//for FIND_IMPLICIT_LOOPS and BUILD_IR_SSA_FORM
+map<FuncInfo*, vector<SAPFOR::BasicBlock*>> fullIR_SSA;
+//

src/Utils/PassManager.h

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