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

Merge branch 'master' into task-create-implicit-pass

Browse Source
This commit is contained in:
ALEXks
2024-03-23 11:19:52 +03:00
parent bdb74c8ae7 d27b9d1ed3
commit 4ae313e93f
17 changed files with 504 additions and 278 deletions
Download Patch File Download Diff File Expand all files Collapse all files

53
sapfor/experts/Sapfor_2017/_src/ProjectManipulation/ConvertFiles.cpp
View File

@@ -32,12 +32,11 @@ extern "C" int out_line_unlimit;
extern "C" int out_line_length;
extern "C" PTR_SYMB last_file_symbol;
static int convertFile(int argc, char* argv[], const string& fileToConv,
const set<string>& filesInProj, const set<string>& moduleDeclsInFiles)
static int convertFile(int argc, char* argv[], const set<string>& filesInProj, const set<string>& moduleDeclsInFiles)
{
FILE* fout = NULL;
FILE* fout_cuf = NULL, * fout_C_cu = NULL, * fout_info = NULL; /*ACC*/
const char* fout_name = "out.DVMH.f";
const char* fout_name = NULL;
char* fout_name_cuf; /*ACC*/
char* fout_name_C_cu; /*ACC*/
char* fout_name_info_C; /*ACC*/
@@ -54,7 +53,8 @@ static int convertFile(int argc, char* argv[], const string& fileToConv,
while ((argc > 1) && (*argv)[0] == '-')
{
if ((*argv)[1] == 'o' && ((*argv)[2] == '\0')) {
fout_name = argv[1];
if (filesInProj.size() == 1)
fout_name = argv[1];
argv++;
argc--;
}
@@ -307,7 +307,8 @@ static int convertFile(int argc, char* argv[], const string& fileToConv,
static int id = 0;
vector<char*> filesList;
filesList.push_back((char*)fileToConv.c_str());
for (auto& file : filesInProj)
filesList.push_back((char*)file.c_str());
SgProject project((proj_name + to_string(id++)).c_str(), filesList.data(), filesList.size());
@@ -317,7 +318,7 @@ static int convertFile(int argc, char* argv[], const string& fileToConv,
removeExecutableFromModuleDeclaration(&(project.file(z)), filesInProj, tmp);
}
SgFile* file;
SgFile* file = NULL;
addNumberOfFileToAttribute(&project);
//----------------------------
@@ -331,23 +332,26 @@ static int convertFile(int argc, char* argv[], const string& fileToConv,
initF2C_FunctionCalls(); // for project, acc_f2c.cpp
for (int id = project.numberOfFiles() - 1; id >= 0; id--)
{
file = &(project.file(id)); //file->unparsestdout();
file = &(project.file(id));
fin_name = new char[strlen(project.fileName(id)) + 2];
sprintf(fin_name, "%s%s", project.fileName(id), " ");
fout_name = doOutFileName(file->filename()); //project.fileName(id);
if (fout_name == NULL)
fout_name = doOutFileName(file->filename());
if (fout_name && source_name && !strcmp(source_name, fout_name))
{
fprintf(stderr, "Output file has the same name as source file\n");
return 1;
}
printf("convert %d to %s\n", id, fout_name);
fout_name_cuf = ChangeFtoCuf(fout_name); /*ACC*/
fout_name_C_cu = ChangeFto_C_Cu(fout_name); /*ACC*/
fout_name_info_C = ChangeFto_info_C(fout_name); /*ACC*/
//set the last symbol of file
last_file_symbol = CUR_FILE_CUR_SYMB();
initLibNames(); //for every file
InitDVM(file); //for every file
current_file = file; // global variable (used in SgTypeComplex)
@@ -402,7 +406,22 @@ static int convertFile(int argc, char* argv[], const string& fileToConv,
UnparseTo_CufAndCu_Files(file, fout_cuf, fout_C_cu, fout_info);
const string fileN = file->filename();
hideUnnecessary(file, fileN, moduleDeclsInFiles, true);
set<SgStatement*> toRemove;
for (SgStatement* st = file->firstStatement(); st; st = st->lexNext())
{
if (st->fileName() != fileN)
{
if (st->variant() == MODULE_STMT && moduleDeclsInFiles.find(st->fileName()) != moduleDeclsInFiles.end())
{
toRemove.insert(st);
st = st->lastNodeOfStmt();
}
}
}
for (auto& toRem : toRemove)
toRem->extractStmt();
if (unparse_functions)
UnparseFunctionsOfFile(file, fout);
@@ -434,7 +453,7 @@ static int convertFile(int argc, char* argv[], const string& fileToConv,
return 1;
}
}
fout_name = NULL;
}
if (v_print)
@@ -467,11 +486,11 @@ void convertFiles(int argc, char* argv[], const char* proj_name)
const string fileText = readFileToStr(proj_name);
vector<string> files;
set<string> filesinSet;
set<string> filesInSet;
splitString(fileText, '\n', files);
for (auto& file : files)
filesinSet.insert(file);
filesInSet.insert(file);
map<string, set<string>> moduleUsesByFile;
map<string, string> moduleDecls;
@@ -482,9 +501,9 @@ void convertFiles(int argc, char* argv[], const char* proj_name)
moduleDeclsInFiles.insert(elem.second);
int codes = 0;
for (auto& file : files)
{
codes += convertFile(args_v.size() - 1, args_v.data(), file, filesinSet, moduleDeclsInFiles);
//for (auto& file : files)
{
codes += convertFile(args_v.size(), args_v.data(), filesInSet, moduleDeclsInFiles);
cur_node = node_list = NULL;
InitializeTable();

15
sapfor/experts/Sapfor_2017/_src/Sapfor.cpp
View File

@@ -1107,11 +1107,13 @@ static bool runAnalysis(SgProject &project, const int curr_regime, const bool ne
{
auto itFound = loopGraph.find(file->filename());
if (itFound != loopGraph.end())
removePrivatesAnalysis(itFound->second, getObjectForFileFromMap(file_name, SPF_messages), usersDirectives, commonBlocks, allFuncInfo);
removePrivatesAnalysis(file_name, itFound->second, getObjectForFileFromMap(file_name, SPF_messages),
usersDirectives, commonBlocks, allFuncInfo);
}
else if (curr_regime == PRIVATE_REMOVING)
{
removePrivates(file, getObjectForFileFromMap(file_name, SPF_messages), countOfTransform);
removePrivates(file_name, getObjectForFileFromMap(file_name, SPF_messages),
commonBlocks, allFuncInfo, countOfTransform);
}
else if (curr_regime == CREATE_INTER_TREE)
{
@@ -2501,15 +2503,8 @@ void runPass(const int curr_regime, const char *proj_name, const char *folderNam
case REMOVE_OMP_DIRS_TRANSFORM:
case REMOVE_COMMENTS:
case INSERT_NO_DISTR_FLAGS_FROM_GUI:
runAnalysis(*project, curr_regime, true, "", folderName);
break;
case PRIVATE_REMOVING:
runAnalysis(*project, curr_regime, false, "", folderName);
runPass(REVERT_SUBST_EXPR_RD, proj_name, folderName);
if (folderName)
runAnalysis(*project, UNPARSE_FILE, true, "", folderName);
else
__spf_print(1, "can not run UNPARSE_FILE - folder name is null\n");
runAnalysis(*project, curr_regime, true, "", folderName);
break;
case INLINE_PROCEDURES:
runAnalysis(*project, curr_regime, false);

100
sapfor/experts/Sapfor_2017/_src/Transformations/dead_code.cpp
View File

@@ -13,7 +13,7 @@ using std::set;
using std::remove_if;
#define PRINT_USELESS_STATEMENTS 0
#define PRINT_USELESS_STATEMENTS 1
static void updateUseDefForInstruction(SAPFOR::BasicBlock* block, SAPFOR::Instruction* instr,
set<SAPFOR::Argument*>& use, set<SAPFOR::Argument*>& def,
@@ -329,10 +329,22 @@ public:
void removeDeadCode(SgStatement* func,
const map<string, vector<FuncInfo*>>& allFuncs,
const map<string, CommonBlock*>& commonBlocks)
const map<string, CommonBlock*>& commonBlocks,
SgStatement* intervalDelStart, SgStatement* intervalDelEnd)
{
if (intervalDelStart && !intervalDelEnd || !intervalDelStart && intervalDelEnd)
printInternalError(convertFileName(__FILE__).c_str(), __LINE__);
SgProgHedrStmt* prog = isSgProgHedrStmt(func);
if (intervalDelStart)
if (intervalDelStart->lineNumber() < prog->lineNumber() || intervalDelStart->lineNumber() > prog->lastNodeOfStmt()->lineNumber())
printInternalError(convertFileName(__FILE__).c_str(), __LINE__);
if (intervalDelEnd)
if (intervalDelEnd->lineNumber() < prog->lineNumber() || intervalDelEnd->lineNumber() > prog->lastNodeOfStmt()->lineNumber())
printInternalError(convertFileName(__FILE__).c_str(), __LINE__);
auto cfg = buildCFGforCurrentFunc(func, SAPFOR::CFG_Settings(true, false, false, false, false, false, false), commonBlocks, allFuncs);
if(cfg.size() != 1)
@@ -422,11 +434,8 @@ void removeDeadCode(SgStatement* func,
}
}
}
//TODO: need to add [intervalDelStart; intervalDelEnd]
// remove dead statements
SgStatement* end = func->lastNodeOfStmt(), *st = func;
set<int> removable =
{
ASSIGN_STAT,
@@ -435,49 +444,52 @@ void removeDeadCode(SgStatement* func,
READ_STAT
};
while (st != end)
vector<SgStatement*> remove;
for (auto st = func; st != func->lastNodeOfStmt(); st = st->lexNext())
{
SgStatement* next = st->lexNext();
if (removable.find(st->variant()) != removable.end() && useful.find(st) == useful.end())
{
remove.push_back(st);
st = st->lastNodeOfStmt();
}
}
for (auto& rem : remove)
{
__spf_print(PRINT_USELESS_STATEMENTS, "[Useless statement on line %d and file %s]\n", rem->lineNumber(), rem->fileName());
rem->deleteStmt();
}
remove.clear();
//remove empty blocks
for (auto st = func; st != func->lastNodeOfStmt(); st = st->lexNext())
{
const int var = st->variant();
if ((var == FOR_NODE || var == WHILE_NODE || var == IF_NODE || var == SWITCH_NODE) &&
st->lexNext()->variant() == CONTROL_END)
{
__spf_print(PRINT_USELESS_STATEMENTS, "[Useless statement '%s' on line %d]\n", st->unparse(), st->lineNumber());
st->deleteStmt();
}
else
{
if (isSgControlEndStmt(st))
{
SgStatement* parent = st->controlParent();
SgStatement* parent_end;
if (parent && (parent_end = parent->lastNodeOfStmt()) && parent_end == st)
{
bool empty_parent = false;
switch (parent->variant())
{
case IF_NODE:
empty_parent =
parent->lexNext() == parent_end || // IF THEN ENDIF
isSgControlEndStmt(parent->lexNext()) &&
parent->lexNext()->lexNext() == parent_end; // IF THEN ELSE ENDIF
break;
default:
empty_parent = parent->lexNext() == parent_end; // DO, WHILE
break;
}
if (empty_parent)
parent->deleteStmt();
else if(isSgIfStmt(parent) && isSgControlEndStmt(parent_end->lexPrev())) // IF with empty ELSE branch
parent_end->deleteStmt();
}
}
remove.push_back(st);
continue;
}
st = next;
if (var == IF_NODE)
{
SgStatement* ifS = st;
while (ifS->lexNext()->variant() == ELSEIF_NODE)
ifS = ifS->lexNext();
if (ifS->lexNext()->variant() == CONTROL_END)
remove.push_back(st);
}
//TODO: SWITCH and other block statements
}
for (auto& rem : remove)
{
__spf_print(PRINT_USELESS_STATEMENTS, "[Useless block statement on line %d and file %s]\n", rem->lineNumber(), rem->fileName());
rem->deleteStmt();
}
deleteCFG(cfg);

3
sapfor/experts/Sapfor_2017/_src/Transformations/dead_code.h
View File

@@ -11,4 +11,5 @@
void removeDeadCode(SgStatement* func,
const std::map<std::string, std::vector<FuncInfo*>>&allFuncs,
const std::map<std::string, CommonBlock*>& commonBlocks);
const std::map<std::string, CommonBlock*>& commonBlocks,
SgStatement* intervalDelStart = NULL, SgStatement* intervalDelEnd = NULL);

488
sapfor/experts/Sapfor_2017/_src/Transformations/private_removing.cpp
View File

@@ -4,6 +4,7 @@
#include "../Utils/SgUtils.h"
#include "../Utils/utils.h"
#include "../ExpressionTransform/expr_transform.h"
#include "dead_code.h"
using std::make_pair;
using std::map;
@@ -16,17 +17,48 @@ using std::wstring;
using CFG_Type = map<FuncInfo*, vector<SAPFOR::BasicBlock*>>;
using UsersDirectives = map<pair<string, int>, set<SgStatement*>>;
// RegularExpr represents expressions like ( coefA * I + coefB ),
// where I is a variable and coefA or coefB can be equal to zero
struct RegularExpr {
int coefA = 0;
int coefB;
string var;
RegularExpr(): coefA(0), coefB(0), var("") {}
};
static bool operator==(const RegularExpr& left, const RegularExpr& right)
{
return left.var == right.var && left.coefA == right.coefA && left.coefB == right.coefB;
}
static bool operator<(const RegularExpr& left, const RegularExpr& right)
{
if (left.var == right.var && left.coefA < right.coefA && left.coefB <= right.coefB)
return true;
if (left.var == right.var && left.coefA == right.coefA && left.coefB < right.coefB)
return true;
return false;
}
// FixedSubscript represents subscript of array. Subscript is fixed if it is INT_VAL value
struct FixedSubscript {
bool isFixed;
int value;
};
// RegularExpr represents expressions like ( coefA * I + coefB ),
// where I is a variable and coefA or coefB can be equal to zero
struct RegularExpr {
int coefA;
int coefB;
bool isRegIndex;
RegularExpr regExprStart;
RegularExpr regExprEnd;
FixedSubscript() {
isFixed = false;
value = 0;
isRegIndex = false;
regExprStart = RegularExpr{};
regExprEnd = RegularExpr{};
}
};
// DefUseStmtsPair represents pair of DEF and USE statements for private variable
@@ -106,15 +138,50 @@ static bool isArrayRefInVector(SgArrayRefExp* ref, const vector<SgArrayRefExp*>&
return false;
}
// findAnyVar returns first found VAR_REF in expr
static SgSymbol* findAnyVar(SgExpression* expr)
{
if (expr == nullptr)
return nullptr;
if (expr->variant() == VAR_REF)
return expr->symbol();
SgSymbol* res = findAnyVar(expr->lhs());
if (res != nullptr)
return res;
return findAnyVar(expr->rhs());
}
// checkAndFillRegularExpr checks if expr is regular and fills regularExpr struct
// with info about expr
static bool checkAndFillRegularExpr(SgExpression* expr, RegularExpr& regularExpr, SgSymbol* iterationVar)
{
if (expr == nullptr)
return false;
// hack for cases when iterationVar doesn't matter:
if (iterationVar == nullptr)
iterationVar = findAnyVar(expr);
bool deleteTmpVar = false;
if (iterationVar == nullptr)
{
iterationVar = new SgSymbol(VARIABLE_NAME, "tmp");
deleteTmpVar = true;
}
pair<int, int> retCoefs;
getCoefsOfSubscript(retCoefs, expr, iterationVar);
regularExpr.coefA = retCoefs.first;
regularExpr.coefB = retCoefs.second;
if (!deleteTmpVar)
regularExpr.var = iterationVar->identifier();
if (deleteTmpVar)
delete iterationVar;
if (retCoefs.first != 0 || retCoefs.second != 0)
return true;
@@ -218,6 +285,33 @@ static bool isSymbolInExpression(SgSymbol* symbol, SgExpression* exp)
isSymbolInExpression(symbol, exp->rhs());
}
static FuncInfo* findFunc(string fileName, string funcName, const map<string, vector<FuncInfo*>>& allFuncInfo)
{
auto fileInfo = allFuncInfo.find(fileName);
if (fileInfo == allFuncInfo.end())
return nullptr;
for (auto funcInfo : fileInfo->second)
if (funcInfo->funcName == funcName)
return funcInfo;
return nullptr;
}
static FuncInfo* getCurrectFunc(SgStatement* stmt, const map<string, vector<FuncInfo*>>& allFuncInfo)
{
auto fileInfo = allFuncInfo.find(stmt->fileName());
if (fileInfo == allFuncInfo.end())
return nullptr;
int stmtLine = stmt->lineNumber();
for (auto funcInfo : fileInfo->second)
if (funcInfo->linesNum.first <= stmtLine && stmtLine <= funcInfo->linesNum.second)
return funcInfo;
return nullptr;
}
/* ************************************** *
* End of block of common used functions: *
* ************************************** */
@@ -505,38 +599,39 @@ static bool isVarChangedBetween(string var, SgStatement* first, SgStatement* sec
return false;
}
// TODO: remove if needless
// removeDeadCodeFromLoop removes assign statements to private scalar vars which are not read in loop
static void removeDeadCodeFromLoop(LoopGraph* loop)
{
SgForStmt* loopStmt = (SgForStmt*) loop->loop->GetOriginal();
set<Symbol*> privateVars;
for (auto data : getAttributes<SgStatement*, SgStatement*>(loopStmt, set<int>{ SPF_ANALYSIS_DIR }))
fillPrivatesFromComment(new Statement(data), privateVars);
set<string> privates;
for (Symbol* symbol : privateVars)
privates.insert(OriginalSymbol((SgSymbol*)symbol)->identifier());
vector<SgStatement*> stmtsToDelete;
for (SgStatement* st = loopStmt->lexNext(); st != loopStmt->lastNodeOfStmt(); st = st->lexNext())
{
if (st->variant() != ASSIGN_STAT)
continue;
SgSymbol* var = st->expr(0)->symbol();
if (var == nullptr || var->variant() != VARIABLE_NAME)
continue;
if (privates.find(var->identifier()) != privates.end() && !isVarReadInLoop(var, loopStmt))
stmtsToDelete.push_back(st);
}
for (auto stmt : stmtsToDelete)
stmt->deleteStmt();
for (auto childLoop : loop->children)
removeDeadCodeFromLoop(childLoop);
}
//static void removeDeadCodeFromLoop(LoopGraph* loop)
//{
// SgForStmt* loopStmt = (SgForStmt*) loop->loop->GetOriginal();
// set<Symbol*> privateVars;
// for (auto data : getAttributes<SgStatement*, SgStatement*>(loopStmt, set<int>{ SPF_ANALYSIS_DIR }))
// fillPrivatesFromComment(new Statement(data), privateVars);
//
// set<string> privates;
// for (Symbol* symbol : privateVars)
// privates.insert(OriginalSymbol((SgSymbol*)symbol)->identifier());
//
// vector<SgStatement*> stmtsToDelete;
// for (SgStatement* st = loopStmt->lexNext(); st != loopStmt->lastNodeOfStmt(); st = st->lexNext())
// {
// if (st->variant() != ASSIGN_STAT)
// continue;
//
// SgSymbol* var = st->expr(0)->symbol();
// if (var == nullptr || var->variant() != VARIABLE_NAME)
// continue;
//
// if (privates.find(var->identifier()) != privates.end() && !isVarReadInLoop(var, loopStmt))
// stmtsToDelete.push_back(st);
// }
//
// for (auto stmt : stmtsToDelete)
// stmt->deleteStmt();
//
// for (auto childLoop : loop->children)
// removeDeadCodeFromLoop(childLoop);
//}
// fillReadShortFixedSumscripts fills all short fixed subscripts vectors of array var,
// which are used for reading from array var in exp
@@ -603,30 +698,31 @@ static void removeExcessiveDefs(const PrivateToRemove& var)
st->deleteStmt();
}
// TODO: remove is needless
// removeEmptyLoops removes loops with empty body and create messages
static void removeEmptyLoops(LoopGraph* loop, vector<Messages>& messages)
{
vector<LoopGraph*> loopsToDelete;
vector<LoopGraph*> newChildrenVector;
for (auto childLoop : loop->children)
{
SgStatement* loopStmt = childLoop->loop->GetOriginal();
if (loopStmt->lastNodeOfStmt() == loopStmt->lexNext())
loopsToDelete.push_back(childLoop);
else
newChildrenVector.push_back(childLoop);
}
for (auto loopToDelete : loopsToDelete)
{
addMessageRemoveLoop(messages, loopToDelete->lineNum);
loopToDelete->loop->extractStmt();
}
loop->children.swap(newChildrenVector);
for (auto childLoop : loop->children)
removeEmptyLoops(childLoop, messages);
}
//static void removeEmptyLoops(LoopGraph* loop, vector<Messages>& messages)
//{
// vector<LoopGraph*> loopsToDelete;
// vector<LoopGraph*> newChildrenVector;
// for (auto childLoop : loop->children)
// {
// SgStatement* loopStmt = childLoop->loop->GetOriginal();
// if (loopStmt->lastNodeOfStmt() == loopStmt->lexNext())
// loopsToDelete.push_back(childLoop);
// else
// newChildrenVector.push_back(childLoop);
// }
//
// for (auto loopToDelete : loopsToDelete)
// {
// addMessageRemoveLoop(messages, loopToDelete->lineNum);
// loopToDelete->loop->extractStmt();
// }
//
// loop->children.swap(newChildrenVector);
// for (auto childLoop : loop->children)
// removeEmptyLoops(childLoop, messages);
//}
// removeVarFromPrivateAttributes removes var from SPF ANALYSIS PRIVATE attributes of loop
static void removeVarFromPrivateAttributes(SgSymbol* var, LoopGraph* loop)
@@ -726,30 +822,36 @@ static set<vector<int>> removeArray(string filename, const PrivateToRemove& arra
SgExpression* substExp = substituteExpressions(useStmt->expr(i), refToExpMap);
useStmt->setExpression(i, *substExp);
// don't revert substitutions in useStmt:
cancelRevertionForStatement(filename, useStmt, i);
}
}
return removedFixedSubscripts;
}
void removePrivates(SgFile* file, vector<Messages>& messages, int& countOfTransform)
void removePrivates(string filename, vector<Messages>& messages,
const map<string, CommonBlock*>& commonBlocks,
const map<string, vector<FuncInfo*>>& allFuncInfo,
int& countOfTransform)
{
for (auto& varToRemove : privatesToRemoveGlobal)
{
if (string(file->filename()) != varToRemove.loop->fileName)
if (filename != varToRemove.loop->fileName)
continue;
auto removedDimensions = removeArray(file->filename(), varToRemove);
auto removedDimensions = removeArray(filename, varToRemove);
countOfTransform++;
//removeDeadCodeFromLoop(varToRemove.loop); // TODO: problem with reverting substitution
//removeDeadCodeFromLoop(varToRemove.loop);
removeExcessiveDefs(varToRemove);
removeEmptyLoops(varToRemove.loop, messages);
//removeEmptyLoops(varToRemove.loop, messages);
SgForStmt* loopStmt = (SgForStmt*)varToRemove.loop->loop->GetOriginal();
FuncInfo* currFunc = getCurrectFunc(loopStmt, allFuncInfo);
if (currFunc == nullptr)
printInternalError(convertFileName(__FILE__).c_str(), __LINE__);
removeDeadCode(currFunc->funcPointer, allFuncInfo, commonBlocks);
vector<SgArrayRefExp*> varRefs = getDirectArrayRefs(loopStmt, varToRemove.varSymbol);
int loopLineNum = varToRemove.loop->lineNum;
string varName = varToRemove.varSymbol->identifier();
@@ -780,7 +882,7 @@ void removePrivates(SgFile* file, vector<Messages>& messages, int& countOfTransf
{
varName = getDimensionVarName(varToRemove.varSymbol, removedDimension,
fixedDimensions, varToRemove.regime);
addMessageRemovePrivateVarPart(messages, varName, loopLineNum);
addMessageRemovePrivateVar(messages, varName, loopLineNum);
}
}
}
@@ -800,6 +902,7 @@ struct Context {
const map<string, vector<FuncInfo*>>& allFuncInfo;
const map<string, CommonBlock*>& commonBlocks;
vector<Messages>& messages;
string filename;
Regime regime;
LoopGraph* loop;
@@ -1042,9 +1145,35 @@ static vector<bool> getFixedDimensionsMask(Context* ctx)
return resultMask;
}
// getScopeLoopStmt returns least outer scope loop statement
static SgForStmt* getScopeLoopStmt(SgStatement* stmt)
{
while (stmt != nullptr && stmt->variant() != FOR_NODE)
stmt = stmt->controlParent();
return (SgForStmt*)stmt;
}
// getLoopStmtForVar searches for loop with iteration var equal loopVar starting from from stmt
static SgForStmt* getLoopStmtForVar(SgStatement* stmt, string loopVar)
{
while (stmt != nullptr)
{
SgForStmt* loopStmt = getScopeLoopStmt(stmt);
if (loopStmt->doName()->identifier() == loopVar)
return loopStmt;
stmt = stmt->controlParent();
}
return nullptr;
}
// getFixedSubscriptsVector returns vector of fixed INT_VAL subscripts of arrayRef
// true - subscript is fixed, false - it isn't
static vector<FixedSubscript> getFixedSubscriptsVector(SgArrayRefExp* arrayRef, int dimensionsNum = 0)
static vector<FixedSubscript> getFixedSubscriptsVector(SgArrayRefExp* arrayRef, int dimensionsNum = 0,
SgStatement* stmt = nullptr)
{
if (arrayRef->numberOfSubscripts() == 0)
return vector<FixedSubscript>(dimensionsNum);
@@ -1052,42 +1181,50 @@ static vector<FixedSubscript> getFixedSubscriptsVector(SgArrayRefExp* arrayRef,
vector<FixedSubscript> subscriptsVector;
for (int i = 0; i < arrayRef->numberOfSubscripts(); ++i)
{
if (arrayRef->subscript(i)->variant() == INT_VAL)
subscriptsVector.push_back(FixedSubscript{ true, arrayRef->subscript(i)->valueInteger() });
else
subscriptsVector.push_back(FixedSubscript{ false, 0 });
SgExpression* subscriptExpr = arrayRef->subscript(i);
FixedSubscript sub;
if (subscriptExpr->variant() == INT_VAL)
{
sub.isFixed = true;
sub.value = subscriptExpr->valueInteger();
}
else if (stmt != nullptr && subscriptExpr->variant() == VAR_REF)
{
SgForStmt* loopStmt = getLoopStmtForVar(stmt, subscriptExpr->symbol()->identifier());
if (loopStmt != nullptr)
{
RegularExpr regExprStep;
SgExpression* step = loopStmt->step();
if (step == nullptr || checkAndFillRegularExpr(step, regExprStep, nullptr) && regExprStep.coefA == 0)
{
SgExpression* start = loopStmt->start();
SgExpression* end = loopStmt->end();
if (regExprStep.coefB < 0)
std::swap(start, end);
bool isRegular = true;
isRegular = isRegular && checkAndFillRegularExpr(start, sub.regExprStart, nullptr);
isRegular = isRegular && checkAndFillRegularExpr(end, sub.regExprEnd, nullptr);
sub.isRegIndex = isRegular;
}
}
}
else {
RegularExpr regExpr;
if (checkAndFillRegularExpr(subscriptExpr, regExpr, nullptr)) {
sub.isRegIndex = true;
sub.regExprStart = regExpr;
sub.regExprEnd = regExpr;
}
}
subscriptsVector.push_back(sub);
}
return subscriptsVector;
}
static FuncInfo* findFunc(string fileName, string funcName, const map<string, vector<FuncInfo*>>& allFuncInfo)
{
auto fileInfo = allFuncInfo.find(fileName);
if (fileInfo == allFuncInfo.end())
return nullptr;
for (auto funcInfo : fileInfo->second)
if (funcInfo->funcName == funcName)
return funcInfo;
return nullptr;
}
static FuncInfo* getCurrectFunc(SgStatement* stmt, const map<string, vector<FuncInfo*>>& allFuncInfo)
{
auto fileInfo = allFuncInfo.find(stmt->fileName());
if (fileInfo == allFuncInfo.end())
return nullptr;
int stmtLine = stmt->lineNumber();
for (auto funcInfo : fileInfo->second)
if (funcInfo->linesNum.first <= stmtLine && stmtLine <= funcInfo->linesNum.second)
return funcInfo;
return nullptr;
}
// checkImplicitDirectUsage returns masks of array implicit usage (as out argument)
// in any function call in exp and writes message about each usage
static void checkImplicitDirectUsage(Context* ctx, SgExpression* exp, int stmtLineNum,
@@ -1474,7 +1611,8 @@ static vector<DefUseStmtsPair> buildDefUsePairs(Context* ctx, const CFG_Type& CF
set<int> RD_defArgs = RD_forUseArg->second; // make copy
// delete recursive definition from RD def args:
// delete recursive and uninit definition from RD def args:
set<int> tmpRD_defArgs;
for (int defArgNum : RD_defArgs)
{
if (defArgNum == SAPFOR::CFG_VAL::UNINIT)
@@ -1487,11 +1625,11 @@ static vector<DefUseStmtsPair> buildDefUsePairs(Context* ctx, const CFG_Type& CF
SgStatement* defStmt = defInsAndBlock.first->getOperator();
auto defInsertedStmt = findInsertedStmt(insertedStmts, defStmt);
if (useInsertedStmt.relatedToStmt == defInsertedStmt->relatedToStmt)
{
RD_defArgs.erase(defArgNum);
break;
}
continue;
tmpRD_defArgs.insert(defArgNum);
}
RD_defArgs.swap(tmpRD_defArgs);
if (RD_defArgs.size() == 0) // argument is not initialized
{
@@ -1551,6 +1689,9 @@ static vector<DefUseStmtsPair> buildDefUsePairs(Context* ctx, const CFG_Type& CF
else
{
auto defInsAndBlock = getInstructionAndBlockByNumber(CFGraph, *RD_defArgs.begin());
if (defInsAndBlock.first == nullptr)
printInternalError(convertFileName(__FILE__).c_str(), __LINE__);
defStmt = defInsAndBlock.first->getOperator();
}
@@ -1576,14 +1717,14 @@ static vector<DefUseStmtsPair> buildDefUsePairs(Context* ctx, const CFG_Type& CF
return defUsePairs;
}
// getScopeLoopStmt returns least outer scope loop statement
static SgForStmt* getScopeLoopStmt(SgStatement* stmt)
{
while (stmt != nullptr && stmt->variant() != FOR_NODE)
stmt = stmt->controlParent();
return (SgForStmt*)stmt;
}
//// getScopeLoopStmt returns least outer scope loop statement
//static SgForStmt* getScopeLoopStmt(SgStatement* stmt)
//{
// while (stmt != nullptr && stmt->variant() != FOR_NODE)
// stmt = stmt->controlParent();
//
// return (SgForStmt*)stmt;
//}
// findChildLoop returns LoopGraph for provided loop statement
static LoopGraph* findLoop(LoopGraph* outerLoop, SgForStmt* loopStmt)
@@ -1649,7 +1790,8 @@ static LoopGraph* leastCommonAncestor(LoopGraph* a, LoopGraph* b, LoopGraph* par
// fillFullFixedSubscriptsVectorsOfAllVars return vector of pairs (name of var, its fixed subscripts vector)
// of all VAR_REF and ARRAY_REF vars in exp
static void fillFixedSubscriptsVectorsOfAllVars(SgExpression* exp,
vector<pair<string, vector<FixedSubscript>>>& vec)
vector<pair<string, vector<FixedSubscript>>>& vec,
SgStatement* stmt = nullptr)
{
if (exp == nullptr)
return;
@@ -1667,22 +1809,54 @@ static void fillFixedSubscriptsVectorsOfAllVars(SgExpression* exp,
else if (exp->variant() == ARRAY_REF)
{
vec.push_back(make_pair(exp->symbol()->identifier(),
getFixedSubscriptsVector((SgArrayRefExp*)exp)));
getFixedSubscriptsVector((SgArrayRefExp*)exp, 0, stmt)));
SgExprListExp* exprList = (SgExprListExp*)exp->lhs();
for (int i = 0; i < exprList->length(); ++i)
fillFixedSubscriptsVectorsOfAllVars(exprList->elem(i), vec);
fillFixedSubscriptsVectorsOfAllVars(exprList->elem(i), vec, stmt);
}
return;
}
fillFixedSubscriptsVectorsOfAllVars(exp->lhs(), vec);
fillFixedSubscriptsVectorsOfAllVars(exp->rhs(), vec);
fillFixedSubscriptsVectorsOfAllVars(exp->lhs(), vec, stmt);
fillFixedSubscriptsVectorsOfAllVars(exp->rhs(), vec, stmt);
}
// fixedSubscriptLess checks if left FixedSubscript is less than right
static bool fixedSubscriptLess(const FixedSubscript& left, const FixedSubscript& right)
{
if (left.isFixed && right.isFixed && left.value < right.value)
return true;
if (left.isFixed && right.isRegIndex
&& right.regExprStart.coefA == 0 && left.value < right.regExprStart.coefB)
return true;
if (left.isRegIndex && right.isFixed
&& left.regExprEnd.coefA == 0 && left.regExprEnd.coefB < right.value)
return true;
if (left.isRegIndex && right.isRegIndex)
return left.regExprEnd < right.regExprStart;
return false;
}
// fixedSubscriptLess checks if left and right FixedSubscripts are different,
// using empirical methods
static bool possibleDifferent(FixedSubscript left, FixedSubscript right)
{
// TODO: add warning?
if (left.isFixed && right.isRegIndex && right.regExprStart == right.regExprEnd) {
return true; // in general, this is not true
}
return false;
}
// isDifferentRefs checks if exp (var reference) is different from var. Refs are different
// if they has at least one different fixed subscript: arr(i, 1) is different from arr(j, 2)
static bool isDifferentRefs(SgExpression* exp, const pair<string, vector<FixedSubscript>>& var)
static bool isDifferentRefs(SgExpression* exp, const pair<string, vector<FixedSubscript>>& var, SgStatement* stmt)
{
if (exp->symbol()->identifier() != var.first)
return true;
@@ -1690,16 +1864,25 @@ static bool isDifferentRefs(SgExpression* exp, const pair<string, vector<FixedSu
if (exp->variant() == VAR_REF)
return false;
vector<FixedSubscript> leftVec = getFixedSubscriptsVector((SgArrayRefExp*)exp);
vector<FixedSubscript> leftVec = getFixedSubscriptsVector((SgArrayRefExp*)exp, 0, stmt);
if (leftVec.size() != var.second.size())
printInternalError(convertFileName(__FILE__).c_str(), __LINE__);
for (int i = 0; i < leftVec.size(); i++)
if (leftVec[i].isFixed && var.second[i].isFixed && leftVec[i].value != var.second[i].value)
{
if (fixedSubscriptLess(leftVec[i], var.second[i])
|| fixedSubscriptLess(var.second[i], leftVec[i])
|| possibleDifferent(leftVec[i], var.second[i]))
{
return true;
}
}
return false;
}
pair<SAPFOR::Argument*, set<int>> findVarInRDSet(map<SAPFOR::Argument*, set<int>> RD_In, string var)
static pair<SAPFOR::Argument*, set<int>> findVarInRDSet(const map<SAPFOR::Argument*, set<int>>& RD_In, const string& var)
{
for (auto& RD_InElem : RD_In)
{
@@ -1717,7 +1900,7 @@ pair<SAPFOR::Argument*, set<int>> findVarInRDSet(map<SAPFOR::Argument*, set<int>
// checkDefUsePair checks if def statement from pair can be substituted into use statement
// and creates messages
static bool checkDefUsePair(Context* ctx, DefUseStmtsPair defUse, const CFG_Type& CFGraph)
static bool checkDefUsePair(Context* ctx, const DefUseStmtsPair& defUse, const CFG_Type& CFGraph)
{
if (defUse.first->lineNumber() > defUse.second->lineNumber())
return false;
@@ -1733,7 +1916,7 @@ static bool checkDefUsePair(Context* ctx, DefUseStmtsPair defUse, const CFG_Type
SgExpression* expToSubst = defUse.first->rhs()->copyPtr();
expToSubst = replaceVarsWithExps(expToSubst, varToExpMap);
fillFixedSubscriptsVectorsOfAllVars(expToSubst, dependOnVars);
fillFixedSubscriptsVectorsOfAllVars(expToSubst, dependOnVars, defUse.second);
}
vector<SgSymbol*> iterationVars{};
@@ -1780,29 +1963,16 @@ static bool checkDefUsePair(Context* ctx, DefUseStmtsPair defUse, const CFG_Type
}
}
return true;
// TODO: ^^^^^
// <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>, <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD> <20> <20><> <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>
// <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD> RTMP <20> <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD> RHS <20><><EFBFBD><EFBFBD><EFBFBD> LU.
// <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD>, <20> <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD>,
// <20><><EFBFBD><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>, <20><><EFBFBD> <20><><EFBFBD> <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD> <20> <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD> rsd <20> <20><><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>
// <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD> <20> <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>:
// rsd(1,i,j,2) = ...
// do k = 4, nz - 3
// rsd(1, i, j, k) = ...
// enddo
// rsd(1, i, j, nz - 2) = ...
// checking arrays:
auto defLoopStmt = getScopeLoopStmt(defUse.first);
auto useLoopStmt = getScopeLoopStmt(defUse.second);
LoopGraph* loop = ctx->loop;
while (loop->perfectLoop != 1) // (what is it? - <EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD> <20><><EFBFBD> <20><> <20><><EFBFBD><EFBFBD><EFBFBD>)
while (loop->perfectLoop != 1) // (what is it? - TODO: may be remove it)
loop = loop->children[0];
auto defLoop = findLoop(loop, defLoopStmt);
auto useLoop = findLoop(loop, useLoopStmt);
LoopGraph* defLoop = findLoop(loop, defLoopStmt);
LoopGraph* useLoop = findLoop(loop, useLoopStmt);
if (!defLoopStmt || !useLoopStmt || !defLoop || !useLoop)
printInternalError(convertFileName(__FILE__).c_str(), __LINE__);
@@ -1846,7 +2016,9 @@ static bool checkDefUsePair(Context* ctx, DefUseStmtsPair defUse, const CFG_Type
{
for (SgStatement* st = startStmt; st != endStmt; st = st->lexNext())
{
if (st->variant() == ASSIGN_STAT && !isDifferentRefs(st->expr(0), var))
if (st == defUse.second)
continue;
if (st->variant() == ASSIGN_STAT && !isDifferentRefs(st->expr(0), var, st))
{
addMessageDependOnNonInvariant(ctx->messages, arrayName,
var.first, defUse.first->lineNumber());
@@ -1910,9 +2082,19 @@ void removePrivateAnalyze(Context *ctx)
{
vector<DefUseStmtsPair> resultDefUsePairs;
for (auto& pair : defUseStmtsPairs)
{
if (checkDefUsePair(ctx, pair, CFG_ForFunc))
{
resultDefUsePairs.push_back(pair);
// don't revert substitutions in use and def stmts:
cancelRevertionForStatement(ctx->filename, pair.first, 1);
cancelRevertionForStatement(ctx->filename, pair.second, 0);
cancelRevertionForStatement(ctx->filename, pair.second, 1);
cancelRevertionForStatement(ctx->filename, pair.second, 2);
}
}
PrivateToRemove newPrivateToRemove;
newPrivateToRemove.loop = ctx->loop;
newPrivateToRemove.varSymbol = ctx->arraySymbol;
@@ -1931,7 +2113,8 @@ void removePrivateAnalyze(Context *ctx)
deleteCFG(CFG_ForFunc);
}
void removePrivatesAnalysis(vector<LoopGraph*>& loopGraphs,
void removePrivatesAnalysis(string filename,
vector<LoopGraph*>& loopGraphs,
vector<Messages>& messages,
const UsersDirectives& usersDirectives,
const map<string, CommonBlock*>& commonBlocks,
@@ -1978,7 +2161,7 @@ void removePrivatesAnalysis(vector<LoopGraph*>& loopGraphs,
if (arrayToRemove == nullptr) // no array to remove
break;
Context context = Context{allFuncInfo, commonBlocks, messages};
Context context = Context{allFuncInfo, commonBlocks, messages, filename};
context.regime = Regime::DEFLT;
context.loop = loop;
context.loopStmt = loopStmt;
@@ -2000,20 +2183,17 @@ void removePrivatesAnalysis(vector<LoopGraph*>& loopGraphs,
{
removePrivateAnalyze(&context);
}
else
else if (checkRegularIndexRefs(&context))
{
if (checkRegularIndexRefs(&context))
{
context.regime = Regime::REGULAR_INDEXES;
context.fixedDimensionsMask = vector<bool>{};
removePrivateAnalyze(&context);
}
else
addMessageDoesNotMatchMask(messages, context.arraySymbol->identifier(), context.loop->lineNum);
context.regime = Regime::REGULAR_INDEXES;
context.fixedDimensionsMask = vector<bool>{};
removePrivateAnalyze(&context);
}
else
addMessageDoesNotMatchMask(messages, context.arraySymbol->identifier(), context.loop->lineNum);
}
}
for (LoopGraph* loop : loopGraphs)
removePrivatesAnalysis(loop->children, messages, usersDirectives, commonBlocks, allFuncInfo);
removePrivatesAnalysis(filename, loop->children, messages, usersDirectives, commonBlocks, allFuncInfo);
}

8
sapfor/experts/Sapfor_2017/_src/Transformations/private_removing.h
View File

@@ -22,12 +22,16 @@ struct PrivateToRemove {
// removePrivates removes all privates from vector privatesToRemoveGloval
// and add info messages
void removePrivates(SgFile* file, std::vector<Messages>& messages, int& countOfTransform);
void removePrivates(std::string filename, std::vector<Messages>& messages,
const std::map<std::string, CommonBlock*>& commonBlocks,
const std::map<std::string, std::vector<FuncInfo*>>& allFuncInfo,
int& countOfTransform);
// removePrivatesAnalysis checks all private variables in loopGraphs specified by usersDirectives
// if they can be removed, and adds those that can to vector privatesToRemoveGloval.
// if private var cannot be removed, the error message is returned with vector messages
void removePrivatesAnalysis(std::vector<LoopGraph*>& loopGraphs,
void removePrivatesAnalysis(std::string filename,
std::vector<LoopGraph*>& loopGraphs,
std::vector<Messages>& messages,
const std::map<std::pair<std::string, int>, std::set<SgStatement*>>& usersDirectives,
const std::map<std::string, CommonBlock*>& commonBlocks,

29
sapfor/experts/Sapfor_2017/_src/Utils/PassManager.h
View File

@@ -212,7 +212,8 @@ void InitPassesDependencies(map<passes, vector<passes>> &passDepsIn, set<passes>
Pass(BUILD_IR) <= Pass(SUBST_EXPR_RD) <= Pass(SUBST_EXPR_RD_AND_UNPARSE);
list({ LOOP_ANALYZER_DATA_DIST_S1, SUBST_EXPR_RD } ) <= Pass(PRIVATE_REMOVING_ANALYSIS) <= Pass(PRIVATE_REMOVING);
list({ LOOP_ANALYZER_DATA_DIST_S1, SUBST_EXPR_RD } ) <= Pass(PRIVATE_REMOVING_ANALYSIS);
list({ PRIVATE_REMOVING_ANALYSIS, REVERT_SUBST_EXPR_RD }) <= Pass(PRIVATE_REMOVING);
Pass(RESTORE_LOOP_FROM_ASSIGN) <= list({ SUBST_EXPR_AND_UNPARSE, SUBST_EXPR_RD_AND_UNPARSE });
@@ -242,7 +243,7 @@ void InitPassesDependencies(map<passes, vector<passes>> &passDepsIn, set<passes>
Pass(MACRO_EXPANSION) <= Pass(CALL_GRAPH);
list({ PREPROC_SPF, PROCESS_IO, CALL_GRAPH2, CONVERT_SAVE_TO_MODULE, REVERT_SUBST_EXPR, REVERT_SUBST_EXPR_RD }) <= Pass(CREATE_CHECKPOINTS);
list({ PREPROC_SPF, PROCESS_IO, CALL_GRAPH2, CONVERT_SAVE_TO_MODULE, REVERT_SUBST_EXPR_RD }) <= Pass(CREATE_CHECKPOINTS);
Pass(FILL_PAR_REGIONS_LINES) <= Pass(VERIFY_EQUIVALENCE);
@@ -254,9 +255,9 @@ void InitPassesDependencies(map<passes, vector<passes>> &passDepsIn, set<passes>
list({ PREPROC_SPF, CALL_GRAPH2, FILL_PAR_REGIONS_LINES }) <= Pass(FILL_PAR_REGIONS) <= Pass(RESOLVE_PAR_REGIONS);
list({ REVERT_SUBST_EXPR, REVERT_SUBST_EXPR_RD, CONVERT_LOOP_TO_ASSIGN }) <= Pass(RESOLVE_PAR_REGIONS);
list({ REVERT_SUBST_EXPR_RD, CONVERT_LOOP_TO_ASSIGN }) <= Pass(RESOLVE_PAR_REGIONS);
list({ REVERT_SUBST_EXPR, REVERT_SUBST_EXPR_RD }) <= Pass(EXPAND_EXTRACT_PAR_REGION);
Pass(REVERT_SUBST_EXPR_RD) <= Pass(EXPAND_EXTRACT_PAR_REGION);
Pass(FILL_PAR_REGIONS) <= Pass(PRINT_PAR_REGIONS_ERRORS);
@@ -268,33 +269,33 @@ void InitPassesDependencies(map<passes, vector<passes>> &passDepsIn, set<passes>
Pass(CALL_GRAPH2) <= list({ PURE_SAVE_TO_PARAMS, PURE_MODULE_TO_PARAMS, PURE_COMMON_TO_PARAMS, PURE_INTENT_INSERT });
list({ REVERT_SUBST_EXPR, REVERT_SUBST_EXPR_RD }) <= list({ PURE_SAVE_TO_PARAMS, PURE_MODULE_TO_PARAMS, PURE_COMMON_TO_PARAMS, PURE_INTENT_INSERT });
Pass(REVERT_SUBST_EXPR_RD) <= list({ PURE_SAVE_TO_PARAMS, PURE_MODULE_TO_PARAMS, PURE_COMMON_TO_PARAMS, PURE_INTENT_INSERT });
list({ CORRECT_VAR_DECL, REVERT_SUBST_EXPR, REVERT_SUBST_EXPR_RD, VERIFY_INCLUDE }) <= list({ CONVERT_TO_ENDDO, CORRECT_CODE_STYLE, REMOVE_DVM_DIRS, REMOVE_DVM_DIRS_TO_COMMENTS, REMOVE_DVM_INTERVALS });
list({ CORRECT_VAR_DECL, REVERT_SUBST_EXPR_RD, VERIFY_INCLUDE }) <= list({ CONVERT_TO_ENDDO, CORRECT_CODE_STYLE, REMOVE_DVM_DIRS, REMOVE_DVM_DIRS_TO_COMMENTS, REMOVE_DVM_INTERVALS });
list({ CALL_GRAPH2, CONVERT_LOOP_TO_ASSIGN, REVERT_SUBST_EXPR, REVERT_SUBST_EXPR_RD, RESTORE_LOOP_FROM_ASSIGN }) <= Pass(INLINE_PROCEDURES);
list({ CALL_GRAPH2, CONVERT_LOOP_TO_ASSIGN, REVERT_SUBST_EXPR_RD, RESTORE_LOOP_FROM_ASSIGN }) <= Pass(INLINE_PROCEDURES);
list({ CONVERT_LOOP_TO_ASSIGN, CORRECT_FORMAT_PLACE }) <= list({ CONVERT_TO_ENDDO, CORRECT_CODE_STYLE, INSERT_INCLUDES, REMOVE_DVM_DIRS, REMOVE_DVM_DIRS_TO_COMMENTS, REMOVE_DVM_INTERVALS });
list({ CORRECT_VAR_DECL, REVERT_SUBST_EXPR, REVERT_SUBST_EXPR_RD }) <= list({ INSERT_INCLUDES, UNPARSE_FILE, SET_TO_ALL_DECL_INIT_ZERO });
list({ CORRECT_VAR_DECL, REVERT_SUBST_EXPR_RD }) <= list({ INSERT_INCLUDES, UNPARSE_FILE, SET_TO_ALL_DECL_INIT_ZERO });
Pass(CALL_GRAPH2) <= Pass(PRIVATE_ARRAYS_SHRINKING_ANALYSIS) <= Pass(PRIVATE_ARRAYS_SHRINKING);
list({ CALL_GRAPH2, LOOP_ANALYZER_ALIGNS, REVERT_SUBST_EXPR, REVERT_SUBST_EXPR_RD }) <= list({ PRIVATE_ARRAYS_EXPANSION, PRIVATE_ARRAYS_SHRINKING });
list({ CALL_GRAPH2, LOOP_ANALYZER_ALIGNS, REVERT_SUBST_EXPR_RD }) <= list({ PRIVATE_ARRAYS_EXPANSION, PRIVATE_ARRAYS_SHRINKING });
list({ GCOV_PARSER, CREATE_INTER_TREE, CALL_GRAPH, CALL_GRAPH2 }) <= Pass(CREATE_PARALLEL_REGIONS);
list({ PRIVATE_CALL_GRAPH_STAGE1, PRIVATE_CALL_GRAPH_STAGE2, MACRO_EXPANSION, CONVERT_ASSIGN_TO_LOOP, DEF_USE_STAGE1, DEF_USE_STAGE2, LOOP_GRAPH, CALL_GRAPH, PRIVATE_ANALYSIS_IR, FIND_FUNC_TO_INCLUDE }) <= Pass(INSERT_REGIONS);
list({ LOOP_ANALYZER_DATA_DIST_S1, REVERT_SUBST_EXPR, REVERT_SUBST_EXPR_RD }) <= list({ LOOPS_SPLITTER, LOOPS_COMBINER, UNROLL_LOOPS, INSERT_REGIONS });
list({ LOOP_ANALYZER_DATA_DIST_S1, REVERT_SUBST_EXPR_RD }) <= list({ LOOPS_SPLITTER, LOOPS_COMBINER, UNROLL_LOOPS, INSERT_REGIONS });
list({ CALL_GRAPH2, REVERT_SUBST_EXPR, REVERT_SUBST_EXPR_RD, CONVERT_LOOP_TO_ASSIGN, RESTORE_LOOP_FROM_ASSIGN }) <= list({ DUPLICATE_FUNCTIONS, REMOVE_UNUSED_FUNCTIONS });
list({ CALL_GRAPH2, REVERT_SUBST_EXPR_RD, CONVERT_LOOP_TO_ASSIGN, RESTORE_LOOP_FROM_ASSIGN }) <= list({ DUPLICATE_FUNCTIONS, REMOVE_UNUSED_FUNCTIONS });
list({ CONVERT_LOOP_TO_ASSIGN, RESTORE_LOOP_FROM_ASSIGN }) <= list({ LOOPS_SPLITTER, LOOPS_COMBINER, PRIVATE_ARRAYS_EXPANSION, PRIVATE_ARRAYS_SHRINKING, CREATE_PARALLEL_REGIONS, PURE_SAVE_TO_PARAMS, PURE_MODULE_TO_PARAMS, PURE_COMMON_TO_PARAMS, PURE_INTENT_INSERT });
list({ GET_ALL_ARRAY_DECL, FILL_PARALLEL_REG_IR }) <= Pass(CONVERT_ASSIGN_TO_LOOP);
list({ CALL_GRAPH2, REVERT_SUBST_EXPR, REVERT_SUBST_EXPR_RD }) <= Pass(RENAME_SYMBOLS);
list({ CALL_GRAPH2, REVERT_SUBST_EXPR_RD }) <= Pass(RENAME_SYMBOLS);
list({ BUILD_IR, CALL_GRAPH }) <= Pass(LIVE_ANALYSIS_IR);
@@ -307,7 +308,7 @@ void InitPassesDependencies(map<passes, vector<passes>> &passDepsIn, set<passes>
Pass(REMOVE_OMP_DIRS) <= Pass(REMOVE_OMP_DIRS_TRANSFORM);
Pass(CALL_GRAPH2) <= Pass(REMOVE_DEAD_CODE);
list({ REMOVE_DEAD_CODE, REVERT_SUBST_EXPR, REVERT_SUBST_EXPR_RD, CONVERT_LOOP_TO_ASSIGN, RESTORE_LOOP_FROM_ASSIGN }) <= Pass(REMOVE_DEAD_CODE_AND_UNPARSE);
list({ REMOVE_DEAD_CODE, REVERT_SUBST_EXPR_RD, CONVERT_LOOP_TO_ASSIGN, RESTORE_LOOP_FROM_ASSIGN }) <= Pass(REMOVE_DEAD_CODE_AND_UNPARSE);
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,
@@ -318,7 +319,7 @@ void InitPassesDependencies(map<passes, vector<passes>> &passDepsIn, set<passes>
//only for print
if (printTree)
{
list({ CREATE_PARALLEL_DIRS, PRIVATE_ANALYSIS_IR, CREATE_REMOTES, REVERT_SUBST_EXPR, REVERT_SUBST_EXPR_RD, UNPARSE_FILE, EXTRACT_PARALLEL_DIRS }) <= Pass(INSERT_PARALLEL_DIRS);
list({ CREATE_PARALLEL_DIRS, PRIVATE_ANALYSIS_IR, CREATE_REMOTES, REVERT_SUBST_EXPR_RD, UNPARSE_FILE, EXTRACT_PARALLEL_DIRS }) <= Pass(INSERT_PARALLEL_DIRS);
depsToGraphViz(passDepsIn);
exit(0);
}

2
sapfor/experts/Sapfor_2017/_src/Utils/SgUtils.cpp
View File

@@ -271,7 +271,7 @@ static int reverseVar(SgStatement* st)
static map<SgStatement*, map<int, set<string>>> insertedIncludes;
static set<SgFile*> genVersionDone;
set<int> hideUnnecessary(SgFile* file, const string& fileN, const set<string>& moduleDeclsInFiles, bool dontReplaceIncludes)
static set<int> hideUnnecessary(SgFile* file, const string& fileN, const set<string>& moduleDeclsInFiles, bool dontReplaceIncludes)
{
set<int> changedVars;
for (SgStatement* st = file->firstStatement(); st; st = st->lexNext())

1
sapfor/experts/Sapfor_2017/_src/Utils/SgUtils.h
View File

@@ -11,7 +11,6 @@ SgStatement* declaratedInStmt(SgSymbol *toFind, std::vector<SgStatement*> *allDe
#include "DefUseList.h"
#include "CommonBlock.h"
std::set<int> hideUnnecessary(SgFile* file, const std::string& fileN, const std::set<std::string>& moduleDeclsInFiles, const bool dontReplaceIncludes);
std::string removeIncludeStatsAndUnparse(SgFile *file, const char *fileName, const char *fout, std::set<std::string> &allIncludeFiles, bool outFree, const std::map<std::string, std::set<std::string>> &moduleUsesByFile, const std::map<std::string, std::string>& moduleDelcs, const std::map<SgStatement*, std::vector<SgStatement*>>& exctactedModuleStats, bool toString, bool dontReplaceIncls = false);
SgSymbol* findSymbolOrCreate(SgFile *file, const std::string toFind, SgType *type = NULL, SgStatement *scope = NULL);
void recExpressionPrint(SgExpression *exp);

2
sapfor/experts/Sapfor_2017/_src/Utils/version.h
View File

@@ -1,3 +1,3 @@
#pragma once
#define VERSION_SPF "2285"
#define VERSION_SPF "2290"