From a882be75e952669a42bef23f582f2cfab2d91c90 Mon Sep 17 00:00:00 2001 From: DenisDudarenko Date: Mon, 11 Dec 2023 21:41:31 +0300 Subject: [PATCH 01/17] WIP : Add new pass - set-implisit-none --- sapfor/experts/Sapfor_2017/CMakeLists.txt | 7 +- sapfor/experts/Sapfor_2017/_src/Sapfor.cpp | 4 + sapfor/experts/Sapfor_2017/_src/Sapfor.h | 3 + .../Transformations/set_implicit_none.cpp | 187 ++++++++++++++++++ .../_src/Transformations/set_implicit_none.h | 7 + .../Sapfor_2017/_src/Utils/PassManager.h | 2 + 6 files changed, 209 insertions(+), 1 deletion(-) create mode 100644 sapfor/experts/Sapfor_2017/_src/Transformations/set_implicit_none.cpp create mode 100644 sapfor/experts/Sapfor_2017/_src/Transformations/set_implicit_none.h diff --git a/sapfor/experts/Sapfor_2017/CMakeLists.txt b/sapfor/experts/Sapfor_2017/CMakeLists.txt index d6c259b..5010d0c 100644 --- a/sapfor/experts/Sapfor_2017/CMakeLists.txt +++ b/sapfor/experts/Sapfor_2017/CMakeLists.txt @@ -187,6 +187,9 @@ set(TR_FUNC_PURE _src/Transformations/function_purifying.cpp _src/Transformations/function_purifying.h) set(TR_GV _src/Transformations/fix_common_blocks.cpp _src/Transformations/fix_common_blocks.h) +set(TR_IMPLICIT_NONE _src/Transformations/set_implicit_none.cpp + _src/Transformations/set_implicit_none.h) + set(TRANSFORMS ${TR_CP} ${TR_VECTOR} @@ -200,7 +203,8 @@ set(TRANSFORMS ${TR_FUNC_PURE} ${TR_LOOP_UNROLL} ${TR_GV} - ${TR_PRIV_DEL}) + ${TR_PRIV_DEL} + ${TR_IMPLICIT_NONE}) set(CFG _src/CFGraph/IR.cpp _src/CFGraph/IR.h @@ -419,6 +423,7 @@ source_group (Transformations\\PrivateArrayRemoving FILES ${TR_PRIV_DEL}) source_group (Transformations\\VectorAssignToLoop FILES ${TR_VECTOR}) source_group (Transformations\\RenameSymbols FILES ${RENAME_SYMBOLS}) source_group (Transformations\\GlobalVariables FILES ${TR_GV}) +source_group (Transformations\\SetImplicitNone FILES ${TR_IMPLICIT_NONE}) source_group (CreateIntervals FILES ${CREATE_INTER_T}) diff --git a/sapfor/experts/Sapfor_2017/_src/Sapfor.cpp b/sapfor/experts/Sapfor_2017/_src/Sapfor.cpp index 9dda347..46f802b 100644 --- a/sapfor/experts/Sapfor_2017/_src/Sapfor.cpp +++ b/sapfor/experts/Sapfor_2017/_src/Sapfor.cpp @@ -78,6 +78,7 @@ #include "Transformations/function_purifying.h" #include "Transformations/private_removing.h" #include "Transformations/fix_common_blocks.h" +#include "Transformations/set_implicit_none.h" #include "RenameSymbols/rename_symbols.h" #include "ProjectParameters/projectParameters.h" @@ -2175,6 +2176,8 @@ static bool runAnalysis(SgProject &project, const int curr_regime, const bool ne runPrivateVariableAnalysis(loopGraph, fullIR, commonBlocks, SPF_messages); else if (curr_regime == FIX_COMMON_BLOCKS) fixCommonBlocks(allFuncInfo, commonBlocks, &project); + else if (curr_regime == SET_IMPLICIT_NONE) + ImplicitCheck(&project); else if (curr_regime == SELECT_ARRAY_DIM_CONF) { map> localMessages; @@ -2608,6 +2611,7 @@ void runPass(const int curr_regime, const char *proj_name, const char *folderNam case LOOPS_SPLITTER: case LOOPS_COMBINER: case FIX_COMMON_BLOCKS: + case SET_IMPLICIT_NONE: case TEST_PASS: runAnalysis(*project, curr_regime, false); case SUBST_EXPR_RD_AND_UNPARSE: diff --git a/sapfor/experts/Sapfor_2017/_src/Sapfor.h b/sapfor/experts/Sapfor_2017/_src/Sapfor.h index 957a1f8..62ad7ef 100644 --- a/sapfor/experts/Sapfor_2017/_src/Sapfor.h +++ b/sapfor/experts/Sapfor_2017/_src/Sapfor.h @@ -168,6 +168,8 @@ enum passes { FIX_COMMON_BLOCKS, + SET_IMPLICIT_NONE, + TEST_PASS, EMPTY_PASS }; @@ -339,6 +341,7 @@ static void setPassValues() passNames[PRIVATE_ANALYSIS_IR] = "PRIVATE_ANALYSIS_IR"; passNames[FIX_COMMON_BLOCKS] = "FIX_COMMON_BLOCKS"; + passNames[SET_IMPLICIT_NONE] = "SET_IMPLICIT_NONE"; passNames[TEST_PASS] = "TEST_PASS"; } diff --git a/sapfor/experts/Sapfor_2017/_src/Transformations/set_implicit_none.cpp b/sapfor/experts/Sapfor_2017/_src/Transformations/set_implicit_none.cpp new file mode 100644 index 0000000..6c4de80 --- /dev/null +++ b/sapfor/experts/Sapfor_2017/_src/Transformations/set_implicit_none.cpp @@ -0,0 +1,187 @@ +#include +#include +#include +#include + +#include "Utils/SgUtils.h" +#include "set_implicit_none.h" + +using std::vector; +using std::map; +using std::multimap; +using std::set; +using std::make_pair; +using std::string; +using std::to_string; + +map implicit; +set vars; +vector toDecl; + +static void InsertToMap(SgType* type, SgExpression* letters) { + + while (letters != NULL && letters->lhs() != NULL) { + + string letter; + + switch (letters->lhs()->sunparse().size()) { + + case 3: + letter = letters->lhs()->sunparse(); + implicit[letter[1]] = type; + + break; + case 7: + letter = letters->lhs()->sunparse(); + + for (char i = letter[1]; i <= letter[5]; i++) { + implicit[i] = type; + } + break; + default : + //printf("IMPLICIT bad format (can bew only {letter : letter} or {letter})"); + throw; + } + + letters = letters->rhs(); + } + +} + +static void InsertDefaultToMap() { + SgType* intType = new SgType(T_INT); + + SgType* realType = new SgType(T_FLOAT); + + for (char i = 'a'; i <= 'z'; i++) { + implicit[i] = realType; + } + + for (char i = 'i'; i <= 'n'; i++) { + implicit[i] = intType; + } +} + +static void CheckVariables(SgStatement* function) { + + for (int k = 0; k < function->numberOfChildrenList1(); k++) { + SgStatement* state = function->childList1(k); + + + if (state->expr(0) && (state->expr(0)->variant() == VAR_REF || state->expr(0)->variant() == ARRAY_REF)) { + SgSymbol* symbol = state->expr(0)->symbol(); + auto x = declaratedInStmt(symbol, NULL, false); + + if (vars.find(symbol) == vars.end() && x == NULL) { + vars.insert(symbol); + + char firstLetter = *symbol->identifier(); + + if (implicit.find(firstLetter) != implicit.end()) { + if (implicit[firstLetter]->variant() != symbol->type()->variant()) { + symbol->setType(implicit[firstLetter]); + + if (symbol->declaredInStmt() == NULL) { + toDecl.push_back(symbol); + } + } + else { + toDecl.push_back(symbol); + } + } + else { + //printf("Variable - "); + //printf(symbol->identifier()); + //printf(" - not found in IMPLICIT\n"); + throw; + } + } + } + } + + makeDeclaration(toDecl, function, NULL); +} + + +void ImplicitCheck(SgProject* project) { + + /* + printf("IMPLICIT\n"); + */ + + for (int i = 0; i < project->numberOfFiles(); i++) { + SgFile file = project->file(i); + int coutOfFunctions; + for (int j = 0; j < file.numberOfFunctions(); j++) { + SgStatement* function = file.functions(j); + + implicit.clear(); + vars.clear(); + toDecl.clear(); + + //fill implicit + + for (int k = 0; k < function->numberOfChildrenList1(); k++) { + SgStatement* state = function->childList1(k); + + + + if (state->variant() == IMPL_DECL) { + + if (state->expr(0) == NULL) { + + } + else { + SgExpression* expression = state->expr(0); + int n = 0; + SgExpression* one = expression; + + while (one != NULL && one->lhs() != NULL) { + + string what_type = one->lhs()->sunparse(); + + if (what_type.find("kind=") != std::string::npos) { + + SgType* baseType = new SgType(one->lhs()->type()->variant()); + + SgType* type = new SgType(T_ARRAY, NULL, baseType); + + SgExpression* letters = one->lhs()->operand(1); + + InsertToMap(type, letters); + } + else { + + SgType* type = new SgType(one->lhs()->type()->variant()); + + SgExpression* letters = one->lhs()->operand(1); + + InsertToMap(type, letters); + } + + one = one->rhs(); + } + + } + + break; + } + + if (state->variant() == CONTROL_END) { + + SgStatement* state = new SgStatement(IMPL_DECL); + auto cp = function->childList1(0)->controlParent(); + function->childList1(0)->insertStmtBefore(*state, *cp); + + + InsertDefaultToMap(); + + break; + } + } + + CheckVariables(function); + + } + } +} diff --git a/sapfor/experts/Sapfor_2017/_src/Transformations/set_implicit_none.h b/sapfor/experts/Sapfor_2017/_src/Transformations/set_implicit_none.h new file mode 100644 index 0000000..985c6d5 --- /dev/null +++ b/sapfor/experts/Sapfor_2017/_src/Transformations/set_implicit_none.h @@ -0,0 +1,7 @@ +#pragma once +#include "Utils/SgUtils.h" + +#include "string" +#include "map" + +void ImplicitCheck(SgProject* project); \ No newline at end of file diff --git a/sapfor/experts/Sapfor_2017/_src/Utils/PassManager.h b/sapfor/experts/Sapfor_2017/_src/Utils/PassManager.h index 7b584e5..ac40cc4 100644 --- a/sapfor/experts/Sapfor_2017/_src/Utils/PassManager.h +++ b/sapfor/experts/Sapfor_2017/_src/Utils/PassManager.h @@ -302,6 +302,8 @@ void InitPassesDependencies(map> &passDepsIn, set Pass(CALL_GRAPH2) <= Pass(FIX_COMMON_BLOCKS); + Pass(CALL_GRAPH2) <= Pass(SET_IMPLICIT_NONE); + passesIgnoreStateDone.insert({ CREATE_PARALLEL_DIRS, INSERT_PARALLEL_DIRS, INSERT_SHADOW_DIRS, EXTRACT_PARALLEL_DIRS, EXTRACT_SHADOW_DIRS, CREATE_REMOTES, UNPARSE_FILE, REMOVE_AND_CALC_SHADOW, REVERSE_CREATED_NESTED_LOOPS, PREDICT_SCHEME, CALCULATE_STATS_SCHEME, REVERT_SPF_DIRS, CLEAR_SPF_DIRS, TRANSFORM_SHADOW_IF_FULL, -- 2.49.1 From 3456226e66afe2a96e407b4c3a50c3ebc4a6df56 Mon Sep 17 00:00:00 2001 From: DenisDudarenko Date: Mon, 11 Dec 2023 21:48:11 +0300 Subject: [PATCH 02/17] Forgot static( --- .../Sapfor_2017/_src/Transformations/set_implicit_none.cpp | 6 +++--- 1 file changed, 3 insertions(+), 3 deletions(-) diff --git a/sapfor/experts/Sapfor_2017/_src/Transformations/set_implicit_none.cpp b/sapfor/experts/Sapfor_2017/_src/Transformations/set_implicit_none.cpp index 6c4de80..432c74c 100644 --- a/sapfor/experts/Sapfor_2017/_src/Transformations/set_implicit_none.cpp +++ b/sapfor/experts/Sapfor_2017/_src/Transformations/set_implicit_none.cpp @@ -14,9 +14,9 @@ using std::make_pair; using std::string; using std::to_string; -map implicit; -set vars; -vector toDecl; +static map implicit; +static set vars; +static vector toDecl; static void InsertToMap(SgType* type, SgExpression* letters) { -- 2.49.1 From a5c31c60a7a88405cf1e947827a041c5ad95afdd Mon Sep 17 00:00:00 2001 From: DenisDudarenko Date: Tue, 12 Mar 2024 10:42:22 +0300 Subject: [PATCH 03/17] WIP : check all implicit stmts --- sapfor/experts/Sapfor_2017/CMakeLists.txt | 4 +- sapfor/experts/Sapfor_2017/_src/Sapfor.cpp | 9 +- .../Transformations/set_implicit_none.cpp | 267 ++++++++++++------ .../_src/Transformations/set_implicit_none.h | 6 +- .../Sapfor_2017/_src/Utils/PassManager.h | 2 - 5 files changed, 194 insertions(+), 94 deletions(-) diff --git a/sapfor/experts/Sapfor_2017/CMakeLists.txt b/sapfor/experts/Sapfor_2017/CMakeLists.txt index de349ae..49d8dea 100644 --- a/sapfor/experts/Sapfor_2017/CMakeLists.txt +++ b/sapfor/experts/Sapfor_2017/CMakeLists.txt @@ -194,7 +194,7 @@ set(TR_IMPLICIT_NONE _src/Transformations/set_implicit_none.cpp _src/Transformations/set_implicit_none.h) set(TRANSFORMS - ${TR_CP} + ${TR_CP} ${TR_VECTOR} ${TR_ENDDO_LOOP} ${TR_LOOP_NEST} @@ -207,7 +207,7 @@ set(TRANSFORMS ${TR_LOOP_UNROLL} ${TR_GV} ${TR_PRIV_DEL} - ${TR_CONV}) + ${TR_CONV} ${TR_PRIV_DEL} ${TR_IMPLICIT_NONE}) diff --git a/sapfor/experts/Sapfor_2017/_src/Sapfor.cpp b/sapfor/experts/Sapfor_2017/_src/Sapfor.cpp index e50cd3f..1a407e6 100644 --- a/sapfor/experts/Sapfor_2017/_src/Sapfor.cpp +++ b/sapfor/experts/Sapfor_2017/_src/Sapfor.cpp @@ -1162,6 +1162,8 @@ static bool runAnalysis(SgProject &project, const int curr_regime, const bool ne getMaxMinBlockDistribution(file, min_max_block); else if (curr_regime == CONVERT_TO_C) covertToC(file); + else if (curr_regime == SET_IMPLICIT_NONE) + ImplicitCheck(file); else if (curr_regime == TEST_PASS) { //test pass @@ -2057,8 +2059,6 @@ static bool runAnalysis(SgProject &project, const int curr_regime, const bool ne runPrivateVariableAnalysis(loopGraph, fullIR, commonBlocks, SPF_messages); else if (curr_regime == FIX_COMMON_BLOCKS) fixCommonBlocks(allFuncInfo, commonBlocks, &project); - else if (curr_regime == SET_IMPLICIT_NONE) - ImplicitCheck(&project); else if (curr_regime == SELECT_ARRAY_DIM_CONF) { SelectArrayConfForParallelization(&project, allFuncInfo, loopGraph, createdDirectives, SPF_messages, arrayLinksByFuncCalls, parallelRegions); removeRegionsWithoutDirs(createdDirectives, parallelRegions, allFuncInfo, SPF_messages); @@ -2522,7 +2522,7 @@ void runPass(const int curr_regime, const char *proj_name, const char *folderNam case LOOPS_SPLITTER: case LOOPS_COMBINER: case FIX_COMMON_BLOCKS: - case SET_IMPLICIT_NONE: + //case SET_IMPLICIT_NONE: case TEST_PASS: runAnalysis(*project, curr_regime, false); case SUBST_EXPR_RD_AND_UNPARSE: @@ -2624,7 +2624,10 @@ int main(int argc, char **argv) else if (string(curr_arg) == "-passN") { i++; + // test + curr_regime = getPassCode(argv[i]); + curr_regime = 130; printf("code for pass %s is %d\n", argv[i], curr_regime); } else if (string(curr_arg) == "-passInfo") diff --git a/sapfor/experts/Sapfor_2017/_src/Transformations/set_implicit_none.cpp b/sapfor/experts/Sapfor_2017/_src/Transformations/set_implicit_none.cpp index 432c74c..bb7928d 100644 --- a/sapfor/experts/Sapfor_2017/_src/Transformations/set_implicit_none.cpp +++ b/sapfor/experts/Sapfor_2017/_src/Transformations/set_implicit_none.cpp @@ -5,6 +5,7 @@ #include "Utils/SgUtils.h" #include "set_implicit_none.h" +#include using std::vector; using std::map; @@ -14,106 +15,120 @@ using std::make_pair; using std::string; using std::to_string; -static map implicit; -static set vars; -static vector toDecl; +map types; +vector varsWithoutDecl; +const char commonIntLetters[6] = {'i', 'j', 'k', 'm', 'n', 'l'}; -static void InsertToMap(SgType* type, SgExpression* letters) { - - while (letters != NULL && letters->lhs() != NULL) { - - string letter; - - switch (letters->lhs()->sunparse().size()) { - - case 3: - letter = letters->lhs()->sunparse(); - implicit[letter[1]] = type; - - break; - case 7: - letter = letters->lhs()->sunparse(); - - for (char i = letter[1]; i <= letter[5]; i++) { - implicit[i] = type; - } - break; - default : - //printf("IMPLICIT bad format (can bew only {letter : letter} or {letter})"); - throw; - } - - letters = letters->rhs(); - } +void InitTypes(); +void FillCommonTypes(); +void GetImplicitTypes(SgExpression* expr); +static inline string getContains(SgStatement* funcSt) +{ + string containsName; + SgStatement* st_cp = funcSt->controlParent(); + if (st_cp->variant() == PROC_HEDR || st_cp->variant() == PROG_HEDR || st_cp->variant() == FUNC_HEDR) + containsName = st_cp->symbol()->identifier() + std::string("."); + return containsName; } -static void InsertDefaultToMap() { - SgType* intType = new SgType(T_INT); +void ImplicitCheck(SgFile* file) { - SgType* realType = new SgType(T_FLOAT); + auto implicitNoneDeclaration = new SgStatement(IMPL_DECL); + auto hasImplicitNone = false; - for (char i = 'a'; i <= 'z'; i++) { - implicit[i] = realType; - } + for (SgStatement* i = file->firstStatement(); i = i->lexNext(); i != NULL) { - for (char i = 'i'; i <= 'n'; i++) { - implicit[i] = intType; - } -} + if (i->variant() == IMPL_DECL) { + SgImplicitStmt* implicitSt = isSgImplicitStmt(i); + if (implicitSt) { + int numberOfTypes = implicitSt->numberOfImplicitTypes(); -static void CheckVariables(SgStatement* function) { + if (numberOfTypes > 0) { + for (int j = 0; j < numberOfTypes; j++) { + SgType* type = implicitSt->implicitType(j); + SgExpression* letters = implicitSt->implicitRangeList(j); - for (int k = 0; k < function->numberOfChildrenList1(); k++) { - SgStatement* state = function->childList1(k); - - - if (state->expr(0) && (state->expr(0)->variant() == VAR_REF || state->expr(0)->variant() == ARRAY_REF)) { - SgSymbol* symbol = state->expr(0)->symbol(); - auto x = declaratedInStmt(symbol, NULL, false); - - if (vars.find(symbol) == vars.end() && x == NULL) { - vars.insert(symbol); - - char firstLetter = *symbol->identifier(); - - if (implicit.find(firstLetter) != implicit.end()) { - if (implicit[firstLetter]->variant() != symbol->type()->variant()) { - symbol->setType(implicit[firstLetter]); - - if (symbol->declaredInStmt() == NULL) { - toDecl.push_back(symbol); - } - } - else { - toDecl.push_back(symbol); + types['a'] = type; + printf("%s\n", letters->unparse()); } } else { - //printf("Variable - "); - //printf(symbol->identifier()); - //printf(" - not found in IMPLICIT\n"); - throw; + hasImplicitNone = true; } } } + else { + printf("%s\nvariant - %d\n\n", i->unparse(), i->variant()); + } } - makeDeclaration(toDecl, function, NULL); + + if (!hasImplicitNone) { + auto firstRealStatementOfFile = file->firstStatement()->lexNext()->lexNext(); + firstRealStatementOfFile->insertStmtBefore(*implicitNoneDeclaration, *(firstRealStatementOfFile->controlParent())); + } + + printf("%s", file->firstStatement()->lexNext()->unparse()); + + return; +} + +void InitTypes() { + for (char i = 'a'; i <= 'z'; i++) { + types[i] = NULL; + } +} + +void FillCommonTypes() { + for (char i: commonIntLetters) { + if (types[i] == NULL) { + types[i] = new SgType(T_INT); + } + } + + for (auto i : types) { + if (i.second == NULL) { + types[i.first] = new SgType(T_FLOAT); + } + } +} + +void GetImplicitTypes(SgExpression* expr) { + if (expr == NULL) { + return; + } + + if (expr->variant() == IMPL_TYPE) { + auto letters = expr->operand(1); + auto type = expr->type(); + + printf("letters - %s\n", letters->unparse()); + } + + if (expr->lhs() != NULL) { + GetImplicitTypes(expr->lhs()); + } + if (expr->rhs() != NULL) { + GetImplicitTypes(expr->rhs()); + } } -void ImplicitCheck(SgProject* project) { - - /* - printf("IMPLICIT\n"); - */ - - for (int i = 0; i < project->numberOfFiles(); i++) { - SgFile file = project->file(i); - int coutOfFunctions; - for (int j = 0; j < file.numberOfFunctions(); j++) { - SgStatement* function = file.functions(j); +/* +* +* +auto x = implicitSt->numberOfImplicitTypes(); + printf("IMPLICIT\n%s", implicitSt->unparse()); + printf("number - %d\n", x); + for (int j = 0; j < x; j++) { + printf("%d - %s\n", j, implicitSt->implicitRangeList(j)->unparse()); + } + printf("\n"); +* +int coutOfFunctions; + for (int j = 0; j < file->numberOfFunctions(); j++) { + SgStatement* function = file->functions(j); implicit.clear(); vars.clear(); @@ -124,7 +139,7 @@ void ImplicitCheck(SgProject* project) { for (int k = 0; k < function->numberOfChildrenList1(); k++) { SgStatement* state = function->childList1(k); - + if (state->variant() == IMPL_DECL) { @@ -162,11 +177,11 @@ void ImplicitCheck(SgProject* project) { one = one->rhs(); } - } - + } + break; } - + if (state->variant() == CONTROL_END) { SgStatement* state = new SgStatement(IMPL_DECL); @@ -183,5 +198,89 @@ void ImplicitCheck(SgProject* project) { CheckVariables(function); } + + +static void InsertToMap(SgType* type, SgExpression* letters) { + + while (letters != NULL && letters->lhs() != NULL) { + + string letter; + + switch (letters->lhs()->sunparse().size()) { + + case 3: + letter = letters->lhs()->sunparse(); + implicit[letter[1]] = type; + + break; + case 7: + letter = letters->lhs()->sunparse(); + + for (char i = letter[1]; i <= letter[5]; i++) { + implicit[i] = type; + } + break; + default: + //printf("IMPLICIT bad format (can bew only {letter : letter} or {letter})"); + throw; + } + + letters = letters->rhs(); + } + +} + +static void InsertDefaultToMap() { + SgType* intType = new SgType(T_INT); + + SgType* realType = new SgType(T_FLOAT); + + for (char i = 'a'; i <= 'z'; i++) { + implicit[i] = realType; + } + + for (char i = 'i'; i <= 'n'; i++) { + implicit[i] = intType; } } + +static void CheckVariables(SgStatement* function) { + + for (int k = 0; k < function->numberOfChildrenList1(); k++) { + SgStatement* state = function->childList1(k); + + + if (state->expr(0) && (state->expr(0)->variant() == VAR_REF || state->expr(0)->variant() == ARRAY_REF)) { + SgSymbol* symbol = state->expr(0)->symbol(); + auto x = declaratedInStmt(symbol, NULL, false); + + if (vars.find(symbol) == vars.end() && x == NULL) { + vars.insert(symbol); + + char firstLetter = *symbol->identifier(); + + if (implicit.find(firstLetter) != implicit.end()) { + if (implicit[firstLetter]->variant() != symbol->type()->variant()) { + symbol->setType(implicit[firstLetter]); + + if (symbol->declaredInStmt() == NULL) { + toDecl.push_back(symbol); + } + } + else { + toDecl.push_back(symbol); + } + } + else { + //printf("Variable - "); + //printf(symbol->identifier()); + //printf(" - not found in IMPLICIT\n"); + throw; + } + } + } + } + + makeDeclaration(toDecl, function, NULL); +} +*/ diff --git a/sapfor/experts/Sapfor_2017/_src/Transformations/set_implicit_none.h b/sapfor/experts/Sapfor_2017/_src/Transformations/set_implicit_none.h index 985c6d5..5d2fb25 100644 --- a/sapfor/experts/Sapfor_2017/_src/Transformations/set_implicit_none.h +++ b/sapfor/experts/Sapfor_2017/_src/Transformations/set_implicit_none.h @@ -1,7 +1,7 @@ #pragma once #include "Utils/SgUtils.h" -#include "string" -#include "map" +#include +#include -void ImplicitCheck(SgProject* project); \ No newline at end of file +void ImplicitCheck(SgFile* file); \ No newline at end of file diff --git a/sapfor/experts/Sapfor_2017/_src/Utils/PassManager.h b/sapfor/experts/Sapfor_2017/_src/Utils/PassManager.h index fd507f9..1085084 100644 --- a/sapfor/experts/Sapfor_2017/_src/Utils/PassManager.h +++ b/sapfor/experts/Sapfor_2017/_src/Utils/PassManager.h @@ -306,8 +306,6 @@ void InitPassesDependencies(map> &passDepsIn, set Pass(REMOVE_OMP_DIRS) <= Pass(REMOVE_OMP_DIRS_TRANSFORM); - Pass(CALL_GRAPH2) <= Pass(SET_IMPLICIT_NONE); - passesIgnoreStateDone.insert({ CREATE_PARALLEL_DIRS, INSERT_PARALLEL_DIRS, INSERT_SHADOW_DIRS, EXTRACT_PARALLEL_DIRS, EXTRACT_SHADOW_DIRS, CREATE_REMOTES, UNPARSE_FILE, REMOVE_AND_CALC_SHADOW, REVERSE_CREATED_NESTED_LOOPS, PREDICT_SCHEME, CALCULATE_STATS_SCHEME, REVERT_SPF_DIRS, CLEAR_SPF_DIRS, TRANSFORM_SHADOW_IF_FULL, -- 2.49.1 From cf2bed5c9cb8fcd1eff33e6f370765b5801d2f78 Mon Sep 17 00:00:00 2001 From: DenisDudarenko Date: Tue, 12 Mar 2024 11:24:52 +0300 Subject: [PATCH 04/17] Add comments --- .../Transformations/set_implicit_none.cpp | 23 +++++++++++-------- 1 file changed, 14 insertions(+), 9 deletions(-) diff --git a/sapfor/experts/Sapfor_2017/_src/Transformations/set_implicit_none.cpp b/sapfor/experts/Sapfor_2017/_src/Transformations/set_implicit_none.cpp index bb7928d..eb01b85 100644 --- a/sapfor/experts/Sapfor_2017/_src/Transformations/set_implicit_none.cpp +++ b/sapfor/experts/Sapfor_2017/_src/Transformations/set_implicit_none.cpp @@ -16,6 +16,7 @@ using std::string; using std::to_string; map types; +vector allVars; vector varsWithoutDecl; const char commonIntLetters[6] = {'i', 'j', 'k', 'm', 'n', 'l'}; @@ -23,15 +24,6 @@ void InitTypes(); void FillCommonTypes(); void GetImplicitTypes(SgExpression* expr); -static inline string getContains(SgStatement* funcSt) -{ - string containsName; - SgStatement* st_cp = funcSt->controlParent(); - if (st_cp->variant() == PROC_HEDR || st_cp->variant() == PROG_HEDR || st_cp->variant() == FUNC_HEDR) - containsName = st_cp->symbol()->identifier() + std::string("."); - return containsName; -} - void ImplicitCheck(SgFile* file) { auto implicitNoneDeclaration = new SgStatement(IMPL_DECL); @@ -49,6 +41,7 @@ void ImplicitCheck(SgFile* file) { SgType* type = implicitSt->implicitType(j); SgExpression* letters = implicitSt->implicitRangeList(j); + // get real letters types['a'] = type; printf("%s\n", letters->unparse()); } @@ -63,6 +56,18 @@ void ImplicitCheck(SgFile* file) { } } + // get all vars + + for each (auto var in allVars) + { + SgStatement* declaredIn = declaratedInStmt(var); + if (declaredIn == NULL) { + varsWithoutDecl.push_back(var); + } + } + + // create decl + // delete implicit if (!hasImplicitNone) { auto firstRealStatementOfFile = file->firstStatement()->lexNext()->lexNext(); -- 2.49.1 From 24f8ead2b0fe4f93707b766032fe2f0647d1b10c Mon Sep 17 00:00:00 2001 From: DenisDudarenko Date: Tue, 12 Mar 2024 17:43:53 +0300 Subject: [PATCH 05/17] fix merge errors --- sapfor/experts/Sapfor_2017/CMakeLists.txt | 1 + sapfor/experts/Sapfor_2017/_src/Sapfor.cpp | 9 - sapfor/experts/Sapfor_2017/_src/Sapfor.h | 3 - .../Transformations/set_implicit_none.cpp | 209 ++---------------- 4 files changed, 14 insertions(+), 208 deletions(-) diff --git a/sapfor/experts/Sapfor_2017/CMakeLists.txt b/sapfor/experts/Sapfor_2017/CMakeLists.txt index 46a19b1..02f7fb9 100644 --- a/sapfor/experts/Sapfor_2017/CMakeLists.txt +++ b/sapfor/experts/Sapfor_2017/CMakeLists.txt @@ -197,6 +197,7 @@ set(TR_IMPLICIT_NONE _src/Transformations/set_implicit_none.cpp set(TRANSFORMS ${TR_DEAD_CODE} + ${TR_CP} ${TR_VECTOR} ${TR_ENDDO_LOOP} ${TR_LOOP_NEST} diff --git a/sapfor/experts/Sapfor_2017/_src/Sapfor.cpp b/sapfor/experts/Sapfor_2017/_src/Sapfor.cpp index 2d42e11..3d283a4 100644 --- a/sapfor/experts/Sapfor_2017/_src/Sapfor.cpp +++ b/sapfor/experts/Sapfor_2017/_src/Sapfor.cpp @@ -83,11 +83,8 @@ #include "Transformations/private_removing.h" #include "Transformations/fix_common_blocks.h" #include "Transformations/convert_to_c.h" -<<<<<<< HEAD #include "Transformations/set_implicit_none.h" -======= #include "Transformations/dead_code.h" ->>>>>>> master #include "RenameSymbols/rename_symbols.h" #include "ProjectParameters/projectParameters.h" @@ -1175,10 +1172,8 @@ static bool runAnalysis(SgProject &project, const int curr_regime, const bool ne getMaxMinBlockDistribution(file, min_max_block); else if (curr_regime == CONVERT_TO_C) covertToC(file); -<<<<<<< HEAD else if (curr_regime == SET_IMPLICIT_NONE) ImplicitCheck(file); -======= else if (curr_regime == INSERT_NO_DISTR_FLAGS_FROM_GUI) addPrivatesToArraysFromGUI(file, declaredArrays, distrStateFromGUI); else if (curr_regime == REMOVE_DEAD_CODE) @@ -1187,7 +1182,6 @@ static bool runAnalysis(SgProject &project, const int curr_regime, const bool ne for (auto& func : funcsForFile) removeDeadCode(func->funcPointer, allFuncInfo, commonBlocks); } ->>>>>>> master else if (curr_regime == TEST_PASS) { //test pass @@ -2645,10 +2639,7 @@ int main(int argc, char **argv) else if (string(curr_arg) == "-passN") { i++; - // test - curr_regime = getPassCode(argv[i]); - curr_regime = 130; printf("code for pass %s is %d\n", argv[i], curr_regime); } else if (string(curr_arg) == "-passInfo") diff --git a/sapfor/experts/Sapfor_2017/_src/Sapfor.h b/sapfor/experts/Sapfor_2017/_src/Sapfor.h index d3ceb53..4a08593 100644 --- a/sapfor/experts/Sapfor_2017/_src/Sapfor.h +++ b/sapfor/experts/Sapfor_2017/_src/Sapfor.h @@ -356,11 +356,8 @@ static void setPassValues() passNames[REMOVE_COMMENTS] = "REMOVE_COMMENTS"; passNames[GET_MIN_MAX_BLOCK_DIST] = "GET_MIN_MAX_BLOCK_DIST"; passNames[CONVERT_TO_C] = "CONVERT_TO_C"; -<<<<<<< HEAD passNames[SET_IMPLICIT_NONE] = "SET_IMPLICIT_NONE"; -======= passNames[INSERT_NO_DISTR_FLAGS_FROM_GUI] = "INSERT_NO_DISTR_FLAGS_FROM_GUI"; ->>>>>>> master passNames[TEST_PASS] = "TEST_PASS"; } diff --git a/sapfor/experts/Sapfor_2017/_src/Transformations/set_implicit_none.cpp b/sapfor/experts/Sapfor_2017/_src/Transformations/set_implicit_none.cpp index eb01b85..85f2389 100644 --- a/sapfor/experts/Sapfor_2017/_src/Transformations/set_implicit_none.cpp +++ b/sapfor/experts/Sapfor_2017/_src/Transformations/set_implicit_none.cpp @@ -22,13 +22,15 @@ const char commonIntLetters[6] = {'i', 'j', 'k', 'm', 'n', 'l'}; void InitTypes(); void FillCommonTypes(); -void GetImplicitTypes(SgExpression* expr); void ImplicitCheck(SgFile* file) { auto implicitNoneDeclaration = new SgStatement(IMPL_DECL); auto hasImplicitNone = false; + InitTypes(); + FillCommonTypes(); + for (SgStatement* i = file->firstStatement(); i = i->lexNext(); i != NULL) { if (i->variant() == IMPL_DECL) { @@ -51,14 +53,11 @@ void ImplicitCheck(SgFile* file) { } } } - else { - printf("%s\nvariant - %d\n\n", i->unparse(), i->variant()); - } } // get all vars - for each (auto var in allVars) + for (auto var : allVars) { SgStatement* declaredIn = declaratedInStmt(var); if (declaredIn == NULL) { @@ -69,7 +68,16 @@ void ImplicitCheck(SgFile* file) { // create decl // delete implicit + if (!hasImplicitNone) { + for (SgStatement* i = file->firstStatement(); ; i != NULL) { + if (i->variant() == IMPL_DECL) { + auto tmp = i; + i = i->lexNext(); + tmp->deleteStmt(); + } + } + auto firstRealStatementOfFile = file->firstStatement()->lexNext()->lexNext(); firstRealStatementOfFile->insertStmtBefore(*implicitNoneDeclaration, *(firstRealStatementOfFile->controlParent())); } @@ -98,194 +106,3 @@ void FillCommonTypes() { } } } - -void GetImplicitTypes(SgExpression* expr) { - if (expr == NULL) { - return; - } - - if (expr->variant() == IMPL_TYPE) { - auto letters = expr->operand(1); - auto type = expr->type(); - - printf("letters - %s\n", letters->unparse()); - } - - if (expr->lhs() != NULL) { - GetImplicitTypes(expr->lhs()); - } - if (expr->rhs() != NULL) { - GetImplicitTypes(expr->rhs()); - } -} - - -/* -* -* -auto x = implicitSt->numberOfImplicitTypes(); - printf("IMPLICIT\n%s", implicitSt->unparse()); - printf("number - %d\n", x); - for (int j = 0; j < x; j++) { - printf("%d - %s\n", j, implicitSt->implicitRangeList(j)->unparse()); - } - printf("\n"); -* -int coutOfFunctions; - for (int j = 0; j < file->numberOfFunctions(); j++) { - SgStatement* function = file->functions(j); - - implicit.clear(); - vars.clear(); - toDecl.clear(); - - //fill implicit - - for (int k = 0; k < function->numberOfChildrenList1(); k++) { - SgStatement* state = function->childList1(k); - - - - if (state->variant() == IMPL_DECL) { - - if (state->expr(0) == NULL) { - - } - else { - SgExpression* expression = state->expr(0); - int n = 0; - SgExpression* one = expression; - - while (one != NULL && one->lhs() != NULL) { - - string what_type = one->lhs()->sunparse(); - - if (what_type.find("kind=") != std::string::npos) { - - SgType* baseType = new SgType(one->lhs()->type()->variant()); - - SgType* type = new SgType(T_ARRAY, NULL, baseType); - - SgExpression* letters = one->lhs()->operand(1); - - InsertToMap(type, letters); - } - else { - - SgType* type = new SgType(one->lhs()->type()->variant()); - - SgExpression* letters = one->lhs()->operand(1); - - InsertToMap(type, letters); - } - - one = one->rhs(); - } - - } - - break; - } - - if (state->variant() == CONTROL_END) { - - SgStatement* state = new SgStatement(IMPL_DECL); - auto cp = function->childList1(0)->controlParent(); - function->childList1(0)->insertStmtBefore(*state, *cp); - - - InsertDefaultToMap(); - - break; - } - } - - CheckVariables(function); - - } - - -static void InsertToMap(SgType* type, SgExpression* letters) { - - while (letters != NULL && letters->lhs() != NULL) { - - string letter; - - switch (letters->lhs()->sunparse().size()) { - - case 3: - letter = letters->lhs()->sunparse(); - implicit[letter[1]] = type; - - break; - case 7: - letter = letters->lhs()->sunparse(); - - for (char i = letter[1]; i <= letter[5]; i++) { - implicit[i] = type; - } - break; - default: - //printf("IMPLICIT bad format (can bew only {letter : letter} or {letter})"); - throw; - } - - letters = letters->rhs(); - } - -} - -static void InsertDefaultToMap() { - SgType* intType = new SgType(T_INT); - - SgType* realType = new SgType(T_FLOAT); - - for (char i = 'a'; i <= 'z'; i++) { - implicit[i] = realType; - } - - for (char i = 'i'; i <= 'n'; i++) { - implicit[i] = intType; - } -} - -static void CheckVariables(SgStatement* function) { - - for (int k = 0; k < function->numberOfChildrenList1(); k++) { - SgStatement* state = function->childList1(k); - - - if (state->expr(0) && (state->expr(0)->variant() == VAR_REF || state->expr(0)->variant() == ARRAY_REF)) { - SgSymbol* symbol = state->expr(0)->symbol(); - auto x = declaratedInStmt(symbol, NULL, false); - - if (vars.find(symbol) == vars.end() && x == NULL) { - vars.insert(symbol); - - char firstLetter = *symbol->identifier(); - - if (implicit.find(firstLetter) != implicit.end()) { - if (implicit[firstLetter]->variant() != symbol->type()->variant()) { - symbol->setType(implicit[firstLetter]); - - if (symbol->declaredInStmt() == NULL) { - toDecl.push_back(symbol); - } - } - else { - toDecl.push_back(symbol); - } - } - else { - //printf("Variable - "); - //printf(symbol->identifier()); - //printf(" - not found in IMPLICIT\n"); - throw; - } - } - } - } - - makeDeclaration(toDecl, function, NULL); -} -*/ -- 2.49.1 From 76d173d5541c171d55db257f8ec9b9335219d8f9 Mon Sep 17 00:00:00 2001 From: DenisDudarenko Date: Wed, 13 Mar 2024 23:38:42 +0300 Subject: [PATCH 06/17] WIP: add deleting implicit stmts aninserting decls --- .../Transformations/set_implicit_none.cpp | 44 ++++++++++++++----- 1 file changed, 34 insertions(+), 10 deletions(-) diff --git a/sapfor/experts/Sapfor_2017/_src/Transformations/set_implicit_none.cpp b/sapfor/experts/Sapfor_2017/_src/Transformations/set_implicit_none.cpp index 85f2389..1cb3ce4 100644 --- a/sapfor/experts/Sapfor_2017/_src/Transformations/set_implicit_none.cpp +++ b/sapfor/experts/Sapfor_2017/_src/Transformations/set_implicit_none.cpp @@ -22,16 +22,26 @@ const char commonIntLetters[6] = {'i', 'j', 'k', 'm', 'n', 'l'}; void InitTypes(); void FillCommonTypes(); +void FunctionImplicitCheck(SgStatement* function); void ImplicitCheck(SgFile* file) { + for (int funcNum = 0; funcNum < file->numberOfFunctions(); funcNum++) { + SgStatement* function = file->functions(funcNum); + FunctionImplicitCheck(function); + } + + return; +} + +void FunctionImplicitCheck(SgStatement* function) { auto implicitNoneDeclaration = new SgStatement(IMPL_DECL); auto hasImplicitNone = false; InitTypes(); FillCommonTypes(); - for (SgStatement* i = file->firstStatement(); i = i->lexNext(); i != NULL) { + for (SgStatement* i = function->lexNext(); i = i->lexNext(); i != NULL) { if (i->variant() == IMPL_DECL) { SgImplicitStmt* implicitSt = isSgImplicitStmt(i); @@ -44,8 +54,7 @@ void ImplicitCheck(SgFile* file) { SgExpression* letters = implicitSt->implicitRangeList(j); // get real letters - types['a'] = type; - printf("%s\n", letters->unparse()); + types['o'] = type; } } else { @@ -55,34 +64,49 @@ void ImplicitCheck(SgFile* file) { } } - // get all vars + for (SgSymbol* symbol = function->symbol(); symbol != NULL; symbol = symbol->next()) { + if (symbol != NULL && symbol->declaredInStmt() != NULL) { + allVars.push_back(symbol); + } + } for (auto var : allVars) { - SgStatement* declaredIn = declaratedInStmt(var); + vector _; + SgStatement* declaredIn = declaratedInStmt(var, &_, false); if (declaredIn == NULL) { varsWithoutDecl.push_back(var); } } - // create decl - // delete implicit + for (auto var : varsWithoutDecl) { + vector test = { var }; + char c = var->identifier()[0]; + if (types.find(c) != types.end()) { + test[0]->setType(types[c]); + } + + makeDeclaration(function, test); + } if (!hasImplicitNone) { - for (SgStatement* i = file->firstStatement(); ; i != NULL) { + for (SgStatement* i = function->lexNext(); i != NULL;) { if (i->variant() == IMPL_DECL) { auto tmp = i; i = i->lexNext(); tmp->deleteStmt(); } + else { + i = i->lexNext(); + } } - auto firstRealStatementOfFile = file->firstStatement()->lexNext()->lexNext(); + auto firstRealStatementOfFile = function->lexNext(); firstRealStatementOfFile->insertStmtBefore(*implicitNoneDeclaration, *(firstRealStatementOfFile->controlParent())); } - printf("%s", file->firstStatement()->lexNext()->unparse()); + printf("%s", function->unparse()); return; } -- 2.49.1 From f145afceef27923b96fb0f89604587467f21d117 Mon Sep 17 00:00:00 2001 From: DenisDudarenko Date: Thu, 14 Mar 2024 15:45:03 +0300 Subject: [PATCH 07/17] Fix warnings --- .../Transformations/set_implicit_none.cpp | 108 ++++++++++-------- 1 file changed, 60 insertions(+), 48 deletions(-) diff --git a/sapfor/experts/Sapfor_2017/_src/Transformations/set_implicit_none.cpp b/sapfor/experts/Sapfor_2017/_src/Transformations/set_implicit_none.cpp index 1cb3ce4..cb719e4 100644 --- a/sapfor/experts/Sapfor_2017/_src/Transformations/set_implicit_none.cpp +++ b/sapfor/experts/Sapfor_2017/_src/Transformations/set_implicit_none.cpp @@ -1,19 +1,8 @@ -#include -#include -#include -#include - #include "Utils/SgUtils.h" #include "set_implicit_none.h" -#include using std::vector; using std::map; -using std::multimap; -using std::set; -using std::make_pair; -using std::string; -using std::to_string; map types; vector allVars; @@ -24,9 +13,11 @@ void InitTypes(); void FillCommonTypes(); void FunctionImplicitCheck(SgStatement* function); -void ImplicitCheck(SgFile* file) { +void ImplicitCheck(SgFile* file) +{ - for (int funcNum = 0; funcNum < file->numberOfFunctions(); funcNum++) { + for (int funcNum = 0; funcNum < file->numberOfFunctions(); funcNum++) + { SgStatement* function = file->functions(funcNum); FunctionImplicitCheck(function); } @@ -34,22 +25,27 @@ void ImplicitCheck(SgFile* file) { return; } -void FunctionImplicitCheck(SgStatement* function) { +void FunctionImplicitCheck(SgStatement* function) +{ auto implicitNoneDeclaration = new SgStatement(IMPL_DECL); auto hasImplicitNone = false; InitTypes(); FillCommonTypes(); - for (SgStatement* i = function->lexNext(); i = i->lexNext(); i != NULL) { - - if (i->variant() == IMPL_DECL) { - SgImplicitStmt* implicitSt = isSgImplicitStmt(i); - if (implicitSt) { + for (SgStatement* statement = function->lexNext(); statement = statement->lexNext(); statement != NULL) + { + if (statement->variant() == IMPL_DECL) + { + SgImplicitStmt* implicitSt = isSgImplicitStmt(statement); + if (implicitSt) + { int numberOfTypes = implicitSt->numberOfImplicitTypes(); - if (numberOfTypes > 0) { - for (int j = 0; j < numberOfTypes; j++) { + if (numberOfTypes > 0) + { + for (int j = 0; j < numberOfTypes; j++) + { SgType* type = implicitSt->implicitType(j); SgExpression* letters = implicitSt->implicitRangeList(j); @@ -57,15 +53,22 @@ void FunctionImplicitCheck(SgStatement* function) { types['o'] = type; } } - else { + else + { hasImplicitNone = true; } } } + else if (statement->variant() == CONTAINS_STMT || isSgExecutableStatement(statement) != NULL) + { + break; + } } - for (SgSymbol* symbol = function->symbol(); symbol != NULL; symbol = symbol->next()) { - if (symbol != NULL && symbol->declaredInStmt() != NULL) { + for (SgSymbol* symbol = function->symbol(); symbol != NULL; symbol = symbol->next()) + { + if (symbol != NULL && symbol->declaredInStmt() != NULL) + { allVars.push_back(symbol); } } @@ -74,36 +77,38 @@ void FunctionImplicitCheck(SgStatement* function) { { vector _; SgStatement* declaredIn = declaratedInStmt(var, &_, false); - if (declaredIn == NULL) { + if (declaredIn == NULL) + { + char c = var->identifier()[0]; + + if (types.find(c) != types.end()) + { + var->setType(types[c]); + } + varsWithoutDecl.push_back(var); } } - for (auto var : varsWithoutDecl) { - vector test = { var }; - char c = var->identifier()[0]; + makeDeclaration(varsWithoutDecl, function, NULL); - if (types.find(c) != types.end()) { - test[0]->setType(types[c]); - } - - makeDeclaration(function, test); - } - - if (!hasImplicitNone) { - for (SgStatement* i = function->lexNext(); i != NULL;) { - if (i->variant() == IMPL_DECL) { + if (!hasImplicitNone) + { + for (SgStatement* i = function->lexNext(); i != NULL;) + { + if (i->variant() == IMPL_DECL) + { auto tmp = i; i = i->lexNext(); tmp->deleteStmt(); } - else { + else + { i = i->lexNext(); } } - auto firstRealStatementOfFile = function->lexNext(); - firstRealStatementOfFile->insertStmtBefore(*implicitNoneDeclaration, *(firstRealStatementOfFile->controlParent())); + function->insertStmtBefore(*implicitNoneDeclaration, *function); } printf("%s", function->unparse()); @@ -111,21 +116,28 @@ void FunctionImplicitCheck(SgStatement* function) { return; } -void InitTypes() { - for (char i = 'a'; i <= 'z'; i++) { +void InitTypes() +{ + for (char i = 'a'; i <= 'z'; i++) + { types[i] = NULL; } } -void FillCommonTypes() { - for (char i: commonIntLetters) { - if (types[i] == NULL) { +void FillCommonTypes() +{ + for (char i: commonIntLetters) + { + if (types[i] == NULL) + { types[i] = new SgType(T_INT); } } - for (auto i : types) { - if (i.second == NULL) { + for (auto i : types) + { + if (i.second == NULL) + { types[i.first] = new SgType(T_FLOAT); } } -- 2.49.1 From c00f8d69777ca3e454265ba1726f30345d7c7507 Mon Sep 17 00:00:00 2001 From: DenisDudarenko Date: Sat, 16 Mar 2024 15:31:06 +0300 Subject: [PATCH 08/17] Fix searching letters and vars --- .../Transformations/set_implicit_none.cpp | 136 +++++++++++++----- 1 file changed, 101 insertions(+), 35 deletions(-) diff --git a/sapfor/experts/Sapfor_2017/_src/Transformations/set_implicit_none.cpp b/sapfor/experts/Sapfor_2017/_src/Transformations/set_implicit_none.cpp index cb719e4..dfefa2e 100644 --- a/sapfor/experts/Sapfor_2017/_src/Transformations/set_implicit_none.cpp +++ b/sapfor/experts/Sapfor_2017/_src/Transformations/set_implicit_none.cpp @@ -3,23 +3,32 @@ using std::vector; using std::map; +using std::set; map types; -vector allVars; +set allVars; vector varsWithoutDecl; const char commonIntLetters[6] = {'i', 'j', 'k', 'm', 'n', 'l'}; void InitTypes(); void FillCommonTypes(); +void CleanTypes(); void FunctionImplicitCheck(SgStatement* function); +void FindAllVars(SgExpression* expr); +char AddLettersToMap(SgExpression* params, SgType* type); void ImplicitCheck(SgFile* file) { - for (int funcNum = 0; funcNum < file->numberOfFunctions(); funcNum++) + for (int functionNumber = 0; functionNumber < file->numberOfFunctions(); functionNumber++) { - SgStatement* function = file->functions(funcNum); + InitTypes(); + FillCommonTypes(); + + SgStatement* function = file->functions(functionNumber); FunctionImplicitCheck(function); + + CleanTypes(); } return; @@ -30,27 +39,23 @@ void FunctionImplicitCheck(SgStatement* function) auto implicitNoneDeclaration = new SgStatement(IMPL_DECL); auto hasImplicitNone = false; - InitTypes(); - FillCommonTypes(); - - for (SgStatement* statement = function->lexNext(); statement = statement->lexNext(); statement != NULL) + for (SgStatement* statement = function; statement = statement->lexNext(); statement != NULL) { if (statement->variant() == IMPL_DECL) { - SgImplicitStmt* implicitSt = isSgImplicitStmt(statement); - if (implicitSt) + SgImplicitStmt* implicitStatement = isSgImplicitStmt(statement); + if (implicitStatement != NULL) { - int numberOfTypes = implicitSt->numberOfImplicitTypes(); + int numberOfTypes = implicitStatement->numberOfImplicitTypes(); if (numberOfTypes > 0) { for (int j = 0; j < numberOfTypes; j++) { - SgType* type = implicitSt->implicitType(j); - SgExpression* letters = implicitSt->implicitRangeList(j); + SgType* type = implicitStatement->implicitType(j); + SgExpression* lettersExpression = implicitStatement->implicitRangeList(j); - // get real letters - types['o'] = type; + AddLettersToMap(lettersExpression, type); } } else @@ -65,19 +70,19 @@ void FunctionImplicitCheck(SgStatement* function) } } - for (SgSymbol* symbol = function->symbol(); symbol != NULL; symbol = symbol->next()) + for (SgStatement* statement = function; statement != function->lastExecutable(); statement = statement->lexNext()) { - if (symbol != NULL && symbol->declaredInStmt() != NULL) + for (int expressionNumber = 0; expressionNumber < 3; expressionNumber++) { - allVars.push_back(symbol); + FindAllVars(statement->expr(expressionNumber)); } } for (auto var : allVars) { vector _; - SgStatement* declaredIn = declaratedInStmt(var, &_, false); - if (declaredIn == NULL) + SgStatement* declaredInStatement = declaratedInStmt(var, &_, false); + if (declaredInStatement == NULL) { char c = var->identifier()[0]; @@ -94,51 +99,112 @@ void FunctionImplicitCheck(SgStatement* function) if (!hasImplicitNone) { - for (SgStatement* i = function->lexNext(); i != NULL;) + for (SgStatement* statement = function->lexNext(); statement != NULL;) { - if (i->variant() == IMPL_DECL) + if (statement->variant() == IMPL_DECL) { - auto tmp = i; - i = i->lexNext(); - tmp->deleteStmt(); + auto tmpStatement = statement; + statement = statement->lexNext(); + tmpStatement->deleteStmt(); } else { - i = i->lexNext(); + statement = statement->lexNext(); } } function->insertStmtBefore(*implicitNoneDeclaration, *function); } - printf("%s", function->unparse()); - return; } void InitTypes() { - for (char i = 'a'; i <= 'z'; i++) + for (char letter = 'a'; letter <= 'z'; letter++) { - types[i] = NULL; + types[letter] = NULL; } } void FillCommonTypes() { - for (char i: commonIntLetters) + for (char letter : commonIntLetters) { - if (types[i] == NULL) + if (types[letter] == NULL) { - types[i] = new SgType(T_INT); + types[letter] = new SgType(T_INT); } } - for (auto i : types) + for (auto letter : types) { - if (i.second == NULL) + if (letter.second == NULL) { - types[i.first] = new SgType(T_FLOAT); + types[letter.first] = new SgType(T_FLOAT); } } } + +void CleanTypes() +{ + types.clear(); + allVars.clear(); + varsWithoutDecl.clear(); +} + +void FindAllVars(SgExpression* expr) +{ + if (expr == NULL) + { + return; + } + + if (expr->symbol() != NULL) + { + allVars.insert(expr->symbol()); + } + + FindAllVars(expr->lhs()); + FindAllVars(expr->rhs()); +} + +char AddLettersToMap(SgExpression* expr, SgType* type) +{ + if (expr == NULL) + { + return NULL; + } + + if (expr->variant() == CHAR_VAL) + { + SgValueExp* val = isSgValueExp(expr); + return val->charValue(); + } + + char leftVal = AddLettersToMap(expr->lhs(), type); + char rightVal = AddLettersToMap(expr->rhs(), type); + + if (expr->variant() == DDOT) + { + if (leftVal != NULL && rightVal != NULL) + { + for (char letter = leftVal; letter <= rightVal; letter++) + { + types[letter] = type; + } + } + } + + if (expr->variant() == EXPR_LIST) + { + if (leftVal != NULL) { + types[leftVal] = type; + } + if (rightVal != NULL) { + types[rightVal] = type; + } + } + + return NULL; +} \ No newline at end of file -- 2.49.1 From 34bc8b0219899637742825b1b993eba3596428f8 Mon Sep 17 00:00:00 2001 From: DenisDudarenko Date: Sat, 16 Mar 2024 19:40:29 +0300 Subject: [PATCH 09/17] Fix problems --- sapfor/experts/Sapfor_2017/_src/Sapfor.cpp | 1 - .../Transformations/set_implicit_none.cpp | 65 ++++--------------- 2 files changed, 13 insertions(+), 53 deletions(-) diff --git a/sapfor/experts/Sapfor_2017/_src/Sapfor.cpp b/sapfor/experts/Sapfor_2017/_src/Sapfor.cpp index 3d283a4..375238c 100644 --- a/sapfor/experts/Sapfor_2017/_src/Sapfor.cpp +++ b/sapfor/experts/Sapfor_2017/_src/Sapfor.cpp @@ -2541,7 +2541,6 @@ void runPass(const int curr_regime, const char *proj_name, const char *folderNam case LOOPS_SPLITTER: case LOOPS_COMBINER: case FIX_COMMON_BLOCKS: - //case SET_IMPLICIT_NONE: case TEST_PASS: runAnalysis(*project, curr_regime, false); case SUBST_EXPR_RD_AND_UNPARSE: diff --git a/sapfor/experts/Sapfor_2017/_src/Transformations/set_implicit_none.cpp b/sapfor/experts/Sapfor_2017/_src/Transformations/set_implicit_none.cpp index dfefa2e..4efb058 100644 --- a/sapfor/experts/Sapfor_2017/_src/Transformations/set_implicit_none.cpp +++ b/sapfor/experts/Sapfor_2017/_src/Transformations/set_implicit_none.cpp @@ -19,7 +19,6 @@ char AddLettersToMap(SgExpression* params, SgType* type); void ImplicitCheck(SgFile* file) { - for (int functionNumber = 0; functionNumber < file->numberOfFunctions(); functionNumber++) { InitTypes(); @@ -30,16 +29,14 @@ void ImplicitCheck(SgFile* file) CleanTypes(); } - - return; } -void FunctionImplicitCheck(SgStatement* function) +static void FunctionImplicitCheck(SgStatement* function) { auto implicitNoneDeclaration = new SgStatement(IMPL_DECL); auto hasImplicitNone = false; - for (SgStatement* statement = function; statement = statement->lexNext(); statement != NULL) + for (SgStatement* statement = function; statement != NULL; statement = statement->lexNext()) { if (statement->variant() == IMPL_DECL) { @@ -59,24 +56,16 @@ void FunctionImplicitCheck(SgStatement* function) } } else - { hasImplicitNone = true; - } } } else if (statement->variant() == CONTAINS_STMT || isSgExecutableStatement(statement) != NULL) - { break; - } } for (SgStatement* statement = function; statement != function->lastExecutable(); statement = statement->lexNext()) - { for (int expressionNumber = 0; expressionNumber < 3; expressionNumber++) - { FindAllVars(statement->expr(expressionNumber)); - } - } for (auto var : allVars) { @@ -87,9 +76,7 @@ void FunctionImplicitCheck(SgStatement* function) char c = var->identifier()[0]; if (types.find(c) != types.end()) - { var->setType(types[c]); - } varsWithoutDecl.push_back(var); } @@ -108,73 +95,55 @@ void FunctionImplicitCheck(SgStatement* function) tmpStatement->deleteStmt(); } else - { statement = statement->lexNext(); - } } - function->insertStmtBefore(*implicitNoneDeclaration, *function); + function->insertStmtAfter(*implicitNoneDeclaration, *function); } - return; + printf("%s", function->unparse()); } -void InitTypes() +static void InitTypes() { for (char letter = 'a'; letter <= 'z'; letter++) - { types[letter] = NULL; - } } -void FillCommonTypes() +static void FillCommonTypes() { for (char letter : commonIntLetters) - { if (types[letter] == NULL) - { types[letter] = new SgType(T_INT); - } - } for (auto letter : types) - { if (letter.second == NULL) - { types[letter.first] = new SgType(T_FLOAT); - } - } } -void CleanTypes() +static void CleanTypes() { types.clear(); allVars.clear(); varsWithoutDecl.clear(); } -void FindAllVars(SgExpression* expr) +static void FindAllVars(SgExpression* expr) { if (expr == NULL) - { return; - } - if (expr->symbol() != NULL) - { + if (expr->variant() == VAR_REF || expr->variant() == ARRAY_REF) allVars.insert(expr->symbol()); - } FindAllVars(expr->lhs()); FindAllVars(expr->rhs()); } -char AddLettersToMap(SgExpression* expr, SgType* type) +static char AddLettersToMap(SgExpression* expr, SgType* type) { if (expr == NULL) - { return NULL; - } if (expr->variant() == CHAR_VAL) { @@ -186,24 +155,16 @@ char AddLettersToMap(SgExpression* expr, SgType* type) char rightVal = AddLettersToMap(expr->rhs(), type); if (expr->variant() == DDOT) - { if (leftVal != NULL && rightVal != NULL) - { for (char letter = leftVal; letter <= rightVal; letter++) - { types[letter] = type; - } - } - } if (expr->variant() == EXPR_LIST) - { - if (leftVal != NULL) { + { + if (leftVal != NULL) types[leftVal] = type; - } - if (rightVal != NULL) { + if (rightVal != NULL) types[rightVal] = type; - } } return NULL; -- 2.49.1 From fbcddeea8ff7db1125fd7a2ec801a57c27e47dce Mon Sep 17 00:00:00 2001 From: DenisDudarenko Date: Sun, 17 Mar 2024 18:46:49 +0300 Subject: [PATCH 10/17] Remove printf --- .../Sapfor_2017/_src/Transformations/set_implicit_none.cpp | 2 -- 1 file changed, 2 deletions(-) diff --git a/sapfor/experts/Sapfor_2017/_src/Transformations/set_implicit_none.cpp b/sapfor/experts/Sapfor_2017/_src/Transformations/set_implicit_none.cpp index 4efb058..f891380 100644 --- a/sapfor/experts/Sapfor_2017/_src/Transformations/set_implicit_none.cpp +++ b/sapfor/experts/Sapfor_2017/_src/Transformations/set_implicit_none.cpp @@ -100,8 +100,6 @@ static void FunctionImplicitCheck(SgStatement* function) function->insertStmtAfter(*implicitNoneDeclaration, *function); } - - printf("%s", function->unparse()); } static void InitTypes() -- 2.49.1 From b80c941fec8ec92f0be743ef442c345efa95929c Mon Sep 17 00:00:00 2001 From: DenisDudarenko Date: Thu, 21 Mar 2024 21:05:14 +0300 Subject: [PATCH 11/17] Fix internal program error --- sapfor/experts/Sapfor_2017/CMakeLists.txt | 7 +- .../Transformations/set_implicit_none.cpp | 176 +++++++++--------- 2 files changed, 96 insertions(+), 87 deletions(-) diff --git a/sapfor/experts/Sapfor_2017/CMakeLists.txt b/sapfor/experts/Sapfor_2017/CMakeLists.txt index 02f7fb9..7d0c5d2 100644 --- a/sapfor/experts/Sapfor_2017/CMakeLists.txt +++ b/sapfor/experts/Sapfor_2017/CMakeLists.txt @@ -178,9 +178,9 @@ set(TR_LOOP_SPLIT _src/Transformations/loops_splitter.cpp set(TR_LOOP_UNROLL _src/Transformations/loops_unrolling.cpp _src/Transformations/loops_unrolling.h) set(TR_PRIV_BR _src/Transformations/private_arrays_resizing.cpp - _src/Transformations/private_arrays_resizing.h) + _src/Transformations/private_arrays_resizing.h) set(TR_PRIV_DEL _src/Transformations/private_removing.cpp - _src/Transformations/private_removing.h) + _src/Transformations/private_removing.h) set(TR_SWAP_ARR_DIMS _src/Transformations/swap_array_dims.cpp _src/Transformations/swap_array_dims.h) set(TR_FUNC_DUP _src/Transformations/uniq_call_chain_dup.cpp @@ -190,8 +190,7 @@ set(TR_FUNC_PURE _src/Transformations/function_purifying.cpp set(TR_GV _src/Transformations/fix_common_blocks.cpp _src/Transformations/fix_common_blocks.h) set(TR_CONV _src/Transformations/convert_to_c.cpp - _src/Transformations/convert_to_c.h) - + _src/Transformations/convert_to_c.h) set(TR_IMPLICIT_NONE _src/Transformations/set_implicit_none.cpp _src/Transformations/set_implicit_none.h) diff --git a/sapfor/experts/Sapfor_2017/_src/Transformations/set_implicit_none.cpp b/sapfor/experts/Sapfor_2017/_src/Transformations/set_implicit_none.cpp index f891380..c7c6eb9 100644 --- a/sapfor/experts/Sapfor_2017/_src/Transformations/set_implicit_none.cpp +++ b/sapfor/experts/Sapfor_2017/_src/Transformations/set_implicit_none.cpp @@ -5,39 +5,86 @@ using std::vector; using std::map; using std::set; -map types; -set allVars; -vector varsWithoutDecl; -const char commonIntLetters[6] = {'i', 'j', 'k', 'm', 'n', 'l'}; +static const char commonIntLetters[6] = {'i', 'j', 'k', 'm', 'n', 'l'}; -void InitTypes(); -void FillCommonTypes(); -void CleanTypes(); -void FunctionImplicitCheck(SgStatement* function); -void FindAllVars(SgExpression* expr); -char AddLettersToMap(SgExpression* params, SgType* type); - -void ImplicitCheck(SgFile* file) +static void InitTypes(map types) { - for (int functionNumber = 0; functionNumber < file->numberOfFunctions(); functionNumber++) - { - InitTypes(); - FillCommonTypes(); - - SgStatement* function = file->functions(functionNumber); - FunctionImplicitCheck(function); - - CleanTypes(); - } + for (char letter = 'a'; letter <= 'z'; letter++) + types[letter] = NULL; } -static void FunctionImplicitCheck(SgStatement* function) +static void FillCommonTypes(map types) { + for (char letter : commonIntLetters) + if (types[letter] == NULL) + types[letter] = new SgType(T_INT); + + for (auto letter : types) + if (letter.second == NULL) + types[letter.first] = new SgType(T_FLOAT); +} + +static void FindAllVars(SgExpression* expr, set* allVars) +{ + if (expr == NULL) + return; + + if (expr->variant() == VAR_REF || expr->variant() == ARRAY_REF) + allVars->insert(expr->symbol()); + + FindAllVars(expr->lhs(), allVars); + FindAllVars(expr->rhs(), allVars); +} + +static char AddLettersToMap(SgExpression* expr, SgType* type, map& types) +{ + if (expr == NULL) + return NULL; + + if (expr->variant() == CHAR_VAL) + { + SgValueExp* val = isSgValueExp(expr); + return val->charValue(); + } + + char leftVal = AddLettersToMap(expr->lhs(), type, types); + char rightVal = AddLettersToMap(expr->rhs(), type, types); + + if (expr->variant() == DDOT) + if (leftVal != NULL && rightVal != NULL) + for (char letter = leftVal; letter <= rightVal; letter++) + types[letter] = type; + + if (expr->variant() == EXPR_LIST) + { + if (leftVal != NULL) + types[leftVal] = type; + if (rightVal != NULL) + types[rightVal] = type; + } + + return NULL; +} + +static map FunctionImplicitCheck(SgStatement* function, map>& typesByFunctions) +{ + set allVars; + map types; + vector varsWithoutDecl; + + InitTypes(types); + FillCommonTypes(types); + + if (typesByFunctions.find(function->controlParent()) != typesByFunctions.end()) + for (auto parentType : typesByFunctions[function->controlParent()]) + types[parentType.first] = parentType.second; + auto implicitNoneDeclaration = new SgStatement(IMPL_DECL); auto hasImplicitNone = false; for (SgStatement* statement = function; statement != NULL; statement = statement->lexNext()) { + if (statement->variant() == IMPL_DECL) { SgImplicitStmt* implicitStatement = isSgImplicitStmt(statement); @@ -52,8 +99,8 @@ static void FunctionImplicitCheck(SgStatement* function) SgType* type = implicitStatement->implicitType(j); SgExpression* lettersExpression = implicitStatement->implicitRangeList(j); - AddLettersToMap(lettersExpression, type); - } + AddLettersToMap(lettersExpression, type, types); + } } else hasImplicitNone = true; @@ -63,9 +110,15 @@ static void FunctionImplicitCheck(SgStatement* function) break; } - for (SgStatement* statement = function; statement != function->lastExecutable(); statement = statement->lexNext()) + for (SgStatement* statement = function; + statement != NULL && statement->variant() != CONTAINS_STMT; statement = statement->lexNext()) + { for (int expressionNumber = 0; expressionNumber < 3; expressionNumber++) - FindAllVars(statement->expr(expressionNumber)); + FindAllVars(statement->expr(expressionNumber), &allVars); + + if (statement == function->lastExecutable()) + break; + } for (auto var : allVars) { @@ -86,7 +139,8 @@ static void FunctionImplicitCheck(SgStatement* function) if (!hasImplicitNone) { - for (SgStatement* statement = function->lexNext(); statement != NULL;) + for (SgStatement* statement = function->lexNext(); + statement != NULL && statement->variant() != CONTAINS_STMT && isSgExecutableStatement(statement) == NULL;) { if (statement->variant() == IMPL_DECL) { @@ -100,70 +154,26 @@ static void FunctionImplicitCheck(SgStatement* function) function->insertStmtAfter(*implicitNoneDeclaration, *function); } -} -static void InitTypes() -{ - for (char letter = 'a'; letter <= 'z'; letter++) - types[letter] = NULL; -} - -static void FillCommonTypes() -{ - for (char letter : commonIntLetters) - if (types[letter] == NULL) - types[letter] = new SgType(T_INT); - - for (auto letter : types) - if (letter.second == NULL) - types[letter.first] = new SgType(T_FLOAT); -} - -static void CleanTypes() -{ - types.clear(); allVars.clear(); varsWithoutDecl.clear(); + + return types; } -static void FindAllVars(SgExpression* expr) +void ImplicitCheck(SgFile* file) { - if (expr == NULL) - return; + map> typesByFunctions; - if (expr->variant() == VAR_REF || expr->variant() == ARRAY_REF) - allVars.insert(expr->symbol()); - - FindAllVars(expr->lhs()); - FindAllVars(expr->rhs()); -} - -static char AddLettersToMap(SgExpression* expr, SgType* type) -{ - if (expr == NULL) - return NULL; - - if (expr->variant() == CHAR_VAL) + for (int functionNumber = 0; functionNumber < file->numberOfFunctions(); functionNumber++) { - SgValueExp* val = isSgValueExp(expr); - return val->charValue(); + SgStatement* function = file->functions(functionNumber); + + map& types = FunctionImplicitCheck(function, typesByFunctions); + typesByFunctions[function] = types; } - char leftVal = AddLettersToMap(expr->lhs(), type); - char rightVal = AddLettersToMap(expr->rhs(), type); - - if (expr->variant() == DDOT) - if (leftVal != NULL && rightVal != NULL) - for (char letter = leftVal; letter <= rightVal; letter++) - types[letter] = type; + typesByFunctions.clear(); - if (expr->variant() == EXPR_LIST) - { - if (leftVal != NULL) - types[leftVal] = type; - if (rightVal != NULL) - types[rightVal] = type; - } - - return NULL; + printf("%s", file->firstStatement()->unparse()); } \ No newline at end of file -- 2.49.1 From 35dc4302437d4c307f4ff9eb2af87d0a8b695e52 Mon Sep 17 00:00:00 2001 From: DenisDudarenko Date: Fri, 22 Mar 2024 09:19:14 +0300 Subject: [PATCH 12/17] Fix link transport --- .../_src/Transformations/set_implicit_none.cpp | 12 +++++------- 1 file changed, 5 insertions(+), 7 deletions(-) diff --git a/sapfor/experts/Sapfor_2017/_src/Transformations/set_implicit_none.cpp b/sapfor/experts/Sapfor_2017/_src/Transformations/set_implicit_none.cpp index c7c6eb9..1aaa4c5 100644 --- a/sapfor/experts/Sapfor_2017/_src/Transformations/set_implicit_none.cpp +++ b/sapfor/experts/Sapfor_2017/_src/Transformations/set_implicit_none.cpp @@ -7,13 +7,13 @@ using std::set; static const char commonIntLetters[6] = {'i', 'j', 'k', 'm', 'n', 'l'}; -static void InitTypes(map types) +static void InitTypes(map& types) { for (char letter = 'a'; letter <= 'z'; letter++) types[letter] = NULL; } -static void FillCommonTypes(map types) +static void FillCommonTypes(map& types) { for (char letter : commonIntLetters) if (types[letter] == NULL) @@ -24,13 +24,13 @@ static void FillCommonTypes(map types) types[letter.first] = new SgType(T_FLOAT); } -static void FindAllVars(SgExpression* expr, set* allVars) +static void FindAllVars(SgExpression* expr, set& allVars) { if (expr == NULL) return; if (expr->variant() == VAR_REF || expr->variant() == ARRAY_REF) - allVars->insert(expr->symbol()); + allVars.insert(expr->symbol()); FindAllVars(expr->lhs(), allVars); FindAllVars(expr->rhs(), allVars); @@ -114,7 +114,7 @@ static map FunctionImplicitCheck(SgStatement* function, mapvariant() != CONTAINS_STMT; statement = statement->lexNext()) { for (int expressionNumber = 0; expressionNumber < 3; expressionNumber++) - FindAllVars(statement->expr(expressionNumber), &allVars); + FindAllVars(statement->expr(expressionNumber), allVars); if (statement == function->lastExecutable()) break; @@ -174,6 +174,4 @@ void ImplicitCheck(SgFile* file) } typesByFunctions.clear(); - - printf("%s", file->firstStatement()->unparse()); } \ No newline at end of file -- 2.49.1 From f345741accef33c897de26f443bea517d2a36ac2 Mon Sep 17 00:00:00 2001 From: ALEXks Date: Sat, 23 Mar 2024 09:13:58 +0300 Subject: [PATCH 13/17] fixed pass --- sapfor/experts/Sapfor_2017/_src/Sapfor.cpp | 1 + 1 file changed, 1 insertion(+) diff --git a/sapfor/experts/Sapfor_2017/_src/Sapfor.cpp b/sapfor/experts/Sapfor_2017/_src/Sapfor.cpp index 375238c..dffb6be 100644 --- a/sapfor/experts/Sapfor_2017/_src/Sapfor.cpp +++ b/sapfor/experts/Sapfor_2017/_src/Sapfor.cpp @@ -2542,6 +2542,7 @@ void runPass(const int curr_regime, const char *proj_name, const char *folderNam case LOOPS_COMBINER: case FIX_COMMON_BLOCKS: case TEST_PASS: + case SET_IMPLICIT_NONE: runAnalysis(*project, curr_regime, false); case SUBST_EXPR_RD_AND_UNPARSE: case SUBST_EXPR_AND_UNPARSE: -- 2.49.1 From c5866f2cf935713411423fc279768861eedc3ae9 Mon Sep 17 00:00:00 2001 From: ALEXks Date: Sat, 23 Mar 2024 10:51:41 +0300 Subject: [PATCH 14/17] improved pass --- .../Transformations/set_implicit_none.cpp | 142 +++++++++--------- .../_src/Transformations/set_implicit_none.h | 4 - 2 files changed, 75 insertions(+), 71 deletions(-) diff --git a/sapfor/experts/Sapfor_2017/_src/Transformations/set_implicit_none.cpp b/sapfor/experts/Sapfor_2017/_src/Transformations/set_implicit_none.cpp index 1aaa4c5..623267f 100644 --- a/sapfor/experts/Sapfor_2017/_src/Transformations/set_implicit_none.cpp +++ b/sapfor/experts/Sapfor_2017/_src/Transformations/set_implicit_none.cpp @@ -1,3 +1,8 @@ +#include "../Utils/leak_detector.h" + +#include +#include + #include "Utils/SgUtils.h" #include "set_implicit_none.h" @@ -5,18 +10,18 @@ using std::vector; using std::map; using std::set; -static const char commonIntLetters[6] = {'i', 'j', 'k', 'm', 'n', 'l'}; +static const char commonIntLetters[6] = { 'i', 'j', 'k', 'm', 'n', 'l' }; static void InitTypes(map& types) { for (char letter = 'a'; letter <= 'z'; letter++) - types[letter] = NULL; + types[letter] = 0; } static void FillCommonTypes(map& types) { for (char letter : commonIntLetters) - if (types[letter] == NULL) + if (types[letter] == 0) types[letter] = new SgType(T_INT); for (auto letter : types) @@ -36,37 +41,47 @@ static void FindAllVars(SgExpression* expr, set& allVars) FindAllVars(expr->rhs(), allVars); } -static char AddLettersToMap(SgExpression* expr, SgType* type, map& types) +static char getValue(SgExpression* ex) { - if (expr == NULL) - return NULL; - - if (expr->variant() == CHAR_VAL) - { - SgValueExp* val = isSgValueExp(expr); - return val->charValue(); - } - - char leftVal = AddLettersToMap(expr->lhs(), type, types); - char rightVal = AddLettersToMap(expr->rhs(), type, types); - - if (expr->variant() == DDOT) - if (leftVal != NULL && rightVal != NULL) - for (char letter = leftVal; letter <= rightVal; letter++) - types[letter] = type; - - if (expr->variant() == EXPR_LIST) - { - if (leftVal != NULL) - types[leftVal] = type; - if (rightVal != NULL) - types[rightVal] = type; - } - - return NULL; + char charVal = 0; + if (ex && ex->variant() == CHAR_VAL) + charVal = isSgValueExp(ex)->charValue(); + return charVal; } -static map FunctionImplicitCheck(SgStatement* function, map>& typesByFunctions) +static void AddLettersToMap(SgExpression* expr, SgType* type, map& types) +{ + while (expr) + { + if (expr->variant() != EXPR_LIST) + printInternalError(convertFileName(__FILE__).c_str(), __LINE__); + + SgExpression* val = expr->lhs(); + if (val->variant() == DDOT) + { + char leftVal = getValue(val->lhs()); + char rightVal = getValue(val->rhs()); + + if (leftVal == 0 || rightVal == 0) + printInternalError(convertFileName(__FILE__).c_str(), __LINE__); + + for (char letter = leftVal; letter <= rightVal; letter++) + types[letter] = type; + } + else + { + char charVal = getValue(val); + if (charVal == 0) + printInternalError(convertFileName(__FILE__).c_str(), __LINE__); + + types[charVal] = type; + } + + expr = expr->rhs(); + } +} + +static map FunctionImplicitCheck(SgStatement* function, const map>& typesByFunctions) { set allVars; map types; @@ -75,26 +90,26 @@ static map FunctionImplicitCheck(SgStatement* function, mapcontrolParent()) != typesByFunctions.end()) - for (auto parentType : typesByFunctions[function->controlParent()]) - types[parentType.first] = parentType.second; + auto cp = function->controlParent(); + if (isSgProgHedrStmt(cp)) + if (typesByFunctions.find(cp) != typesByFunctions.end()) + for (auto& parentType : typesByFunctions.at(cp)) + types[parentType.first] = parentType.second; - auto implicitNoneDeclaration = new SgStatement(IMPL_DECL); auto hasImplicitNone = false; - - for (SgStatement* statement = function; statement != NULL; statement = statement->lexNext()) + auto endOfFunc = function->lastNodeOfStmt(); + for (auto st = function; st != endOfFunc; st = st->lexNext()) { - - if (statement->variant() == IMPL_DECL) + if (st->variant() == IMPL_DECL) { - SgImplicitStmt* implicitStatement = isSgImplicitStmt(statement); + SgImplicitStmt* implicitStatement = isSgImplicitStmt(st); if (implicitStatement != NULL) { - int numberOfTypes = implicitStatement->numberOfImplicitTypes(); + const int numberOfTypes = implicitStatement->numberOfImplicitTypes(); if (numberOfTypes > 0) { - for (int j = 0; j < numberOfTypes; j++) + for (int j = 0; j < numberOfTypes; ++j) { SgType* type = implicitStatement->implicitType(j); SgExpression* lettersExpression = implicitStatement->implicitRangeList(j); @@ -106,27 +121,21 @@ static map FunctionImplicitCheck(SgStatement* function, mapvariant() == CONTAINS_STMT || isSgExecutableStatement(statement) != NULL) + else if (st->variant() == CONTAINS_STMT || isSgExecutableStatement(st) != NULL) break; } - for (SgStatement* statement = function; - statement != NULL && statement->variant() != CONTAINS_STMT; statement = statement->lexNext()) - { - for (int expressionNumber = 0; expressionNumber < 3; expressionNumber++) - FindAllVars(statement->expr(expressionNumber), allVars); + for (auto st = function; st != endOfFunc && st->variant() != CONTAINS_STMT; st = st->lexNext()) + for (int i = 0; i < 3; ++i) + FindAllVars(st->expr(i), allVars); - if (statement == function->lastExecutable()) - break; - } - - for (auto var : allVars) + for (auto& var : allVars) { vector _; SgStatement* declaredInStatement = declaratedInStmt(var, &_, false); if (declaredInStatement == NULL) { - char c = var->identifier()[0]; + const char c = var->identifier()[0]; if (types.find(c) != types.end()) var->setType(types[c]); @@ -139,20 +148,21 @@ static map FunctionImplicitCheck(SgStatement* function, maplexNext(); - statement != NULL && statement->variant() != CONTAINS_STMT && isSgExecutableStatement(statement) == NULL;) + for (auto st = function->lexNext(); + st != endOfFunc && st->variant() != CONTAINS_STMT && isSgExecutableStatement(st) == NULL; + ) { - if (statement->variant() == IMPL_DECL) + if (st->variant() == IMPL_DECL) { - auto tmpStatement = statement; - statement = statement->lexNext(); + auto tmpStatement = st; + st = st->lexNext(); tmpStatement->deleteStmt(); } else - statement = statement->lexNext(); + st = st->lexNext(); } - function->insertStmtAfter(*implicitNoneDeclaration, *function); + function->insertStmtAfter(*new SgStatement(IMPL_DECL), *function); } allVars.clear(); @@ -165,13 +175,11 @@ void ImplicitCheck(SgFile* file) { map> typesByFunctions; - for (int functionNumber = 0; functionNumber < file->numberOfFunctions(); functionNumber++) + for (int func = 0; func < file->numberOfFunctions(); ++func) { - SgStatement* function = file->functions(functionNumber); - - map& types = FunctionImplicitCheck(function, typesByFunctions); - typesByFunctions[function] = types; + SgStatement* function = file->functions(func); + typesByFunctions[function] = FunctionImplicitCheck(function, typesByFunctions); } typesByFunctions.clear(); -} \ No newline at end of file +} diff --git a/sapfor/experts/Sapfor_2017/_src/Transformations/set_implicit_none.h b/sapfor/experts/Sapfor_2017/_src/Transformations/set_implicit_none.h index 5d2fb25..6d7e4bd 100644 --- a/sapfor/experts/Sapfor_2017/_src/Transformations/set_implicit_none.h +++ b/sapfor/experts/Sapfor_2017/_src/Transformations/set_implicit_none.h @@ -1,7 +1,3 @@ #pragma once -#include "Utils/SgUtils.h" - -#include -#include void ImplicitCheck(SgFile* file); \ No newline at end of file -- 2.49.1 From 24fe7b4bad2d26a7f7f9204087f710d00ec1434b Mon Sep 17 00:00:00 2001 From: ALEXks Date: Sat, 23 Mar 2024 10:53:14 +0300 Subject: [PATCH 15/17] fixed cmake --- sapfor/experts/Sapfor_2017/CMakeLists.txt | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/sapfor/experts/Sapfor_2017/CMakeLists.txt b/sapfor/experts/Sapfor_2017/CMakeLists.txt index 7d0c5d2..82e446e 100644 --- a/sapfor/experts/Sapfor_2017/CMakeLists.txt +++ b/sapfor/experts/Sapfor_2017/CMakeLists.txt @@ -209,7 +209,7 @@ set(TRANSFORMS ${TR_LOOP_UNROLL} ${TR_GV} ${TR_PRIV_DEL} - ${TR_CONV} + ${TR_CONV} ${TR_PRIV_DEL} ${TR_IMPLICIT_NONE}) -- 2.49.1 From bdb74c8ae72d4f82162017db9d39ec90ecc994b7 Mon Sep 17 00:00:00 2001 From: ALEXks Date: Sat, 23 Mar 2024 11:17:46 +0300 Subject: [PATCH 16/17] fixed function names --- .../_src/Transformations/set_implicit_none.cpp | 10 +++++++++- 1 file changed, 9 insertions(+), 1 deletion(-) diff --git a/sapfor/experts/Sapfor_2017/_src/Transformations/set_implicit_none.cpp b/sapfor/experts/Sapfor_2017/_src/Transformations/set_implicit_none.cpp index 623267f..12e3b27 100644 --- a/sapfor/experts/Sapfor_2017/_src/Transformations/set_implicit_none.cpp +++ b/sapfor/experts/Sapfor_2017/_src/Transformations/set_implicit_none.cpp @@ -9,6 +9,7 @@ using std::vector; using std::map; using std::set; +using std::string; static const char commonIntLetters[6] = { 'i', 'j', 'k', 'm', 'n', 'l' }; @@ -131,6 +132,9 @@ static map FunctionImplicitCheck(SgStatement* function, const map for (auto& var : allVars) { + if (string(var->identifier()) == function->symbol()->identifier()) + continue; + vector _; SgStatement* declaredInStatement = declaratedInStmt(var, &_, false); if (declaredInStatement == NULL) @@ -162,7 +166,11 @@ static map FunctionImplicitCheck(SgStatement* function, const map st = st->lexNext(); } - function->insertStmtAfter(*new SgStatement(IMPL_DECL), *function); + auto implNone = new SgStatement(IMPL_DECL); + implNone->setlineNumber(function->lineNumber()); + implNone->setFileName(function->fileName()); + + function->insertStmtAfter(*implNone, *function); } allVars.clear(); -- 2.49.1 From 277a1f8bef35cdc97828fbe58dc961c2371868ed Mon Sep 17 00:00:00 2001 From: ALEXks Date: Sat, 23 Mar 2024 11:20:56 +0300 Subject: [PATCH 17/17] version updated --- sapfor/experts/Sapfor_2017/_src/Utils/version.h | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/sapfor/experts/Sapfor_2017/_src/Utils/version.h b/sapfor/experts/Sapfor_2017/_src/Utils/version.h index 3b5edc5..6f967cf 100644 --- a/sapfor/experts/Sapfor_2017/_src/Utils/version.h +++ b/sapfor/experts/Sapfor_2017/_src/Utils/version.h @@ -1,3 +1,3 @@ #pragma once -#define VERSION_SPF "2290" +#define VERSION_SPF "2291" -- 2.49.1