REMOVE_DIST_ARRAYS_FROM_IO: regard generated intent statements, carefully detect assumed-shape arrays

.gitignore

@@ -78,4 +78,3 @@ Sapfor/Sapc++/x64/
 
 Sapfor/out/
 Sapfor/_bin/*
-_bin/*

CMakeLists.txt

@@ -204,8 +204,6 @@ set(TR_INLINER src/Transformations/FunctionInlining/inliner.cpp
         src/Transformations/FunctionInlining/inliner.h)
 set(TR_RENAME_SYMBOLS  src/Transformations/RenameSymbols/rename_symbols.cpp
                     src/Transformations/RenameSymbols/rename_symbols.h)
-SET(TR_SWAP_OPERATORS src/Transformations/SwapOperators/swap_operators.cpp
-        src/Transformations/SwapOperators/swap_operators.h)
 
 set(TRANSFORMS 
         ${TR_DEAD_CODE}
@@ -228,8 +226,7 @@ set(TRANSFORMS
         ${TR_REPLACE_ARRAYS_IN_IO}
         ${TR_EXPR_TRANSFORM}
         ${TR_INLINER}
-        ${TR_RENAME_SYMBOLS}
+        ${TR_RENAME_SYMBOLS})
-        ${TR_SWAP_OPERATORS})
         
 set(CFG src/CFGraph/IR.cpp
         src/CFGraph/IR.h
@@ -462,7 +459,6 @@ source_group (Transformations\\GlobalVariables FILES ${TR_GV})
 source_group (Transformations\\ConvertToC FILES ${TR_CONV})
 source_group (Transformations\\SetImplicitNone FILES ${TR_IMPLICIT_NONE})
 source_group (Transformations\\ReplaceArraysInIO FILES ${TR_REPLACE_ARRAYS_IN_IO})
-source_group (Transformations\\SwapOperators FILES ${TR_SWAP_OPERATORS})
 
 
 source_group (CreateIntervals FILES ${CREATE_INTER_T})
@@ -500,9 +496,7 @@ else()
     else()
         set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -std=c++11")
     endif()
-    if(NOT CMAKE_BUILD_TYPE)
+   set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -O2")
-        set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -O3")
-    endif()
 endif()
 
 add_subdirectory(projects/Fdvm)

src/DirectiveProcessing/shadow.cpp

@@ -15,7 +15,7 @@
 #include "SgUtils.h"
 #include "expr_transform.h"
 
-#include "CFGraph/CFGraph.h"
+#include "../CFGraph/CFGraph.h"
 
 #include "shadow.h"
 #include "dvm.h"

src/GraphCall/graph_calls.cpp

@@ -14,7 +14,7 @@
 #include "dvm.h"
 #include "graph_calls_func.h"
 
-#include "CFGraph/CFGraph.h"
+#include "../CFGraph/CFGraph.h"
 #include "graph_loops_func.h"
 #include "../DirectiveProcessing/directive_parser.h"
 #include "SgUtils.h"

src/Predictor/PredictScheme.cpp

@@ -22,7 +22,7 @@
 #include "graph_loops_func.h"
 #include "expr_transform.h"
 #include "../LoopAnalyzer/loop_analyzer.h"
-#include "CFGraph/CFGraph.h"
+#include "../CFGraph/CFGraph.h"
 
 #include "json.hpp"
 

src/PrivateAnalyzer/private_analyzer.cpp

@@ -12,7 +12,7 @@
 #include "graph_calls.h"
 #include "private_analyzer.h"
 #include "dvm.h"
-#include "CFGraph/CFGraph.h"
+#include "../CFGraph/CFGraph.h"
 
 using std::vector;
 

src/PrivateAnalyzer/private_arrays_search.cpp

@@ -11,11 +11,11 @@
 #include "region.h"
 #include "SgUtils.h"
 #include "graph_loops.h"
-#include "CFGraph/CFGraph.h"
+#include "../CFGraph/CFGraph.h"
 
 using namespace std;
 
-static void Collapse(Region* region)
+void Collapse(Region* region)
 {
     if (region->getBasickBlocks().empty())
         return;

src/PrivateAnalyzer/private_arrays_search.h

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

src/PrivateAnalyzer/region.h

@@ -6,7 +6,7 @@
 #include <string>
 
 #include "graph_loops.h"
-#include "CFGraph/CFGraph.h"
+#include "../CFGraph/CFGraph.h"
 
 class Region : public SAPFOR::BasicBlock {
 public:

src/ProjectManipulation/ConvertFiles.cpp

@@ -403,7 +403,7 @@ static int convertFile(int argc, char* argv[], const set<string>& filesInProj, c
             fprintf(stderr, "<<<<<  Unparsing   %s  >>>>>\n", fout_name);
 
         if (mod_gpu) /*ACC*/
-            UnparseTo_CufAndCu_Files(file, fout_cuf, fout_C_cu, fout_info, fout_name);
+            UnparseTo_CufAndCu_Files(file, fout_cuf, fout_C_cu, fout_info);
 
         const string fileN = file->filename();
         set<SgStatement*> toRemove;

src/Sapfor.cpp

@@ -89,7 +89,6 @@
 #include "Transformations/DeadCodeRemoving/dead_code.h"
 #include "Transformations/RenameSymbols/rename_symbols.h"
 #include "Transformations/FunctionInlining/inliner.h"
-#include "Transformations/SwapOperators/swap_operators.h"
 
 #include "ProjectParameters/projectParameters.h"
 
@@ -940,8 +939,6 @@ static bool runAnalysis(SgProject &project, const int curr_regime, const bool ne
                     internalExit = err;
             }
         }
-        else if (curr_regime == SWAP_OPERATORS)        
-            runSwapOperators(file, loopGraph, fullIR, countOfTransform);        
         else if (curr_regime == PRIVATE_REMOVING_ANALYSIS)
         {
             auto itFound = loopGraph.find(file->filename());
@@ -1040,8 +1037,7 @@ static bool runAnalysis(SgProject &project, const int curr_regime, const bool ne
                           PRIVATE_REMOVING,
                           PRIVATE_ARRAYS_EXPANSION, 
                           PRIVATE_ARRAYS_SHRINKING,
-                          REMOVE_DEAD_CODE,
+                          REMOVE_DEAD_CODE };
-                          SWAP_OPERATORS };
 
     if ((countOfTransform == 0 || internalExit > 0) && applyFor.find(curr_regime) != applyFor.end())
     {
@@ -2338,7 +2334,6 @@ void runPass(const int curr_regime, const char *proj_name, const char *folderNam
     case INSERT_NO_DISTR_FLAGS_FROM_GUI:
     case PRIVATE_REMOVING:
     case RENAME_INLCUDES:
-    case SWAP_OPERATORS:
         runAnalysis(*project, curr_regime, true, "", folderName);
         break;
     case INLINE_PROCEDURES:

src/Sapfor.h

@@ -122,8 +122,6 @@ enum passes {
     CREATE_INTER_TREE,
     INSERT_INTER_TREE,
 
-    SWAP_OPERATORS,
-
     SHADOW_GROUPING,
     INLINE_PROCEDURES,
     FILL_PARALLEL_REG_IR,
@@ -321,7 +319,6 @@ static void setPassValues()
     passNames[CHECK_PAR_REG_DIR] = "CHECK_PAR_REG_DIR";
     passNames[CREATE_INTER_TREE] = "CREATE_INTER_TREE";
     passNames[INSERT_INTER_TREE] = "INSERT_INTER_TREE";
-    passNames[SWAP_OPERATORS] = "SWAP_OPERATORS";
     passNames[CREATE_PARALLEL_REGIONS] = "CREATE_PARALLEL_REGIONS";
     passNames[PRIVATE_REMOVING_ANALYSIS] = "PRIVATE_REMOVING_ANALYSIS";
     passNames[PRIVATE_REMOVING] = "PRIVATE_REMOVING";

src/Transformations/DeadCodeRemoving/dead_code.cpp

@@ -6,7 +6,7 @@
 #include <set>
 #include <algorithm>
 
-#include "../CFGraph/CFGraph.h"
+#include "../../CFGraph/CFGraph.h"
 
 using std::map;
 using std::string;

src/Transformations/DeadCodeRemoving/dead_code.h

@@ -4,10 +4,10 @@
 #include<vector>
 
 #include "SgUtils.h"
-#include "CFGraph/CFGraph.h"
+#include "../CFGraph/CFGraph.h"
-#include "CFGraph/live_variable_analysis.h"
+#include "../CFGraph/live_variable_analysis.h"
-#include "CFGraph/DataFlow/data_flow.h"
+#include "../CFGraph/DataFlow/data_flow.h"
-#include "CFGraph/DataFlow/backward_data_flow.h"
+#include "../CFGraph/DataFlow/backward_data_flow.h"
 
 int removeDeadCode(SgStatement* func, 
                    const std::map<std::string, std::vector<FuncInfo*>>&allFuncs,

src/Transformations/FunctionPurifying/function_purifying.cpp

@@ -103,7 +103,7 @@ void insertIntrinsicStat(const vector<FuncInfo*>& allFuncInfo)
             if (line <= 0)
                 printInternalError(convertFileName(__FILE__).c_str(), __LINE__);
 
-            intr->setlineNumber(getNextNegativeLineNumber());
+            intr->setlineNumber(line);
             st->insertStmtBefore(*intr, *func->funcPointer);
         }
         else
@@ -525,7 +525,7 @@ static void insertIntents(set<string>& identificators, SgStatement* header, cons
     if (args.size())
     {
         SgIntentStmt* intent = new SgIntentStmt(*makeExprList(args), *attr);
-        intent->setlineNumber(getNextNegativeLineNumber());
+        intent->setlineNumber(lastDecl->lineNumber());
 
         lastDecl->insertStmtAfter(*intent, (header == lastDecl) ? *header : *lastDecl->controlParent());
     }

src/Transformations/LoopSplitting/loops_splitter.cpp

@@ -6,7 +6,7 @@
 #include "../LoopAnalyzer/loop_analyzer.h"
 #include "expr_transform.h"
 #include "errors.h"
-#include "CFGraph/CFGraph.h"
+#include "../CFGraph/CFGraph.h"
 #include "../SageAnalysisTool/OmegaForSage/include/lang-interf.h"
 #include "../DirectiveProcessing/directive_parser.h"
 #include "../DirectiveProcessing/directive_omp_parser.h"

src/Transformations/PrivateArrayRemoving/private_removing.h

@@ -2,8 +2,8 @@
 
 #include "dvm.h"
 #include "../DirectiveProcessing/directive_parser.h"
-#include "CFGraph/CFGraph.h"
+#include "../CFGraph/CFGraph.h"
-#include "CFGraph/RD_subst.h"
+#include "../CFGraph/RD_subst.h"
 
 // Regime defines the regime of private removing
 enum class Regime { DEFLT = 1, REGULAR_INDEXES };

src/Transformations/ReplaceArraysInIO/replace_dist_arrays_in_io.cpp

@@ -17,17 +17,17 @@ using std::pair;
 
 #define DEBUG_TRACE 0
 
-static bool hasArrayRef(SgExpression* ex)
+static SgStatement* getDeclStatement(int line_num)
 {
-    if (ex)
+    PTR_BFND node = current_file->firstStatement()->thebif;
-        return isArrayRef(ex) || hasArrayRef(ex->lhs()) || hasArrayRef(ex->rhs());
+    for (; node; node = node->thread)
+    {
+        SgStatement *st = BfndMapping(node);
+        if (st->lineNumber() == line_num && isSgDeclarationStatement(st))
+            return st;
+    }
 
-    return false;
+    return NULL;
-}
-
-static inline bool isArrayDeclaration(SgStatement* st)
-{
-    return isSgDeclarationStatement(st) || isSgVarListDeclStmt(st) || isSgNestedVarListDeclStmt(st);
 }
 
 static SgExpression* findExprWithVariant(SgExpression* exp, int variant)
@@ -49,10 +49,10 @@ static SgExpression* findExprWithVariant(SgExpression* exp, int variant)
     return NULL;
 }
 
-static bool switchToDeclarationFile(DIST::Array* array_p, 
+bool switchToDeclarationFile(DIST::Array* array_p, 
-                                    pair<string, int>& decl_place, 
+                             pair<string, int>& decl_place, 
-                                    const string &current_file_name,
+                             const string &current_file_name,
-                                    FuncInfo *current_func)
+                             FuncInfo *current_func)
 {
     if (!array_p)
         return false;
@@ -134,8 +134,10 @@ static bool checkAssumedSize(const string &array_name, DIST::Array* array_p, con
     if (!switchToDeclarationFile(array_p, decl_place, current_file_name, current_func))
         return true;
 
-    auto *st = SgStatement::getStatementByFileAndLine(decl_place.first, decl_place.second);
+    auto *st = getDeclStatement(decl_place.second);
-    checkNull(st, convertFileName(__FILE__).c_str(), __LINE__);
+
+    if (!st)
+        printInternalError(convertFileName(__FILE__).c_str(), __LINE__);
     
     SgExpression* list = st->expr(0);    
     while (list)
@@ -180,7 +182,7 @@ static void findArrays(SgExpression* exp, set<SgSymbol*>& arrays)
     }
 }
 
-static bool populateDistributedIoArrays(map<SgSymbol*, set<SgStatement*>>& arrays, 
+static void populateDistributedIoArrays(map<SgSymbol*, set<SgStatement*>>& arrays, 
                                         SgStatement* stat, 
                                         const string& current_file_name,
                                         FuncInfo *current_func)
@@ -188,7 +190,7 @@ static bool populateDistributedIoArrays(map<SgSymbol*, set<SgStatement*>>& array
     auto var = stat->variant();
 
     if (var != READ_STAT && var != PRINT_STAT && var != WRITE_STAT)
-        return false;
+        return;
 
     // check if such IO allowed in dvm: 
     // list should consist only of single array and format string should be *
@@ -198,26 +200,22 @@ static bool populateDistributedIoArrays(map<SgSymbol*, set<SgStatement*>>& array
     SgExpression* ioList = stat->expr(0);
 
     if (!ioList)
-        return false;
+        return;
 
     if (ioList->variant() != EXPR_LIST)
-        return false;
+        return;
 
     if (ioList->rhs() == NULL)
     {
         SgExpression* arg = ioList->lhs();
         if (!arg)
-            return false;
+            return;
 
-        if (hasArrayRef(arg))
+        if (!isArrayRef(arg))
-        {
+            return;
-            if (isArrayRef(arg) && arg->lhs())
+
-                need_replace = true;
+        if (arg->lhs())
-        }
+            need_replace = true;
-        else
-        {
-            return false;
-        }
     }
     else
     {
@@ -237,6 +235,7 @@ static bool populateDistributedIoArrays(map<SgSymbol*, set<SgStatement*>>& array
             if (fmt->rhs()->variant() != KEYWORD_VAL || fmt->rhs()->sunparse() != "*")
                 need_replace = true;
 
+
             break;
         }
         case READ_STAT:
@@ -269,7 +268,6 @@ static bool populateDistributedIoArrays(map<SgSymbol*, set<SgStatement*>>& array
                     spec = spec->rhs();
                 }
             }
-            break;
         }
         default:
             break;
@@ -277,9 +275,7 @@ static bool populateDistributedIoArrays(map<SgSymbol*, set<SgStatement*>>& array
     }
 
     if (!need_replace)
-        return false;
+        return;
-
-    bool ret = false;
 
     set<SgSymbol*> found_arrays;
 
@@ -292,19 +288,17 @@ static bool populateDistributedIoArrays(map<SgSymbol*, set<SgStatement*>>& array
         DIST::Array* array_p = getArrayFromDeclarated(declaratedInStmt(by_symb), array_name);
         if (array_p && 
             array_p->GetDistributeFlagVal() == Distribution::distFlag::IO_PRIV && 
-            !checkAssumedSize(array_name, array_p, current_file_name, current_func))
+            !checkAssumedSize(array_name, array_p, current_file_name, current_func)
+        )
         {
             auto inserted = arrays[by_symb].insert(stat).second;
 
             if (inserted)
                 __spf_print(DEBUG_TRACE, "[%d]: add array %s %p\n", stat->lineNumber(), array_p->GetName().c_str(), by_symb);
-
-            ret = true;
         }
     }
 
     __spf_print(DEBUG_TRACE, "[replace]\n");
-    return ret;
 }
 
 static void replaceArrayRec(SgSymbol* arr, SgSymbol* replace_by, SgExpression* exp, bool& has_read, bool& has_write, bool from_read, bool from_write)
@@ -398,7 +392,6 @@ static void copyArrayBetweenStatements(SgSymbol* replace_symb,
         auto* parent = start_is_scope ? start : start->controlParent();
         if (parent && parent->lastNodeOfStmt() == start)
             parent = parent->controlParent();
-        checkNull(parent, convertFileName(__FILE__).c_str(), __LINE__);
 
         start->insertStmtAfter(*assign, *parent);
     }
@@ -522,16 +515,12 @@ static bool ioReginBorder(SgStatement* stat, SgStatement* last_io_bound)
         STOP_STAT,
         STOP_NODE,
         EXIT_STMT,
-        EXIT_NODE,
+        EXIT_NODE
-        GOTO_NODE
     };
 
     if (border_stats.find(var) != border_stats.end())
         return true;
 
-    if (stat->hasLabel())
-        return true;
-
     if (last_io_bound && last_io_bound->lastNodeOfStmt() && last_io_bound->lastNodeOfStmt() == stat)
         return true;
 
@@ -564,10 +553,13 @@ void replaceDistributedArraysInIO(vector<ParallelRegion*>& regions,
 
             auto func_info_it = allFuncInfo.find(current_file_name);
             if (func_info_it == allFuncInfo.end())
+            {
                 printInternalError(convertFileName(__FILE__).c_str(), __LINE__);
+                return;
+            }
 
-            auto *lbound_symb = new SgSymbol(FUNCTION_NAME, "lbound");
+            auto *lbound_symb = new SgSymbol(PROCEDURE_NAME, "lbound");
-            auto *ubound_symb = new SgSymbol(FUNCTION_NAME, "ubound");
+            auto *ubound_symb = new SgSymbol(PROCEDURE_NAME, "ubound");
 
             for (auto& lines : lines_by_file.second)
             {
@@ -615,7 +607,10 @@ void replaceDistributedArraysInIO(vector<ParallelRegion*>& regions,
                         }
 
                         if (!current_func_info)
+                        {
                             printInternalError(convertFileName(__FILE__).c_str(), __LINE__);
+                            return;
+                        }    
 
                         curr_stmt = curr_stmt->lexNext();
                         while (curr_stmt && !isSgExecutableStatement(curr_stmt))
@@ -669,17 +664,17 @@ void replaceDistributedArraysInIO(vector<ParallelRegion*>& regions,
                                                                newDeclsToInclude, 
                                                                copied_syms);
                             
-                                // original declaration statement
-                                auto *decl_stmt = SgStatement::getStatementByFileAndLine(decl_place.first, decl_place.second);
 
-                                if (!decl_stmt || !isArrayDeclaration(decl_stmt))
+                                // original declaration statement
+                                auto* decl_stmt = getDeclStatement(decl_place.second);
+                                if (!decl_stmt || !isSgDeclarationStatement(decl_stmt))
                                     printInternalError(convertFileName(__FILE__).c_str(), __LINE__);
 
                                 auto dynamic_array = checkAssumedShape(decl_stmt, array_name);  
 
                                 while (decl_stmt && !isSgExecutableStatement(decl_stmt))
                                 {
-                                    if (isArrayDeclaration(decl_stmt) &&
+                                    if (isSgDeclarationStatement(decl_stmt) &&
                                         decl_stmt->expr(0) &&
                                         decl_stmt->expr(0)->lhs() &&
                                         decl_stmt->expr(0)->lhs()->symbol() == copied_symbol.second)
@@ -691,7 +686,7 @@ void replaceDistributedArraysInIO(vector<ParallelRegion*>& regions,
                                 }
                                 
                                 // created declaration statement
-                                if (!decl_stmt || !isArrayDeclaration(decl_stmt))
+                                if (!decl_stmt || !isSgDeclarationStatement(decl_stmt))
                                     printInternalError(convertFileName(__FILE__).c_str(), __LINE__);
 
                                 // insert !$SPF ANALYSIS(PROCESS_PRIVATE(array)) directive before declaration statement
@@ -857,17 +852,7 @@ void replaceDistributedArraysInIO(vector<ParallelRegion*>& regions,
                         }
                     }
 
-                    auto need_fix_io = populateDistributedIoArrays(need_replace, curr_stmt, current_file_name, current_func_info);
+                    populateDistributedIoArrays(need_replace, curr_stmt, current_file_name, current_func_info);
-                    
-                    // incorrect IO statement with label
-                    // move label to dummy statement and insert copy statements between dummy statement and IO
-                    if (need_fix_io && curr_stmt->hasLabel())
-                    {
-                        moveLabelBefore(curr_stmt);
-                        if (last_io_bound == curr_stmt) // always true
-                            last_io_bound = curr_stmt->lexPrev();
-                    }
-
                     curr_stmt = curr_stmt->lexNext();
                 }
             }

src/Transformations/SwapOperators/swap_operators.cpp

@@ -1,299 +0,0 @@
-#include <map>
-#include <unordered_set>
-#include <vector>
-#include <queue>
-#include <iostream>
-#include <algorithm>
-
-#include "../../Utils/errors.h"
-#include "../../Utils/SgUtils.h"
-#include "../../GraphCall/graph_calls.h"
-#include "../../GraphCall/graph_calls_func.h"
-#include "../../CFGraph/CFGraph.h"
-#include "../../CFGraph/IR.h"
-#include "../../GraphLoop/graph_loops.h"
-#include "swap_operators.h"
-
-using namespace std;
-
-string getNameByArg(SAPFOR::Argument* arg);
-SgSymbol* getSybolByArg(SAPFOR::Argument* arg);
-
-static vector<SAPFOR::IR_Block*> findInstructionsFromOperator(SgStatement* st, vector<SAPFOR::BasicBlock*> Blocks) {
-    vector<SAPFOR::IR_Block*> result;
-    string filename = st->fileName();
-    
-    for (auto& block: Blocks) {
-        vector<SAPFOR::IR_Block*> instructionsInBlock = block->getInstructions();
-        for (auto& instruction: instructionsInBlock) {
-            SgStatement* curOperator = instruction->getInstruction()->getOperator();
-            // Match by line number to find corresponding IR instruction
-            if (curOperator->lineNumber() == st->lineNumber()) {
-                result.push_back(instruction);
-            }
-        }
-    }
-    return result;
-}
-
-unordered_set<int> loop_tags = {FOR_NODE};
-unordered_set<int> control_tags = {IF_NODE, ELSEIF_NODE, DO_WHILE_NODE, WHILE_NODE};
-unordered_set<int> control_end_tags = {CONTROL_END};
-
-struct OperatorInfo {
-    SgStatement* stmt;
-    set<string> usedVars;
-    set<string> definedVars;
-    int lineNumber;
-    bool isMovable;
-    OperatorInfo(SgStatement* s) : stmt(s), lineNumber(s->lineNumber()), isMovable(true) {}
-};
-
-static vector<OperatorInfo> analyzeOperatorsInLoop(SgForStmt* loop, vector<SAPFOR::BasicBlock*> blocks, map<FuncInfo*, vector<SAPFOR::BasicBlock*>>& FullIR) {
-    vector<OperatorInfo> operators;
-    SgStatement* loopStart = loop->lexNext();
-    SgStatement* loopEnd = loop->lastNodeOfStmt();
-    
-    SgStatement* current = loopStart;
-    while (current && current != loopEnd) {
-        if (isSgExecutableStatement(current)) {
-            OperatorInfo opInfo(current);
-            
-            vector<SAPFOR::IR_Block*> irBlocks = findInstructionsFromOperator(current, blocks);
-            for (auto irBlock : irBlocks) {
-                SAPFOR::Instruction* instr = irBlock->getInstruction();
-                
-                if (instr->getArg1()) {
-                    string varName = getNameByArg(instr->getArg1());
-                    if (!varName.empty()) {
-                        opInfo.usedVars.insert(varName);
-                    }
-                }
-                if (instr->getArg2()) {
-                    string varName = getNameByArg(instr->getArg2());
-                    if (!varName.empty()) {
-                        opInfo.usedVars.insert(varName);
-                    }
-                }
-                if (instr->getResult()) {
-                    string varName = getNameByArg(instr->getResult());
-                    if (!varName.empty()) {
-                        opInfo.definedVars.insert(varName);
-                    }
-                }
-            }
-            
-            if (control_tags.find(current->variant()) != control_tags.end()) {
-                opInfo.isMovable = false;
-            }
-            
-            operators.push_back(opInfo);
-        }
-        current = current->lexNext();
-    }
-    
-    return operators;
-}
-
-static map<string, vector<SgStatement*>> findVariableDefinitions(SgForStmt* loop, vector<OperatorInfo>& operators) {
-    map<string, vector<SgStatement*>> varDefinitions;
-    
-    for (auto& op : operators) {
-        for (const string& var : op.definedVars) {
-            varDefinitions[var].push_back(op.stmt);
-        }
-    }
-    
-    return varDefinitions;
-}
-
-static int calculateDistance(SgStatement* from, SgStatement* to) {
-    if (!from || !to) return INT_MAX;
-    return abs(to->lineNumber() - from->lineNumber());
-}
-
-static SgStatement* findBestPosition(SgStatement* operatorStmt, vector<OperatorInfo>& operators, map<string, vector<SgStatement*>>& varDefinitions) {
-    OperatorInfo* opInfo = nullptr;
-    for (auto& op : operators) {
-        if (op.stmt == operatorStmt) {
-            opInfo = &op;
-            break;
-        }
-    }
-    
-    if (!opInfo || !opInfo->isMovable) return nullptr;
-    
-    SgStatement* bestPos = nullptr;
-    int minDistance = INT_MAX;
-    
-    for (const string& usedVar : opInfo->usedVars) {
-        if (varDefinitions.find(usedVar) != varDefinitions.end()) {
-            for (SgStatement* defStmt : varDefinitions[usedVar]) {
-                int distance = calculateDistance(operatorStmt, defStmt);
-                if (distance < minDistance) {
-                    minDistance = distance;
-                    bestPos = defStmt;
-                }
-            }
-        }
-    }
-    
-    return bestPos;
-}
-
-static bool canMoveTo(SgStatement* from, SgStatement* to, SgForStmt* loop) {
-    if (!from || !to || from == to) return false;
-    
-    SgStatement* loopStart = loop->lexNext();
-    SgStatement* loopEnd = loop->lastNodeOfStmt();
-    
-    if (to->lineNumber() < loopStart->lineNumber() || to->lineNumber() > loopEnd->lineNumber()) {
-        return false;
-    }
-    
-    SgStatement* current = from;
-    while (current && current != loopEnd) {
-        if (control_tags.find(current->variant()) != control_tags.end()) {
-            return false;
-        }
-        if (current == to) break;
-        current = current->lexNext();
-    }
-    
-    return true;
-}
-
-static vector<SgStatement*> optimizeOperatorOrder(SgForStmt* loop, vector<OperatorInfo>& operators, map<string, vector<SgStatement*>>& varDefinitions) {
-    vector<SgStatement*> newOrder;
-    vector<bool> moved(operators.size(), false);
-    
-    for (size_t i = 0; i < operators.size(); i++) {
-        if (moved[i] || !operators[i].isMovable) {
-            newOrder.push_back(operators[i].stmt);
-            moved[i] = true;
-            continue;
-        }
-        
-        SgStatement* bestPos = findBestPosition(operators[i].stmt, operators, varDefinitions);
-        
-        if (bestPos && canMoveTo(operators[i].stmt, bestPos, loop)) {
-            bool inserted = false;
-            for (size_t j = 0; j < newOrder.size(); j++) {
-                if (newOrder[j] == bestPos) {
-                    newOrder.insert(newOrder.begin() + j + 1, operators[i].stmt);
-                    inserted = true;
-                    break;
-                }
-            }
-            if (!inserted) {
-                newOrder.push_back(operators[i].stmt);
-            }
-        } else {
-            newOrder.push_back(operators[i].stmt);
-        }
-        moved[i] = true;
-    }
-    
-    return newOrder;
-}
-
-static bool applyOperatorReordering(SgForStmt* loop, vector<SgStatement*>& newOrder) {
-    if (!loop || newOrder.empty()) return false;
-    
-    SgStatement* loopStart = loop->lexNext();
-    SgStatement* loopEnd = loop->lastNodeOfStmt();
-    
-    vector<SgStatement*> extractedStatements;
-    vector<char*> savedComments;
-    
-    for (SgStatement* stmt : newOrder) {
-        if (stmt && stmt != loop && stmt != loopEnd) {
-            savedComments.push_back(stmt->comments() ? strdup(stmt->comments()) : nullptr);
-            SgStatement* extracted = stmt->extractStmt();
-            if (extracted) {
-                extractedStatements.push_back(extracted);
-            }
-        }
-    }
-    
-    SgStatement* currentPos = loop;
-    int lineCounter = loop->lineNumber() + 1;
-    
-    for (size_t i = 0; i < extractedStatements.size(); i++) {
-        SgStatement* stmt = extractedStatements[i];
-        if (stmt) {
-            if (i < savedComments.size() && savedComments[i]) {
-                stmt->setComments(savedComments[i]);
-            }
-            stmt->setlineNumber(lineCounter++);
-            currentPos->insertStmtAfter(*stmt, *loop);
-            currentPos = stmt;
-        }
-    }
-    
-    for (char* comment : savedComments) {
-        if (comment) {
-            free(comment);
-        }
-    }
-    
-    if (currentPos && currentPos->lexNext() != loopEnd) {
-        currentPos->setLexNext(*loopEnd);
-    }
-    
-    return true;
-}
-
-vector<SAPFOR::BasicBlock*> findFuncBlocksByFuncStatement(SgStatement *st, map<FuncInfo*, vector<SAPFOR::BasicBlock*>>& FullIR) {
-    vector<SAPFOR::BasicBlock*> result;
-    Statement* forSt = (Statement*)st;
-    for (auto& func: FullIR) {
-        if (func.first -> funcPointer -> getCurrProcessFile() == forSt -> getCurrProcessFile()
-            && func.first -> funcPointer -> lineNumber() == forSt -> lineNumber())
-            result = func.second;
-    }
-    return result;
-}
-
-map<SgForStmt*, vector<SAPFOR::BasicBlock*>> findAndAnalyzeLoops(SgStatement *st, vector<SAPFOR::BasicBlock*> blocks) {
-    map<SgForStmt*, vector<SAPFOR::BasicBlock*>> result;
-    SgStatement *lastNode = st->lastNodeOfStmt();
-    while (st && st != lastNode) {
-        if (loop_tags.find(st -> variant()) != loop_tags.end()) {
-            SgForStmt *forSt = (SgForStmt*)st;
-            SgStatement *loopBody = forSt -> body();
-            SgStatement *lastLoopNode = st->lastNodeOfStmt();
-            unordered_set<int> blocks_nums;
-            while (loopBody && loopBody != lastLoopNode) {
-                SAPFOR::IR_Block* IR = findInstructionsFromOperator(loopBody, blocks).front();
-                if (blocks_nums.find(IR -> getBasicBlock() -> getNumber()) == blocks_nums.end()) {
-                    result[forSt].push_back(IR -> getBasicBlock());
-                    blocks_nums.insert(IR -> getBasicBlock() -> getNumber());
-                }
-                loopBody = loopBody -> lexNext();
-            }
-            std::sort(result[forSt].begin(), result[forSt].end());
-        }
-        st = st -> lexNext();
-    }
-    return result;
-}
-
-void runSwapOperators(SgFile *file, std::map<std::string, std::vector<LoopGraph*>>& loopGraph, std::map<FuncInfo*, std::vector<SAPFOR::BasicBlock*>>& FullIR, int& countOfTransform) {
-    countOfTransform += 1;
-
-    const int funcNum = file -> numberOfFunctions();
-    for (int i = 0; i < funcNum; ++i) {
-        SgStatement *st = file -> functions(i);
-        vector<SAPFOR::BasicBlock*> blocks = findFuncBlocksByFuncStatement(st, FullIR);
-        map<SgForStmt*, vector<SAPFOR::BasicBlock*>> loopsMapping = findAndAnalyzeLoops(st, blocks);
-        
-        for (pair<SgForStmt*, vector<SAPFOR::BasicBlock*>> loopForAnalyze: loopsMapping) {
-            vector<OperatorInfo> operators = analyzeOperatorsInLoop(loopForAnalyze.first, loopForAnalyze.second, FullIR);
-            map<string, vector<SgStatement*>> varDefinitions = findVariableDefinitions(loopForAnalyze.first, operators);
-            
-            vector<SgStatement*> newOrder = optimizeOperatorOrder(loopForAnalyze.first, operators, varDefinitions);
-            applyOperatorReordering(loopForAnalyze.first, newOrder);
-        }
-    }
-}

src/Transformations/SwapOperators/swap_operators.h

@@ -1,6 +0,0 @@
-#pragma once
-
-#include "../../GraphLoop/graph_loops.h"
-#include "../../CFGraph/CFGraph.h"
-
-void runSwapOperators(SgFile *file, std::map<std::string, std::vector<LoopGraph*>>& loopGraph, std::map<FuncInfo*, std::vector<SAPFOR::BasicBlock*>>& FullIR, int& countOfTransform);

src/Utils/PassManager.h

@@ -212,8 +212,6 @@ void InitPassesDependencies(map<passes, vector<passes>> &passDepsIn, set<passes>
 
     Pass(BUILD_IR) <= Pass(SUBST_EXPR_RD) <= Pass(SUBST_EXPR_RD_AND_UNPARSE);
 
-    list({BUILD_IR, CALL_GRAPH2}) <= Pass(SWAP_OPERATORS);
-
     list({ LOOP_ANALYZER_DATA_DIST_S1, SUBST_EXPR_RD } ) <= Pass(PRIVATE_REMOVING_ANALYSIS);
     list({ PRIVATE_REMOVING_ANALYSIS, REVERT_SUBST_EXPR_RD }) <= Pass(PRIVATE_REMOVING);
 

src/Utils/utils.cpp

@@ -390,14 +390,31 @@ void clearGlobalBuffer() { globalOutputBuffer = ""; }
 const string& getGlobalBuffer() { return globalOutputBuffer; }
 
 set<short*> allocated;
+set<int*> allocatedInt;
+static void convertGlobalBuffer(short *&result, int *&resultSize)
+{
+    const unsigned len = (unsigned)globalOutputBuffer.size();
+    result = new short[len + 1];
+    allocated.insert(result);
+
+    result[len] = '\0';
+    for (unsigned i = 0; i < len; ++i)
+        result[i] = globalOutputBuffer[i];
+
+    resultSize = new int[1];
+    resultSize[0] = (int)len;
+}
+
 extern map<string, vector<Messages>> SPF_messages; //file ->messages
 void clearGlobalMessagesBuffer()
 {
     //clear allocated memory
     for (auto& elem : allocated)
-        delete []elem;    
+        delete[]elem;
+    for (auto& elem : allocatedInt)
+        delete[]elem;
     allocated.clear();
-    
+    allocatedInt.clear();
 
     SPF_messages.clear();
 }
@@ -434,7 +451,7 @@ static map<string, vector<Messages>> removeCopies(map<string, vector<Messages>>
     return out;
 }
 
-static string convertGlobalMessagesBuffer()
+static void convertGlobalMessagesBuffer(short *&result, int *&resultSize)
 {
     auto copySPF_messages = removeCopies(SPF_messages);
     for (auto &byFile : copySPF_messages)
@@ -472,13 +489,21 @@ static string convertGlobalMessagesBuffer()
     json all;
     all["allMessages"] = allMessages;
 
-    return all.dump();    
+    const string str = all.dump();    
+    const unsigned len = (unsigned)str.size();
+
+    copyStringToShort(result, str);
+    allocated.insert(result);
+
+    resultSize = new int[1];
+    resultSize[0] = (int)len;
 }
 
-void convertBuffers(string &resultM, string &result)
+
+void convertBuffers(short*& resultM, int*& resultSizeM, short*& result, int*& resultSize)
 {
-    resultM = convertGlobalMessagesBuffer();
+    convertGlobalMessagesBuffer(resultM, resultSizeM);
-    result = getGlobalBuffer();
+    convertGlobalBuffer(result, resultSize);
 }
 
 bool isSPF_comment(const string &bufStr)

src/Utils/utils.h

@@ -33,7 +33,7 @@ void addToGlobalBufferAndPrint(const std::string &toPrint);
 void clearGlobalBuffer();
 const std::string& getGlobalBuffer();
 std::wstring to_wstring(const std::string);
-void convertBuffers(std::string& resultM, std::string& result);
+void convertBuffers(short*& resultM, int*& resultSizeM, short*& result, int*& resultSize);
 void clearGlobalMessagesBuffer();
 std::string renameInclude(const std::string& inc);
 void copyIncludes(const std::set<std::string> &allIncludeFiles, const std::map<std::string, std::map<int, std::set<std::string>>> &commentsToInclude, const std::map<std::string, std::map<int, std::set<std::string>>>& newCopyDeclToIncl, const char *folderName, bool keepSpfDirs, bool isFreeStyle, bool isRename, int removeDirs = 0);

src/Utils/version.h

@@ -1,3 +1,3 @@
 #pragma once
 
-#define VERSION_SPF "2446"
+#define VERSION_SPF "2442"