Alexander_KS/SAPFOR
4
2
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

Add Dominator tree builder and interprocedural analysis

Browse Source
This commit is contained in:
Vladislav Abrosimov
2025-04-15 12:23:32 +03:00
committed by Alexander
parent 4eb057731f
commit 537d60222f
5 changed files with 289 additions and 55 deletions
Download Patch File Download Diff File Expand all files Collapse all files

4
src/CFGraph/CFGraph.h
View File

@@ -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,6 +70,7 @@ 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

111
src/ProjectParameters/domTree.h Normal file
View File

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

173
src/ProjectParameters/projectParameters.cpp
View File

@@ -1,10 +1,10 @@
#include <cassert>
#include <cstdio>
#include <cstring>
#include <fstream>
#include <iostream>
#include <cstdlib>
#include <set>
#include <string>
#include <vector>
#include <algorithm>
#include <tuple>
@@ -20,11 +20,40 @@
#include "libSage++.h"
#include "projectParameters.h"
#include "domTree.h"
using namespace std;
tuple<FuncInfo*, SAPFOR::Instruction*, SAPFOR::BasicBlock*> stmtToIR(const map<FuncInfo*, vector<SAPFOR::BasicBlock*>>& CFGraph, SgStatement* stmt)
{
SgStatement* cur = stmt;
while (cur->variant() != PROC_HEDR && cur->variant() != PROG_HEDR && cur->variant() != FUNC_HEDR)
cur = cur->controlParent();
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) {
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)
@@ -37,8 +66,13 @@ static void processArgument(set<SAPFOR::Argument*>& worklist, SAPFOR::Argument*
}
template<typename Iterator>
void extract_vars_from_reg(set<SAPFOR::Argument*>& worklist, SAPFOR::Argument* reg, Iterator instr, Iterator first_instr) {
for (; instr >= first_instr; instr--) {
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);
@@ -48,7 +82,7 @@ void extract_vars_from_reg(set<SAPFOR::Argument*>& worklist, SAPFOR::Argument* r
}
}
static void lookup_for_vars(ResultSet& result_set,
static void lookup_for_vars(std::map<SgStatement*, std::string>& where_to_add,
set<SAPFOR::Argument*>& worklist,
SAPFOR::Instruction* instr,
SAPFOR::BasicBlock* bblock,
@@ -84,11 +118,12 @@ static void lookup_for_vars(ResultSet& result_set,
if ((*f_call_instr)->getInstruction()->getArg1()->getValue() == "_READ")
{
auto filename = (*f_call_instr)->getInstruction()->getOperator()->fileName();
auto line = (*f_call_instr)->getInstruction()->getOperator()->lineNumber();
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);
result_set.insert(make_tuple(filename, line, arg1->getValue()));
where_to_add[stmt_before] = var_name;
std::cout << "worklist erase: " << arg1->getValue() << std::endl; //DEBUG PRINT
worklist.erase(arg1);
} else
@@ -98,14 +133,13 @@ static void lookup_for_vars(ResultSet& result_set,
}
}
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() == 0)
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());
@@ -121,17 +155,24 @@ static void lookup_for_vars(ResultSet& result_set,
}
}
for (const auto& [bblock, instr] : group_by_block)
auto idom = bblock->getIdom();
while (idom != NULL)
{
lookup_for_vars(result_set, worklist, instr, bblock, fullIR);
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(ResultSet& result_set,
SAPFOR::Instruction* instr,
SAPFOR::BasicBlock* bblock,
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;
@@ -178,33 +219,107 @@ static void handle_single_allocate(ResultSet& result_set,
}
}
}
lookup_for_vars(result_set,worklist, instr, bblock, fullIR);
lookup_for_vars(where_to_add,worklist, instr, bblock, fullIR);
}
ResultSet
findParameters(const std::map<FuncInfo*, std::vector<SAPFOR::BasicBlock*>>& 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)
{
ResultSet foundParameters;
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;
assert(array->GetLocation().first == Distribution::arrayLocation::l_LOCAL); // v0.1
SgSymbol* arraySymb = array->GetDeclSymbol()->GetOriginal();
SgStatement* decl = declaratedInStmt(arraySymb);
for (auto &stmt : getAttributes<SgStatement*, SgStatement*>(decl, set<int>{ ALLOCATE_STMT }))
{
for (auto& stmt : getAttributes<SgStatement*, SgStatement*>(decl, set<int>{ ALLOCATE_STMT }))
alloc_statements.insert(stmt);
}
}
for (const auto& alloc_statement : alloc_statements)
{
auto [instr, bblock] = getInstructionAndBlockByStatement(fullIR, alloc_statement);
ResultSet result_set;
handle_single_allocate(result_set, instr, bblock, fullIR);
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));
}
return foundParameters;
}

18
src/ProjectParameters/projectParameters.h
View File

@@ -1,5 +1,6 @@
#pragma once
#include "libSage++.h"
#include <map>
#include <string>
#include <set>
@@ -7,18 +8,25 @@
using ResultSet = std::set<std::tuple<std::string, int, std::string>>;
template<typename Iterator>
void extract_vars_from_reg(std::set<SAPFOR::Argument*>& worklist, SAPFOR::Argument* reg, Iterator instr, Iterator first_instr);
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 processArgument(std::set<SAPFOR::Argument*>& worklist,
SAPFOR::Argument* arg,
Iterator instr,
Iterator first_instr);
static void lookup_for_vars(ResultSet& result_set,
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);
ResultSet
findParameters(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);

4
src/Sapfor.cpp
View File

@@ -1895,9 +1895,7 @@ static bool runAnalysis(SgProject &project, const int curr_regime, const bool ne
runRenameSymbols(&project, commonBlocks);
else if (curr_regime == FIND_PARAMETERS)
{
performRDSubst(fullIR, commonBlocks, &project);
parametersOfProject = findParameters(fullIR, declaredArrays);
performRDSubst(fullIR, commonBlocks, &project);
findParameters(parametersOfProject, fullIR, declaredArrays);
}
else if (curr_regime == BUILD_IR)
{