Merge pull request 'ArrayAnalysis: consider case of IO_PRIV array from module' (#65) from io_priv_module_arrays into master

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

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"

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/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

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

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"

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/Sapfor.cpp

@@ -1281,7 +1281,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 +1914,8 @@ 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);
 
     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/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)
+        if (toCalc->variant() == UNARY_ADD_OP)
-            toCalc = ret->lhs();
+            toCalc = toCalc->lhs();
-        if (ret->variant() == MINUS_OP)
+
+        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();
@@ -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));
+            has = true;
-            list = list->rhs();
+
+            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()))
+                                if (changeIfHasStarRange(list->lhs(), scope, parNames))
-                                {
+                                    assumedSizeArraysByFunc[func->funcName].push_back(z);
-                                    hasRefs = true;
-                                    hasAssumedSizeArrays.insert(func);
-                                }
-                                else
-                                    arrayRefs.push_back(list->lhs());
                                 break;
                             }
                             list = list->rhs();
@@ -259,13 +284,20 @@ void createInterfacesForAssumedSize(const map<string, vector<FuncInfo*>>& allFun
                 }
             }
 
-            if (hasRefs)
+            if (parNames.size())
-                for (auto& ref : arrayRefs)
+            {
-                    changeIfHasStarRange(ref, true);
+                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& detailedCall : func->callsFromDetailed)
-            for (auto& elem : sortByName(func->callsFromV))
             {
-                auto it = hasAssumedSizeArrays.find(elem);
+                auto it = assumedSizeArraysByFunc.find(detailedCall.detailCallsFrom.first);
-                if (it != hasAssumedSizeArrays.end())
+                if (it != assumedSizeArraysByFunc.end())
                 {
-                    auto callFrom = *it;
+                    auto pointer = detailedCall.pointerDetailCallsFrom;
-                    DvmhRegionInserter::createInterfaceBlockForOutCall(func, callFrom);
+
-                    addedInterfaceFor.insert(callFrom->funcName);
+                    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);
         }
@@ -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) || 
+                if ( (s->attributes() & SAVE_BIT) ||
-                     (s->attributes() & DATA_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, 
+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*>>>& 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> idents(pars.identificators.begin(), pars.identificators.end());
-    const set<string> ident(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();
+                toExtract.push_back(st);
-                st->extractStmt();
+                st = st->lexNext();
-                st = next;
             }
             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
+        const int var = st->variant();
-            || 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();
-            }
 
-            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)) && 
+                    if ((isSgExecutableStatement(start) || isSgDeclarationStatement(start)) &&
-                        !strcmp(hedr->fileName(), start->fileName())) 
+                        !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/ReplaceArraysInIO/replace_dist_arrays_in_io.cpp

@@ -74,10 +74,7 @@ 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;
@@ -104,10 +101,7 @@ static void populateDistributedIoArrays(map<SgSymbol*, set<SgStatement*>>& array
                 {
                     auto *kv = spec->lhs();
                     if (!kv || kv->variant() != SPEC_PAIR || !kv->rhs())
-                    {
                         printInternalError(convertFileName(__FILE__).c_str(), __LINE__);
-                        return;
-                    }
 
                     if (kv->rhs()->variant() != KEYWORD_VAL || kv->rhs()->sunparse() != "*")
                     {
@@ -368,11 +362,8 @@ void replaceDistributedArraysInIO(vector<ParallelRegion*>& regions,
         {
             const auto& filename = linesByFile.first;
 
-            if (SgFile::switchToFile(filename) < 0)
+            if (SgFile::switchToFile(filename) == -1)
-            {
                 printInternalError(convertFileName(__FILE__).c_str(), __LINE__);
-                return;
-            }
 
             for (auto& lines : linesByFile.second)
             {
@@ -481,9 +472,7 @@ void replaceDistributedArraysInIO(vector<ParallelRegion*>& regions,
                                     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);
 
@@ -504,6 +493,9 @@ void replaceDistributedArraysInIO(vector<ParallelRegion*>& regions,
                                     decl->addComment(dir_str.c_str());
                                 }
                                 created_copies.insert({ array_to_copy, copied.second });
+
+                                if (curr_stmt->switchToFile() == -1)
+                                    printInternalError(convertFileName(__FILE__).c_str(), __LINE__);
                             }
                         }
 
@@ -517,10 +509,7 @@ void replaceDistributedArraysInIO(vector<ParallelRegion*>& regions,
                                 if (it != created_copies.end())
                                     replaceArrayInFragment(p.first, p.second, it->second, last_io_bound, curr_stmt, filename);
                                 else
-                                {
                                     printInternalError(convertFileName(__FILE__).c_str(), __LINE__);
-                                    return;
-                                }
                             }
                         }
 

src/Utils/version.h

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