fix codestyle

Reviewed-on: #63

CMakeLists.txt

@@ -12,6 +12,7 @@ add_definitions("-D SYS5")
 add_definitions("-D YYDEBUG")
 
 set(CMAKE_CXX_STANDARD 17)
+set(CMAKE_C_STANDARD 17)
 
 set(fdvm_include    projects/dvm/fdvmh/include/fdvmh/)
 set(fdvm_sources    projects/dvm/fdvmh/tools/fdvmh/)
@@ -33,6 +34,7 @@ include_directories(src/Distribution)
 include_directories(src/GraphCall)
 include_directories(src/GraphLoop)
 include_directories(src/Transformations/ExpressionSubstitution)
+include_directories(src/Transformations)
 
 #Sage lib includes
 include_directories(${fdvm_include})
@@ -485,7 +487,7 @@ source_group (Predictor\\Library FILES ${LIBPREDICTOR})
 source_group (Parser FILES ${PARSER})
 source_group (PPPA\\PPPA FILES ${PPPA})
 source_group (PPPA\\ZLib FILES ${ZLIB})
-   
+
 if (MSVC_IDE)   
    set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} /MP /Zc:__cplusplus")
 else()
@@ -494,7 +496,9 @@ else()
     else()
         set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -std=c++11")
     endif()
-   set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -O2")
+    if(NOT CMAKE_BUILD_TYPE)
+        set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -O3")
+    endif()
 endif()
 
 add_subdirectory(projects/Fdvm)

src/CFGraph/CFGraph.cpp

@@ -1162,6 +1162,9 @@ map<FuncInfo*, vector<BBlock*>> buildCFG(const map<string, CommonBlock*>& common
     if (SgFile::switchToFile(oldFile) == -1)
         printInternalError(convertFileName(__FILE__).c_str(), __LINE__);
 
+    for (auto& [func, blocks] : result)
+        removedUnreachableBlocks(blocks);
+
     return result;
 }
 
@@ -1236,4 +1239,49 @@ map<FuncInfo*, vector<SAPFOR::BasicBlock*>>
             fileFuncInfoMap[callFrom->fileName].push_back(callFrom);
 
     return buildCFG(commonBlocks, fileFuncInfoMap, settings);
+}
+
+
+void removedUnreachableBlocks(vector<SAPFOR::BasicBlock*>& blocks)
+{
+    set<SAPFOR::BasicBlock*> reachable;
+
+    for (auto& b : blocks)
+        if (b->getInstructions().front()->isHeader() ||
+            b->getInstructions().front()->getInstruction()->getOperation() == SAPFOR::CFG_OP::ENTRY)
+            reachable.insert(b);
+
+    set<SAPFOR::BasicBlock*> worklist = reachable;
+    while (worklist.size() != 0)
+    {
+        set<SAPFOR::BasicBlock*> to_insert;
+
+        for (auto& b : worklist)
+            for (auto& next : b->getNext())
+                if (reachable.insert(next).second)
+                    to_insert.insert(next);
+
+        worklist = to_insert;
+    }
+
+    auto remove_unreachable_it = remove_if(blocks.begin(), blocks.end(),
+        [&reachable](SAPFOR::BasicBlock* b)
+        {
+            if (reachable.find(b) == reachable.end())
+            {
+                for (auto& next : b->getNext())
+                    if (reachable.find(next) != reachable.end())
+                        next->removePrev(b);
+
+                delete b;
+                return true;
+            }
+
+            return false;
+        }
+    );
+
+    reachable.clear();
+
+    blocks.erase(remove_unreachable_it, blocks.end());
 }

src/CFGraph/CFGraph.h

@@ -156,3 +156,5 @@ static inline void deleteCFG(std::map<FuncInfo*, std::vector<SAPFOR::BasicBlock*
     }
     cfg.clear();
 }
+
+void removedUnreachableBlocks(std::vector<SAPFOR::BasicBlock*>& blocks);

src/CFGraph/private_variables_analysis.cpp

@@ -250,7 +250,7 @@ static set<SAPFOR::BasicBlock*> analyzeLoop(LoopGraph* loop, const set<SAPFOR::B
                                             const map<string, SgSymbol*>& commonArgs, FuncInfo* func,
                                             map<string, vector<Messages>>& messages)
 {
-    if (!loop->isFor)
+    if (!loop->isFor())
         printInternalError(convertFileName(__FILE__).c_str(), __LINE__); //should be called only with FOR loops
 
     SgStatement* loop_operator = loop->loop->GetOriginal();
@@ -450,7 +450,7 @@ static void recAnalyzeLoop(LoopGraph* loop, const set<SAPFOR::BasicBlock*>& bloc
                            const map<string, SgSymbol*>& commonArgs,
                            FuncInfo* func, map<string, vector<Messages>>& messages)
 {
-    const auto& loop_body = loop->isFor ? analyzeLoop(loop, blocks, commonVars, commonArgs, func, messages) : blocks;
+    const auto& loop_body = loop->isFor() ? analyzeLoop(loop, blocks, commonVars, commonArgs, func, messages) : blocks;
     
     for (const auto& inner_loop : loop->children)
         recAnalyzeLoop(inner_loop, loop_body, commonVars, commonArgs, func, messages);

src/DirectiveProcessing/directive_creator.cpp

@@ -22,7 +22,7 @@
 #include "SgUtils.h"
 #include "../Sapfor.h"
 #include "graph_loops_func.h"
-#include "../Transformations/LoopNesting/loop_transform.h"
+#include "LoopNesting/loop_transform.h"
 #include "expr_transform.h"
 #include "graph_calls_func.h"
 

src/DirectiveProcessing/directive_creator_base.cpp

@@ -10,7 +10,7 @@
 
 #include "../ParallelizationRegions/ParRegions.h"
 #include "../Distribution/Arrays.h"
-#include "../Transformations/LoopNesting/loop_transform.h"
+#include "LoopNesting/loop_transform.h"
 
 #include "errors.h"
 #include "directive_parser.h"
@@ -75,7 +75,7 @@ static LoopGraph* createDirectiveForLoop(LoopGraph *currentLoop, MapToArray &mai
         }
     }
 
-    directive->parallel.push_back(currentLoop->loopSymbol);
+    directive->parallel.push_back(currentLoop->loopSymbol());
     directive->arrayRef = mainArray.arrayRef;
 
     DIST::Array *tmp = mainArray.arrayRef;
@@ -84,7 +84,7 @@ static LoopGraph* createDirectiveForLoop(LoopGraph *currentLoop, MapToArray &mai
         for (int i = 0; i < tmp->GetDimSize(); ++i)
         {
             if (i == pos)
-                directive->on.push_back(make_pair(currentLoop->loopSymbol, mainAccess));
+                directive->on.push_back(make_pair(currentLoop->loopSymbol(), mainAccess));
             else
                 directive->on.push_back(make_pair("*", make_pair(0, 0)));
         }
@@ -808,7 +808,7 @@ void createParallelDirectives(const map<LoopGraph*, map<DIST::Array*, ArrayInfo*
                             for (int i = 0; i < mainArrayOfLoop->GetDimSize(); ++i)
                             {
                                 if (i == dimPos)
-                                    parDir->on2.push_back(make_pair(currLoop->loopSymbol, mainAccess));
+                                    parDir->on2.push_back(make_pair(currLoop->loopSymbol(), mainAccess));
                                 else
                                     parDir->on2.push_back(make_pair("*", make_pair(0, 0)));
                             }
@@ -1100,7 +1100,7 @@ static bool tryToResolveUnmatchedDims(const map<DIST::Array*, vector<bool>> &dim
     LoopGraph* tmpL = loop;
     for (int z = 0; z < nested; ++z)
     {
-        deprecateToMatch.insert(tmpL->loopSymbol);
+        deprecateToMatch.insert(tmpL->loopSymbol());
         if (tmpL->children.size())
             tmpL = tmpL->children[0];
         else if (z != nested - 1)
@@ -1113,7 +1113,7 @@ static bool tryToResolveUnmatchedDims(const map<DIST::Array*, vector<bool>> &dim
     tmpL = loop->parent;
     while (tmpL)
     {
-        if (!tmpL->isFor) // TODO: need to add all inductive variables!
+        if (tmpL->isWhile()) // TODO: need to add all inductive variables!
         {
             SgWhileStmt* dow = isSgWhileStmt(tmpL->loop->GetOriginal());
             if (dow->conditional())
@@ -1124,7 +1124,7 @@ static bool tryToResolveUnmatchedDims(const map<DIST::Array*, vector<bool>> &dim
             }
         }
         else
-            deprecateToMatch.insert(tmpL->loopSymbol);
+            deprecateToMatch.insert(tmpL->loopSymbol());
         tmpL = tmpL->parent;
     }
 

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/Distribution/ArrayAnalysis.cpp

@@ -241,13 +241,15 @@ static void findArrayRefs (SgExpression* ex, SgStatement* st, string fName, int
                 itNew->second.first->SetRegionPlace(reg);
 
             const auto oldVal = itNew->second.first->GetDistributeFlagVal();
-            bool isarrayInModule = (itNew->second.first->GetLocation().first == DIST::l_MODULE);
+            bool isArrayInModule = (itNew->second.first->GetLocation().first == DIST::l_MODULE);
 
             if (oldVal == DIST::DISTR || oldVal == DIST::NO_DISTR)
             {
                 if (itNew->second.first->IsOmpThreadPrivate())
                     itNew->second.first->SetDistributeFlag(DIST::SPF_PRIV);
-                else if (privates.find(symb->identifier()) != privates.end() || isarrayInModule)
+                else if (deprecatedByIO.find(symb->identifier()) != deprecatedByIO.end())
+                    itNew->second.first->SetDistributeFlag(DIST::IO_PRIV);
+                else if (isArrayInModule || privates.find(symb->identifier()) != privates.end())
                 {
                     //check in module
                     if (itNew->second.first->GetLocation().first == DIST::l_MODULE)
@@ -274,8 +276,6 @@ static void findArrayRefs (SgExpression* ex, SgStatement* st, string fName, int
                     else
                         itNew->second.first->SetDistributeFlag(DIST::SPF_PRIV);
                 }
-                else if (deprecatedByIO.find(symb->identifier()) != deprecatedByIO.end())
-                    itNew->second.first->SetDistributeFlag(DIST::IO_PRIV);
                 else if (isSgConstantSymb(symb) || inDataStat)
                     itNew->second.first->SetDistributeFlag(DIST::SPF_PRIV);
                 else

src/Distribution/DvmhDirective.cpp

@@ -346,7 +346,7 @@ static vector<SgExpression*>
                             {
                                 needToAdd = true;
                                 dim_found = true;
-                                subs[i] = new SgVarRefExp(findSymbolOrCreate(file, currLoop->loopSymbol));
+                                subs[i] = new SgVarRefExp(findSymbolOrCreate(file, currLoop->loopSymbol()));
                                 break;
                             }
                         }

src/DvmhRegions/DvmhRegionInserter.cpp

@@ -11,9 +11,9 @@
 #include "DvmhRegionInserter.h"
 #include "DvmhRegions/RegionsMerger.h"
 #include "../VerificationCode/verifications.h"
-#include "../Transformations/FunctionPurifying/function_purifying.h"
 #include "../LoopAnalyzer/loop_analyzer.h"
 #include "../DirectiveProcessing/directive_parser.h"
+#include "FunctionPurifying/function_purifying.h"
 
 using namespace std;
 
@@ -794,154 +794,6 @@ ArraySet DvmhRegionInserter::get_used_arrs_for_block(SgStatement* st, int usage_
     return usages;
 }
 
-static bool filterFromList(SgStatement* st, const set<string>& idents, bool exclude = false)
-{
-    bool empty = false;
-    SgExpression* list = st->expr(0);
-    vector<SgExpression*> newList;
-
-    int total = 0;
-    while (list)
-    {
-        if (exclude)
-        {
-            if (idents.find(list->lhs()->symbol()->identifier()) == idents.end())
-                newList.push_back(list->lhs());
-        }
-        else
-        {
-            if (idents.find(list->lhs()->symbol()->identifier()) != idents.end())
-                newList.push_back(list->lhs());
-        }
-        total++;
-        list = list->rhs();
-    }
-
-    if (newList.size() == 0)
-        empty = true;
-    else if (total != newList.size())
-        st->setExpression(0, makeExprList(newList));
-
-    return empty;
-}
-
-static string getInterfaceBlock(SgStatement* func, const FuncParam& pars)
-{
-    string oldFile = current_file->filename();
-    if (!func->switchToFile())
-        printInternalError(convertFileName(__FILE__).c_str(), __LINE__);
-
-    auto copy = duplicateProcedure(func, NULL, false, false, false, true);
-    const set<string> idents(pars.identificators.begin(), pars.identificators.end());
-
-    bool need = (func->symbol()->identifier() == string("bl182"));
-
-    //remove all exec
-    SgStatement* st = copy->lexNext();
-    SgStatement* last = copy->lastNodeOfStmt();
-    vector<SgStatement*> toExtract;
-
-    while (st != last)
-    {
-        if (isDVM_stat(st) || isSPF_stat(st))
-        {
-            if (st->variant() != ACC_ROUTINE_DIR)
-            {
-                toExtract.push_back(st);
-                st = st->lexNext();
-            }
-            else
-                st = st->lexNext();
-        }
-        else if (isSgExecutableStatement(st))
-        {
-            SgStatement* next = st->lastNodeOfStmt();
-            if (next != last)
-                next = next->lexNext();
-            toExtract.push_back(st);
-            st = next;
-        }
-        else
-            st = st->lexNext();
-    }  
-
-    //remove unused declarations
-    st = copy->lexNext();
-    while (st != last)
-    {
-        const int var = st->variant();
-
-        if (var == VAR_DECL
-            || var == VAR_DECL_90
-            || var == DIM_STAT
-            || var == INTENT_STMT
-            || var == EXTERN_STAT)
-        {
-            bool empty = filterFromList(st, idents);
-            if (empty)
-            {
-                toExtract.push_back(st);
-                st = st->lexNext();
-                continue;
-            }
-        }
-        else if (!isDVM_stat(st) && !isSPF_stat(st))
-            toExtract.push_back(st);
-
-        if (st->variant() == CONTAINS_STMT)
-            break;
-        st = st->lexNext();
-    }
-
-    for (auto& elem : toExtract)
-        elem->extractStmt();
-
-    string retVal = copy->unparse();
-
-    if (SgFile::switchToFile(oldFile) == -1)
-        printInternalError(convertFileName(__FILE__).c_str(), __LINE__);
-
-    return retVal;
-}
-
-static void insertInterface(SgStatement* func, const string& iface, const string& fName)
-{
-    string oldFile = current_file->filename();
-    if (!func->switchToFile())
-        printInternalError(convertFileName(__FILE__).c_str(), __LINE__);
-
-    SgStatement* st = func->lexNext();
-    SgStatement* last = func->lastNodeOfStmt();
-    while (st != last)
-    {
-        if (st->variant() == VAR_DECL || st->variant() == VAR_DECL_90)
-        {
-            bool empty = filterFromList(st, { fName }, true);
-            if (empty)
-            {
-                SgStatement* next = st->lexNext();
-                st->extractStmt();
-                st = next;
-                continue;
-            }
-        }
-
-        if (isSgExecutableStatement(st))
-            break;
-        st = st->lexNext();
-    }
-    SgStatement* ifaceBlock = new SgStatement(INTERFACE_STMT);
-    addControlEndToStmt(ifaceBlock->thebif);
-
-    ifaceBlock->setlineNumber(getNextNegativeLineNumber()); // st->lineNumber()
-    ifaceBlock->setFileName(st->fileName());
-    st->insertStmtBefore(*ifaceBlock, *st->controlParent());    
-    ifaceBlock->lastNodeOfStmt()->addComment(iface.c_str());
-
-    if (SgFile::switchToFile(oldFile) == -1)
-        printInternalError(convertFileName(__FILE__).c_str(), __LINE__);
-}
-
 static LoopGraph* getParallelLoop(LoopGraph* loop)
 {
     auto prev_st = loop->loop->lexPrev();
@@ -1172,7 +1024,7 @@ static bool isPure(SgStatement* func)
 
 void DvmhRegionInserter::createInterfaceBlockForOutCall(FuncInfo* func, FuncInfo* callFrom)
 {
-    insertInterface(func->funcPointer, getInterfaceBlock(callFrom->funcPointer->GetOriginal(), callFrom->funcParams), callFrom->funcName);
+    insertInterface(func->funcPointer, callFrom);
 }
 
 void DvmhRegionInserter::createInterfaceBlockForParallelFunctions(bool onlyRoutine)
@@ -1445,7 +1297,10 @@ static set<DIST::Array*>
                 {
                     declStat = SgStatement::getStatementByFileAndLine(decl.first, decl.second);
                     if (declStat == NULL) // check in inlcudes 
-                    {                        
+                    {
+                        if (!main->switchToFile())
+                            printInternalError(convertFileName(__FILE__).c_str(), __LINE__);
+
                         for (auto st = main; st != main->lastNodeOfStmt() && !declStat; st = st->lexNext())
                         {
                             if (st->fileName() == decl.first && st->lineNumber() == decl.second)
@@ -1457,7 +1312,7 @@ static set<DIST::Array*>
                     }
                     else
                     {
-                        declStat = getFuncStat(declStat);
+                        declStat = getFuncStat(declStat, { BLOCK_DATA });
                         if (declStat != main)
                         {
                             declStat = NULL;

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"
@@ -779,6 +779,20 @@ static void checkSpecList(SgExpression *spec, FuncInfo* currF, const map<string,
     }
 }
 
+static void checkInTypeDescription(SgExpression *ex, FuncInfo* currF, const map<string, int>& parNames)
+{
+    if (ex)
+    {
+        if (ex->variant() == ARRAY_REF)
+            fillIn(currF, ex->lhs(), parNames, false);
+        else
+        {
+            checkInTypeDescription(ex->lhs(), currF, parNames);
+            checkInTypeDescription(ex->rhs(), currF, parNames);
+        }
+    }
+}
+
 static void fillInOut(FuncInfo *currF, SgStatement *start, SgStatement *last, const set<SgStatement*>& activeOps)
 {
     if (currF->funcParams.countOfPars == 0)
@@ -798,8 +812,13 @@ static void fillInOut(FuncInfo *currF, SgStatement *start, SgStatement *last, co
 
         if (st->variant() == ENTRY_STAT)
             continue;
+        
+        if (isSgExecutableStatement(st) == NULL) {
+            checkInTypeDescription(st->expr(0), currF, parNames);
+            continue;
+        }
 
-        if (isSgExecutableStatement(st) == NULL || st->lineNumber() <= 0)
+        if (st->lineNumber() <= 0)
             continue;
 
         if (activeOps.size() && activeOps.find(st) == activeOps.end())

src/GraphLoop/graph_loops.cpp

@@ -31,7 +31,7 @@
 #include "../DirectiveProcessing/directive_parser.h"
 #include "../DynamicAnalysis/gCov_parser_func.h"
 
-#include "../Transformations/VectorAssignToLoop/array_assign_to_loop.h"
+#include "VectorAssignToLoop/array_assign_to_loop.h"
 
 using std::vector;
 using std::map;
@@ -699,7 +699,12 @@ void loopGraphAnalyzer(SgFile *file, vector<LoopGraph*> &loopGraph, const vector
                 newLoop->hasPrints = hasThisIds(st, newLoop->linesOfIO, { WRITE_STAT, READ_STAT, OPEN_STAT, CLOSE_STAT, PRINT_STAT } ); // FORMAT_STAT
                 newLoop->hasStops = hasThisIds(st, newLoop->linesOfStop, { STOP_STAT, PAUSE_NODE });
                 newLoop->hasDvmIntervals = hasThisIds(st, tmpLines, { DVM_INTERVAL_DIR, DVM_ENDINTERVAL_DIR, DVM_EXIT_INTERVAL_DIR });
-                newLoop->isFor = isSgForStmt(st) ? true : false;
+                if (isSgForStmt(st))
+                    newLoop->loopType = LoopType::FOR;
+                else if (isSgWhileStmt(st))
+                    newLoop->loopType = LoopType::WHILE;
+                else 
+                    newLoop->loopType = LoopType::NONE;
                 newLoop->inCanonicalFrom = isSgForStmt(st) ? true : false;
                 newLoop->hasSubstringRefs = hasSubstringRef(st);
 
@@ -777,7 +782,7 @@ void loopGraphAnalyzer(SgFile *file, vector<LoopGraph*> &loopGraph, const vector
                     newLoop->startEndExpr = std::make_pair((Expression*)NULL, (Expression*)NULL);
 
                 newLoop->loop = new Statement(st);
-                newLoop->loopSymbol = st->symbol() ? st->symbol()->identifier() : "unknown";
+                newLoop->loopSymbols.addMainVar(st->symbol() ? st->symbol()->identifier() : "unknown");
                 findArrayRefs(newLoop);
 
                 SgStatement *lexPrev = st->lexPrev();

src/GraphLoop/graph_loops.h

@@ -25,6 +25,33 @@ namespace DIST = Distribution;
 void getRealArrayRefs(DIST::Array* addTo, DIST::Array* curr, std::set<DIST::Array*>& realArrayRefs, const std::map<DIST::Array*, std::set<DIST::Array*>>& arrayLinksByFuncCalls);
 void getAllArrayRefs(DIST::Array* addTo, DIST::Array* curr, std::set<DIST::Array*>& realArrayRefs, const std::map<DIST::Array*, std::set<DIST::Array*>>& arrayLinksByFuncCalls);
 
+enum class LoopType { NONE, FOR, WHILE, IMPLICIT };
+
+struct InductiveVariables
+{
+private:
+    std::string mainVar;
+    std::set<std::string> allVars;
+
+public:
+    InductiveVariables() { }
+
+    explicit InductiveVariables(const std::string& mainVar, const std::set<std::string>& allVars) : mainVar(mainVar), allVars(allVars) { };
+
+    std::string getMainVar() const { return mainVar; }
+    std::set<std::string> getAllVars() const { return allVars; }
+
+    void addVar(const std::string& var) { allVars.insert(var); }
+    void addMainVar(const std::string& var) { mainVar = var; allVars.insert(var); }
+
+    void replaceMainVar(const std::string& var) 
+    {
+        allVars.erase(mainVar);
+
+        addMainVar(var);
+    }
+};
+
 struct LoopGraph
 {
 private:
@@ -70,7 +97,7 @@ public:
         calculatedCountOfIters = 0;
         executionTimeInSec = -1.0;
         inDvmhRegion = 0;
-        isFor = false;
+        loopType = LoopType::NONE;
         inCanonicalFrom = false;
         hasAccessToSubArray = false;
         hasSubstringRefs = false;
@@ -113,21 +140,24 @@ public:
     {
         return hasUnknownArrayDep || hasUnknownScalarDep || hasGoto || hasPrints || (hasConflicts.size() != 0) || hasStops || hasNonPureProcedures ||
                hasUnknownArrayAssigns || hasNonRectangularBounds || hasIndirectAccess || hasWritesToNonDistribute || hasDifferentAlignRules || hasDvmIntervals ||
-               !isFor || lastprivateScalars.size() || hasAccessToSubArray || hasSubstringRefs;
+               !isFor() || lastprivateScalars.size() || hasAccessToSubArray || hasSubstringRefs;
     }
     
     bool hasLimitsToSplit() const
     {
-        return hasGoto || hasStops || !isFor || hasPrints;
+        return hasGoto || hasStops || !isFor() || hasPrints;
     }
 
     bool hasLimitsToCombine() const
     {
-        return hasGoto || hasStops || !isFor || hasPrints || linesOfCycle.size();
+        return hasGoto || hasStops || !isFor() || hasPrints || linesOfCycle.size();
     }
 
     void addConflictMessages(std::vector<Messages> *messages)
     {
+        if (messages == NULL)
+            return;
+
         const int line = altLineNum > 0 ? altLineNum : lineNum;
         if (hasUnknownArrayDep)
             messages->push_back(Messages(NOTE, line, R113, L"unknown array dependency prevents parallelization of this loop", 3006));
@@ -168,7 +198,7 @@ public:
         if (hasDvmIntervals)
             messages->push_back(Messages(NOTE, line, R145, L"DVM intervals prevent parallelization of this loop", 3006));
 
-        if (!isFor || !inCanonicalFrom)
+        if (!isFor() || !inCanonicalFrom)
             messages->push_back(Messages(NOTE, line, R178, L"This type of loop is not supported by the system", 3006));
 
         if (lastprivateScalars.size())
@@ -393,6 +423,14 @@ public:
 
     void* getRealStat(const char* file) const;
 
+    bool isFor() const { return loopType == LoopType::FOR; }
+
+    bool isWhile() const { return loopType == LoopType::WHILE; }
+
+    bool isImplicit() const { return loopType == LoopType::IMPLICIT; }
+
+    std::string loopSymbol() const { return loopSymbols.getMainVar(); }
+
 public:
     int lineNum;
     int altLineNum;
@@ -407,7 +445,7 @@ public:
     int startVal, endVal, stepVal;
     std::tuple<Expression*, Expression*, Expression*> startEndStepVals;
 
-    std::string loopSymbol;
+    InductiveVariables loopSymbols;
     std::pair<Expression*, Expression*> startEndExpr;
 
     bool hasGoto;
@@ -448,7 +486,7 @@ public:
 
     bool hasSubstringRefs;
 
-    bool isFor;
+    LoopType loopType;
 
     bool inCanonicalFrom;
     

src/GraphLoop/graph_loops_base.cpp

@@ -551,7 +551,7 @@ void addToDistributionGraph(const map<LoopGraph*, map<DIST::Array*, ArrayInfo*>>
             continue;
         }
 
-        if (!loopAccess.first->isFor)
+        if (!loopAccess.first->isFor())
             continue;
 
         DIST::GraphCSR<int, double, attrType>& G = currReg->GetGraphToModify();
@@ -775,7 +775,7 @@ static void isAllOk(const vector<LoopGraph*> &loops, vector<Messages> &currMessa
     {
         if (loops[i]->region)
         {            
-            if (loops[i]->countOfIters == 0 && loops[i]->region && loops[i]->isFor)
+            if (loops[i]->countOfIters == 0 && loops[i]->region && loops[i]->isFor())
             {
                 wstring bufE, bufR;
                 __spf_printToLongBuf(bufE, L"  Can not calculate count of iterations for this loop, information about iterations in all loops in parallel regions '%s' will be ignored", 

src/LoopAnalyzer/loop_analyzer.cpp

@@ -48,7 +48,7 @@ extern int passDone;
 #include "../VisualizerCalls/get_information.h"
 #include "../VisualizerCalls/SendMessage.h"
 
-#include "../Transformations/LoopEndDoConverter/enddo_loop_converter.h"
+#include "LoopEndDoConverter/enddo_loop_converter.h"
 
 #include "../DirectiveProcessing/remote_access.h"
 #include "../DirectiveProcessing/directive_omp_parser.h"
@@ -2199,7 +2199,7 @@ void loopAnalyzer(SgFile *file, vector<ParallelRegion*> &regions, map<tuple<int,
                             LoopGraph *tmpLoop = new LoopGraph();
 
                             tmpLoop->region = reg;
-                            tmpLoop->isFor = true;
+                            tmpLoop->loopType = LoopType::FOR;
 
                             tmpLoops.push_back(tmpLoop);
 

src/ParallelizationRegions/resolve_par_reg_conflicts.cpp

@@ -18,7 +18,7 @@
 #include "../DirectiveProcessing/insert_directive.h"
 #include "SgUtils.h"
 #include "expr_transform.h"
-#include "../Transformations/FunctionPurifying/function_purifying.h"
+#include "FunctionPurifying/function_purifying.h"
 
 using std::map;
 using std::pair;

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;
 
-void Collapse(Region* region)
+static void Collapse(Region* region)
 {
     if (region->getBasickBlocks().empty())
         return;
@@ -124,16 +124,30 @@ static void SolveDataFlow(Region* DFG)
 map<LoopGraph*, ArrayAccessingIndexes>  FindPrivateArrays(map<string, vector<LoopGraph*>> &loopGraph, map<FuncInfo*, vector<SAPFOR::BasicBlock*>>& FullIR)
 {  
     map<LoopGraph*, ArrayAccessingIndexes> result;
-    for (const auto& [loopName, loops] : loopGraph)
+    for (const auto& [fileName, loops] : loopGraph)
     {
+        SgFile::switchToFile(fileName);
         for (const auto& loop : loops)
         {
+            SgStatement* search_func = loop->loop->GetOriginal();
+
+            while (search_func && (!isSgProgHedrStmt(search_func)))
+                search_func = search_func->controlParent();
+
             for (const auto& [funcInfo, blocks]: FullIR)
             {   
-                Region* loopRegion = new Region(loop, blocks);
-                SolveDataFlow(loopRegion);
-                result[loop] = loopRegion->array_priv;
-                delete(loopRegion);
+                if (funcInfo->fileName == fileName && funcInfo->funcPointer->GetOriginal() == search_func)
+                {
+                    Region* loopRegion = new Region(loop, blocks);
+                    if (loopRegion->getBasickBlocks().size() <= 1)
+                    {
+                        delete(loopRegion);
+                        continue;
+                    }
+                    SolveDataFlow(loopRegion);
+                    result[loop] = loopRegion->array_priv;
+                    delete(loopRegion);
+                }
             }
         }
     }

src/PrivateAnalyzer/private_arrays_search.h

@@ -5,10 +5,8 @@
 #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.cpp

@@ -51,7 +51,7 @@ pair<SAPFOR::BasicBlock*, unordered_set<SAPFOR::BasicBlock*>> GetBasicBlocksForL
 }
 
 static void BuildLoopIndex(map<string, LoopGraph*>& loopForIndex, LoopGraph* loop) {
-    string index = loop->loopSymbol;
+    string index = loop->loopSymbol();
     loopForIndex[index] = loop;
 
     for (const auto& childLoop : loop->children)

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);
+            UnparseTo_CufAndCu_Files(file, fout_cuf, fout_C_cu, fout_info, fout_name);
 
         const string fileN = file->filename();
         set<SgStatement*> toRemove;

src/Sapfor.cpp

@@ -1019,8 +1019,6 @@ static bool runAnalysis(SgProject &project, const int curr_regime, const bool ne
                 if(func->funcPointer->variant() != ENTRY_STAT)
                     countOfTransform += removeDeadCode(func->funcPointer, allFuncInfo, commonBlocks);
         }
-        else if (curr_regime == FIND_PRIVATE_ARRAYS)
-            FindPrivateArrays(loopGraph, fullIR);
         else if (curr_regime == TEST_PASS)
         {
         //test pass
@@ -1281,7 +1279,6 @@ static bool runAnalysis(SgProject &project, const int curr_regime, const bool ne
         detectCopies(allFuncInfo);
         fillInterfaceBlock(allFuncInfo);
         intentInsertToInterfaces(allFuncInfo);
-        createInterfacesForAssumedSize(allFuncInfo);
 
         //this call is only for testing
         //setPureStatus(allFuncInfo);
@@ -1915,6 +1912,10 @@ static bool runAnalysis(SgProject &project, const int curr_regime, const bool ne
         calculateStatsForPredictor(allFuncInfo, gCovInfo);
         parseDvmDirForPredictor(declaredArrays, commonBlocks, allFuncInfo, gCovInfo);
     }
+    else if (curr_regime == TRANSFORM_ASSUMED_SIZE_PARAMETERS)
+        transformAssumedSizeParameters(allFuncInfo);
+    else if (curr_regime == FIND_PRIVATE_ARRAYS) 
+        auto result = FindPrivateArrays(loopGraph, fullIR);
 
     const float elapsed = duration_cast<milliseconds>(high_resolution_clock::now() - timeForPass).count() / 1000.;
     const float elapsedGlobal = duration_cast<milliseconds>(high_resolution_clock::now() - globalTime).count() / 1000.;
@@ -2150,6 +2151,8 @@ void runPass(const int curr_regime, const char *proj_name, const char *folderNam
         runAnalysis(*project, REMOVE_COPIES, false);
         runAnalysis(*project, SWAP_LOOPS, false);
 
+        runPass(TRANSFORM_ASSUMED_SIZE_PARAMETERS, proj_name, folderName);
+
         if (folderName || consoleMode)
             runAnalysis(*project, UNPARSE_FILE, true, additionalName.c_str(), folderName);
     }
@@ -2632,7 +2635,10 @@ int main(int argc, char **argv)
         }
 
         if (curr_regime == INSERT_PARALLEL_DIRS_NODIST)
+        {
             ignoreArrayDistributeState = true;
+            sharedMemoryParallelization = 1;
+        }
 
         if (runAsClient)
         {

src/Sapfor.h

@@ -185,6 +185,8 @@ enum passes {
 
     FIND_PRIVATE_ARRAYS,
 
+    TRANSFORM_ASSUMED_SIZE_PARAMETERS,
+
     TEST_PASS,
     EMPTY_PASS
 };
@@ -371,6 +373,8 @@ static void setPassValues()
     passNames[INSERT_NO_DISTR_FLAGS_FROM_GUI] = "INSERT_NO_DISTR_FLAGS_FROM_GUI";
     passNames[FIND_PRIVATE_ARRAYS] = "FIND_PRIVATE_ARRAYS";
 
+    passNames[TRANSFORM_ASSUMED_SIZE_PARAMETERS] = "TRANSFORM_ASSUMED_SIZE_PARAMETERS";
+
     passNames[TEST_PASS] = "TEST_PASS";
 }
 

src/Transformations/DeadCodeRemoving/dead_code.cpp

@@ -6,6 +6,8 @@
 #include <set>
 #include <algorithm>
 
+#include "../CFGraph/CFGraph.h"
+
 using std::map;
 using std::string;
 using std::vector;
@@ -88,13 +90,13 @@ static void updateUseDefForInstruction(SAPFOR::BasicBlock* block, SAPFOR::Instru
             instr_operation == SAPFOR::CFG_OP::STORE)
             last_stack_op_useful = true;
 
-        for (auto e : res)
+        for (auto& e : res)
         {
             def.insert(e);
             use.erase(e);
         }
 
-        for (auto e : args)
+        for (auto& e : args)
         {
             use.insert(e);
             def.erase(e);
@@ -164,7 +166,7 @@ public:
         {
             const auto& example = dynamic_cast<DeadCodeAnalysisNode*>(*prev.begin())->next_notempty_out;
             
-            for (auto p : prev)
+            for (auto& p : prev)
             {
                 DeadCodeAnalysisNode* next = dynamic_cast<DeadCodeAnalysisNode*>(p);
 
@@ -188,7 +190,7 @@ public:
         {
             set<DeadCodeAnalysisNode*> current = {};
 
-            for (auto nextP : getPrevBlocks())
+            for (auto& nextP : getPrevBlocks())
             {
                 DeadCodeAnalysisNode* next = dynamic_cast<DeadCodeAnalysisNode*>(nextP);
 
@@ -428,49 +430,7 @@ int removeDeadCode(SgStatement* func,
         printInternalError(convertFileName(__FILE__).c_str(), __LINE__);
 
     auto& cfg_pair = *(cfg.begin());
-
-    // delete unreachable blocks
-
-    set<SAPFOR::BasicBlock*> reachable;
-
-    for (auto b : cfg_pair.second)
-        if(b->getInstructions().front()->isHeader() || 
-           b->getInstructions().front()->getInstruction()->getOperation() == SAPFOR::CFG_OP::ENTRY)
-            reachable.insert(b);
-
-    set<SAPFOR::BasicBlock*> worklist = reachable;
-    while (worklist.size() != 0)
-    {
-        set<SAPFOR::BasicBlock*> to_insert;
-
-        for(auto b : worklist)
-            for(auto next: b->getNext())
-                if(reachable.insert(next).second)
-                    to_insert.insert(next);
-
-        worklist = to_insert;
-    }
-
-    auto remove_unreachable_it = remove_if(cfg_pair.second.begin(), cfg_pair.second.end(), 
-        [&reachable](SAPFOR::BasicBlock* b)
-        {
-            if (reachable.find(b) == reachable.end())
-            {
-                for(auto next: b->getNext())
-                    if(reachable.find(next) != reachable.end())
-                        next->removePrev(b);
-
-                delete b;
-                return true;
-            }
-
-            return false;
-        }
-    );
-
-    reachable.clear();
-
-    cfg_pair.second.erase(remove_unreachable_it, cfg_pair.second.end());
+    removedUnreachableBlocks(cfg_pair.second);
 
 #if DEBUG_IR
     dumpCFG({ cfg_pair }, false);
@@ -481,7 +441,7 @@ int removeDeadCode(SgStatement* func,
     map<string, FuncInfo*> funcByName;
 
     for (auto& byFile : allFuncs)
-        for (auto byFunc : byFile.second)
+        for (auto& byFunc : byFile.second)
             funcByName[byFunc->funcName] = byFunc;
 
     DeadCodeAnalysis analysis_object(func_parameters, funcByName);

src/Transformations/DeadCodeRemoving/dead_code.h

@@ -4,10 +4,10 @@
 #include<vector>
 
 #include "SgUtils.h"
-#include "../CFGraph/CFGraph.h"
-#include "../CFGraph/live_variable_analysis.h"
-#include "../CFGraph/DataFlow/data_flow.h"
-#include "../CFGraph/DataFlow/backward_data_flow.h"
+#include "CFGraph/CFGraph.h"
+#include "CFGraph/live_variable_analysis.h"
+#include "CFGraph/DataFlow/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/ExpressionSubstitution/expr_transform.cpp

@@ -440,15 +440,18 @@ bool replaceConstantRec(SgExpression *&exp)
     if (exp->variant() == CONST_REF)
     {
         SgExpression *ret = ReplaceParameter_(exp);
+
         int sign = 1;
         SgExpression* toCalc = ret;
-        if (ret->variant() == UNARY_ADD_OP)
-            toCalc = ret->lhs();
-        if (ret->variant() == MINUS_OP)
+        if (toCalc->variant() == UNARY_ADD_OP)
+            toCalc = toCalc->lhs();
+
+        if (toCalc->variant() == MINUS_OP)
         {
-            toCalc = ret->lhs();
+            toCalc = toCalc->lhs();
             sign = -1;
         }
+
         if (toCalc->isInteger())
         {
             exp = new SgValueExp(sign * toCalc->valueInteger());

src/Transformations/FunctionPurifying/function_purifying.cpp

@@ -66,7 +66,7 @@ void insertIntrinsicStat(const vector<FuncInfo*>& allFuncInfo)
 
             void* ptr = call.pointerDetailCallsFrom.first;
             int var = call.pointerDetailCallsFrom.second;
-            
+
             SgSymbol* s = NULL;
             if (var == PROC_STAT)
                 s = ((SgStatement*)ptr)->symbol();
@@ -103,7 +103,7 @@ void insertIntrinsicStat(const vector<FuncInfo*>& allFuncInfo)
             if (line <= 0)
                 printInternalError(convertFileName(__FILE__).c_str(), __LINE__);
 
-            intr->setlineNumber(line);
+            intr->setlineNumber(getNextNegativeLineNumber());
             st->insertStmtBefore(*intr, *func->funcPointer);
         }
         else
@@ -126,7 +126,7 @@ bool checkOutCalls(const set<string>& outCalls)
     return false;
 }
 
-void createInterfacesForOutCalls(FuncInfo* func) 
+void createInterfacesForOutCalls(FuncInfo* func)
 {
     if (func->isPure && !func->isMain)
     {
@@ -136,33 +136,41 @@ void createInterfacesForOutCalls(FuncInfo* func)
     }
 }
 
-static bool changeIfHasStarRange(SgExpression* arrayDecl, bool doReplace = false)
+static bool changeIfHasStarRange(SgExpression* arrayDecl, SgStatement* scope, vector<SgSymbol*>& parNames)
 {
     SgExpression* list = arrayDecl->lhs();
-    bool has = doReplace;
-    
+    string varN = arrayDecl->symbol()->identifier() + string("_sz");
+    bool has = false;
+
+    SgExpression* allDimsBefore = NULL;
     while (list)
     {
         const int var = list->lhs()->variant();
         if (var == STAR_RANGE)
-            has = true;
-        list = list->rhs();
-    }
-
-    if (has)
-    {
-        list = arrayDecl->lhs();
-        while (list)
         {
-            list->setLhs(new SgExpression(DDOT));
-            list = list->rhs();
+            has = true;
+
+            parNames.push_back(new SgSymbol(VARIABLE_NAME, varN.c_str(), SgTypeInt(), scope));
+            SgExpression* par = allDimsBefore ? &(*new SgVarRefExp(parNames.back()) / *allDimsBefore) : (new SgVarRefExp(parNames.back()));
+
+            list->setLhs(par);
+            break;
         }
+        else
+        {
+            if (allDimsBefore == NULL)
+                allDimsBefore = list->lhs();
+            else
+                allDimsBefore = &(*allDimsBefore * *list->lhs()->copyPtr());
+        }
+
+        list = list->rhs();
     }
 
     return has;
 }
 
-static void removeExternalStat(SgStatement* func, const set<string>& addedInterfaceFor)
+/*static void removeExternalStat(SgStatement* func, const set<string>& addedInterfaceFor)
 {
     vector<SgStatement*> toRem;
     for (auto st = func; st != func->lastNodeOfStmt(); st = st->lexNext())
@@ -197,7 +205,7 @@ static void removeExternalStat(SgStatement* func, const set<string>& addedInterf
 
     for (auto& rem : toRem)
         rem->deleteStmt();
-}
+}*/
 
 template<typename T>
 static vector<FuncInfo*> sortByName(const T &funcs)
@@ -210,9 +218,25 @@ static vector<FuncInfo*> sortByName(const T &funcs)
     return funcList;
 }
 
-void createInterfacesForAssumedSize(const map<string, vector<FuncInfo*>>& allFuncInfo)
+static bool hasDvmParallel(SgStatement *func)
 {
-    set<FuncInfo*> hasAssumedSizeArrays;
+    for (auto st = func; st != func->lastNodeOfStmt(); st = st->lexNext())
+    {
+        const int var = st->variant();
+        if (var == DVM_PARALLEL_ON_DIR || var == ACC_REGION_DIR ||
+            var == ACC_ACTUAL_DIR || var == ACC_GET_ACTUAL_DIR)
+            return true;
+
+        if (st->variant() == CONTAINS_STMT)
+            break;
+    }
+
+    return false;
+}
+
+void transformAssumedSizeParameters(const map<string, vector<FuncInfo*>>& allFuncInfo)
+{
+    map<string, vector<int>> assumedSizeArraysByFunc;
 
     for (auto& funcByFile : allFuncInfo)
     {
@@ -220,11 +244,17 @@ void createInterfacesForAssumedSize(const map<string, vector<FuncInfo*>>& allFun
             printInternalError(convertFileName(__FILE__).c_str(), __LINE__);
 
         for (auto& func : funcByFile.second)
-        {            
+        {
             SgProgHedrStmt* prog = isSgProgHedrStmt(func->funcPointer->GetOriginal());
             if (prog == NULL)
                 continue;
 
+            if (!hasDvmParallel(prog))
+                continue;
+
+            vector<SgSymbol*> parNames;
+            SgStatement* scope = prog->getScopeForDeclare();
+
             vector<SgExpression*> arrayRefs;
             bool hasRefs = false;
             for (int z = 0; z < func->funcParams.countOfPars; ++z)
@@ -244,13 +274,8 @@ void createInterfacesForAssumedSize(const map<string, vector<FuncInfo*>>& allFun
                         {
                             if (list->lhs() && list->lhs()->symbol()->identifier() == name)
                             {
-                                if (changeIfHasStarRange(list->lhs()))
-                                {
-                                    hasRefs = true;
-                                    hasAssumedSizeArrays.insert(func);
-                                }
-                                else
-                                    arrayRefs.push_back(list->lhs());
+                                if (changeIfHasStarRange(list->lhs(), scope, parNames))
+                                    assumedSizeArraysByFunc[func->funcName].push_back(z);
                                 break;
                             }
                             list = list->rhs();
@@ -259,13 +284,20 @@ void createInterfacesForAssumedSize(const map<string, vector<FuncInfo*>>& allFun
                 }
             }
 
-            if (hasRefs)
-                for (auto& ref : arrayRefs)
-                    changeIfHasStarRange(ref, true);
+            if (parNames.size())
+            {
+                SgProcHedrStmt* proc = isSgProcHedrStmt(func->funcPointer->GetOriginal());
+                checkNull(proc, convertFileName(__FILE__).c_str(), __LINE__);
+
+                //makeDeclaration(parNames, scope);
+
+                for (auto& newPar : parNames)
+                    proc->AddArg(*new SgVarRefExp(newPar));
+            }
         }
     }
 
-    if (hasAssumedSizeArrays.size() == 0)
+    if (assumedSizeArraysByFunc.size() == 0)
         return;
 
     for (auto& funcByFile : allFuncInfo)
@@ -273,27 +305,61 @@ void createInterfacesForAssumedSize(const map<string, vector<FuncInfo*>>& allFun
         if (SgFile::switchToFile(funcByFile.first) == -1)
             printInternalError(convertFileName(__FILE__).c_str(), __LINE__);
 
+        SgSymbol* funcSize = new SgSymbol(FUNCTION_NAME, "size");
+
         for (auto& func : sortByName(funcByFile.second))
         {
             SgProgHedrStmt* prog = isSgProgHedrStmt(func->funcPointer->GetOriginal());
             if (prog == NULL)
                 continue;
 
-            set<string> addedInterfaceFor;
-            for (auto& elem : sortByName(func->callsFromV))
+            for (auto& detailedCall : func->callsFromDetailed)
             {
-                auto it = hasAssumedSizeArrays.find(elem);
-                if (it != hasAssumedSizeArrays.end())
+                auto it = assumedSizeArraysByFunc.find(detailedCall.detailCallsFrom.first);
+                if (it != assumedSizeArraysByFunc.end())
                 {
-                    auto callFrom = *it;
-                    DvmhRegionInserter::createInterfaceBlockForOutCall(func, callFrom);
-                    addedInterfaceFor.insert(callFrom->funcName);
+                    auto pointer = detailedCall.pointerDetailCallsFrom;
+
+                    SgExpression* list = NULL;
+                    if (pointer.second == FUNC_CALL)
+                    {
+                        SgExpression* p = (SgExpression*)pointer.first;
+                        list = p->lhs();
+                    }
+                    else
+                    {
+                        SgStatement* p = (SgStatement*)pointer.first;
+                        list = p->expr(0);
+                    }
+
+                    SgExpression* last = list;
+                    vector<SgExpression*> pars;
+                    while (list)
+                    {
+                        last = list;
+                        pars.push_back(list->lhs());
+                        list = list->rhs();
+                    }
+
+                    for (int z = 0; z < it->second.size(); ++z)
+                    {
+                        int parNum = it->second[z];
+                        if (parNum >= pars.size())
+                            printInternalError(convertFileName(__FILE__).c_str(), __LINE__);
+
+                        //TODO: need to do it better
+                        SgExpression* parArray = pars[parNum]->copyPtr();
+                        parArray->setLhs(NULL);
+                        parArray->setRhs(NULL);
+
+                        SgFunctionCallExp* call = new SgFunctionCallExp(*funcSize, *parArray);
+
+                        last->setRhs(new SgExpression(EXPR_LIST, call));
+                        last = last->rhs();
+                    }
                 }
             }
-
-            if (addedInterfaceFor.size())
-                removeExternalStat(prog, addedInterfaceFor);
-        }       
+        }
     }
 }
 
@@ -313,7 +379,7 @@ static void setPureStatus(FuncInfo* func)
         bool hasIO = func->linesOfIO.size() || func->linesOfStop.size();
 
         if (!hasPure && !hasIO && ((isFunc == false) || (isFunc && hasOut == false)))
-        {            
+        {
             header->setExpression(2, new SgExpression(PURE_OP));
             header->symbol()->setAttribute(header->symbol()->attributes() | PURE_BIT);
         }
@@ -459,7 +525,7 @@ static void insertIntents(set<string>& identificators, SgStatement* header, cons
     if (args.size())
     {
         SgIntentStmt* intent = new SgIntentStmt(*makeExprList(args), *attr);
-        intent->setlineNumber(lastDecl->lineNumber());
+        intent->setlineNumber(getNextNegativeLineNumber());
 
         lastDecl->insertStmtAfter(*intent, (header == lastDecl) ? *header : *lastDecl->controlParent());
     }
@@ -527,7 +593,7 @@ static void intentInsert(const FuncInfo* func, SgStatement* headerSt)
             OutIdentificators.insert(ident);
     }
 
-    //remove conflicted intents 
+    //remove conflicted intents
     for (auto& entry : func->entry)
     {
         for (int i = 0; i < entry->funcParams.countOfPars; i++)
@@ -558,11 +624,11 @@ static void intentInsert(const FuncInfo* func, SgStatement* headerSt)
     }
 
     insertIntents(InOutIdentificators, headerSt, parSym, INOUT_OP, INOUT_BIT);
-    insertIntents(InIdentificators, headerSt, parSym, IN_OP, IN_BIT);    
+    insertIntents(InIdentificators, headerSt, parSym, IN_OP, IN_BIT);
     insertIntents(OutIdentificators, headerSt, parSym, OUT_OP, OUT_BIT);
 }
 
-void intentInsert(const vector<FuncInfo*>& allFuncInfo) 
+void intentInsert(const vector<FuncInfo*>& allFuncInfo)
 {
     for (auto& func : allFuncInfo)
     {
@@ -631,7 +697,7 @@ static void collectForChange(set<FuncInfo*>& allForChange, FuncInfo* start)
             for (auto& call : elem->callsFromV)
                 if (allForChange.find(call) == allForChange.end())
                     newAdd.insert(call);
-        
+
         chagned = newAdd.size() != 0;
 
         allForChange.insert(newAdd.begin(), newAdd.end());
@@ -639,7 +705,7 @@ static void collectForChange(set<FuncInfo*>& allForChange, FuncInfo* start)
 }
 
 template<typename CallExp>
-static void transferVarToArg(const map<string, vector<int>>& commonVarsUsed, const map<string, CommonBlock*>& commonBlocks, 
+static void transferVarToArg(const map<string, vector<int>>& commonVarsUsed, const map<string, CommonBlock*>& commonBlocks,
                              const FuncInfo* curFunc, CallExp* callExp)
 {
     for (auto& common : commonVarsUsed)
@@ -723,7 +789,7 @@ static void transferCommons(set<FuncInfo*>& allForChange, map <FuncInfo*, map<st
             {
                 SgFunctionCallExp* callExp = (SgFunctionCallExp*)call.first;
                 if (callExp->funName()->identifier() == precFunc->funcName)
-                    transferVarToArg(commonVarsUsed, commonBlocks, curFunc, callExp);                
+                    transferVarToArg(commonVarsUsed, commonBlocks, curFunc, callExp);
             }
             else if (isSgProcHedrStmt(precFunc->funcPointer->GetOriginal()) && call.second == PROC_STAT)
             {
@@ -748,7 +814,7 @@ static void transferCommons(set<FuncInfo*>& allForChange, map <FuncInfo*, map<st
                 if (v == var)
                     done = true;
 
-            if (!done) 
+            if (!done)
             {
                 funcCommons[curFunc][common.first].push_back(var);
                 if (nextCommonVarsUsed.count(common.first) == 0)
@@ -766,7 +832,7 @@ static void transferCommons(set<FuncInfo*>& allForChange, map <FuncInfo*, map<st
     {
         bool uses = false;
         auto groupedVars = commonBlocks.find(common.first)->second->getGroupedVars();
-        
+
         if (curFunc->commonBlocks.count(common.first) > 0) //rename common vars in funcs
         {
             uses = true;
@@ -798,7 +864,7 @@ static void transferCommons(set<FuncInfo*>& allForChange, map <FuncInfo*, map<st
                     }
                 }
             }
-        }        
+        }
         else if (!allForChange.count(curFunc)) //add of commons to main
         {
             SgExprListExp* res = NULL;
@@ -961,13 +1027,13 @@ void commonTransfer(const map<string, vector<FuncInfo*>>& allFuncInfo, const map
 
             if (func->commonBlocks.size() > 0 && st->variant() != PROG_HEDR)
             {
-                for (SgStatement* start = st, *end = st->lastNodeOfStmt(); start != end;) 
+                for (SgStatement* start = st, *end = st->lastNodeOfStmt(); start != end;)
                 {
                     if (start->variant() == CONTAINS_STMT)
                         break;
 
                     SgStatement* next = start->lexNext();
-                    if (start->variant() == COMM_STAT && string(start->fileName()) == func->fileName) 
+                    if (start->variant() == COMM_STAT && string(start->fileName()) == func->fileName)
                     {
                         if (funcCommonDeclared.count(func) == 0)
                             funcCommonDeclared[func] = set<string>();
@@ -998,11 +1064,11 @@ void commonTransfer(const map<string, vector<FuncInfo*>>& allFuncInfo, const map
         if (st->variant() < 0 || st->variant() == PROG_HEDR || func->isInterface)
             continue;
 
-        if (func->commonBlocks.size() > 0) 
+        if (func->commonBlocks.size() > 0)
         {
             map<string, vector<int>> commonVarsUsed;
             set<string> usedVars;
-            for (SgStatement* start = st->lastDeclaration()->lexNext(), *end = st->lastNodeOfStmt(); start != end; start = start->lexNext()) 
+            for (SgStatement* start = st->lastDeclaration()->lexNext(), *end = st->lastNodeOfStmt(); start != end; start = start->lexNext())
             {
                 if (start->variant() == CONTAINS_STMT)
                     break;
@@ -1072,7 +1138,7 @@ static string changeData(const string& data, const map<string, string>& constSym
     return res;
 }
 
-static void transferSave(map<FuncInfo*, set<FuncInfo*>>& funcAddedVarsFuncs, vector <SgSymbol*>& varsToTransfer, vector <string>& dataToTransfer, 
+static void transferSave(map<FuncInfo*, set<FuncInfo*>>& funcAddedVarsFuncs, vector <SgSymbol*>& varsToTransfer, vector <string>& dataToTransfer,
                          FuncInfo* curFunc, FuncInfo* precFunc, FuncInfo* startFunc)
 {
     if (curFunc != precFunc)
@@ -1093,7 +1159,7 @@ static void transferSave(map<FuncInfo*, set<FuncInfo*>>& funcAddedVarsFuncs, vec
             else if (isSgProcHedrStmt(precFunc->funcPointer->GetOriginal()) && call.second == PROC_STAT)
             {
                 SgCallStmt* callSt = (SgCallStmt*)call.first;
-                if (callSt->name()->identifier() == precFunc->funcName)                
+                if (callSt->name()->identifier() == precFunc->funcName)
                     for (auto& var : varsToTransfer)
                         callSt->addArg(*new SgVarRefExp(*var));
             }
@@ -1119,7 +1185,7 @@ static void transferSave(map<FuncInfo*, set<FuncInfo*>>& funcAddedVarsFuncs, vec
             {
                 ((SgProcHedrStmt*)(hedr))->AddArg(*new SgVarRefExp(var->copy()));
                 hedr->lexNext()->deleteStmt();
-                if (curFunc != startFunc || i!=0) 
+                if (curFunc != startFunc || i!=0)
                 {
                     vector<SgSymbol*> varVec = vector<SgSymbol*>();
                     varVec.push_back(var);
@@ -1159,7 +1225,7 @@ static void transferSave(map<FuncInfo*, set<FuncInfo*>>& funcAddedVarsFuncs, vec
 
         for (SgStatement* start = hedr->lexNext(), *end = hedr->lastNodeOfStmt(); start != end; start = start->lexNext())
         {
-            if ((isSgExecutableStatement(start) || isSgDeclarationStatement(start)) && !strcmp(hedr->fileName(), start->fileName())) 
+            if ((isSgExecutableStatement(start) || isSgDeclarationStatement(start)) && !strcmp(hedr->fileName(), start->fileName()))
             {
                 firstExDec = start;
                 break;
@@ -1198,7 +1264,7 @@ void saveTransfer(const map<string, vector<FuncInfo*>>& allFuncInfo)
     for (auto& byfile : allFuncInfo)
         for (auto& func : byfile.second)
             if (func->isMain)
-                start = func;    
+                start = func;
 
     collectForChange(allForChange, start);
     allForChange.erase(start);
@@ -1240,8 +1306,8 @@ void saveTransfer(const map<string, vector<FuncInfo*>>& allFuncInfo)
 
             if (s->scope() == st)
             {
-                if ( (s->attributes() & SAVE_BIT) || 
-                     (s->attributes() & DATA_BIT) || 
+                if ( (s->attributes() & SAVE_BIT) ||
+                     (s->attributes() & DATA_BIT) ||
                      allSave && s->variant() == VARIABLE_NAME && !params.count(s->identifier()))
                 {
                     if ((s->type() ? s->type()->variant() : (T_COMPLEX + 1)) > T_COMPLEX)
@@ -1292,21 +1358,21 @@ void saveTransfer(const map<string, vector<FuncInfo*>>& allFuncInfo)
 
                 SgExprListExp* attrsNoSave = new SgExprListExp();
                 bool needChange = false;
-                for (int i = 0; i < vst->numberOfAttributes(); i++) 
+                for (int i = 0; i < vst->numberOfAttributes(); i++)
                 {
                     if (vst->attribute(i)->variant() != SAVE_OP)
                     {
                         attrsNoSave->append(vst->attribute(i)->copy());
-                    } 
+                    }
                     else
-                        needChange = true;                    
+                        needChange = true;
                 }
 
-                if (needChange) 
+                if (needChange)
                 {
                     SgVarDeclStmt* newVst;
                     if (!attrsNoSave->length())
-                        newVst = new SgVarDeclStmt(vst->varList()->copy(), *attrsNoSave, vst->type()->copy());                    
+                        newVst = new SgVarDeclStmt(vst->varList()->copy(), *attrsNoSave, vst->type()->copy());
                     else
                         newVst = new SgVarDeclStmt(vst->varList()->copy(), vst->type()->copy());
 
@@ -1334,8 +1400,8 @@ void saveTransfer(const map<string, vector<FuncInfo*>>& allFuncInfo)
     }
 }*/
 
-static string makeName(SgSymbol* var, map<SgSymbol*, set< SgSymbol*>>& modVarsToAdd, const set<string>& useMod, 
-                       const map<string, vector<pair<SgSymbol*, SgSymbol*>>>& modByUse, 
+static string makeName(SgSymbol* var, map<SgSymbol*, set< SgSymbol*>>& modVarsToAdd, const set<string>& useMod,
+                       const map<string, vector<pair<SgSymbol*, SgSymbol*>>>& modByUse,
                        const map<string, vector<pair<SgSymbol*, SgSymbol*>>>& modByUseOnly)
 {
     string name = "", modName = OriginalSymbol(var)->scope()->symbol()->identifier();
@@ -1357,7 +1423,7 @@ static string makeName(SgSymbol* var, map<SgSymbol*, set< SgSymbol*>>& modVarsTo
         }
 
         if (!name.length())
-            name = varOrName;        
+            name = varOrName;
     }
     else if (mbuo)
     {
@@ -1388,6 +1454,37 @@ static string makeName(SgSymbol* var, map<SgSymbol*, set< SgSymbol*>>& modVarsTo
     return name;
 }
 
+static bool filterFromList(SgStatement* st, const set<string>& idents, bool exclude = false)
+{
+    bool empty = false;
+    SgExpression* list = st->expr(0);
+    vector<SgExpression*> newList;
+
+    int total = 0;
+    while (list)
+    {
+        if (exclude)
+        {
+            if (idents.find(list->lhs()->symbol()->identifier()) == idents.end())
+                newList.push_back(list->lhs());
+        }
+        else
+        {
+            if (idents.find(list->lhs()->symbol()->identifier()) != idents.end())
+                newList.push_back(list->lhs());
+        }
+        total++;
+        list = list->rhs();
+    }
+
+    if (newList.size() == 0)
+        empty = true;
+    else if (total != newList.size())
+        st->setExpression(0, makeExprList(newList));
+
+    return empty;
+}
+
 static string getInterfaceBlock(SgStatement* func, const FuncParam& pars)
 {
     string oldFile = current_file->filename();
@@ -1395,22 +1492,21 @@ static string getInterfaceBlock(SgStatement* func, const FuncParam& pars)
         printInternalError(convertFileName(__FILE__).c_str(), __LINE__);
 
     auto copy = duplicateProcedure(func, NULL, false, false, false, true);
-
-    const set<string> ident(pars.identificators.begin(), pars.identificators.end());
+    const set<string> idents(pars.identificators.begin(), pars.identificators.end());
 
     //remove all exec
     SgStatement* st = copy->lexNext();
     SgStatement* last = copy->lastNodeOfStmt();
     vector<SgStatement*> toExtract;
+
     while (st != last)
     {
         if (isDVM_stat(st) || isSPF_stat(st))
         {
             if (st->variant() != ACC_ROUTINE_DIR)
             {
-                SgStatement* next = st->lexNext();
-                st->extractStmt();
-                st = next;
+                toExtract.push_back(st);
+                st = st->lexNext();
             }
             else
                 st = st->lexNext();
@@ -1431,31 +1527,20 @@ static string getInterfaceBlock(SgStatement* func, const FuncParam& pars)
     st = copy->lexNext();
     while (st != last)
     {
-        if (st->variant() == VAR_DECL
-            || st->variant() == VAR_DECL_90
-            || st->variant() == DIM_STAT
-            || st->variant() == INTENT_STMT)
-        {
-            SgExpression* list = st->expr(0);
-            vector<SgExpression*> newList;
-            while (list)
-            {
-                if (ident.find(list->lhs()->symbol()->identifier()) != ident.end())
-                    newList.push_back(list->lhs());
-                list = list->rhs();
-            }
+        const int var = st->variant();
 
-            if (newList.size() == 0)
+        if (var == VAR_DECL || var == VAR_DECL_90 || var == DIM_STAT ||
+            var == INTENT_STMT || var == EXTERN_STAT)
+        {
+            bool empty = filterFromList(st, idents);
+            if (empty)
             {
-                SgStatement* next = st->lexNext();
                 toExtract.push_back(st);
-                st = next;
+                st = st->lexNext();
                 continue;
             }
-            else
-                st->setExpression(0, makeExprList(newList));
         }
-        else
+        else if (!isDVM_stat(st) && !isSPF_stat(st))
             toExtract.push_back(st);
 
         if (st->variant() == CONTAINS_STMT)
@@ -1466,16 +1551,56 @@ static string getInterfaceBlock(SgStatement* func, const FuncParam& pars)
     for (auto& elem : toExtract)
         elem->extractStmt();
 
-    string retVal = copy->unparse();
+    string codeString = copy->unparse();
 
     if (SgFile::switchToFile(oldFile) == -1)
         printInternalError(convertFileName(__FILE__).c_str(), __LINE__);
 
+    //insert tabs
+    const string tab = "    ";
+    const int countEnds = std::count(codeString.begin(), codeString.end(), '\n');
+
+    string retVal = "  ";
+    retVal.reserve(retVal.size() + codeString.size() + countEnds * tab.size());
+
+    for (int z = 0, ends = 0; z < codeString.size(); ++z)
+    {
+        retVal += codeString[z];
+        if (codeString[z] == '\n')
+        {
+            ends++;
+            if (ends == countEnds)
+                continue;
+
+            int p = z + 1;
+            while (codeString[p] == ' ' && p < codeString.size())
+                ++p;
+
+            auto start = p;
+            auto end = string::npos;
+            auto sub = codeString.find("subroutine", p);
+            auto func = codeString.find("function", p);
+            auto end_sub = codeString.find("end subroutine", p);
+            auto end_func = codeString.find("end function", p);
+
+            if (sub != end && sub == start || end_sub != end && end_sub == start ||
+                func != end && func == start || end_func != end && end_func == start)
+            {
+                retVal += "  ";
+            }
+            else
+                retVal += tab;
+        }
+    }
+
     return retVal;
 }
 
-static void insertInterface(SgStatement* func, const string& iface)
+void insertInterface(SgStatement* func, const FuncInfo *callFrom)
 {
+    const string& iface = getInterfaceBlock(callFrom->funcPointer->GetOriginal(), callFrom->funcParams);
+    const string& fName = callFrom->funcName;
+
     string oldFile = current_file->filename();
     if (!func->switchToFile())
         printInternalError(convertFileName(__FILE__).c_str(), __LINE__);
@@ -1484,6 +1609,18 @@ static void insertInterface(SgStatement* func, const string& iface)
     SgStatement* last = func->lastNodeOfStmt();
     while (st != last)
     {
+        if (st->variant() == VAR_DECL || st->variant() == VAR_DECL_90)
+        {
+            bool empty = filterFromList(st, { fName }, true);
+            if (empty)
+            {
+                SgStatement* next = st->lexNext();
+                st->extractStmt();
+                st = next;
+                continue;
+            }
+        }
+
         if (isSgExecutableStatement(st))
             break;
         st = st->lexNext();
@@ -1491,7 +1628,7 @@ static void insertInterface(SgStatement* func, const string& iface)
     SgStatement* ifaceBlock = new SgStatement(INTERFACE_STMT);
     addControlEndToStmt(ifaceBlock->thebif);
 
-    ifaceBlock->setlineNumber(st->lineNumber());
+    ifaceBlock->setlineNumber(getNextNegativeLineNumber());
     ifaceBlock->setFileName(st->fileName());
     st->insertStmtBefore(*ifaceBlock, *st->controlParent());
     ifaceBlock->lastNodeOfStmt()->addComment(iface.c_str());
@@ -1507,12 +1644,12 @@ static void createInterfaceBlockForToCalls(FuncInfo* func)
         if (callTo->interfaceBlocks.find(func->funcName) == callTo->interfaceBlocks.end())
         {
             callTo->interfaceBlocks[func->funcName] = func;
-            insertInterface(callTo->funcPointer, getInterfaceBlock(func->funcPointer->GetOriginal(), func->funcParams));
+            insertInterface(callTo->funcPointer, func);
         }
     }
 }
 
-static void transferModule(map<FuncInfo*, set<SgSymbol*>>& funcAddedVarsMods, set<FuncInfo*>& allForChange, 
+static void transferModule(map<FuncInfo*, set<SgSymbol*>>& funcAddedVarsMods, set<FuncInfo*>& allForChange,
                            vector<SgSymbol*>& varsToTransfer, FuncInfo* curFunc, FuncInfo* precFunc, set<FuncInfo*>& funcForInterfaceAdd)
 {
     SgStatement* st = curFunc->funcPointer->GetOriginal();
@@ -1564,7 +1701,7 @@ static void transferModule(map<FuncInfo*, set<SgSymbol*>>& funcAddedVarsMods, se
             else if (isSgProcHedrStmt(precFunc->funcPointer->GetOriginal()) && call.second == PROC_STAT)
             {
                 SgCallStmt* callSt = (SgCallStmt*)call.first;
-                if (callSt->name()->identifier() == precFunc->funcName) 
+                if (callSt->name()->identifier() == precFunc->funcName)
                 {
                     for (auto& var : varsToTransfer)
                     {
@@ -1616,7 +1753,7 @@ static void transferModule(map<FuncInfo*, set<SgSymbol*>>& funcAddedVarsMods, se
             {
                 if (i == 0)
                     curFunc->funcParams.identificators.push_back(var->identifier());
-     
+
                 ((SgProcHedrStmt*)(hedr))->AddArg(*new SgVarRefExp(var->copy()));
                 hedr->lexNext()->deleteStmt();
                 vector<SgSymbol*> varVec = vector<SgSymbol*>();
@@ -1640,7 +1777,7 @@ static void transferModule(map<FuncInfo*, set<SgSymbol*>>& funcAddedVarsMods, se
                         }
                     }
 
-                    if (!isAuto) 
+                    if (!isAuto)
                     {
                         funcForInterfaceAdd.insert(curFunc);
                         SgAttributeExp* a = new SgAttributeExp(ALLOCATABLE_OP);
@@ -1660,8 +1797,8 @@ static void transferModule(map<FuncInfo*, set<SgSymbol*>>& funcAddedVarsMods, se
                 SgStatement* firstExDec = NULL;
                 for (SgStatement* start = hedr->lexNext(), *end = hedr->lastNodeOfStmt(); start != end; start = start->lexNext())
                 {
-                    if ((isSgExecutableStatement(start) || isSgDeclarationStatement(start)) && 
-                        !strcmp(hedr->fileName(), start->fileName())) 
+                    if ((isSgExecutableStatement(start) || isSgDeclarationStatement(start)) &&
+                        !strcmp(hedr->fileName(), start->fileName()))
                     {
                         firstExDec = start;
                         break;
@@ -1752,7 +1889,7 @@ void moduleTransfer(const map<string, vector<FuncInfo*>>& allFuncInfo)
                 break;
 
             SgStatement* next = start->lexNext();
-            if (start->variant() == USE_STMT) 
+            if (start->variant() == USE_STMT)
             {
                 SgExpression* onlyE = start->expr(0);
                 if (onlyE)
@@ -1778,7 +1915,7 @@ void moduleTransfer(const map<string, vector<FuncInfo*>>& allFuncInfo)
                     }
 
                     if (renameL)
-                        onlyE->setLhs(renameL);                    
+                        onlyE->setLhs(renameL);
                     else
                         start->deleteStmt();
                 }
@@ -1786,7 +1923,7 @@ void moduleTransfer(const map<string, vector<FuncInfo*>>& allFuncInfo)
             if (isSgExecutableStatement(start)|| isSgDeclarationStatement(start))
                 for (int i = 0; i < 3; i++)
                     fillUsedVars(usedVars, start->expr(i));
-            
+
           //  if (start->variant() == IMPL_DECL)
             //    start->deleteStmt();
             start = next;

src/Transformations/FunctionPurifying/function_purifying.h

@@ -6,11 +6,14 @@ bool checkOutCalls(const std::set<std::string>& outCalls);
 std::map<SgStatement*, std::set<std::string>> fillFromIntent(SgStatement* header);
 void intentInsert(const std::vector<FuncInfo*>& allFuncInfo);
 void intentInsertToInterfaces(const std::map<std::string, std::vector<FuncInfo*>>& allFuncInfo);
-void createInterfacesForAssumedSize(const std::map<std::string, std::vector<FuncInfo*>>& allFuncInfo);
 void createInterfacesForOutCalls(FuncInfo* func);
 void setPureStatus(const std::set<FuncInfo*>& funcInfo);
 void setPureStatus(const std::map<std::string, std::vector<FuncInfo*>>& allFuncInfo);
 
 void commonTransfer(const std::map<std::string, std::vector<FuncInfo*>>& allFuncInfo, const std::map<std::string, CommonBlock*>& commonBlocks);
 void saveTransfer(const std::map<std::string, std::vector<FuncInfo*>>& allFuncInfo);
-void moduleTransfer(const std::map<std::string, std::vector<FuncInfo*>>& allFuncInfo);
+void moduleTransfer(const std::map<std::string, std::vector<FuncInfo*>>& allFuncInfo);
+
+void insertInterface(SgStatement* func, const FuncInfo* callFrom);
+
+void transformAssumedSizeParameters(const std::map<std::string, std::vector<FuncInfo*>>& allFuncInfo);

src/Transformations/LoopCombining/loops_combiner.cpp

@@ -20,7 +20,7 @@ using std::wstring;
 
 static SgSymbol* getLoopSymbol(const LoopGraph* loop)
 {
-    if (!loop || !loop->isFor)
+    if (!loop || !loop->isFor())
         return NULL;
 
     SgForStmt* stmt = (SgForStmt*)loop->loop->GetOriginal();
@@ -667,12 +667,12 @@ static void renameIterationVariables(LoopGraph* loop, const map<SgSymbol*, SgSym
 {
     if (loop)
     {
-        string& loopName = loop->loopSymbol;
-        for (auto& pair : symbols)
+        const string& loopName = loop->loopSymbol();
+        for (auto& [from, to] : symbols)
         {
-            if (pair.first->identifier() == loopName)
+            if (from->identifier() == loopName)
             {
-                loop->loopSymbol = (string)pair.second->identifier();
+                loop->loopSymbols.replaceMainVar(to->identifier());
                 break;
             }
         }
@@ -691,9 +691,9 @@ static void renameVariablesInLoop(LoopGraph* loop, const map<SgSymbol*, SgSymbol
         if (st->variant() == FOR_NODE)
         {
             SgForStmt* for_st = (SgForStmt*)st;
-            for (auto& pair : symbols)
-                if (isEqSymbols(pair.first, for_st->symbol()))
-                    for_st->setDoName(*pair.second);
+            for (auto& [from, to] : symbols)
+                if (isEqSymbols(from, for_st->symbol()))
+                    for_st->setDoName(*to);
         }
 
         for (int i = 0; i < 3; ++i)
@@ -710,12 +710,12 @@ static void renamePrivatesInMap(LoopGraph* loop, const map<SgSymbol*, SgSymbol*>
         for (auto& priv : privates->second)
         {
             bool found = false;
-            for (auto& pair : symbols)
+            for (auto& [from, to] : symbols)
             {
-                if (isEqSymbols(priv, pair.first))
+                if (isEqSymbols(priv, from))
                 {
                     found = true;
-                    newList.insert(pair.second);
+                    newList.insert(to);
                     break;
                 }
             }
@@ -1590,7 +1590,7 @@ static bool combine(LoopGraph* firstLoop, const vector<LoopGraph*>& nextLoops, s
     bool wasCombine = false;
     for (LoopGraph* loop : nextLoops)
     {
-        if (!loop->isFor)
+        if (!loop->isFor())
             return wasCombine;
 
         int perfectLoop = std::min(firstLoop->perfectLoop, loop->perfectLoop);
@@ -1723,7 +1723,7 @@ static bool tryToCombine(vector<LoopGraph*>& loopGraphs, map<LoopGraph*, set<SgS
     {
         LoopGraph* loop = loops[z];
         newloopGraphs.push_back(loop);
-        if (!loop->isFor)
+        if (!loop->isFor())
             continue;
 
         vector<LoopGraph*> nextLoops = getNextLoops(loop, loopGraphs, -1);

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"
@@ -1035,7 +1035,7 @@ int splitLoops(SgFile *file, vector<LoopGraph*> &loopGraphs, vector<Messages> &m
 
     for (auto &loopPair : mapLoopGraph)
     {
-        if (!loopPair.second->isFor)
+        if (!loopPair.second->isFor())
             continue;
 
         LoopGraph *loop = loopPair.second;

src/Transformations/PrivateArrayRemoving/private_removing.cpp

@@ -2257,7 +2257,7 @@ void removePrivatesAnalysis(string filename,
 {
     for (LoopGraph* loop : loopGraphs)
     {
-        if (!loop->isFor)
+        if (!loop->isFor())
             continue;
 
         SgForStmt* loopStmt = (SgForStmt*)loop->loop->GetOriginal();

src/Transformations/PrivateArrayRemoving/private_removing.h

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

src/Transformations/PrivateArrayResizing/private_arrays_resizing.cpp

@@ -74,7 +74,7 @@ static void fillIterationVariables(const LoopGraph* loop, set<string>& vars, int
 {
     if (dimensions == -1)
     {
-        vars.insert(loop->loopSymbol);
+        vars.insert(loop->loopSymbol());
         for (LoopGraph* child : loop->children)
             fillIterationVariables(child, vars);
     }
@@ -82,7 +82,7 @@ static void fillIterationVariables(const LoopGraph* loop, set<string>& vars, int
     {
         for (int i = 0; i < dimensions; ++i)
         {
-            vars.insert(loop->loopSymbol);
+            vars.insert(loop->loopSymbol());
             if (i != dimensions - 1)
                 loop = loop->children[0];
         }

src/Transformations/ReplaceArraysInIO/replace_dist_arrays_in_io.cpp

@@ -17,6 +17,157 @@ using std::pair;
 
 #define DEBUG_TRACE 0
 
+static bool hasArrayRef(SgExpression* ex)
+{
+    if (ex)
+        return isArrayRef(ex) || hasArrayRef(ex->lhs()) || hasArrayRef(ex->rhs());
+
+    return false;
+}
+
+static inline bool isArrayDeclaration(SgStatement* st)
+{
+    return isSgDeclarationStatement(st) || isSgVarListDeclStmt(st) || isSgNestedVarListDeclStmt(st);
+}
+
+static SgExpression* findExprWithVariant(SgExpression* exp, int variant)
+{
+    if (exp)
+    {
+        if (exp->variant() == variant)
+            return exp;
+
+        auto *l = findExprWithVariant(exp->lhs(), variant);
+        if (l)
+            return l;
+
+        auto *r = findExprWithVariant(exp->rhs(), variant);
+        if (r)
+            return r;
+    }
+
+    return NULL;
+}
+
+static bool switchToDeclarationFile(DIST::Array* array_p, 
+                                    pair<string, int>& decl_place, 
+                                    const string &current_file_name,
+                                    FuncInfo *current_func)
+{
+    if (!array_p)
+        return false;
+
+    // try to find declaration from current function
+    for (const auto &p : array_p->GetDeclInfo())
+    {
+        if (p.first == current_file_name && 
+            current_func->linesNum.first <= p.second && 
+            p.second <= current_func->linesNum.second)
+        {
+            decl_place = p;
+            return true;
+        }
+    }
+
+    for (const auto &p : array_p->GetDeclInfo())
+    {
+        if (SgFile::switchToFile(p.first) != -1)
+        {
+            decl_place = p;
+            return true;
+        }
+    }
+
+    return false;
+}
+
+static bool checkAssumedShape(SgStatement* decl, const string& array_name)
+{
+    SgExpression* list = decl->expr(0);
+    SgExpression* dim_list = NULL;
+
+    while (list)
+    {
+        auto *arr_ref = list->lhs();
+
+        if (arr_ref && 
+            arr_ref->symbol() && 
+            arr_ref->symbol()->identifier() && 
+            arr_ref->symbol()->identifier() == array_name)
+        {
+            dim_list = arr_ref->lhs();
+            break;
+        }
+
+        list = list->rhs();
+    }
+
+    if (!dim_list)
+    {
+        auto *dim_expr = findExprWithVariant(decl->expr(2), DIMENSION_OP);
+        if (dim_expr)
+            dim_list = dim_expr->lhs();
+    }
+
+    while (dim_list)
+    {
+        auto *lhs = dim_list->lhs();
+
+        if (lhs && lhs->variant() == DDOT && (!lhs->lhs() || !lhs->rhs()))
+            return true;
+
+        dim_list = dim_list->rhs();
+    }
+
+    return false;
+}
+
+static bool checkAssumedSize(const string &array_name, DIST::Array* array_p, const string &current_file_name, FuncInfo *current_func)
+{
+    if (!array_p)
+        return true; // raise true to prevent array from copying
+
+    bool found = false;
+
+    pair<string, int> decl_place;
+
+    if (!switchToDeclarationFile(array_p, decl_place, current_file_name, current_func))
+        return true;
+
+    auto *st = SgStatement::getStatementByFileAndLine(decl_place.first, decl_place.second);
+    checkNull(st, convertFileName(__FILE__).c_str(), __LINE__);
+    
+    SgExpression* list = st->expr(0);    
+    while (list)
+    {
+        if (list->lhs() && 
+            list->lhs()->symbol() && 
+            list->lhs()->symbol()->identifier() && 
+            list->lhs()->symbol()->identifier() == array_name
+        )
+        {
+            if(findExprWithVariant(list->lhs(), STAR_RANGE))
+                found = true;
+
+            break;
+        }
+
+        list = list->rhs();
+    }
+
+    if (!found)
+    {
+        auto *dim_expr = findExprWithVariant(st->expr(2), DIMENSION_OP);
+        if (dim_expr && findExprWithVariant(dim_expr, STAR_RANGE))
+            found = true;
+    }
+
+    if (SgFile::switchToFile(current_file_name) == -1)
+        printInternalError(convertFileName(__FILE__).c_str(), __LINE__); // can't switch back to file with array usage
+
+    return found;
+}
+
 static void findArrays(SgExpression* exp, set<SgSymbol*>& arrays)
 {
     if (exp)
@@ -29,12 +180,15 @@ static void findArrays(SgExpression* exp, set<SgSymbol*>& arrays)
     }
 }
 
-static void populateDistributedIoArrays(map<SgSymbol*, set<SgStatement*>>& arrays, SgStatement* stat)
+static bool populateDistributedIoArrays(map<SgSymbol*, set<SgStatement*>>& arrays, 
+                                        SgStatement* stat, 
+                                        const string& current_file_name,
+                                        FuncInfo *current_func)
 {
     auto var = stat->variant();
 
     if (var != READ_STAT && var != PRINT_STAT && var != WRITE_STAT)
-        return;
+        return false;
 
     // check if such IO allowed in dvm: 
     // list should consist only of single array and format string should be *
@@ -44,22 +198,26 @@ static void populateDistributedIoArrays(map<SgSymbol*, set<SgStatement*>>& array
     SgExpression* ioList = stat->expr(0);
 
     if (!ioList)
-        return;
+        return false;
 
     if (ioList->variant() != EXPR_LIST)
-        return;
+        return false;
 
     if (ioList->rhs() == NULL)
     {
         SgExpression* arg = ioList->lhs();
         if (!arg)
-            return;
+            return false;
 
-        if (!isArrayRef(arg))
-            return;
-
-        if (arg->lhs())
-            need_replace = true;
+        if (hasArrayRef(arg))
+        {
+            if (isArrayRef(arg) && arg->lhs())
+                need_replace = true;
+        }
+        else
+        {
+            return false;
+        }
     }
     else
     {
@@ -74,37 +232,43 @@ static void populateDistributedIoArrays(map<SgSymbol*, set<SgStatement*>>& array
         {
             SgExpression* fmt = stat->expr(1);
             if (!fmt || fmt->variant() != SPEC_PAIR || fmt->lhs()->variant() != KEYWORD_VAL)
-            {
                 printInternalError(convertFileName(__FILE__).c_str(), __LINE__);
-                return;
-            }
 
             if (fmt->rhs()->variant() != KEYWORD_VAL || fmt->rhs()->sunparse() != "*")
                 need_replace = true;
 
-
             break;
         }
         case READ_STAT:
         case WRITE_STAT:
         {
-
             SgExpression* spec = stat->expr(1);
-            __spf_print(DEBUG_TRACE, "[%d: %s (%d)]\n", 2000, spec->rhs()->unparse(), spec->rhs()->variant());
-            if (!spec || spec->variant() != EXPR_LIST ||
-                spec->lhs()->variant() != SPEC_PAIR ||
-                !spec->rhs() || !spec->rhs()->lhs() || spec->rhs()->lhs()->variant() != SPEC_PAIR)
+
+            if (spec->variant() == SPEC_PAIR)
             {
-                printInternalError(convertFileName(__FILE__).c_str(), __LINE__);
-                return;
+                if (spec->rhs()->variant() != KEYWORD_VAL || spec->rhs()->sunparse() != "*")
+                {
+                    need_replace = true;
+                    break;
+                }
             }
+            else
+            {
+                while (spec)
+                {
+                    auto *kv = spec->lhs();
+                    if (!kv || kv->variant() != SPEC_PAIR || !kv->rhs())
+                        printInternalError(convertFileName(__FILE__).c_str(), __LINE__);
 
-            SgExpression* unit_val = spec->lhs()->rhs(), * fmt_val = spec->rhs()->lhs()->rhs();
-
-            if (unit_val->variant() != KEYWORD_VAL || unit_val->sunparse() != "*" ||
-                fmt_val->variant() != KEYWORD_VAL || fmt_val->sunparse() != "*")
-                need_replace = true;
+                    if (kv->rhs()->variant() != KEYWORD_VAL || kv->rhs()->sunparse() != "*")
+                    {
+                        need_replace = true;
+                        break;
+                    }
 
+                    spec = spec->rhs();
+                }
+            }
             break;
         }
         default:
@@ -113,7 +277,9 @@ static void populateDistributedIoArrays(map<SgSymbol*, set<SgStatement*>>& array
     }
 
     if (!need_replace)
-        return;
+        return false;
+
+    bool ret = false;
 
     set<SgSymbol*> found_arrays;
 
@@ -124,11 +290,21 @@ static void populateDistributedIoArrays(map<SgSymbol*, set<SgStatement*>>& array
     {
         string array_name = string(by_symb->identifier());
         DIST::Array* array_p = getArrayFromDeclarated(declaratedInStmt(by_symb), array_name);
-        if (array_p && array_p->GetDistributeFlagVal() == Distribution::distFlag::IO_PRIV && arrays[by_symb].insert(stat).second)
-            __spf_print(DEBUG_TRACE, "[%d]: add array %s\n", stat->lineNumber(), array_p->GetName().c_str());
+        if (array_p && 
+            array_p->GetDistributeFlagVal() == Distribution::distFlag::IO_PRIV && 
+            !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)
@@ -136,7 +312,8 @@ static void replaceArrayRec(SgSymbol* arr, SgSymbol* replace_by, SgExpression* e
     if (!exp)
         return;
 
-    if (exp->symbol() && exp->symbol()->identifier() && strcmp(exp->symbol()->identifier(), arr->identifier()) == 0)
+    if (isArrayRef(exp) && 
+        strcmp(exp->symbol()->identifier(), arr->identifier()) == 0)
     {
         has_read |= from_read;
         has_write |= from_write;
@@ -197,16 +374,19 @@ static void replaceArrayRec(SgSymbol* arr, SgSymbol* replace_by, SgStatement* st
     }
 }
 
-static void copyArrayBetweenStatements(SgSymbol* replace_symb, SgSymbol* replace_by, SgStatement* start, SgStatement* last, bool start_is_scope)
+static void copyArrayBetweenStatements(SgSymbol* replace_symb, 
+                                       SgSymbol* replace_by,
+                                       SgStatement* start, 
+                                       SgStatement* last, 
+                                       bool start_is_scope,
+                                       FuncInfo *func_info)
 {
     while (start->lexNext() && !isSgExecutableStatement(start->lexNext()))
         start = start->lexNext();
 
-    auto* stop = last->lexNext();
-
     bool has_read = false, has_write = false;
 
-    for (auto* st = start->lexNext(); st && st != stop->lexPrev(); st = st->lexNext())
+    for (auto* st = start->lexNext(); st && st != last; st = st->lexNext())
         replaceArrayRec(replace_symb, replace_by, st, has_read, has_write);
 
 
@@ -218,10 +398,23 @@ static void copyArrayBetweenStatements(SgSymbol* replace_symb, SgSymbol* replace
         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);
     }
 
+    if (has_write)
+    {
+        for (int i = 0; i < func_info->funcParams.identificators.size(); i++)
+        {
+            if (func_info->funcParams.identificators[i] == replace_symb->identifier())
+            {
+                has_write &= func_info->funcParams.isArgOut(i);
+                break;
+            }
+        }
+    }
+
     if (has_write)
     {
         // A = A_reg
@@ -232,9 +425,14 @@ static void copyArrayBetweenStatements(SgSymbol* replace_symb, SgSymbol* replace
     }
 }
 
-static void replaceArrayInFragment(SgSymbol* replace_symb, const set<SgStatement*> usages, SgSymbol* replace_by, SgStatement* start, SgStatement* last, const string& filename)
+static void replaceArrayInFragment(SgSymbol* replace_symb, 
+                                   const set<SgStatement*> usages, 
+                                   SgSymbol* replace_by, 
+                                   SgStatement* start, 
+                                   SgStatement* last, 
+                                   FuncInfo *func_info)
 {
-    while (start->lexNext() && !isSgExecutableStatement(start->lexNext()))
+    while (start->lexNext() && (!isSgExecutableStatement(start->lexNext()) || start->lexNext()->variant() == ALLOCATE_STMT))
         start = start->lexNext();
 
     set<SgStatement*> not_opened, not_closed, copied;
@@ -301,7 +499,7 @@ static void replaceArrayInFragment(SgSymbol* replace_symb, const set<SgStatement
         }
 
         __spf_print(DEBUG_TRACE, "[copy %s] [%d, %d]\n", replace_symb->identifier(), scope_start->lineNumber(), scope_end->lineNumber());
-        copyArrayBetweenStatements(replace_symb, replace_by, scope_start, scope_end, copy_scope == scope_start);
+        copyArrayBetweenStatements(replace_symb, replace_by, scope_start, scope_end, copy_scope == scope_start, func_info);
         copied.insert(copy_scope);
     }
 }
@@ -324,12 +522,16 @@ 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;
 
@@ -342,9 +544,9 @@ static bool ioReginBorder(SgStatement* stat, SgStatement* last_io_bound)
 }
 
 void replaceDistributedArraysInIO(vector<ParallelRegion*>& regions,
-    const map<string, vector<FuncInfo*>>& allFuncInfo,
-    map<string, vector<Messages>>& SPF_messages,
-    map<string, map<int, set<string>>>& newDeclsToInclude)
+                                  const map<string, vector<FuncInfo*>>& allFuncInfo,
+                                  map<string, vector<Messages>>& SPF_messages,
+                                  map<string, map<int, set<string>>>& newDeclsToInclude)
 {
     map<SgSymbol*, SgSymbol*> created_copies;
     map<string, map<int, set<string>>> copied_syms;
@@ -353,26 +555,29 @@ void replaceDistributedArraysInIO(vector<ParallelRegion*>& regions,
     {
         __spf_print(DEBUG_TRACE, "[%s]: enter region\n", region->GetName().c_str());
 
-        for (auto& linesByFile : region->GetAllLinesToModify())
+        for (auto& lines_by_file : region->GetAllLinesToModify())
         {
-            const auto& filename = linesByFile.first;
+            const auto& current_file_name = lines_by_file.first;
 
-            if (SgFile::switchToFile(filename) < 0)
-            {
+            if (SgFile::switchToFile(current_file_name) == -1)
                 printInternalError(convertFileName(__FILE__).c_str(), __LINE__);
-                return;
-            }
 
-            for (auto& lines : linesByFile.second)
+            auto func_info_it = allFuncInfo.find(current_file_name);
+            if (func_info_it == allFuncInfo.end())
+                printInternalError(convertFileName(__FILE__).c_str(), __LINE__);
+
+            auto *lbound_symb = new SgSymbol(FUNCTION_NAME, "lbound");
+            auto *ubound_symb = new SgSymbol(FUNCTION_NAME, "ubound");
+
+            for (auto& lines : lines_by_file.second)
             {
-                __spf_print(DEBUG_TRACE, "[fragment] %s: %d:%d %d\n", filename.c_str(), lines.lines.first,
+                __spf_print(DEBUG_TRACE, "[fragment] %s: %d:%d %d\n", current_file_name.c_str(), lines.lines.first,
                     lines.lines.second, lines.isImplicit());
 
                 SgStatement* curr_stmt, * end;
 
                 if (lines.isImplicit())
                 {
-
                     curr_stmt = current_file->SgStatementAtLine(lines.lines.first);
                     end = current_file->SgStatementAtLine(lines.lines.second);
 
@@ -388,6 +593,7 @@ void replaceDistributedArraysInIO(vector<ParallelRegion*>& regions,
                 map<SgSymbol*, set<SgStatement*>> need_replace;
                 SgStatement* last_io_bound = NULL;
 
+                FuncInfo *current_func_info = NULL;
 
                 while (curr_stmt != end)
                 {
@@ -396,9 +602,21 @@ void replaceDistributedArraysInIO(vector<ParallelRegion*>& regions,
 
                     auto var = curr_stmt->variant();
 
-
                     if (var == PROC_HEDR || var == PROG_HEDR || var == FUNC_HEDR)
                     {
+                        current_func_info = NULL;
+                        for (auto *func_info : func_info_it->second)
+                        {
+                            if (func_info->funcName == curr_stmt->symbol()->identifier())
+                            {
+                                current_func_info = func_info;
+                                break;
+                            }
+                        }
+
+                        if (!current_func_info)
+                            printInternalError(convertFileName(__FILE__).c_str(), __LINE__);
+
                         curr_stmt = curr_stmt->lexNext();
                         while (curr_stmt && !isSgExecutableStatement(curr_stmt))
                         {
@@ -422,77 +640,192 @@ void replaceDistributedArraysInIO(vector<ParallelRegion*>& regions,
                                 string array_name = string(array_to_copy->identifier());
                                 DIST::Array* array_p = getArrayFromDeclarated(declaratedInStmt(array_to_copy), array_name);
 
-                                bool fromModule = (array_p->GetLocation().first == DIST::l_MODULE);
-                                const string locationName = array_p->GetLocation().second;
+                                // at this point all considered arrays must have DIST::Array* references
+                                if (!array_p)
+                                    printInternalError(convertFileName(__FILE__).c_str(), __LINE__);
+
+                                // ... and be declared in switchable files (not in headers)
+                                pair<string, int> decl_place;
+                                if (!switchToDeclarationFile(array_p, decl_place, current_file_name, current_func_info))
+                                    printInternalError(convertFileName(__FILE__).c_str(), __LINE__);
 
-                                auto place = *array_p->GetDeclInfo().begin();
-                                string fileName = place.first;
                                 string suffix = "_io_l";
 
-                                if (fromModule)
-                                    suffix = "_io_m";
-
-                                pair<SgSymbol*, SgSymbol*> copied;
-                                copied.first = array_to_copy;
-
-                                if (SgFile::switchToFile(fileName) == -1)
+                                switch (array_p->GetLocation().first)
                                 {
-                                    auto* func_stmt = curr_stmt->getScopeForDeclare();
+                                    case DIST::l_MODULE:
+                                        suffix = "_io_m";
+                                        break;
+                                    case DIST::l_COMMON:
+                                        suffix = "_io_c";
+                                        break;
+                                }
+                                
+                                auto copied_symbol = copyArray(decl_place, 
+                                                               array_p, 
+                                                               lines_by_file.second, 
+                                                               suffix + to_string(region->GetId()), 
+                                                               decl_place.first, 
+                                                               newDeclsToInclude, 
+                                                               copied_syms);
+                            
+                                // original declaration statement
+                                auto *decl_stmt = SgStatement::getStatementByFileAndLine(decl_place.first, decl_place.second);
 
-                                    SgStatement* insertPlace = NULL;
+                                if (!decl_stmt || !isArrayDeclaration(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) &&
+                                        decl_stmt->expr(0) &&
+                                        decl_stmt->expr(0)->lhs() &&
+                                        decl_stmt->expr(0)->lhs()->symbol() == copied_symbol.second)
+                                    {
+                                        break;
+                                    }
+
+                                    decl_stmt = decl_stmt->lexNext();
+                                }
+                                
+                                // created declaration statement
+                                if (!decl_stmt || !isArrayDeclaration(decl_stmt))
+                                    printInternalError(convertFileName(__FILE__).c_str(), __LINE__);
+
+                                // insert !$SPF ANALYSIS(PROCESS_PRIVATE(array)) directive before declaration statement
+                                
+                                string dir_str;
+                                if (decl_stmt->comments())
+                                {
+                                    auto str_comment = string(decl_stmt->comments());
+                                    if (str_comment.size() && str_comment.back() != '\n')
+                                        dir_str += "\n";
+                                }
+
+                                dir_str += "!$SPF ANALYSIS(PROCESS_PRIVATE(" + string(copied_symbol.second->identifier()) + "))\n";
+                                decl_stmt->addComment(dir_str.c_str());
+                            
+                                created_copies.insert({ array_to_copy, copied_symbol.second });
+
+                                // make array copy allocatable in case of assumed-shape array
+                                if(dynamic_array)
+                                {
+                                    // insert allocatable keyword in declaration
+                                    auto *kword_list = decl_stmt->expr(2);
+                                    if (!findExprWithVariant(kword_list, ALLOCATABLE_OP))
+                                    {
+                                        if (!kword_list)
+                                        {
+                                            kword_list = new SgExprListExp();
+                                            decl_stmt->setExpression(2, *kword_list);
+                                        }
+                                        
+                                        while (kword_list->rhs())
+                                            kword_list = kword_list->rhs();
+                                        
+                                        if (kword_list->lhs())
+                                        {
+                                            kword_list->setRhs(new SgExprListExp());
+                                            kword_list = kword_list->rhs();
+                                        }
+
+                                        kword_list->setLhs(new SgExpression(ALLOCATABLE_OP));
+                                    }
+
+                                    // can't switch back to file with array usage
+                                    if (SgFile::switchToFile(current_file_name) == -1)
+                                        printInternalError(convertFileName(__FILE__).c_str(), __LINE__); 
+                                        
+                                    // insert allocate(a_l(lbound(a, 1):ubound(a,1),...)) statement
+                                    SgStatement* allocate_stmt_place = NULL;
+
+                                    auto* func_stmt = curr_stmt->getScopeForDeclare();
                                     for (auto iterator = func_stmt->lexNext();
-                                        !isSgExecutableStatement(iterator) || isSPF_stat(iterator) &&
-                                        !(iterator->variant() == SPF_PARALLEL_REG_DIR || iterator->variant() == SPF_END_PARALLEL_REG_DIR);
+                                        iterator && !isSgExecutableStatement(iterator);
                                         iterator = iterator->lexNext())
                                     {
-                                        insertPlace = iterator;
+                                            allocate_stmt_place = iterator;
                                     }
 
                                     //NULL - no decl stats in function!
-                                    if (!insertPlace)
-                                        insertPlace = func_stmt;
+                                    if (!allocate_stmt_place)
+                                        allocate_stmt_place = func_stmt;
 
-                                    auto st = insertPlace->controlParent();
-                                    if (st->variant() == GLOBAL)
-                                        st = insertPlace;
+                                    auto *allocate_stmt_parent = allocate_stmt_place->controlParent();
+                                    if (allocate_stmt_parent->variant() == GLOBAL)
+                                        allocate_stmt_parent = allocate_stmt_place;
+                                    
+                                    auto *created_array_ref = new SgArrayRefExp(*copied_symbol.second);
 
-                                    auto& copied_symb = array_to_copy->copy();
-                                    copied.second = &copied_symb;
-
-                                    auto new_name = string(array_to_copy->identifier()) + "_io_c";
-                                    copied_symb.changeName(new_name.c_str());
-
-                                    auto stat = array_to_copy->makeVarDeclStmt();
-                                    auto res = CalculateInteger(stat->expr(0)->copyPtr());
-                                    res->lhs()->setSymbol(copied_symb);
-                                    stat->setExpression(0, res);
-
-                                    insertPlace->insertStmtAfter(*stat, *st);
-                                }
-                                else
-                                {
-                                    copied = copyArray(place, array_p, linesByFile.second, suffix + to_string(region->GetId()), fileName, newDeclsToInclude, copied_syms);
-                                }
-
-                                SgStatement* decl = SgStatement::getStatementByFileAndLine(place.first, place.second);
-
-                                if (decl)
-                                    decl = decl->lexNext();
-
-                                if (decl)
-                                {
-                                    string dir_str;
-                                    if (decl->comments())
+                                    auto* dim_list = new SgExprListExp();
+                                    created_array_ref->setLhs(dim_list);
+                                    
+                                    int dim_len = array_p->GetSizes().size();
+                                    for (int i = 1; i <= dim_len; i++)
                                     {
-                                        string str_comment = string(decl->comments());
-                                        if (str_comment.size() && str_comment.back() != '\n')
-                                            dir_str += "\n";
+                                        auto *lcall = new SgFunctionCallExp(*lbound_symb);
+                                        auto *rcall = new SgFunctionCallExp(*ubound_symb);
+                                        
+                                        for (auto *call : {lcall, rcall})
+                                        {
+                                            call->setLhs(new SgExprListExp());
+
+                                            call->lhs()->setLhs(new SgArrayRefExp(*array_to_copy));
+                                            call->lhs()->setRhs(new SgValueExp(i));
+                                        }
+                                        
+                                        auto *dot_expr = new SgExpression(DDOT);
+                                        dot_expr->setLhs(lcall);
+                                        dot_expr->setRhs(rcall);
+
+                                        dim_list->setLhs(dot_expr);
+
+                                        if (i < dim_len)
+                                        {
+                                            auto *next = new SgExprListExp();
+                                            dim_list->setRhs(next);
+                                            dim_list = next;
+                                        }
                                     }
 
-                                    dir_str += "!$SPF ANALYSIS(PROCESS_PRIVATE(" + string(copied.second->identifier()) + "))\n";
-                                    decl->addComment(dir_str.c_str());
+                                    auto *allocate_stmt = new SgStatement(ALLOCATE_STMT);
+                                    allocate_stmt->setExpression(0, created_array_ref);
+
+                                    allocate_stmt_place->insertStmtAfter(*allocate_stmt, *allocate_stmt_parent);
+
+                                    // insert deallocate statemens before all returns
+                                    auto *find_return_stmt = func_stmt;
+                                    while (find_return_stmt != func_stmt->lastNodeOfStmt())
+                                    {
+                                        auto *next = find_return_stmt->lexNext();
+                                        if (next && (isSgReturnStmt(next) || next == func_stmt->lastNodeOfStmt()))
+                                        {
+                                            if (next->hasLabel())
+                                            {
+                                                moveLabelBefore(next);
+                                                find_return_stmt = next->lexPrev();
+                                            }
+                                            
+                                            auto *dealloc_stmt = new SgStatement(DEALLOCATE_STMT);
+
+                                            dealloc_stmt->setExpression(0, new SgExprListExp());
+                                            dealloc_stmt->expr(0)->setLhs(new SgArrayRefExp(*copied_symbol.second));
+
+                                            find_return_stmt->insertStmtAfter(*dealloc_stmt, *next->controlParent());
+
+                                            if (next == curr_stmt)
+                                                curr_stmt = dealloc_stmt;
+                                        }
+
+                                        find_return_stmt = next;
+                                    }
                                 }
-                                created_copies.insert({ array_to_copy, copied.second });
+
+                                // can't switch back to file with array usage
+                                if (SgFile::switchToFile(current_file_name) == -1)
+                                    printInternalError(convertFileName(__FILE__).c_str(), __LINE__); 
                             }
                         }
 
@@ -504,12 +837,9 @@ void replaceDistributedArraysInIO(vector<ParallelRegion*>& regions,
                             {
                                 auto it = created_copies.find(p.first);
                                 if (it != created_copies.end())
-                                    replaceArrayInFragment(p.first, p.second, it->second, last_io_bound, curr_stmt, filename);
+                                    replaceArrayInFragment(p.first, p.second, it->second, last_io_bound, curr_stmt, current_func_info);
                                 else
-                                {
                                     printInternalError(convertFileName(__FILE__).c_str(), __LINE__);
-                                    return;
-                                }
                             }
                         }
 
@@ -527,7 +857,17 @@ void replaceDistributedArraysInIO(vector<ParallelRegion*>& regions,
                         }
                     }
 
-                    populateDistributedIoArrays(need_replace, curr_stmt);
+                    auto need_fix_io = 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/Utils/utils.cpp

@@ -390,32 +390,15 @@ 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;
-    for (auto& elem : allocatedInt)
-        delete[]elem;
+        delete []elem;    
     allocated.clear();
-    allocatedInt.clear();
-
+    
+    
     SPF_messages.clear();
 }
 
@@ -451,7 +434,7 @@ static map<string, vector<Messages>> removeCopies(map<string, vector<Messages>>
     return out;
 }
 
-static void convertGlobalMessagesBuffer(short *&result, int *&resultSize)
+static string convertGlobalMessagesBuffer()
 {
     auto copySPF_messages = removeCopies(SPF_messages);
     for (auto &byFile : copySPF_messages)
@@ -489,21 +472,13 @@ static void convertGlobalMessagesBuffer(short *&result, int *&resultSize)
     json all;
     all["allMessages"] = allMessages;
 
-    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;
+    return all.dump();    
 }
 
-
-void convertBuffers(short*& resultM, int*& resultSizeM, short*& result, int*& resultSize)
+void convertBuffers(string &resultM, string &result)
 {
-    convertGlobalMessagesBuffer(resultM, resultSizeM);
-    convertGlobalBuffer(result, resultSize);
+    resultM = convertGlobalMessagesBuffer();
+    result = getGlobalBuffer();
 }
 
 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(short*& resultM, int*& resultSizeM, short*& result, int*& resultSize);
+void convertBuffers(std::string& resultM, std::string& result);
 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 "2427"
+#define VERSION_SPF "2446"