change reordering logic

src/CreateInterTree/CreateInterTree.cpp

@@ -17,7 +17,7 @@ using std::fstream;
 static long int getNextTag()
 {
     static long int INTERVAL_TAG = 0;
-    return INTERVAL_TAG++;
+    return -(INTERVAL_TAG++);
 }
 
 //Debug funcs
@@ -413,7 +413,7 @@ static void findIntervals(SpfInterval *interval, map<int, int> &labelsRef, map<i
         inter->lineFile = std::make_pair(currentSt->lineNumber(), currentSt->fileName());
         inter->parent = interval;
         inter->exit_levels.push_back(0);
-        inter->tag = getNextTag();
+        inter->tag = currentSt->lineNumber();//getNextTag();
         interval->nested.push_back(inter);
 
         findIntervals(inter, labelsRef, gotoStmts, currentSt);

src/Sapfor.cpp

@@ -1,4 +1,4 @@
-#include "Utils/leak_detector.h"
+#include "Utils/leak_detector.h"
 
 #pragma comment(linker, "/STACK:536870912") // 512 МБ
 
@@ -943,7 +943,7 @@ static bool runAnalysis(SgProject &project, const int curr_regime, const bool ne
             }
         }
         else if (curr_regime == MOVE_OPERATORS)        
-            moveOperators(file, loopGraph, fullIR, countOfTransform);        
+            moveOperators(file, fullIR, countOfTransform);
         else if (curr_regime == PRIVATE_REMOVING_ANALYSIS)
         {
             auto itFound = loopGraph.find(file->filename());

src/Transformations/FunctionInlining/inliner.cpp

@@ -1089,6 +1089,8 @@ static int clean(const string& funcName, SgStatement* funcSt, const map<string,
             }
 
             SgGotoStmt* gotoSt = new SgGotoStmt(*contLab);
+            if (st->label())
+                gotoSt->setLabel(*st->label());
             st->insertStmtBefore(*gotoSt, *st->controlParent());
 
             toDelete.push_back(st);

src/Transformations/MoveOperators/move_operators.cpp

@@ -1,10 +1,8 @@
 #include <map>
 #include <set>
 #include <vector>
-#include <queue>
 #include <iostream>
 #include <algorithm>
-#include <limits>
 #include <cstring>
 #include <cstdlib>
 
@@ -19,7 +17,10 @@
 
 using namespace std;
 
-string getNameByArg(SAPFOR::Argument* arg);
+set<int> loop_tags = {FOR_NODE};
+set<int> control_tags = {IF_NODE, ELSEIF_NODE, DO_WHILE_NODE, WHILE_NODE, LOGIF_NODE};
+set<int> control_end_tags = {CONTROL_END};
+
 
 static vector<SAPFOR::IR_Block*> findInstructionsFromStatement(SgStatement* st, const vector<SAPFOR::BasicBlock*>& blocks)
 {
@@ -49,642 +50,27 @@ static vector<SAPFOR::IR_Block*> findInstructionsFromStatement(SgStatement* st,
     return result;
 }
 
-set<int> loop_tags = {FOR_NODE};
-set<int> control_tags = {IF_NODE, ELSEIF_NODE, DO_WHILE_NODE, WHILE_NODE, LOGIF_NODE};
-set<int> control_end_tags = {CONTROL_END};
-
-static bool isBarrierIR(const SAPFOR::Instruction* instr)
-{
-    if (!instr)
-        return true;
-
-    using SAPFOR::CFG_OP;
-    const auto op = instr->getOperation();
-
-    switch (op)
-    {
-    case CFG_OP::F_CALL:
-    case CFG_OP::STORE:
-    case CFG_OP::REC_REF_STORE:
-    case CFG_OP::IO_PARAM:
-    case CFG_OP::DVM_DIR:
-    case CFG_OP::SPF_DIR:
-    case CFG_OP::POINTER_ASS:
-    case CFG_OP::EXIT:
-        return true;
-    default:
-        return false;
-    }
-}
-
-static bool isMovableStmtIR(const vector<SAPFOR::IR_Block*>& irs,
-                            set<SAPFOR::Argument*>& uses,
-                            set<SAPFOR::Argument*>& defs,
-                            bool& spansMultipleBB)
-{
-    uses.clear();
-    defs.clear();
-    spansMultipleBB = false;
-
-    if (irs.empty())
-        return false;
-
-    SAPFOR::BasicBlock* bb = irs.front()->getBasicBlock();
-    for (auto* ir : irs)
-        if (ir && ir->getBasicBlock() != bb)
-            spansMultipleBB = true;
-
-    for (auto* ir : irs)
-    {
-        if (!ir || !ir->getInstruction())
-            return false;
-
-        const auto* instr = ir->getInstruction();
-        if (isBarrierIR(instr))
-            return false;
-
-        auto addUse = [&](SAPFOR::Argument* a)
-        {
-            if (!a)
-                return;
-            if (a->getType() == SAPFOR::CFG_ARG_TYPE::VAR)
-                uses.insert(a);
-            else if (a->getType() == SAPFOR::CFG_ARG_TYPE::ARRAY || a->getType() == SAPFOR::CFG_ARG_TYPE::RECORD)
-                uses.insert(a);
-        };
-
-        auto addDef = [&](SAPFOR::Argument* a)
-        {
-            if (!a)
-                return;
-            if (a->getType() == SAPFOR::CFG_ARG_TYPE::VAR)
-                defs.insert(a);
-            else if (a->getType() == SAPFOR::CFG_ARG_TYPE::ARRAY || a->getType() == SAPFOR::CFG_ARG_TYPE::RECORD)
-                defs.insert(a);
-        };
-
-        addUse(instr->getArg1());
-        addUse(instr->getArg2());
-        addDef(instr->getResult());
-    }
-
-    for (auto* a : uses)
-        if (a && (a->getType() == SAPFOR::CFG_ARG_TYPE::ARRAY || a->getType() == SAPFOR::CFG_ARG_TYPE::RECORD))
-            return false;
-    for (auto* a : defs)
-        if (a && (a->getType() == SAPFOR::CFG_ARG_TYPE::ARRAY || a->getType() == SAPFOR::CFG_ARG_TYPE::RECORD))
-            return false;
-
-    if (spansMultipleBB)
-        return false;
-
-    if (defs.empty())
-        return false;
-
-    return true;
-}
-
-static bool isStatementEmbedded(SgStatement* stmt, SgStatement* parent) {
-    if (!stmt || !parent || stmt == parent)
-        return false;
-    
-    if (parent->variant() == LOGIF_NODE) {
-        if (stmt->lineNumber() == parent->lineNumber())
-            return true;
-        
-        SgStatement* current = parent;
-        SgStatement* lastNode = parent->lastNodeOfStmt();
-
-        while (current && current != lastNode) {
-            if (current == stmt)
-                return true;
-
-            if (current->isIncludedInStmt(*stmt))
-                return true;
-
-            current = current->lexNext();
-        }
-    }
-    
-    if (parent->isIncludedInStmt(*stmt))
-        return true;
-    
-    return false;
-}
-
-static bool isLoopBoundary(SgStatement* stmt) {
-    if (!stmt)
-        return false;
-    
-    if (stmt->variant() == FOR_NODE || stmt->variant() == CONTROL_END)
-        return true;
-    
-    return false;
-}
-
-static bool isPartOfNestedLoop(SgStatement* stmt, SgForStmt* loop) {
-    if (!stmt || !loop)
-        return false;
-    
-    SgStatement* loopStart = loop->lexNext();
-    SgStatement* loopEnd = loop->lastNodeOfStmt();
-    if (!loopStart || !loopEnd)
-        return false;
-    
-    if (stmt->lineNumber() < loopStart->lineNumber() || stmt->lineNumber() > loopEnd->lineNumber())
-        return false;
-    
-    SgStatement* current = loopStart;
-    
-    while (current && current != loopEnd) {
-        
-        if (current->variant() == FOR_NODE && current != loop) {
-            SgForStmt* nestedLoop = (SgForStmt*)current;
-            SgStatement* nestedStart = nestedLoop->lexNext();
-            SgStatement* nestedEnd = nestedLoop->lastNodeOfStmt();
-            
-            if (nestedStart && nestedEnd && 
-                stmt->lineNumber() >= nestedStart->lineNumber() && 
-                stmt->lineNumber() <= nestedEnd->lineNumber()) {
-                return true;
-            }
-        }
-        
-        current = current->lexNext();
-    }
-    
-    return false;
-}
-
-static bool canSafelyExtract(SgStatement* stmt, SgForStmt* loop) {
-    if (!stmt || !loop)
-        return false;
-    
-    if (isLoopBoundary(stmt))
-        return false;
-    
-    if (control_tags.find(stmt->variant()) != control_tags.end())
-        return false;
-    
-    if (isPartOfNestedLoop(stmt, loop))
-        return false;
-    
-    SgStatement* loopStart = loop->lexNext();
-    SgStatement* loopEnd = loop->lastNodeOfStmt();
-    if (!loopStart || !loopEnd) 
-        return false;
-    
-    SgStatement* current = loopStart;
-    
-    while (current && current != loopEnd) {
-        if (current->variant() == LOGIF_NODE && current->lineNumber() == stmt->lineNumber())
-            return false;
-
-        if (control_tags.find(current->variant()) != control_tags.end())
-            if (isStatementEmbedded(stmt, current))
-                return false;
-
-        if (current == stmt) 
-            break;
-        current = current->lexNext();
-    }
-    
-    return true;
-}
-
-namespace
-{
-    struct StmtInfo
-    {
-        SgStatement* stmt = nullptr;
-        SAPFOR::BasicBlock* bb = nullptr;
-        int firstInstr = std::numeric_limits<int>::max();
-        int lastInstr = std::numeric_limits<int>::min();
-        vector<SAPFOR::IR_Block*> irs;
-        set<SAPFOR::Argument*> uses;
-        set<SAPFOR::Argument*> defs;
-    };
-
-    using RDState = map<SAPFOR::Argument*, set<int>>;
-
-    static void killGlobalsAndParams(RDState& st)
-    {
-        for (auto it = st.begin(); it != st.end();)
-        {
-            SAPFOR::Argument* a = it->first;
-            if (!a)
-            {
-                it = st.erase(it);
-                continue;
-            }
-
-            const bool kill = a->isMemGlobal() || a->isParameter();
-            if (kill)
-                it = st.erase(it);
-            else
-                ++it;
-        }
-    }
-
-    static void transferRD(RDState& st, const SAPFOR::Instruction* instr)
-    {
-        if (!instr)
-            return;
-
-        if (isBarrierIR(instr))
-        {
-            killGlobalsAndParams(st);
-            return;
-        }
-
-        using SAPFOR::CFG_OP;
-        const auto op = instr->getOperation();
-        if (op == CFG_OP::ASSIGN || op == CFG_OP::LOAD)
-        {
-            SAPFOR::Argument* res = instr->getResult();
-            if (res && res->getType() == SAPFOR::CFG_ARG_TYPE::VAR)
-                st[res] = { instr->getNumber() };
-        }
-    }
-
-    static RDState computeRD_BeforeInstr(const SAPFOR::BasicBlock* bb, int beforeInstrNum)
-    {
-        RDState st;
-        if (!bb)
-            return st;
-
-        st = bb->getRD_In();
-        for (auto* ir : bb->getInstructions())
-        {
-            if (!ir || !ir->getInstruction())
-                continue;
-            if (ir->getNumber() >= beforeInstrNum)
-                break;
-            transferRD(st, ir->getInstruction());
-        }
-        return st;
-    }
-
-    static bool topoSchedule(const vector<SgStatement*>& original,
-                             const vector<vector<int>>& succ,
-                             const vector<int>& indegInit,
-                             vector<SgStatement*>& scheduled)
-    {
-        const int n = (int)original.size();
-        scheduled.clear();
-        scheduled.reserve(n);
-
-        vector<int> indeg = indegInit;
-        vector<int> maxPredPos(n, 0);
-
-        struct Node
-        {
-            int idx;
-            int keyMaxPredPos;
-        };
-        struct Cmp
-        {
-            bool operator()(const Node& a, const Node& b) const
-            {
-                if (a.keyMaxPredPos != b.keyMaxPredPos)
-                    return a.keyMaxPredPos < b.keyMaxPredPos;
-                return a.idx > b.idx;
-            }
-        };
-
-        std::priority_queue<Node, vector<Node>, Cmp> ready;
-        for (int i = 0; i < n; ++i)
-            if (indeg[i] == 0)
-                ready.push(Node{ i, 0 });
-
-        int outPos = 0;
-        while (!ready.empty())
-        {
-            Node cur = ready.top();
-            ready.pop();
-
-            const int u = cur.idx;
-            scheduled.push_back(original[u]);
-            ++outPos;
-
-            for (int v : succ[u])
-            {
-                maxPredPos[v] = std::max(maxPredPos[v], outPos);
-                if (--indeg[v] == 0)
-                    ready.push(Node{ v, maxPredPos[v] });
-            }
-        }
-
-        return (int)scheduled.size() == n;
-    }
-
-    static bool applyReorderContiguous(SgForStmt* loop,
-                                       const vector<SgStatement*>& oldOrder,
-                                       const vector<SgStatement*>& newOrder)
-    {
-        if (!loop || oldOrder.size() != newOrder.size() || oldOrder.size() < 2)
-            return false;
-
-        bool changed = false;
-        for (size_t i = 0; i < oldOrder.size(); ++i)
-            if (oldOrder[i] != newOrder[i])
-            {
-                changed = true;
-                break;
-            }
-        if (!changed)
-            return false;
-
-        SgStatement* loopStart = loop->lexNext();
-        SgStatement* loopEnd = loop->lastNodeOfStmt();
-        if (!loopStart || !loopEnd)
-            return false;
-
-        SgStatement* first = oldOrder.front();
-        SgStatement* anchor = loop;
-        for (SgStatement* cur = loopStart; cur && cur != loopEnd; cur = cur->lexNext())
-        {
-            if (cur == first)
-                break;
-            anchor = cur;
-        }
-
-        map<SgStatement*, int> savedLine;
-        map<SgStatement*, char*> savedComments;
-        map<SgStatement*, SgStatement*> extracted;
-
-        for (SgStatement* st : oldOrder)
-        {
-            if (!st || st == loop || st == loopEnd)
-                return false;
-            if (!canSafelyExtract(st, loop))
-                return false;
-
-            savedLine[st] = st->lineNumber();
-            savedComments[st] = st->comments() ? strdup(st->comments()) : nullptr;
-
-            SgStatement* ex = st->extractStmt();
-            if (!ex)
-                return false;
-            extracted[st] = ex;
-        }
-
-        SgStatement* insertAfter = anchor;
-        for (SgStatement* st : newOrder)
-        {
-            SgStatement* ex = extracted[st];
-            if (!ex)
-                continue;
-
-            auto itC = savedComments.find(st);
-            if (itC != savedComments.end() && itC->second)
-                ex->setComments(itC->second);
-
-            auto itL = savedLine.find(st);
-            if (itL != savedLine.end())
-                ex->setlineNumber(itL->second);
-
-            insertAfter->insertStmtAfter(*ex, *loop);
-            insertAfter = ex;
-        }
-
-        for (auto& kv : savedComments)
-            if (kv.second)
-                free(kv.second);
-
-        return true;
-    }
-}
-
-static bool reorderMovableRegionsInLoop(SgForStmt* loop, const vector<SAPFOR::BasicBlock*>& blocks)
-{
-    if (!loop)
-        return false;
-
-    SgStatement* loopStart = loop->lexNext();
-    SgStatement* loopEnd = loop->lastNodeOfStmt();
-    if (!loopStart || !loopEnd)
-        return false;
-
-    bool anyChange = false;
-
-    vector<SgStatement*> region;
-    auto flushRegion = [&]() {
-        if (region.size() < 2)
-        {
-            region.clear();
-            return;
-        }
-
-        vector<StmtInfo> infos;
-        infos.reserve(region.size());
-        map<SgStatement*, int> idxOf;
-
-        map<int, int> defInstrToIdx;
-
-        for (int i = 0; i < (int)region.size(); ++i)
-        {
-            SgStatement* st = region[i];
-            idxOf[st] = i;
-
-            StmtInfo info;
-            info.stmt = st;
-            info.irs = findInstructionsFromStatement(st, blocks);
-            if (info.irs.empty())
-            {
-                infos.clear();
-                region.clear();
-                return;
-            }
-
-            info.bb = info.irs.front()->getBasicBlock();
-            for (auto* ir : info.irs)
-            {
-                info.firstInstr = std::min(info.firstInstr, ir->getNumber());
-                info.lastInstr = std::max(info.lastInstr, ir->getNumber());
-
-                const auto* instr = ir->getInstruction();
-                if (!instr)
-                    continue;
-
-                if (instr->getResult() && instr->getResult()->getType() == SAPFOR::CFG_ARG_TYPE::VAR &&
-                    (instr->getOperation() == SAPFOR::CFG_OP::ASSIGN || instr->getOperation() == SAPFOR::CFG_OP::LOAD))
-                {
-                    defInstrToIdx[instr->getNumber()] = i;
-                }
-            }
-
-            bool spansMultiple = false;
-            if (!isMovableStmtIR(info.irs, info.uses, info.defs, spansMultiple) || spansMultiple)
-            {
-                infos.clear();
-                region.clear();
-                return;
-            }
-
-            infos.push_back(std::move(info));
-        }
-
-        const int n = (int)infos.size();
-        vector<vector<int>> succ(n);
-        vector<int> indeg(n, 0);
-
-        auto addEdge = [&](int u, int v) {
-            if (u == v)
-                return;
-            succ[u].push_back(v);
-            indeg[v]++;
-        };
-
-        for (int i = 0; i < n; ++i)
-        {
-            const StmtInfo& cur = infos[i];
-            RDState stRD = computeRD_BeforeInstr(cur.bb, cur.firstInstr);
-
-            for (SAPFOR::Argument* use : cur.uses)
-            {
-                if (!use || use->getType() != SAPFOR::CFG_ARG_TYPE::VAR)
-                    continue;
-
-                auto it = stRD.find(use);
-                if (it == stRD.end())
-                    continue;
-
-                for (int defInstr : it->second)
-                {
-                    if (defInstr < 0)
-                        continue;
-
-                    auto itDef = defInstrToIdx.find(defInstr);
-                    if (itDef != defInstrToIdx.end())
-                        addEdge(itDef->second, i);
-                }
-            }
-        }
-
-        map<SAPFOR::Argument*, vector<int>> defsByVar;
-        for (int i = 0; i < n; ++i)
-            for (auto* d : infos[i].defs)
-                if (d && d->getType() == SAPFOR::CFG_ARG_TYPE::VAR)
-                    defsByVar[d].push_back(i);
-
-        for (auto& kv : defsByVar)
-        {
-            auto& list = kv.second;
-            sort(list.begin(), list.end());
-            list.erase(unique(list.begin(), list.end()), list.end());
-            for (int k = 0; k + 1 < (int)list.size(); ++k)
-                addEdge(list[k], list[k + 1]);
-        }
-
-        map<SAPFOR::Argument*, vector<int>> defPositions;
-        for (auto& kv : defsByVar)
-            defPositions[kv.first] = kv.second;
-
-        for (int i = 0; i < n; ++i)
-        {
-            for (SAPFOR::Argument* use : infos[i].uses)
-            {
-                if (!use || use->getType() != SAPFOR::CFG_ARG_TYPE::VAR)
-                    continue;
-
-                auto itDefs = defPositions.find(use);
-                if (itDefs == defPositions.end())
-                    continue;
-
-                const auto& dpos = itDefs->second;
-                auto it = std::upper_bound(dpos.begin(), dpos.end(), i);
-                if (it != dpos.end())
-                    addEdge(i, *it);
-            }
-        }
-
-        for (int u = 0; u < n; ++u)
-        {
-            auto& out = succ[u];
-            sort(out.begin(), out.end());
-            out.erase(unique(out.begin(), out.end()), out.end());
-        }
-        fill(indeg.begin(), indeg.end(), 0);
-        for (int u = 0; u < n; ++u)
-            for (int v : succ[u])
-                indeg[v]++;
-
-        vector<SgStatement*> scheduled;
-        vector<SgStatement*> original = region;
-        if (!topoSchedule(original, succ, indeg, scheduled))
-        {
-            region.clear();
-            return;
-        }
-
-        if (applyReorderContiguous(loop, original, scheduled))
-            anyChange = true;
-
-        region.clear();
-    };
-
-    SgStatement* current = loopStart;
-    set<SgStatement*> visited;
-
-    while (current && current != loopEnd)
-    {
-        if (!visited.insert(current).second)
-            break;
-
-        if (isLoopBoundary(current))
-        {
-            flushRegion();
-            current = current->lexNext();
-            continue;
-        }
-
-        if (current->variant() == FOR_NODE && current != loop)
-        {
-            flushRegion();
-            SgStatement* nestedEnd = current->lastNodeOfStmt();
-            current = nestedEnd ? nestedEnd->lexNext() : current->lexNext();
-            continue;
-        }
-
-        if (!isSgExecutableStatement(current) || control_tags.count(current->variant()))
-        {
-            flushRegion();
-            current = current->lexNext();
-            continue;
-        }
-
-        const bool isTopLevel = (current->controlParent() == loop);
-        if (isTopLevel && current->variant() == ASSIGN_STAT && canSafelyExtract(current, loop))
-        {
-            auto irs = findInstructionsFromStatement(current, blocks);
-            set<SAPFOR::Argument*> uses, defs;
-            bool spansMultiple = false;
-            if (isMovableStmtIR(irs, uses, defs, spansMultiple) && !spansMultiple)
-            {
-                region.push_back(current);
-                current = current->lexNext();
-                continue;
-            }
-        }
-
-        flushRegion();
-        current = current->lexNext();
-    }
-
-    flushRegion();
-    return anyChange;
-}
-
 vector<SAPFOR::BasicBlock*> findFuncBlocksByFuncStatement(SgStatement *st, const map<FuncInfo*, vector<SAPFOR::BasicBlock*>>& FullIR) {
     vector<SAPFOR::BasicBlock*> result;
+    if (!st)
+        return result;
+
     Statement* forSt = (Statement*)st;
+    const string stmtFile = st->fileName();
+    const int stmtLine = st->lineNumber();
 
     for (auto& func: FullIR) {
-        if (func.first->funcPointer->getCurrProcessFile() == forSt->getCurrProcessFile()
-            && func.first->funcPointer->lineNumber() == forSt->lineNumber())
+        if (!func.first || !func.first->funcPointer)
+            continue;
+
+        const string funcFile = func.first->fileName;
+        const int funcLine = func.first->funcPointer->lineNumber();
+
+        // Important: select CFG blocks only for the same file and function header.
+        if (funcFile == stmtFile && funcLine == stmtLine)
         {
             result = func.second;
+            break;
         }
     }
     return result;
@@ -721,34 +107,6 @@ map<SgForStmt*, vector<SAPFOR::BasicBlock*>> findAndAnalyzeLoops(SgStatement *st
     return result;
 }
 
-static void processLoopRecursively(SgForStmt* loop, const vector<SAPFOR::BasicBlock*>& blocks, 
-                                   const map<FuncInfo*, vector<SAPFOR::BasicBlock*>>& FullIR) {
-    if (!loop) 
-        return;
-    
-    SgStatement* loopStart = loop->lexNext();
-    SgStatement* loopEnd = loop->lastNodeOfStmt();
-    if (loopStart && loopEnd) {
-        SgStatement* current = loopStart;
-        while (current && current != loopEnd) {
-            if (current->variant() == FOR_NODE && current != loop) {
-                SgForStmt* nestedLoop = (SgForStmt*)current;
-                processLoopRecursively(nestedLoop, blocks, FullIR);
-                SgStatement* nestedEnd = nestedLoop->lastNodeOfStmt();
-
-                if (nestedEnd)
-                    current = nestedEnd->lexNext();
-                else
-                    current = current->lexNext();
-            } 
-            else
-                current = current->lexNext();
-        }
-    }
-
-    reorderMovableRegionsInLoop(loop, blocks);
-}
-
 
 vector<SAPFOR::BasicBlock*> findBlocksInLoopsByFullIR(
     SgStatement* funcStmt,
@@ -813,40 +171,60 @@ static map<SgStatement*, vector<SgStatement*>> analyzeBasicBlockIntraDependencie
         if (!instr)
             return string();
         SgExpression* ex = instr->getExpression();
-        if (!ex || !ex->unparse())
+        if (!ex)
             return string();
-        auto normalizeExprText = [](const string& raw) -> string
-        {
-            string t;
-            t.reserve(raw.size());
-            for (unsigned char c : raw)
-                if (!std::isspace(c))
-                    t.push_back((char)c);
 
-            auto stripOneLayer = [](const string& x) -> string
+        auto exprKey = [&](auto&& self, SgExpression* e) -> string
+        {
+            if (!e)
+                return string("_");
+
+            if (auto* ar = isSgArrayRefExp(e))
             {
-                if (x.size() < 2 || x.front() != '(' || x.back() != ')')
-                    return x;
-                int bal = 0;
-                for (size_t i = 0; i + 1 < x.size(); ++i)
+                SgSymbol* sym = ar->symbol() ? OriginalSymbol(ar->symbol()) : nullptr;
+                string key = string("A(") + (sym ? sym->identifier() : "?");
+                const int n = ar->numberOfSubscripts();
+                for (int i = 0; i < n; ++i)
                 {
-                    if (x[i] == '(') bal++;
-                    else if (x[i] == ')') bal--;
-                    if (bal == 0 && i + 1 < x.size() - 1)
-                        return x;
+                    key += ",";
+                    key += self(self, ar->subscript(i));
                 }
-                return x.substr(1, x.size() - 2);
-            };
-            while (true)
-            {
-                const string stripped = stripOneLayer(t);
-                if (stripped == t)
-                    break;
-                t = stripped;
+                key += ")";
+                return key;
             }
-            return t;
+
+            if (e->variant() == VAR_REF || e->variant() == CONST_REF)
+            {
+                SgSymbol* sym = e->symbol() ? OriginalSymbol(e->symbol()) : nullptr;
+                return string((e->variant() == VAR_REF) ? "V(" : "C(") + (sym ? sym->identifier() : "?") + ")";
+            }
+
+            if (auto* v = isSgValueExp(e))
+            {
+                if (e->variant() == INT_VAL)
+                    return string("I(") + to_string(v->intValue()) + ")";
+                if (e->variant() == BOOL_VAL)
+                    return string("B(") + (v->boolValue() ? "1" : "0") + ")";
+                if (e->variant() == CHAR_VAL)
+                    return string("CH(") + string(1, v->charValue()) + ")";
+                if (e->variant() == FLOAT_VAL)
+                    return string("F(") + (v->floatValue() ? v->floatValue() : "") + ")";
+                if (e->variant() == DOUBLE_VAL)
+                    return string("D(") + (v->doubleValue() ? v->doubleValue() : "") + ")";
+                if (e->variant() == STRING_VAL)
+                    return string("S(") + (v->stringValue() ? v->stringValue() : "") + ")";
+            }
+
+            string key = string("N(") + to_string(e->variant());
+            if (e->lhs())
+                key += ",L=" + self(self, e->lhs());
+            if (e->rhs())
+                key += ",R=" + self(self, e->rhs());
+            key += ")";
+            return key;
         };
-        return "MEMEX#" + normalizeExprText(ex->unparse());
+
+        return "MEMEX#" + exprKey(exprKey, ex);
     };
 
     auto isBarrier = [&](const SAPFOR::Instruction* instr) -> bool
@@ -949,6 +327,9 @@ static map<SgStatement*, vector<SgStatement*>> analyzeBasicBlockIntraDependencie
 
         addDep(instr->getArg1());
         addDep(instr->getArg2());
+        if (instr->getOperation() == SAPFOR::CFG_OP::RANGE)
+            addDep(instr->getResult());
+
         if (instr->getOperation() == SAPFOR::CFG_OP::STORE || instr->getOperation() == SAPFOR::CFG_OP::REC_REF_STORE)
             addDep(instr->getResult());
 
@@ -996,7 +377,7 @@ static map<SgStatement*, vector<SgStatement*>> analyzeBasicBlockIntraDependencie
     return result;
 }
 
-static bool reorderOperatorsInBasicBlockUsingDeps(SAPFOR::BasicBlock* bb)
+static bool reorderOperatorsInBasicBlockUsingDeps(SAPFOR::BasicBlock* bb, const char* expectedFile)
 {
     if (!bb)
         return false;
@@ -1026,6 +407,18 @@ static bool reorderOperatorsInBasicBlockUsingDeps(SAPFOR::BasicBlock* bb)
     if (ops.size() < 2)
         return false;
 
+    // Check that analyzed BB is in the same file as the expected file
+    const char* bbFile = ops.front()->fileName();
+    if (!bbFile)
+        bbFile = "(unknown)";
+    if (expectedFile && strcmp(expectedFile, bbFile) != 0)
+        return false;
+    for (auto* st : ops)
+    {
+        if (!st || !st->fileName() || strcmp(st->fileName(), bbFile) != 0)
+            return false;
+    }
+
     SgStatement* parent = ops.front()->controlParent();
     if (!parent)
         return false;
@@ -1077,60 +470,70 @@ static bool reorderOperatorsInBasicBlockUsingDeps(SAPFOR::BasicBlock* bb)
     // as close as possible after its last dependency (if any).
     const auto depsMap = analyzeBasicBlockIntraDependencies(bb);
     vector<SgStatement*> order = ops;
+    const vector<SgStatement*> originalOrder = ops;
+    const int nOrig = (int)originalOrder.size();
 
-    auto buildPos = [&](const vector<SgStatement*>& v)
+    auto indexIn = [](const vector<SgStatement*>& v, SgStatement* s) -> int
     {
-        map<SgStatement*, int> pos;
         for (int i = 0; i < (int)v.size(); ++i)
-            pos[v[i]] = i;
-        return pos;
+            if (v[i] == s)
+                return i;
+        return -1;
     };
 
-    const int maxIterations = (int)order.size() * (int)order.size() + 10;
-    bool anyMove = false;
-    for (int iter = 0; iter < maxIterations; ++iter)
+    auto indexInOriginal = [&](SgStatement* s) -> int
     {
-        bool movedThisIter = false;
-        const auto pos = buildPos(order);
+        return indexIn(originalOrder, s);
+    };
 
-        for (int i = 0; i < (int)order.size(); ++i)
+    for (SgStatement* s : ops)
+    {
+        auto itDeps = depsMap.find(s);
+        if (itDeps == depsMap.end() || itDeps->second.empty())
+            continue;
+
+        int lastDepOrigIdx = -1;
+        for (SgStatement* dep : itDeps->second)
         {
-            SgStatement* curSt = order[i];
-            auto it = depsMap.find(curSt);
-            if (it == depsMap.end() || it->second.empty())
+            const int j = indexInOriginal(dep);
+            if (j >= 0)
+                lastDepOrigIdx = max(lastDepOrigIdx, j);
+        }
+        if (lastDepOrigIdx < 0)
+            continue;
+
+        SgStatement* successor = nullptr;
+        if (lastDepOrigIdx + 1 < nOrig)
+            successor = originalOrder[lastDepOrigIdx + 1];
+
+        int posS = indexIn(order, s);
+        if (posS < 0)
+            continue;
+
+        if (successor == nullptr)
+        {
+            if (posS == (int)order.size() - 1)
                 continue;
-
-            int lastDepIdx = -1;
-            for (SgStatement* dep : it->second)
-            {
-                auto itP = pos.find(dep);
-                if (itP != pos.end())
-                    lastDepIdx = max(lastDepIdx, itP->second);
-            }
-            if (lastDepIdx < 0)
-                continue;
-
-            int target = lastDepIdx + 1;
-            if (target == i)
-                continue;
-
-            SgStatement* moved = order[i];
-            order.erase(order.begin() + i);
-            if (target > i)
-                target -= 1;
-            if (target < 0)
-                target = 0;
-            if (target > (int)order.size())
-                target = (int)order.size();
-            order.insert(order.begin() + target, moved);
-
-            movedThisIter = true;
-            anyMove = true;
-            break;
+            order.erase(order.begin() + posS);
+            order.push_back(s);
+            continue;
         }
 
-        if (!movedThisIter)
-            break;
+        if (successor == s)
+            continue;
+
+        const int posSucc = indexIn(order, successor);
+        if (posSucc < 0)
+            continue;
+
+        if (posS + 1 == posSucc)
+            continue;
+
+        order.erase(order.begin() + posS);
+        const int posSucc2 = indexIn(order, successor);
+        if (posSucc2 < 0)
+            printInternalError(convertFileName(__FILE__).c_str(), __LINE__);
+        order.insert(order.begin() + posSucc2, s);
     }
 
     bool changed = false;
@@ -1201,17 +604,14 @@ static bool reorderOperatorsInBasicBlockUsingDeps(SAPFOR::BasicBlock* bb)
     return true;
 }
 
-void moveOperators(SgFile *file, map<string, vector<LoopGraph*>>& loopGraph, 
-                   const map<FuncInfo*, vector<SAPFOR::BasicBlock*>>& FullIR, 
-                   int& countOfTransform) {
-    // countOfTransform += 1;
-
+void moveOperators(SgFile* file, const map<FuncInfo*, vector<SAPFOR::BasicBlock*>>& FullIR, int& countOfTransform) {
     if (!file)
         return;
-
+    if (SgFile::switchToFile(file->filename()) == -1)
+        printInternalError(convertFileName(__FILE__).c_str(), __LINE__);
     const int funcNum = file->numberOfFunctions();
-
-    for (int i = 0; i < funcNum; ++i) {
+    for (int i = 0; i < funcNum; ++i)
+    {
         SgStatement* st = file->functions(i);
 
         const auto loopBlocks = findBlocksInLoopsByFullIR(st, FullIR);
@@ -1219,14 +619,8 @@ void moveOperators(SgFile *file, map<string, vector<LoopGraph*>>& loopGraph,
         {
             if (!bb)
                 continue;
-            if (reorderOperatorsInBasicBlockUsingDeps(bb))
+            if (reorderOperatorsInBasicBlockUsingDeps(bb, file->filename()))
                 countOfTransform += 1;
         }
-
-        // vector<SAPFOR::BasicBlock*> blocks = findFuncBlocksByFuncStatement(st, FullIR);
-        // map<SgForStmt*, vector<SAPFOR::BasicBlock*>> loopsMapping = findAndAnalyzeLoops(st, blocks);
-
-        // for (auto& loopForAnalyze : loopsMapping)
-        //     processLoopRecursively(loopForAnalyze.first, loopForAnalyze.second, FullIR);
     }
-}
+}

src/Transformations/MoveOperators/move_operators.h

@@ -3,4 +3,4 @@
 #include "../../GraphLoop/graph_loops.h"
 #include "../../CFGraph/CFGraph.h"
 
-void moveOperators(SgFile *file, std::map<std::string, std::vector<LoopGraph*>>& loopGraph, const std::map<FuncInfo*, std::vector<SAPFOR::BasicBlock*>>& FullIR, int& countOfTransform);
+void moveOperators(SgFile* file, const std::map<FuncInfo*, std::vector<SAPFOR::BasicBlock*>>& FullIR, int& countOfTransform);

src/Utils/version.h

@@ -1,3 +1,3 @@
 #pragma once
 
-#define VERSION_SPF "2468"
+#define VERSION_SPF "2472"