Add Dominator tree builder and interprocedural analysis

src/CFGraph/CFGraph.h

@@ -24,7 +24,7 @@ namespace SAPFOR
 
         std::vector<BasicBlock*> next;
         std::vector<BasicBlock*> prev;
-        
+        BasicBlock* idom{};
         //reaching definition
         std::map<SAPFOR::Argument*, std::set<int>> RD_in, RD_out;
 
@@ -42,6 +42,7 @@ namespace SAPFOR
         void addInstruction(IR_Block* item);
         void addPrev(BasicBlock* prev_) { prev.push_back(prev_); }
         void addNext(BasicBlock* next_) { next.push_back(next_); }
+        void setIdom(BasicBlock* idom_) { idom = idom_; }
 
         int removePrev(BasicBlock* removed);
         int removeNext(BasicBlock* removed);
@@ -69,7 +70,8 @@ namespace SAPFOR
         const std::vector<IR_Block*>& getInstructions() const { return instructions; }
         const std::vector<BasicBlock*>& getNext() const { return next; }
         const std::vector<BasicBlock*>& getPrev() const { return prev; }
-        
+        BasicBlock* getIdom() const { return idom; }
+
         /*
         *  FOR LIVE ANALYSIS
         */                
@@ -146,4 +148,4 @@ static inline void deleteCFG(std::map<FuncInfo*, std::vector<SAPFOR::BasicBlock*
         byFunc.second.clear();
     }
     cfg.clear();
-}
+}

src/ProjectParameters/domTree.h

@@ -0,0 +1,111 @@
+#pragma once
+
+#include "vector"
+#include "map"
+
+#include "../CFGraph/CFGraph.h"
+#include <unordered_map>
+
+using namespace std;
+
+namespace SAPFOR {
+class DominatorFinder {
+private:
+    BasicBlock* entry;
+    std::vector<BasicBlock*> vertices;
+    std::unordered_map<BasicBlock*, int> dfs_num;
+    std::vector<int> parent, semi, vertex, ancestor, label;
+    std::vector<std::vector<int>> bucket;
+    int n;
+
+    void DFS(BasicBlock* v, int parent_num) {
+        dfs_num[v] = n;
+        vertex[n] = n;
+        semi[n] = n;
+        label[n] = n;
+        ancestor[n] = -1;
+        parent[n] = parent_num;
+        vertices[n++] = v;
+
+        for (const auto& w : v->getNext()) {
+            if (dfs_num[w] == -1) {
+                DFS(w, dfs_num[v]);
+            }
+        }
+    }
+
+    void Compress(int v) {
+        if (ancestor[ancestor[v]] != -1) {
+            Compress(ancestor[v]);
+            if (semi[label[ancestor[v]]] < semi[label[v]])
+                label[v] = label[ancestor[v]];
+            ancestor[v] = ancestor[ancestor[v]];
+        }
+    }
+
+    int Eval(int v) {
+        if (ancestor[v] == -1) return v;
+        Compress(v);
+        return label[v];
+    }
+
+    void Link(int v, int w) {
+        ancestor[w] = v;
+    }
+
+public:
+    DominatorFinder(std::vector<BasicBlock*>& blocks) {
+        if (blocks.empty()) return;
+        entry = blocks[0];
+        n = 0;
+
+        for (auto block : blocks) dfs_num[block] = -1;
+
+        int max_size = blocks.size();
+        vertices.resize(max_size);
+        parent.assign(max_size, -1);
+        semi.assign(max_size, -1);
+        vertex.assign(max_size, -1);
+        ancestor.assign(max_size, -1);
+        label.assign(max_size, -1);
+        bucket.resize(max_size);
+
+        DFS(entry, -1);
+
+        for (int i = n - 1; i > 0; --i) {
+            int w = vertex[i];
+
+            for (BasicBlock* v : vertices[w]->getPrev()) {
+                int u = Eval(dfs_num[v]);
+                if (semi[u] < semi[w])
+                    semi[w] = semi[u];
+            }
+            bucket[vertex[semi[w]]].push_back(w);
+            Link(parent[w], w);
+
+            for (int v : bucket[parent[w]])
+            {
+                int u = Eval(v);
+                if (semi[u] < semi[v])
+                    vertices[v]->setIdom(vertices[u]);
+                else
+                    vertices[v]->setIdom(vertices[parent[w]]);
+            }
+            bucket[parent[w]].clear();
+        }
+
+        for (int i = 1; i < n; ++i) {
+            int w = vertex[i];
+            if (vertices[w]->getIdom() != vertices[vertex[semi[w]]])
+                vertices[w]->setIdom(vertices[w]->getIdom()->getIdom());
+        }
+
+        entry->setIdom(nullptr);
+    }
+};
+
+void buildDominatorTreeLT(std::vector<BasicBlock*>& blocks) {
+    DominatorFinder finder(blocks);
+}
+
+}

src/ProjectParameters/projectParameters.cpp

@@ -1,33 +1,325 @@
-#include "../Utils/leak_detector.h"
-
 #include <cstdio>
 #include <cstring>
-#include <cstring>
 #include <fstream>
 #include <iostream>
 #include <cstdlib>
 #include <set>
+#include <string>
 #include <vector>
 #include <algorithm>
 #include <tuple>
 
+#include "../Utils/SgUtils.h"
+#include "../CFGraph/CFGraph.h"
+#include "CFGraph/IR.h"
+#include "Distribution/Array.h"
 #include "dvm.h"
 #include "../Utils/errors.h"
-#include "../Utils/SgUtils.h"
 #include "../GraphCall/graph_calls.h"
 #include "../GraphCall/graph_calls_func.h"
 
+#include "libSage++.h"
 #include "projectParameters.h"
+#include "domTree.h"
 
 using namespace std;
 
-map< pair<string, int>, set<string>> 
+tuple<FuncInfo*, SAPFOR::Instruction*, SAPFOR::BasicBlock*> stmtToIR(const map<FuncInfo*, vector<SAPFOR::BasicBlock*>>& CFGraph, SgStatement* stmt)
-	findParameters(const map<string, vector<DefUseList>> &defUseByFunctions, 
-                   const map<string, CommonBlock*> &commonBlocks, 
-				   const map<string, vector<FuncInfo*>> &allFuncInfo)
 {
-	map< pair<string, int>, set<string>> foundParameters;
+    SgStatement* cur = stmt;
-	
+    while (cur->variant() != PROC_HEDR && cur->variant() != PROG_HEDR && cur->variant() != FUNC_HEDR)
-	
+        cur = cur->controlParent();
-	return foundParameters;
+
-}
+    string funcName = ((SgProcHedrStmt*)cur)->nameWithContains();
+
+    int stmtID = stmt->id();
+    for (const auto& [func, bblocks] : CFGraph)
+    {
+        if (func->funcName != funcName)
+            continue;
+
+        for (auto basicBlock : bblocks)
+            for (auto ins : basicBlock->getInstructions())
+                if (stmtID == ins->getInstruction()->getOperator()->id())
+                    return make_tuple(func, ins->getInstruction(), basicBlock);
+    }
+
+    printInternalError(convertFileName(__FILE__).c_str(), __LINE__);
+    return { NULL, NULL, NULL };
+}
+
+template<typename Iterator>
+static void processArgument(set<SAPFOR::Argument*>& worklist,
+                            SAPFOR::Argument* arg,
+                            Iterator instr,
+                            Iterator first_instr)
+{
+    if (arg == NULL)
+        return;
+    if (arg->getType() == SAPFOR::CFG_ARG_TYPE::REG)
+        extract_vars_from_reg(worklist, arg, instr, first_instr);
+    else if (arg->getType() == SAPFOR::CFG_ARG_TYPE::VAR && arg->getMemType() == SAPFOR::CFG_MEM_TYPE::LOCAL_)
+    {
+        std::cout << "worklist add: " << arg->getValue() << std::endl;           //DEBUG PRINT
+        worklist.insert(arg);
+    }
+}
+
+template<typename Iterator>
+static void extract_vars_from_reg(set<SAPFOR::Argument*>& worklist,
+                                  SAPFOR::Argument* reg,
+                                  Iterator instr,
+                                  Iterator first_instr)
+{
+    for (; instr >= first_instr; instr--)
+    {
+        if ((*instr)->getInstruction()->getResult() == reg)
+        {
+            processArgument(worklist, (*instr)->getInstruction()->getArg1(), instr, first_instr);
+            processArgument(worklist, (*instr)->getInstruction()->getArg2(), instr, first_instr);
+            return;
+        }
+    }
+}
+
+static void lookup_for_vars(std::map<SgStatement*, std::string>& where_to_add,
+                            set<SAPFOR::Argument*>& worklist,
+                            SAPFOR::Instruction* instr,
+                            SAPFOR::BasicBlock* bblock,
+                            const std::map<FuncInfo*, std::vector<SAPFOR::BasicBlock*>>& fullIR)
+{
+    std::cout << "Lookup in bblock no." << bblock->getNumber() << std::endl;                //DEBUG PRINT
+
+    auto first_instr = bblock->getInstructions().begin();
+    auto cur_instr = std::find_if(first_instr, bblock->getInstructions().end(), [instr](SAPFOR::IR_Block* i) {
+        return i->getInstruction() == instr;
+    });
+
+    for (; cur_instr >= bblock->getInstructions().begin(); cur_instr--)
+    {
+        auto instr = (*cur_instr)->getInstruction();
+        auto result_arg = instr->getResult();
+        auto arg1 = instr->getArg1();
+        auto arg2 = instr->getArg2();
+
+        if (worklist.count(result_arg))
+        {
+            processArgument(worklist, arg1, cur_instr, first_instr);
+            processArgument(worklist, arg2, cur_instr, first_instr);
+            std::cout << "worklist erase: " << result_arg->getValue() << std::endl;                 //DEBUG PRINT
+            worklist.erase(result_arg);
+        }
+        if (instr->getOperation() == SAPFOR::CFG_OP::PARAM && worklist.count(arg1))
+        {
+            // skip to F_CALL
+            auto f_call_instr = cur_instr;
+            while ((*f_call_instr)->getInstruction()->getOperation() != SAPFOR::CFG_OP::F_CALL)
+                f_call_instr++;
+
+            if ((*f_call_instr)->getInstruction()->getArg1()->getValue() == "_READ")
+            {
+                auto stmt_before = (*f_call_instr)->getInstruction()->getOperator();
+                auto filename = stmt_before->fileName();
+                auto line = stmt_before->lineNumber();
+                auto var_name = arg1->getValue().substr(arg1->getValue().find('%') + 1);
+                __spf_print(1,"Please specify value of variable %s on line %d of file %s", arg1->getValue().c_str(), line, filename);
+                where_to_add[stmt_before] = var_name;
+                std::cout << "worklist erase: " << arg1->getValue() << std::endl;               //DEBUG PRINT
+                worklist.erase(arg1);
+            } else
+            {
+                 //check if variable is modified in called function
+            }
+        }
+    }
+
+    const auto& RD = bblock->getRD_In();
+    map<SAPFOR::BasicBlock*, SAPFOR::Instruction*> group_by_block;
+    for (auto& arg : worklist)
+    {
+        if (RD.count(arg))
+        {
+            if (RD.at(arg).size() == 1 && *RD.at(arg).begin() == SAPFOR::CFG_VAL::UNINIT)
+                __spf_print(1, "variable %s has no definition", arg->getValue().c_str());
+            else if (RD.at(arg).size() > 1)
+                __spf_print(1, "variable %s has multiple reaching definitions, further analysis is impossible", arg->getValue().c_str());
+            else
+            {
+                for (const auto& instr_num : RD.at(arg))
+                {
+                    auto [instr, bblock] = getInstructionAndBlockByNumber(fullIR, instr_num);
+                    if (group_by_block[bblock] == NULL || group_by_block[bblock]->getNumber() < instr_num)
+                        group_by_block[bblock] = instr;
+                }
+            }
+        }
+    }
+
+    auto idom = bblock->getIdom();
+    while (idom != NULL)
+    {
+        if (group_by_block.count(idom))
+        {
+            lookup_for_vars(where_to_add, worklist, group_by_block[idom], idom, fullIR);
+            return;
+        }
+        idom = idom->getIdom();
+    }
+}
+
+static void handle_single_allocate(std::map<SgStatement*, std::string>& where_to_add,
+                                   SgStatement* alloc_statement,
+                                   const std::map<FuncInfo*, std::vector<SAPFOR::BasicBlock*>>& fullIR)
+{
+    auto [func, instr, bblock] = stmtToIR(fullIR, alloc_statement);
+
+    auto first_instr = bblock->getInstructions().begin();
+    auto cur_instr = std::find_if(first_instr, bblock->getInstructions().end(), [instr](SAPFOR::IR_Block* i) {
+        return i->getInstruction() == instr;
+    });
+    auto alloc_instr = cur_instr;
+
+    // skip to F_CALL _ALLOC n
+    while ((*alloc_instr)->getInstruction()->getOperation() != SAPFOR::CFG_OP::F_CALL ||
+           (*alloc_instr)->getInstruction()->getArg1()->getValue() != "_ALLOC")
+    {
+        alloc_instr++;
+    }
+
+    auto arrays_num = stoi((*alloc_instr)->getInstruction()->getArg2()->getValue());
+    std::cout << "arrays_num: " << arrays_num << std::endl;                 //DEBUG PRINT
+
+    set<SAPFOR::Argument*> worklist;
+    for (int i = 0; i < arrays_num; i++)
+    {
+        auto param_instr = --alloc_instr;
+        auto param_reg = (*param_instr)->getInstruction()->getArg1();
+
+        while ((*param_instr)->getInstruction()->getOperation() != SAPFOR::CFG_OP::LOAD ||
+               (*param_instr)->getInstruction()->getResult() != param_reg)
+        {
+            param_instr--;
+        }
+
+        auto dimensions_num = stoi((*param_instr)->getInstruction()->getArg2()->getValue());
+
+        for (int j = 0; j < dimensions_num; j++)
+        {
+            auto ref_instr = --param_instr;
+
+            auto arg = (*ref_instr)->getInstruction()->getArg1();
+            if (arg->getType() == SAPFOR::CFG_ARG_TYPE::REG)
+            {
+                extract_vars_from_reg(worklist, arg, ref_instr, first_instr);
+            }
+            else if (arg->getType() == SAPFOR::CFG_ARG_TYPE::VAR && arg->getMemType() == SAPFOR::CFG_MEM_TYPE::LOCAL_)
+            {
+                std::cout << "worklist add: " << arg->getValue() << std::endl;          //DEBUG PRINT
+                worklist.insert(arg);
+            }
+        }
+    }
+    lookup_for_vars(where_to_add,worklist, instr, bblock, fullIR);
+}
+
+static void handle_single_loop(std::map<SgStatement*, std::string>& where_to_add,
+                               SgStatement* loop_stmt,
+                               const std::map<FuncInfo*, std::vector<SAPFOR::BasicBlock*>>& fullIR)
+{
+    auto [func_name, instr, bblock] = stmtToIR(fullIR, loop_stmt);
+    std::cout << "bblock: " << bblock->getNumber() << " instr: " << instr->getNumber() << std::endl;
+
+    auto cur_instr = bblock->getInstructions().end() - 1;
+
+    set<SAPFOR::Argument*> worklist;
+    extract_vars_from_reg(worklist, (*cur_instr)->getInstruction()->getResult(), cur_instr, bblock->getInstructions().begin());
+
+    lookup_for_vars(where_to_add, worklist, (*cur_instr)->getInstruction(), bblock, fullIR);
+}
+
+void
+findParameters(ResultSet& foundParameters,
+               std::map<FuncInfo*, std::vector<SAPFOR::BasicBlock*>>& fullIR,
+               const std::map<std::tuple<int, std::string, std::string>, std::pair<DIST::Array*, DIST::ArrayAccessInfo*>>& declaredArrays)
+{
+    map<SgStatement*, string> where_to_add;
+
+    map<string, FuncInfo*> name_to_func;
+    for (const auto& [func, _] : fullIR)
+        name_to_func[func->funcName] = func;
+
+    map<FuncInfo*, vector<SAPFOR::Instruction*>> call_sites;
+    for (auto& [func, bblocks] : fullIR)
+    {
+        for (const auto& block : bblocks)
+        {
+            for (const auto& ir_block : block->getInstructions())
+            {
+                auto instr = ir_block->getInstruction();
+                if (instr->getOperation() == SAPFOR::CFG_OP::F_CALL)
+                {
+                    auto func_name = instr->getArg1()->getValue();
+                    auto func_info = name_to_func.find(func_name);
+
+                    if (func_info != name_to_func.end())
+                        call_sites[func_info->second].push_back(instr);
+                }
+            }
+        }
+
+        SAPFOR::buildDominatorTreeLT(bblocks);
+        for (auto block : bblocks)
+        {
+            if (block->getIdom() != NULL)
+                std::cout << "BB: " << block->getNumber() << " IDOM: " << block->getIdom()->getNumber() << std::endl;
+        }
+        std::cout << "+++++++++++\n";
+    }
+
+    std::set<SgStatement*> alloc_statements;
+    for (const auto& elem : declaredArrays)
+    {
+        const auto& array = elem.second.first;
+        SgSymbol* arraySymb = array->GetDeclSymbol()->GetOriginal();
+        SgStatement* decl = declaratedInStmt(arraySymb);
+
+        for (auto& stmt : getAttributes<SgStatement*, SgStatement*>(decl, set<int>{ ALLOCATE_STMT }))
+            alloc_statements.insert(stmt);
+    }
+
+    for (const auto& alloc_statement : alloc_statements)
+    {
+        handle_single_allocate(where_to_add, alloc_statement, fullIR);
+    }
+
+    set<SgStatement*> for_statements;
+    // Find all FOR statements in the program
+    for (const auto& [func, bblocks] : fullIR)
+        for (const auto& block : bblocks)
+            for (auto instr = block->getInstructions().begin(); instr != block->getInstructions().end(); ++instr)
+            {
+                auto op = (*instr)->getInstruction()->getOperator();
+                if (op && op->variant() == FOR_NODE) {
+                    std::cout << block->getNumber() << std::endl;
+                    for_statements.insert(op);
+                }
+            }
+
+    for (const auto& stmt : for_statements)
+    {
+        handle_single_loop(where_to_add, stmt, fullIR);
+    }
+
+    for (const auto& [stmt_before, var_name] : where_to_add)
+    {
+        // SgVariableSymb* var_symb = new SgVariableSymb(var_name.c_str());
+        // SgVarRefExp* var = new SgVarRefExp(var_symb);
+        // SgValueExp* zero = new SgValueExp(0);
+        // SgExprListExp* ex = new SgExprListExp();
+        // ex->setLhs(new SgExpression(ASSGN_OP, var, zero));
+        // SgStatement* toAdd = new SgStatement(SPF_PARAMETER_OP, NULL, NULL, ex, NULL, NULL);
+        // stmt_before->insertStmtAfter(*toAdd, *stmt_before->controlParent());
+
+        foundParameters.insert(make_tuple(stmt_before->fileName(), stmt_before->lineNumber(), var_name));
+    }
+}

src/ProjectParameters/projectParameters.h

@@ -1,3 +1,32 @@
 #pragma once
 
-std::map< std::pair<std::string, int>, std::set<std::string>> findParameters(const std::map<std::string, std::vector<DefUseList>> &defUseByFunctions, const std::map<std::string, CommonBlock*> &commonBlocks, const std::map<std::string, std::vector<FuncInfo*>> &allFuncInfo);
+#include "libSage++.h"
+#include <map>
+#include <string>
+#include <set>
+
+using ResultSet = std::set<std::tuple<std::string, int, std::string>>;
+
+template<typename Iterator>
+static void extract_vars_from_reg(std::set<SAPFOR::Argument*>& worklist,
+                                  SAPFOR::Argument* reg,
+                                  Iterator instr,
+                                  Iterator first_instr);
+
+
+template<typename Iterator>
+static void processArgument(std::set<SAPFOR::Argument*>& worklist,
+                            SAPFOR::Argument* arg,
+                            Iterator instr,
+                            Iterator first_instr);
+
+static void lookup_for_vars(std::map<SgStatement*, std::string>& where_to_add,
+                            std::set<SAPFOR::Argument*>& worklist,
+                            SAPFOR::Instruction* instr,
+                            SAPFOR::BasicBlock* bblock,
+                            const std::map<FuncInfo*, std::vector<SAPFOR::BasicBlock*>>& fullIR);
+
+void
+findParameters(ResultSet& foundParameters,
+               std::map<FuncInfo*, std::vector<SAPFOR::BasicBlock*>>& fullIR,
+			   const std::map<std::tuple<int, std::string, std::string>, std::pair<DIST::Array*, DIST::ArrayAccessInfo*>>& declaredArrays);

src/Sapfor.cpp

@@ -1878,7 +1878,9 @@ static bool runAnalysis(SgProject &project, const int curr_regime, const bool ne
     else if (curr_regime == RENAME_SYMBOLS)
         runRenameSymbols(&project, commonBlocks);
     else if (curr_regime == FIND_PARAMETERS)
-        parametersOfProject = findParameters(defUseByFunctions, commonBlocks, allFuncInfo);
+    {
+        findParameters(parametersOfProject, fullIR, declaredArrays);
+    }
     else if (curr_regime == BUILD_IR)
     {
         auto CFG_forFile = buildCFG(commonBlocks, allFuncInfo_IR, SAPFOR::CFG_Settings(0));
@@ -2357,6 +2359,7 @@ void runPass(const int curr_regime, const char *proj_name, const char *folderNam
     case FIX_COMMON_BLOCKS:
     case TEST_PASS:
     case SET_IMPLICIT_NONE:
+    case FIND_PARAMETERS:
         runAnalysis(*project, curr_regime, false);
     case SUBST_EXPR_RD_AND_UNPARSE:
     case SUBST_EXPR_AND_UNPARSE:

src/SapforData.h

@@ -168,7 +168,7 @@ std::map<int, UserFiles> filesInfo; // information about open,close,write and re
 //
 
 //for FIND_PARAMETERS
-std::map< std::pair<std::string, int>, std::set<std::string>> parametersOfProject; // [file, line] -> set[vars]
+std::set<std::tuple<std::string, int, std::string>> parametersOfProject; // [file, line, varname]
 //
 
 //for GET_MIN_MAX_BLOCK_DIST

tests/sapfor/parameter/dynamic_array_maximum.f90

@@ -0,0 +1,52 @@
+program dynamic_array_maximum_3d
+    implicit none
+    integer :: n1, n2, n3, n4 , k, i, j, l, a
+    integer :: sum3
+    real :: max_element
+    real, allocatable :: array(:,:,:), array2(:,:,:), array3(:,:,:)
+
+    write(*, *) "Enter 3 integers"
+    read(*, *) n, m, k
+    m = 100
+
+    if (1 .eq. 1) then
+        a = 3
+    else if (2 .eq. 1) then
+        a = 4
+    endif
+
+    m = m + 1
+    k = m * 1000 + n * 10
+
+    allocate(array(n, m + n, k + m + n), &
+            &array2(k, m + n, k), &
+            &array3(k, m, k + n))
+
+    call random_seed()
+    do i = 1, n1
+        do j = 1, m * n1
+            do l = 1, k * m * n1
+                call random_number(array(i,j,l))
+                array(i,j,l) = int(array(i,j,l) * 100)
+            end do
+        end do
+    end do
+
+    max_element = array(1,1,1)
+    do i = 1, n1
+        do j = 1, m
+            do l = 1, k
+                max_element = MAX(array(i,j,l), max_element)
+            end do
+        end do
+    end do
+    deallocate(array, array2, array3)
+    write(*, *) max_element
+end program dynamic_array_maximum_3d
+
+! function sum3(x, y, z)
+!  implicit none
+!  integer :: x, y, z
+!  integer :: sum3
+!  sum3 = x + y + z
+! end function sum3