region merging: derive array types

CMakeLists.txt

@@ -166,6 +166,8 @@ set(PARALLEL_REG src/ParallelizationRegions/ParRegions.cpp
 set(ARRAY_PROP src/ArrayConstantPropagation/propagation.cpp
 	src/ArrayConstantPropagation/propagation.h	
 )
+set(MERGE_COPY_ARRAYS src/ParallelizationRegions/parse_merge_dirs.cpp
+         src/ParallelizationRegions/parse_merge_dirs.h)
 
 set(TR_DEAD_CODE src/Transformations/DeadCodeRemoving/dead_code.cpp
         src/Transformations/DeadCodeRemoving/dead_code.h)
@@ -426,6 +428,7 @@ set(SOURCE_EXE
     ${LOOP_ANALYZER}
     ${TRANSFORMS}
     ${PARALLEL_REG}
+    ${MERGE_COPY_ARRAYS}
     ${PRIV}
     ${ARRAY_PROP}
     ${FDVM}
@@ -479,6 +482,7 @@ source_group (GraphCall FILES ${GR_CALL})
 source_group (GraphLoop FILES ${GR_LOOP})
 source_group (LoopAnalyzer FILES ${LOOP_ANALYZER})
 source_group (ParallelizationRegions FILES ${PARALLEL_REG})
+source_group (MergeCopyArrays FILES ${MERGE_COPY_ARRAYS})
 source_group (PrivateAnalyzer FILES ${PRIV})      
 source_group (ArrayConstantPropagation FILES ${ARRAY_PROP})      
 source_group (FDVM_Compiler FILES ${FDVM})

src/CFGraph/private_variables_analysis.cpp

@@ -321,6 +321,12 @@ static set<SAPFOR::BasicBlock*> analyzeLoop(LoopGraph* loop, const set<SAPFOR::B
         }
     }
 
+    if (currentLoop.empty()) // can't find loop IR - loop unreachable!
+    {
+        __spf_print(1, "Unreachable loop on %s:%d\n", current_file->filename(), loop_operator->lineNumber());
+        return currentLoop;
+    }
+
     if (!head_block)
         printInternalError(convertFileName(__FILE__).c_str(), __LINE__);
     

src/ParallelizationRegions/parse_merge_dirs.cpp

@@ -0,0 +1,616 @@
+#include "parse_merge_dirs.h"
+
+#include <unordered_set>
+
+using std::map;
+using std::pair;
+using std::string;
+using std::unordered_map;
+using std::unordered_set;
+using std::vector;
+
+static void parseMergeDirective(const char *comment,
+                                vector<pair<string, string>> &parsed_mapping)
+{
+    while (comment)
+    {
+        auto *line_end = strchr(comment, '\n');
+
+        static const char prefix[] = "!!SPF TRANSFORM(MERGE_ARRAYS(";
+        static const auto compare_chars = sizeof(prefix) - 1;
+
+        if (strncasecmp(comment, prefix, compare_chars) == 0)
+        {
+            auto *pair_start = comment + compare_chars;
+            auto *comma = strchr(pair_start, ',');
+            if (comma)
+            {
+                auto *close_br = strchr(comma + 1, ')');
+                if (close_br)
+                {
+                    parsed_mapping.emplace_back(
+                        string(pair_start, comma - pair_start),
+                        string(comma + 1, close_br - comma - 1));
+                }
+            }
+        }
+
+        comment = line_end;
+
+        if (comment)
+            comment++;
+    }
+}
+
+static string getNonDefaultRegion(DIST::Array *a)
+{
+    string result;
+
+    if (!a)
+        return result;
+
+    for (const auto &reg_name : a->GetRegionsName())
+    {
+        if (reg_name != "default")
+        {
+            if (!result.empty())
+                printInternalError(convertFileName(__FILE__).c_str(), __LINE__);
+
+            result = reg_name;
+        }
+    }
+
+    return result;
+}
+
+static bool hasSameSizes(DIST::Array *a, DIST::Array *b)
+{
+    for (auto *array : {a, b})
+    {
+        for (const auto &p : array->GetSizes())
+        {
+            if (p.first < 0 || p.second < 0)
+                return false;
+        }
+    }
+
+    return a->GetSizes() == b->GetSizes() && a->GetTypeSize() == b->GetTypeSize();
+}
+
+static bool checkSimilarTemplates(vector<ParallelRegion *> &regions,
+                                  const unordered_map<string, string> &new_region_mapping)
+{
+    // new region -> old regions
+    unordered_map<string, unordered_set<string>> new_region_inverse_mapping;
+    for (const auto &p : new_region_mapping)
+        new_region_inverse_mapping[p.second].insert(p.first);
+
+    for (const auto &new_reg : new_region_inverse_mapping)
+    {
+        DIST::Array *template_array = nullptr;
+        string first_reg_name;
+
+        for (const auto &old_region_name : new_reg.second)
+        {
+            auto *old_reg = getRegionByName(regions, old_region_name);
+
+            if (!old_reg)
+                printInternalError(convertFileName(__FILE__).c_str(), __LINE__);
+
+            const auto &distr_rules = old_reg->GetDataDir().GetDistrRules();
+            if (distr_rules.size() != 1)
+                printInternalError(convertFileName(__FILE__).c_str(), __LINE__);
+
+            auto *current_template = distr_rules.front().first;
+
+            if (template_array)
+            {
+                if (!hasSameSizes(template_array, current_template))
+                {
+                    __spf_print(1, "Templates of %s and %s has different sizes\n",
+                                first_reg_name.c_str(),
+                                old_region_name.c_str());
+
+                    return false;
+                }
+                // else everything OK
+            }
+            else
+            {
+                template_array = current_template;
+                first_reg_name = old_region_name;
+            }
+        }
+    }
+
+    return true;
+}
+
+static bool hasSameAlignment(const std::unordered_set<const AlignRule *> &align_a,
+                             const std::unordered_set<const AlignRule *> &align_b)
+{
+    if (align_a.size() != 1 || align_b.size() != 1)
+        return false;
+
+    const auto *rule_a = *align_a.begin();
+    const auto *rule_b = *align_b.begin();
+
+    if (rule_a->alignRule != rule_b->alignRule)
+        return false;
+
+    return true;
+}
+
+static void printExpr(SgExpression *e, string pad)
+{
+    if (!e)
+        return;
+
+    __spf_print(1, "%s%d: %s\n", pad.c_str(), e->variant(), e->unparse());
+
+    printExpr(e->lhs(), pad + "  ");
+    printExpr(e->rhs(), pad + "  ");
+}
+
+static pair<vector<SgStatement *>, SgSymbol *> generateDeclaration(const string &array_name, const string &common_block_name,
+                                                                   const vector<pair<int, int>> &sizes, SgType *type, SgStatement *scope)
+{
+    auto *array_symbol = new SgSymbol(VARIABLE_NAME, array_name.c_str(), new SgType(T_ARRAY), scope);
+
+    auto *decl = new SgDeclarationStatement(VAR_DECL);
+
+    decl->setExpression(1, new SgTypeExp(*type));
+
+    SgExpression *subs = new SgExprListExp();
+
+    auto *array_ref = new SgArrayRefExp(*array_symbol, *subs);
+
+    for (int i = 0; i < sizes.size(); i++)
+    {
+        const auto &p = sizes[i];
+        auto *d = new SgExpression(DDOT, new SgValueExp(p.first), new SgValueExp(p.second));
+        subs->setLhs(d);
+
+        if (i + 1 < sizes.size())
+        {
+            subs->setRhs(new SgExprListExp());
+            subs = subs->rhs();
+        }
+    }
+
+    decl->setExpression(0, array_ref);
+
+    auto comm = new SgStatement(COMM_STAT);
+
+    comm->setExpression(0, new SgExpression(COMM_LIST,
+                                            new SgVarRefExp(array_symbol),
+                                            NULL,
+                                            new SgSymbol(COMMON_NAME, common_block_name.c_str())));
+
+    return {{decl, comm}, array_symbol};
+}
+
+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;
+}
+
+SgType* GetArrayType(DIST::Array *array)
+{
+    if (!array)
+        return NULL;
+
+    for (const auto& decl_place : array->GetDeclInfo())
+    {
+        if (SgFile::switchToFile(decl_place.first) != -1)
+        {
+            auto* decl = SgStatement::getStatementByFileAndLine(decl_place.first, decl_place.second);
+            if (decl)
+            {
+                for (int i = 0; i < 3; i++)
+                {
+                    auto* found_type = isSgTypeExp(findExprWithVariant(decl->expr(i), TYPE_OP));
+                    if (found_type)
+                        return found_type->type();
+                }
+            }
+        }
+    }
+
+    return NULL;
+}
+
+SgSymbol *insertDeclIfNeeded(const string &array_name,
+                             const string &common_block_name,
+                             DIST::Array *example_array,
+                             FuncInfo *dest,
+                             unordered_map<FuncInfo *, unordered_map<string, SgSymbol *>> &inserted_arrays)
+{
+    auto *type = GetArrayType(example_array);
+
+    if (!type)
+        printInternalError(convertFileName(__FILE__).c_str(), __LINE__);
+
+    if (SgFile::switchToFile(dest->fileName) == -1)
+        printInternalError(convertFileName(__FILE__).c_str(), __LINE__);
+
+    auto &by_func = inserted_arrays[dest];
+    auto it = by_func.find(array_name);
+
+    if (it != by_func.end())
+        return it->second;
+
+    SgStatement *st = dest->funcPointer;
+
+    auto *end = st->lastNodeOfStmt();
+
+    st = st->lexNext();
+
+    while (st != end && !isSgExecutableStatement(st))
+    {
+        st = st->lexNext();
+    }
+
+    auto generated = generateDeclaration(array_name, common_block_name,
+                                         example_array->GetSizes(),
+                                         type, dest->funcPointer);
+    for (auto *new_stmt : generated.first)
+        st->insertStmtBefore(*new_stmt, *dest->funcPointer);
+
+    by_func[array_name] = generated.second;
+
+    return generated.second;
+}
+
+static pair<string, string> createNewArray(DIST::Array *example_array, const string &base_name,
+                                           const map<string, vector<FuncInfo *>> &allFuncInfo,
+                                           unordered_map<FuncInfo *, unordered_map<string, SgSymbol *>> &inserted_arrays)
+{
+    auto common_block_name = base_name + "_merge_cb";
+    auto array_name = base_name;
+
+    for (const auto &by_file : allFuncInfo)
+    {
+        for (auto *func_info : by_file.second)
+        {
+            if (func_info->isMain)
+            {
+                insertDeclIfNeeded(
+                    array_name,
+                    common_block_name,
+                    example_array,
+                    func_info,
+                    inserted_arrays);
+            }
+        }
+    }
+
+    return std::make_pair(array_name, common_block_name);
+}
+
+static void replaceArrayRec(SgExpression *e,
+                            const unordered_set<string> &arrays_to_replace,
+                            SgSymbol **func_symbol_hint,
+                            const pair<string, string> &replace_by,
+                            DIST::Array *example_array,
+                            FuncInfo *func,
+                            unordered_map<FuncInfo *, unordered_map<string, SgSymbol *>> &inserted_arrays)
+{
+    if (!e)
+        return;
+
+    if (isArrayRef(e) && arrays_to_replace.find(e->symbol()->identifier()) != arrays_to_replace.end())
+    {
+        if (!(*func_symbol_hint))
+        {
+            *func_symbol_hint = insertDeclIfNeeded(
+                replace_by.first, replace_by.second,
+                example_array,
+                func,
+                inserted_arrays);
+        }
+
+        e->setSymbol(*func_symbol_hint);
+    }
+
+    replaceArrayRec(
+        e->lhs(),
+        arrays_to_replace,
+        func_symbol_hint,
+        replace_by,
+        example_array,
+        func,
+        inserted_arrays);
+
+    replaceArrayRec(
+        e->rhs(),
+        arrays_to_replace,
+        func_symbol_hint,
+        replace_by,
+        example_array,
+        func,
+        inserted_arrays);
+}
+
+static void replaceRegion(SgStatement* st, const unordered_map<string, string> &new_region_mapping)
+{
+    if (!st)
+        return;
+
+    if(isSPF_stat(st) && st->variant() == SPF_PARALLEL_REG_DIR)
+    {
+        auto it = new_region_mapping.find(st->symbol()->identifier());
+
+        if (it != new_region_mapping.end())
+            st->setSymbol(*(new SgSymbol(CONST_NAME, it->second.c_str())));
+    }
+}
+
+void mergeCopyArrays(vector<ParallelRegion *> &regions, const map<string, vector<FuncInfo *>> &allFuncInfo)
+{
+    for (const auto *region : regions)
+    {
+        __spf_print(1, "region %s\n", region->GetName().c_str());
+
+        const auto &dirs = region->GetDataDir();
+
+        __spf_print(1, "  distr rules: %d\n", dirs.distrRules.size());
+
+        const auto &currentVariant = region->GetCurrentVariant();
+
+        int distr_idx = 0;
+        for (const auto &distr : dirs.distrRules)
+        {
+            const auto &dist_rule = distr.second.back().distRule;
+
+            string sizes;
+            for (const auto &p : distr.first->GetSizes())
+            {
+                if (!sizes.empty())
+                    sizes.push_back(',');
+
+                sizes += std::to_string(p.first) + ":" + std::to_string(p.second);
+            }
+
+            __spf_print(1, "      DIST %s(%s)", distr.first->GetName().c_str(), sizes.c_str());
+            for (const auto &dim : dist_rule)
+                __spf_print(1, " %c", dim == dist::BLOCK ? 'B' : '*');
+
+            __spf_print(1, "\n");
+            distr_idx++;
+        }
+
+        __spf_print(1, "  align rules: %d\n", dirs.alignRules.size());
+
+        for (const auto &align : dirs.alignRules)
+        {
+            string sub_a, sub_b;
+
+            int i = 0;
+            for (const auto coefs : align.alignRule)
+            {
+                if (!sub_a.empty())
+                    sub_a.push_back(',');
+
+                sub_a += std::to_string(coefs.first) + "*i" +
+                         std::to_string(i) + "+" + std::to_string(coefs.second);
+
+                i++;
+            }
+
+            for (const auto coefs : align.alignRuleWith)
+            {
+                if (!sub_b.empty())
+                    sub_b.push_back(',');
+
+                sub_b += std::to_string(coefs.second.first) + "*i" +
+                         std::to_string(coefs.first) + "+" + std::to_string(coefs.second.second);
+            }
+
+            __spf_print(1, "      ALIGN %s(%s) WITH %s(%s)\n",
+                        align.alignArray->GetName().c_str(), sub_a.c_str(),
+                        align.alignWith->GetName().c_str(), sub_b.c_str());
+        }
+    }
+
+    // parse directives
+
+    // new array name -> current arrays
+    unordered_map<string, unordered_set<DIST::Array *>> arrays_to_merge;
+    unordered_map<DIST::Array *, unordered_set<const AlignRule *>> array_alignment;
+
+    for (const auto &by_file : allFuncInfo)
+    {
+        const auto current_file_name = by_file.first;
+
+        if (SgFile::switchToFile(current_file_name) == -1)
+            printInternalError(convertFileName(__FILE__).c_str(), __LINE__);
+
+        for (auto *func_info : by_file.second)
+        {
+            SgStatement *curr_stmt = func_info->funcPointer;
+            if (!curr_stmt)
+                continue;
+
+            auto *stmt_end = curr_stmt->lastDeclaration();
+            if (!stmt_end)
+                continue;
+
+            stmt_end = stmt_end->lexNext();
+
+            for (; curr_stmt && curr_stmt != stmt_end; curr_stmt = curr_stmt->lexNext())
+            {
+                if (curr_stmt->comments())
+                {
+                    vector<pair<string, string>> parsed_mapping;
+                    parseMergeDirective(curr_stmt->comments(), parsed_mapping);
+
+                    for (const auto &p : parsed_mapping)
+                    {
+                        auto *found_array = getArrayFromDeclarated(curr_stmt, p.first);
+                        if (found_array)
+                        {
+                            arrays_to_merge[p.second].insert(found_array);
+                            array_alignment[found_array] = {};
+                        }
+                    }
+                }
+            }
+        }
+    }
+
+    // find alignment rules for array
+
+    for (const auto *region : regions)
+    {
+        const auto &dirs = region->GetDataDir();
+
+        for (const auto &align : dirs.alignRules)
+        {
+            auto it = array_alignment.find(align.alignArray);
+
+            if (it != array_alignment.end())
+                it->second.insert(&align);
+        }
+    }
+
+    // old region -> new region
+    unordered_map<string, string> new_region_mapping;
+
+    // new array -> new region
+    unordered_map<string, string> arrays_new_region_mapping;
+    vector<string> created_region_names;
+
+    for (const auto &by_new_array : arrays_to_merge)
+    {
+        string new_region_name;
+        for (auto *current_array : by_new_array.second)
+        {
+            auto current_array_region = getNonDefaultRegion(current_array);
+            auto it = new_region_mapping.find(current_array_region);
+            if (it != new_region_mapping.end())
+            {
+                if (new_region_name.empty())
+                    new_region_name = it->second;
+                else if (new_region_name != it->second)
+                    printInternalError(convertFileName(__FILE__).c_str(), __LINE__);
+            }
+        }
+
+        if (new_region_name.empty())
+        {
+            new_region_name = "merged_reg_" + std::to_string(created_region_names.size());
+            created_region_names.push_back(new_region_name);
+        }
+
+        for (auto *current_array : by_new_array.second)
+        {
+            auto current_array_region = getNonDefaultRegion(current_array);
+            new_region_mapping[current_array_region] = new_region_name;
+        }
+
+        arrays_new_region_mapping[by_new_array.first] = new_region_name;
+    }
+
+    if (!checkSimilarTemplates(regions, new_region_mapping))
+        printInternalError(convertFileName(__FILE__).c_str(), __LINE__);
+
+    unordered_map<FuncInfo *, unordered_map<string, SgSymbol *>> inserted_arrays;
+
+    for (const auto &by_dest_array : arrays_to_merge)
+    {
+        const auto &copy_arrays = by_dest_array.second;
+
+        if (copy_arrays.empty())
+            printInternalError(convertFileName(__FILE__).c_str(), __LINE__);
+
+        auto *first_element = *copy_arrays.begin();
+        auto first_elem_rules_it = array_alignment.find(first_element);
+
+        if (first_elem_rules_it == array_alignment.end())
+            continue;
+
+        const auto &first_elem_rules = first_elem_rules_it->second;
+
+        for (auto *array_to_merge : copy_arrays)
+        {
+            auto array_rules_it = array_alignment.find(array_to_merge);
+
+            if (array_rules_it == array_alignment.end())
+                printInternalError(convertFileName(__FILE__).c_str(), __LINE__);
+
+            const auto &array_rules = array_rules_it->second;
+
+            if (!hasSameSizes(array_to_merge, first_element) || !hasSameAlignment(first_elem_rules, array_rules))
+            {
+                __spf_print(1, "Arrays %s and %s has different sizes or align rules\n",
+                            array_to_merge->GetName().c_str(),
+                            first_element->GetName().c_str());
+
+                printInternalError(convertFileName(__FILE__).c_str(), __LINE__);
+            }
+        }
+
+        __spf_print(1, "merge into %s (%s):\n", by_dest_array.first.c_str(), arrays_new_region_mapping[by_dest_array.first].c_str());
+        for (auto *array_to_merge : copy_arrays)
+            __spf_print(1, "%s\n", array_to_merge->GetName().c_str());
+
+        auto created_array_info = createNewArray(first_element, by_dest_array.first, allFuncInfo, inserted_arrays);
+
+        unordered_set<string> arrays_to_replace;
+        for (auto *array_to_merge : copy_arrays)
+            arrays_to_replace.insert(array_to_merge->GetShortName());
+
+        for (const auto &by_file : allFuncInfo)
+        {
+            if (SgFile::switchToFile(by_file.first) == -1)
+                printInternalError(convertFileName(__FILE__).c_str(), __LINE__);
+
+            for (auto *func_info : by_file.second)
+            {
+                SgSymbol *func_symbol_hint = nullptr;
+                SgStatement *st = func_info->funcPointer;
+
+                auto *func_end = st->lastNodeOfStmt();
+
+                st = st->lexNext();
+
+                while (st && !isSgExecutableStatement(st) && st != func_end)
+                    st = st->lexNext();
+
+                while (st && st != func_end)
+                {
+                    for (int i = 0; i < 3; i++)
+                    {
+                        replaceArrayRec(
+                            st->expr(i),
+                            arrays_to_replace,
+                            &func_symbol_hint,
+                            created_array_info,
+                            first_element,
+                            func_info,
+                            inserted_arrays);
+                    }
+
+                    replaceRegion(st, new_region_mapping);
+
+                    st = st->lexNext();
+                }
+            }
+        }
+    }
+}

src/ParallelizationRegions/parse_merge_dirs.h

@@ -0,0 +1,8 @@
+#include "../GraphCall/graph_calls.h"
+#include "ParRegions.h"
+
+#include <string>
+#include <vector>
+#include <map>
+
+void mergeCopyArrays(std::vector<ParallelRegion*> &regions, const std::map<std::string, std::vector<FuncInfo*>> &allFuncInfo);

src/Sapfor.cpp

@@ -23,6 +23,7 @@
 #include "ParallelizationRegions/ParRegions_func.h"
 #include "ParallelizationRegions/resolve_par_reg_conflicts.h"
 #include "ParallelizationRegions/expand_extract_reg.h"
+#include "ParallelizationRegions/parse_merge_dirs.h"
 
 #include "Distribution/Distribution.h"
 #include "Distribution/GraphCSR.h"
@@ -1922,6 +1923,10 @@ static bool runAnalysis(SgProject &project, const int curr_regime, const bool ne
         transformAssumedSizeParameters(allFuncInfo);
     else if (curr_regime == FIND_PRIVATE_ARRAYS_ANALYSIS)
         FindPrivateArrays(loopGraph, fullIR, insertedPrivates);
+    else if (curr_regime == MERGE_COPY_ARRAYS)
+    {
+        mergeCopyArrays(parallelRegions, allFuncInfo);
+    }
 
     else if (curr_regime == ARRAY_PROPAGATION)
         ArrayConstantPropagation(project);
@@ -2379,6 +2384,7 @@ void runPass(const int curr_regime, const char *proj_name, const char *folderNam
     case FIX_COMMON_BLOCKS:
     case TEST_PASS:
     case SET_IMPLICIT_NONE:
+    case MERGE_COPY_ARRAYS:
         runAnalysis(*project, curr_regime, false);
     case SUBST_EXPR_RD_AND_UNPARSE:
     case SUBST_EXPR_AND_UNPARSE:

src/Sapfor.h

@@ -88,6 +88,8 @@ enum passes {
     REMOVE_DVM_INTERVALS,
     VERIFY_DVM_DIRS,
 
+    MERGE_COPY_ARRAYS,
+
     REMOVE_DIST_ARRAYS_FROM_IO,
 
     SUBST_EXPR,
@@ -273,6 +275,7 @@ static void setPassValues()
     passNames[VERIFY_DVM_DIRS] = "VERIFY_DVM_DIRS";
     passNames[REMOVE_DVM_DIRS_TO_COMMENTS] = "REMOVE_DVM_DIRS_TO_COMMENTS";
     passNames[REMOVE_SPF_DIRS] = "REMOVE_SPF_DIRS";
+    passNames[MERGE_COPY_ARRAYS] = "MERGE_COPY_ARRAYS";
     passNames[REMOVE_DIST_ARRAYS_FROM_IO] = "REMOVE_DIST_ARRAYS_FROM_IO";
     passNames[SUBST_EXPR] = "SUBST_EXPR";
     passNames[SUBST_EXPR_RD] = "SUBST_EXPR_RD";

src/Transformations/GlobalVariables/fix_common_blocks.cpp

@@ -18,69 +18,66 @@ using std::tuple;
 
 /// main function:
 // renew unions for all common blocks in the file
-static void BuildNewCommDecls(SgFile* file, const map<string, CommonBlock*> allCommonBlocks,
-    map<string, deque<CommConstraint>>& newCommonDecls, map<string, map<string, deque<CommConstraint>>>& commDecls,
-    set<string>& badCommon, map<string, set<string>>& notUsedVars, vector<SgStatement*>& programUnits);
+//void BuildNewCommDecls
 
 // get names of variables and array elements, which were referenced in programm unit
-static set<string> getUses(SgStatement* firstSt, const set<string>& commonVarNames);
-static void getUsesFromExpr(SgExpression* expr, const set<string>& commonVarNames, set<string>& used);
+//set<string> getUses
+//void getUsesFromExpr
 
 // splits arrays into elements and replaces not used vars with empty constraints
-static bool splitType(deque<CommConstraint>& d, bool check_use, const set<string>& namesOfUsedVars);
+//bool splitType
+ 
 // create constraits set
-static deque<CommConstraint> makeConstraints(deque<CommConstraint>& constraints, const set<string>& namesOfUsedVars, set<string>& notUsedVars);
+//deque<CommConstraint> makeConstraints
+ 
 // build union
-static bool buildConstraintsUnion(deque<CommConstraint>& U, deque<CommConstraint> B, const set<string>& namesOfUsedVars, pair<CommConstraint, CommConstraint>& problemConstraints);
-static bool docheckUnequalConstraints(deque<CommConstraint>& U, deque<CommConstraint>& B, deque<CommConstraint>& newU, pair<CommConstraint, CommConstraint>& problemConstraints);
-static bool check(deque<CommConstraint>& A, deque<CommConstraint>& B, pair<CommConstraint, CommConstraint>& problemConstraints);
+//bool buildConstraintsUnion
+//bool docheckUnequalConstraints
+//bool check
 
 /// small help functions:
-static string getParentName(const string& name);
-static bool equalDims(const CommConstraint& a, const CommConstraint& b);
-static bool equalConstraints(const CommConstraint& a, const CommConstraint& b);
-static void addElem(deque<CommConstraint>& comm, const CommConstraint& elem);
-//////
+//string getParentName
+//bool equalDims
+//bool equalConstraints
+//void addElem
 
 // change names of variables in 'constraints'
-static void fixNames(deque<CommConstraint>& constraints, const string& commName);
+//void fixNames
 
 ////// step2: transformation
-
 /// main function
 // peform transformation on every program unit in the file
-static void fixFunctions(SgFile* file, vector<SgStatement*> programUnits, map<string, deque<CommConstraint>>& newCommonDecls,
-    map<string, map<string, deque<CommConstraint>>>& commDecls, const set<string>& badCommon, map<string, set<string>>& notUsedVars);
+//void fixFunctions
 
 // get pairs of names (namesOldToNew) for renaming
-static bool getNamesOldToNew(deque<CommConstraint> newDecl, deque<CommConstraint> oldDecl, map<string, string>& namesOldToNew);
+//bool getNamesOldToNew
 
 // create new symbols for new variables in new common declaration (constraints)
-static void makeCommVarSymbs(const deque<CommConstraint>& constraints, SgFile* file, SgStatement* func, string commName,
-    map<string, SgSymbol*>& symbs, vector<SgSymbol*>& needNewDecl);
+//void makeCommVarSymbs
+
 // delete from program unit all references to names in commVarNames
-static void deleteOldVars(SgStatement* firstSt, const set<string>& commVarNames);
+//void deleteOldVars
 
 // calls fixExpression for each statement, replaces names in data statement
-static void renameVariables(SgStatement* firstSt, const map<string, SgSymbol*>& newVarSymbs, const map<string, string>& namesOldToNew);
+//void renameVariables
+
 // replacing variables or array elements in expression expr if their names are in namesOldToNew
-static SgExpression* fixExpression(SgExpression* expr, const map<string, SgSymbol*>& newSymbs, const map<string, string>& namesOldToNew);
+//SgExpression* fixExpression
 
 // make new exprList exprssion for new declaration decl with symbols from newSymbs
-static SgExpression* makeExprListForCommon(const deque<CommConstraint>& decl, const map<string, SgSymbol*>& newSymbs,
-    SgFile* file, SgStatement* firstSt);
+//SgExpression* makeExprListForCommon
+
 // replace old common declarations with new ones
-static void rewriteCommon(SgStatement* firstSt, map<string, SgExpression*>& commListExprs);
+//void rewriteCommon
 
 /// help functions:
-static SgExpression* makeIdxFromStr(const string& str);
+//SgExpression* makeIdxFromStr(const string& str);
+
 // make new expression of array element
-static SgExpression* newArrElemExpr(const string& newName, const map<string, SgSymbol*>& newSymbs);
-static bool variablePositionComp(const Variable* lhs, const Variable* rhs);
+//SgExpression* newArrElemExpr
+//bool variablePositionComp
 //////
 
-
-
 CommConstraint::CommConstraint(const Variable* var, bool u, const string& funcName, const string& fileName)
 {
     used = u;
@@ -125,7 +122,6 @@ CommConstraint::CommConstraint(const Variable* var, bool u, const string& funcNa
     }
 }
 
-
 CommConstraint::CommConstraint(const string& name, SgType* t, bool u) : used(u), type(t), identifier(name)
 {
     typeVariant = type->variant();
@@ -139,8 +135,7 @@ CommConstraint::CommConstraint(const string& name, SgType* t, bool u, vector<Dec
     size = getSizeOfType(type);
 }
 
-
-string getParentName(const string& name)
+static string getParentName(const string& name)
 {
     size_t len = name.find("%");
     size_t posB = name.find("(");
@@ -154,8 +149,7 @@ string getParentName(const string& name)
     return name.substr(0, len);
 }
 
-
-void getUsesFromExpr(SgExpression* expr, const set<string>& commonVarNames, set<string>& used)
+static void getUsesFromExpr(SgExpression* expr, const set<string>& commonVarNames, set<string>& used)
 {
     if (expr == NULL)
         return;
@@ -194,8 +188,7 @@ void getUsesFromExpr(SgExpression* expr, const set<string>& commonVarNames, set<
     getUsesFromExpr(expr->rhs(), commonVarNames, used);
 }
 
-
-set<string> getUses(SgStatement* firstSt, const set<string>& commonVarNames)
+static set<string> getUses(SgStatement* firstSt, const set<string>& commonVarNames)
 {
     set<string> used;
     SgStatement* lastSt = firstSt->lastNodeOfStmt();
@@ -212,8 +205,7 @@ set<string> getUses(SgStatement* firstSt, const set<string>& commonVarNames)
     return used;
 }
 
-
-bool equalDims(const CommConstraint& a, const CommConstraint& b)
+static bool equalDims(const CommConstraint& a, const CommConstraint& b)
 {
     const vector<pair<int, int>>& adim = a.arrayInfo->GetSizes();
     const vector<pair<int, int>>& bdim = b.arrayInfo->GetSizes();
@@ -228,9 +220,8 @@ bool equalDims(const CommConstraint& a, const CommConstraint& b)
     return true;
 }
 
-
 // TODO: add attributes to CommConstraints, check if a and b have equal attributes
-bool equalConstraints(const CommConstraint& a, const CommConstraint& b)
+static bool equalConstraints(const CommConstraint& a, const CommConstraint& b)
 {
     if ((a.arrayInfo != NULL && b.arrayInfo == NULL) || ((a.arrayInfo == NULL && b.arrayInfo != NULL)))
         return false;
@@ -241,8 +232,7 @@ bool equalConstraints(const CommConstraint& a, const CommConstraint& b)
     return true;
 }
 
-
-void addElem(deque<CommConstraint>& comm, const CommConstraint& elem)
+static void addElem(deque<CommConstraint>& comm, const CommConstraint& elem)
 {
     if (elem.typeVariant == 0 && !comm.empty() && comm.back().typeVariant == 0)
         comm.back().size += elem.size;
@@ -250,9 +240,8 @@ void addElem(deque<CommConstraint>& comm, const CommConstraint& elem)
         comm.push_back(elem);
 }
 
-
 // TODO: check attributes: do not split arrays with pointer or target attributes if check_use == true
-bool splitType(deque<CommConstraint>& d, bool check_use, const set<string>& namesOfUsedVars = {})
+static bool splitType(deque<CommConstraint>& d, bool check_use, const set<string>& namesOfUsedVars = {})
 {
     CommConstraint var = d.front();
     string name = var.identifier;
@@ -300,8 +289,7 @@ bool splitType(deque<CommConstraint>& d, bool check_use, const set<string>& name
     }
 }
 
-
-deque<CommConstraint> makeConstraints(deque<CommConstraint>& constraints, const set<string>& namesOfUsedVars, set<string>& notUsedVars)
+static deque<CommConstraint> makeConstraints(deque<CommConstraint>& constraints, const set<string>& namesOfUsedVars, set<string>& notUsedVars)
 {
     deque<CommConstraint> res;
     while (!constraints.empty())
@@ -318,8 +306,7 @@ deque<CommConstraint> makeConstraints(deque<CommConstraint>& constraints, const
     return res;
 }
 
-
-bool check(deque<CommConstraint>& A, deque<CommConstraint>& B, pair<CommConstraint, CommConstraint>& problemConstraints)
+static bool check(deque<CommConstraint>& A, deque<CommConstraint>& B, pair<CommConstraint, CommConstraint>& problemConstraints)
 {
     while (!A.empty() && !B.empty())
     {
@@ -358,8 +345,8 @@ bool check(deque<CommConstraint>& A, deque<CommConstraint>& B, pair<CommConstrai
     return true;
 }
 
-
-bool docheckUnequalConstraints(deque<CommConstraint>& U, deque<CommConstraint>& B, deque<CommConstraint>& newU, pair<CommConstraint, CommConstraint>& problemConstraints)
+static bool docheckUnequalConstraints(deque<CommConstraint>& U, deque<CommConstraint>& B, deque<CommConstraint>& newU, 
+                                      pair<CommConstraint, CommConstraint>& problemConstraints)
 {
     if (U.front().typeVariant == 0)
     {
@@ -382,8 +369,8 @@ bool docheckUnequalConstraints(deque<CommConstraint>& U, deque<CommConstraint>&
     return true;
 }
 
-
-bool buildConstraintsUnion(deque<CommConstraint>& U, deque<CommConstraint> B, const set<string>& namesOfUsedVars, pair<CommConstraint, CommConstraint>& problemConstraints)
+static bool buildConstraintsUnion(deque<CommConstraint>& U, deque<CommConstraint> B, 
+                                  const set<string>& namesOfUsedVars, pair<CommConstraint, CommConstraint>& problemConstraints)
 {
     deque<CommConstraint> newU;
     while (!U.empty() && !B.empty())
@@ -438,8 +425,8 @@ bool buildConstraintsUnion(deque<CommConstraint>& U, deque<CommConstraint> B, co
     return true;
 }
 
-
-bool getNamesOldToNew(deque<CommConstraint> newDecl, deque<CommConstraint> oldDecl, map<string, string>& namesOldToNew)
+//TODO: check this: newDecl and oldDecl => do these variables need references?
+static bool getNamesOldToNew(deque<CommConstraint> newDecl, deque<CommConstraint> oldDecl, map<string, string>& namesOldToNew)
 {
     bool needChange = false;
     map<string, string> rename;
@@ -504,15 +491,17 @@ bool getNamesOldToNew(deque<CommConstraint> newDecl, deque<CommConstraint> oldDe
             newDecl.pop_front();
         }
     }
+
     if (!oldDecl.empty() || !newDecl.empty())
         needChange = true;
+
     if (needChange)
         namesOldToNew.insert(rename.begin(), rename.end());
+
     return needChange;
 }
 
-
-void makeCommVarSymbs(const deque<CommConstraint>& constraints, SgFile* file, SgStatement* func, string commName,
+static void makeCommVarSymbs(const deque<CommConstraint>& constraints, SgFile* file, SgStatement* func, const string& commName,
                              map<string, SgSymbol*>& symbs, vector<SgSymbol*>& needNewDecl)
 {
     for (const CommConstraint& var : constraints)
@@ -526,8 +515,7 @@ void makeCommVarSymbs(const deque<CommConstraint>& constraints, SgFile* file, Sg
     }
 }
 
-
-void deleteOldVars(SgStatement* firstSt, const set<string>& commVarNames)
+static void deleteOldVars(SgStatement* firstSt, const set<string>& commVarNames)
 {
     SgStatement* lastSt = firstSt->lastNodeOfStmt();
     vector<SgStatement*> stmtsToDelete;
@@ -573,12 +561,12 @@ void deleteOldVars(SgStatement* firstSt, const set<string>& commVarNames)
         }
         // TODO: delete common variables form attributes statements (like DIM_STAT)
     }
+
     for (SgStatement* st : stmtsToDelete)
         st->deleteStmt();
 }
 
-
-SgExpression* makeIdxFromStr(const string& str)
+static SgExpression* makeIdxFromStr(const string& str)
 {
     vector<SgExpression*> items;
     int num = 0;
@@ -593,13 +581,13 @@ SgExpression* makeIdxFromStr(const string& str)
             num = 0;
         }
     }
+
     reverse(items.begin(), items.end());
     SgExpression* exprList = makeExprList(items, false);
     return exprList;
 }
 
-
-SgExpression* newArrElemExpr(const string& newName, const map<string, SgSymbol*>& newSymbs)
+static SgExpression* newArrElemExpr(const string& newName, const map<string, SgSymbol*>& newSymbs)
 {
     size_t pos = newName.find('(');
     SgExpression* newExpr = new SgArrayRefExp(*newSymbs.at(newName.substr(0, pos)));
@@ -607,11 +595,11 @@ SgExpression* newArrElemExpr(const string& newName, const map<string, SgSymbol*>
     return newExpr;
 }
 
-
-SgExpression* fixExpression(SgExpression* expr, const map<string, SgSymbol*>& newSymbs, const map<string, string>& namesOldToNew)
+static SgExpression* fixExpression(SgExpression* expr, const map<string, SgSymbol*>& newSymbs, const map<string, string>& namesOldToNew)
 {
     if (expr == NULL)
         return NULL;
+
     if (expr->variant() == VAR_REF || expr->variant() == ARRAY_REF)
     {
         string name = expr->symbol()->identifier();
@@ -647,17 +635,18 @@ SgExpression* fixExpression(SgExpression* expr, const map<string, SgSymbol*>& ne
             }
         }
     }
+
     SgExpression* lhs = fixExpression(expr->lhs(), newSymbs, namesOldToNew);
     if (lhs != NULL)
         expr->setLhs(lhs);
+
     SgExpression* rhs = fixExpression(expr->rhs(), newSymbs, namesOldToNew);
     if (rhs != NULL)
         expr->setRhs(rhs);
     return NULL;
 }
 
-
-void renameVariables(SgStatement* firstSt, const map<string, SgSymbol*>& newVarSymbs, const map<string, string>& namesOldToNew)
+static void renameVariables(SgStatement* firstSt, const map<string, SgSymbol*>& newVarSymbs, const map<string, string>& namesOldToNew)
 {
     SgStatement* lastSt = firstSt->lastNodeOfStmt();
     for (SgStatement* curSt = firstSt; curSt != NULL && curSt != lastSt; curSt = curSt->lexNext())
@@ -705,8 +694,7 @@ void renameVariables(SgStatement* firstSt, const map<string, SgSymbol*>& newVarS
     }
 }
 
-
-SgExpression* makeExprListForCommon(const deque<CommConstraint>& decl, const map<string, SgSymbol*>& newSymbs,
+static SgExpression* makeExprListForCommon(const deque<CommConstraint>& decl, const map<string, SgSymbol*>& newSymbs,
     SgFile* file, SgStatement* firstSt)
 {
     vector<SgExpression*> items;
@@ -740,8 +728,7 @@ SgExpression* makeExprListForCommon(const deque<CommConstraint>& decl, const map
     return exprList;
 }
 
-
-void rewriteCommon(SgStatement* firstSt, map<string, SgExpression*>& commListExprs)
+static void rewriteCommon(SgStatement* firstSt, map<string, SgExpression*>& commListExprs)
 {
     vector<SgStatement*> commonStmtsToDelete;
     for (SgStatement* st = firstSt; st != firstSt->lastDeclaration()->lexNext(); st = st->lexNext())
@@ -792,12 +779,12 @@ void rewriteCommon(SgStatement* firstSt, map<string, SgExpression*>& commListExp
                 commonStmtsToDelete.push_back(st);
         }
     }
+
     for (SgStatement* st : commonStmtsToDelete)
         st->deleteStmt();
 }
 
-
-void fixNames(deque<CommConstraint>& constraints, const string& commName)
+static void fixNames(deque<CommConstraint>& constraints, const string& commName)
 {
     for (auto& var : constraints)
     {
@@ -812,14 +799,12 @@ void fixNames(deque<CommConstraint>& constraints, const string& commName)
     }
 }
 
-
-bool variablePositionComp(const Variable* lhs, const Variable* rhs)
+static bool variablePositionComp(const Variable* lhs, const Variable* rhs)
 {
     return lhs->getPosition() < rhs->getPosition();
 }
 
-
-void fixFunctions(SgFile* file, vector<SgStatement*> programUnits, map<string, deque<CommConstraint>>& newCommonDecls,
+static void fixFunctions(SgFile* file, const vector<SgStatement*>& programUnits, map<string, deque<CommConstraint>>& newCommonDecls,
                          map<string, map<string, deque<CommConstraint>>>& commDecls, const set<string>& badCommon, map<string, set<string>>& notUsedVars)
 {
     for (SgStatement* unitSt : programUnits)
@@ -827,11 +812,13 @@ void fixFunctions(SgFile* file, vector<SgStatement*> programUnits, map<string, d
         string funcName = unitSt->symbol()->identifier();
         if (commDecls.find(funcName) == commDecls.end())
             continue;
+
         SgStatement* firstSt = unitSt;
         map<string, SgExpression*> commListExprs;
         map<string, SgSymbol*> newVarSymbs; // new symbols for new variables
         map<string, string> namesOldToNew; // for ranaming: old name -> new name
         vector<SgSymbol*> needNewDecl;
+
         for (auto& common : commDecls[funcName])
         {
             string commName = common.first;
@@ -842,9 +829,11 @@ void fixFunctions(SgFile* file, vector<SgStatement*> programUnits, map<string, d
             bool needChange = getNamesOldToNew(newDecl, common.second, namesOldToNew);
             if (!needChange)
                 continue;
+
             makeCommVarSymbs(newDecl, file, firstSt, commName, newVarSymbs, needNewDecl);
             commListExprs[commName] = makeExprListForCommon(newDecl, newVarSymbs, file, firstSt);
         }
+
         if (!commListExprs.empty())
         {
             for (const auto& item : commListExprs)
@@ -858,8 +847,7 @@ void fixFunctions(SgFile* file, vector<SgStatement*> programUnits, map<string, d
     }
 }
 
-
-void BuildNewCommDecls(SgFile* file, const map<string, CommonBlock*> allCommonBlocks,
+static void buildNewCommDecls(SgFile* file, const map<string, CommonBlock*>& allCommonBlocks,
                               map<string, deque<CommConstraint>>& newCommonDecls, map<string, map<string, deque<CommConstraint>>>& commDecls,
                               set<string>& badCommon, map<string, set<string>>& notUsedVars, vector<SgStatement*>& programUnits)
 {
@@ -900,7 +888,8 @@ void BuildNewCommDecls(SgFile* file, const map<string, CommonBlock*> allCommonBl
                     constraints.push_back(newConstr);
                 }
                 if (hasChar && hasNotChar)  // TDOO: make proper warning message or separate such common blocks
-                    __spf_print(1, "common block '%s' ('%s':%d) contains variables of symbolic and numeric types. It is required to divide\n", commName.c_str(), fileName.c_str(), constraints.back().uses.back().lineNum);
+                    __spf_print(1, "common block '%s' ('%s':%d) contains variables of symbolic and numeric types. It is required to divide\n", 
+                                    commName.c_str(), fileName.c_str(), constraints.back().uses.back().getLineNum());
                 if (hasChar)
                 {
                     badCommon.insert(commName);
@@ -917,7 +906,7 @@ void BuildNewCommDecls(SgFile* file, const map<string, CommonBlock*> allCommonBl
                     for (auto x : problemConstraints.first.uses)         // TODO: make proper warning message
                         for (auto y : problemConstraints.second.uses)
                             __spf_print(1, "variables '%s' and '%s' in one storage association (common block '%s') have different types (files - %s:%d and %s:%d)\n",
-                                x.varName.c_str(), y.varName.c_str(), commName.c_str(), x.fileName.c_str(), x.lineNum, y.fileName.c_str(), y.lineNum);
+                                            x.getVarName(), y.getVarName(), commName.c_str(), x.getFileName(), x.getLineNum(), y.getFileName(), y.getLineNum());
                 }
             }
             curSt = curSt->lastNodeOfStmt();
@@ -929,7 +918,7 @@ void BuildNewCommDecls(SgFile* file, const map<string, CommonBlock*> allCommonBl
 
 
 // main function
-void fixCommonBlocks(const map<string, vector<FuncInfo*>> allFuncInfo, const map<string, CommonBlock*> allCommonBlocks, SgProject* project)  // TODO: separate into 2 steps?
+void fixCommonBlocks(const map<string, vector<FuncInfo*>>& allFuncInfo, const map<string, CommonBlock*>& allCommonBlocks, SgProject* project)  // TODO: separate into 2 steps?
 {
     int filesNum = project->numberOfFiles();
     map<string, map<string, map<string, deque<CommConstraint>>>> commDecls; // file_name -> function_name -> common block name -> old declaration of common block
@@ -943,10 +932,12 @@ void fixCommonBlocks(const map<string, vector<FuncInfo*>> allFuncInfo, const map
         SgFile* file = &project->file(i);
         string fileName = file->filename();
         file->switchToFile(fileName);
-        BuildNewCommDecls(file, allCommonBlocks, newCommonDecls, commDecls[fileName], badCommon, notUsedVars, programUnitsInFile[fileName]);
+        buildNewCommDecls(file, allCommonBlocks, newCommonDecls, commDecls[fileName], badCommon, notUsedVars, programUnitsInFile[fileName]);
     }
+
     for (auto& elem : newCommonDecls)
         fixNames(elem.second, elem.first);
+
     for (int i = 0; i < filesNum; i++)  // second step
     {
         SgFile* file = &project->file(i);

src/Transformations/GlobalVariables/fix_common_blocks.h

@@ -16,12 +16,18 @@
 
 struct DeclInfo // for error messages
 {
+private:
     std::string varName;
     std::string fileName;
     int lineNum;
 
+public:
     DeclInfo() : varName(""), fileName(""), lineNum(0) {};
     DeclInfo(const std::string& vn, const std::string& fn, int ln) : varName(vn), fileName(fn), lineNum(ln) {};
+
+    const char* getVarName() const { return varName.c_str(); }
+    const char* getFileName() const { return fileName.c_str(); }
+    int getLineNum() const { return lineNum; }
 };
 
 struct CommConstraint  // TODO: add variable attributes
@@ -42,4 +48,4 @@ struct CommConstraint  // TODO: add variable attributes
 };
 
 
-void fixCommonBlocks(const std::map<std::string, std::vector<FuncInfo*>> allFuncInfo, const std::map<std::string, CommonBlock*> allCommonBlocks, SgProject* project);
+void fixCommonBlocks(const std::map<std::string, std::vector<FuncInfo*>>& allFuncInfo, const std::map<std::string, CommonBlock*>& allCommonBlocks, SgProject* project);

src/Utils/PassManager.h

@@ -322,6 +322,7 @@ void InitPassesDependencies(map<passes, vector<passes>> &passDepsIn, set<passes>
     list({ FIND_PRIVATE_ARRAYS_ANALYSIS, CONVERT_LOOP_TO_ASSIGN, RESTORE_LOOP_FROM_ASSIGN, REVERT_SUBST_EXPR_RD }) <= Pass(FIND_PRIVATE_ARRAYS);
 
     list({ BUILD_IR, CALL_GRAPH2, RESTORE_LOOP_FROM_ASSIGN, REVERT_SUBST_EXPR_RD }) <= Pass(MOVE_OPERATORS);
+    Pass(CREATE_TEMPLATE_LINKS) <= Pass(MERGE_COPY_ARRAYS);
 
     passesIgnoreStateDone.insert({ CREATE_PARALLEL_DIRS, INSERT_PARALLEL_DIRS, INSERT_SHADOW_DIRS, EXTRACT_PARALLEL_DIRS, 
                                    EXTRACT_SHADOW_DIRS, CREATE_REMOTES, UNPARSE_FILE, REMOVE_AND_CALC_SHADOW,

src/Utils/module_utils.cpp

@@ -325,7 +325,7 @@ static void getModuleSymbols(SgStatement* func, set<SgSymbol*>& symbs)
     }
 }
 
-set<SgSymbol*> getModuleSymbols(SgStatement *func)
+const set<SgSymbol*>& getModuleSymbols(SgStatement *func)
 {
     auto it = symbolsForFunc.find(func->symbol()->identifier());
     if (it != symbolsForFunc.end())
@@ -345,7 +345,7 @@ set<SgSymbol*> getModuleSymbols(SgStatement *func)
     }
 
     symbolsForFunc[func->symbol()->identifier()] = symbs;
-    return symbs;
+    return symbolsForFunc[func->symbol()->identifier()];
 }
 
 static void findSymbol(SgStatement* func, const string& varName, const string& locName,

src/Utils/module_utils.h

@@ -1,7 +1,7 @@
 #pragma once
 
 std::string correctSymbolModuleName(const std::string& origFull);
-std::set<SgSymbol*> getModuleSymbols(SgStatement* func);
+const std::set<SgSymbol*>& getModuleSymbols(SgStatement* func);
 void getModulesAndFunctions(SgFile* file, std::vector<SgStatement*>& modulesAndFunctions);
 void findModulesInFile(SgFile* file, std::vector<SgStatement*>& modules);
 std::map<std::string, std::set<std::string>> createMapOfModuleUses(SgFile* file);

src/Utils/version.h

@@ -1,3 +1,3 @@
 #pragma once
 
-#define VERSION_SPF "2464"
+#define VERSION_SPF "2465"