change reordering logic

src/GraphCall/graph_calls.cpp

@@ -800,58 +800,29 @@ static void fillInOut(FuncInfo *currF, SgStatement *start, SgStatement *last, co
 
     static map<string, vector<int>> supportedKeyWordArg = { {"system_clock", { OUT_BIT, OUT_BIT, OUT_BIT } } };
 
-    map<string, int> parNamesMain;
-    map<string, int> parNamesContains;
+    map<string, int> parNames;
 
     for (int i = 0; i < currF->funcParams.identificators.size(); ++i)
-        parNamesMain[currF->funcParams.identificators[i]] = i;
+        parNames[currF->funcParams.identificators[i]] = i;
 
-    map<string, int>& parNames = parNamesMain;
-
-    bool isContainsFunctions = false;
     for (auto st = start; st != last; st = st->lexNext())
     {
-        if (st->variant() == CONTAINS_STMT) {
-            isContainsFunctions = true;
-            continue;
-        }
-
-        if (isContainsFunctions) {
-            if (st->variant() == PROC_HEDR || st->variant() == FUNC_HEDR) {
-                parNamesContains = parNamesMain;
-                
-                SgProgHedrStmt* hedr = (SgProgHedrStmt*)st;
-
-                int numOfParams = hedr->numberOfParameters();
-                if (numOfParams > 0)
-                {
-                    for (int i = 0; i < numOfParams; ++i)
-                    {
-                        auto it = parNamesContains.find(hedr->parameter(i)->identifier());
-                        if (it != parNamesContains.end())
-                            parNamesContains.erase(it);
-                    }
-                }
-                parNames = parNamesContains;
-            }
-        }
+        if (st->variant() == CONTAINS_STMT)
+            break;
 
         if (st->variant() == ENTRY_STAT)
             continue;
         
         if (isSgExecutableStatement(st) == NULL) {
-            if (!isContainsFunctions)
-                checkInTypeDescription(st->expr(0), currF, parNames);
+            checkInTypeDescription(st->expr(0), currF, parNames);
             continue;
         }
 
         if (st->lineNumber() <= 0)
             continue;
 
-        //XXX: use parameters removing in block ... isContainsFunctions ...
-        //TODO need to use IR for parameters checking
-        /*if (activeOps.size() && activeOps.find(st) == activeOps.end())
-            continue; */
+        if (activeOps.size() && activeOps.find(st) == activeOps.end())
+            continue;
 
         if (st->variant() == ASSIGN_STAT)
         {

src/Transformations/MoveOperators/move_operators.cpp

@@ -470,6 +470,8 @@ static bool reorderOperatorsInBasicBlockUsingDeps(SAPFOR::BasicBlock* bb, const
     // 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 indexIn = [](const vector<SgStatement*>& v, SgStatement* s) -> int
     {
@@ -479,37 +481,59 @@ static bool reorderOperatorsInBasicBlockUsingDeps(SAPFOR::BasicBlock* bb, const
         return -1;
     };
 
+    auto indexInOriginal = [&](SgStatement* s) -> int
+    {
+        return indexIn(originalOrder, s);
+    };
+
     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)
+        {
+            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;
 
-        int lastDepIdx = -1;
-        for (SgStatement* dep : itDeps->second)
+        if (successor == nullptr)
         {
-            const int j = indexIn(order, dep);
-            if (j >= 0)
-                lastDepIdx = max(lastDepIdx, j);
+            if (posS == (int)order.size() - 1)
+                continue;
+            order.erase(order.begin() + posS);
+            order.push_back(s);
+            continue;
         }
-        if (lastDepIdx < 0)
+
+        if (successor == s)
             continue;
 
-        if (posS == lastDepIdx + 1)
+        const int posSucc = indexIn(order, successor);
+        if (posSucc < 0)
+            continue;
+
+        if (posS + 1 == posSucc)
             continue;
 
         order.erase(order.begin() + posS);
-
-        int lp = lastDepIdx;
-        if (posS < lastDepIdx)
-            lp = lastDepIdx - 1;
-
-        const int insertAt = lp + 1;
-        order.insert(order.begin() + insertAt, s);
+        const int posSucc2 = indexIn(order, successor);
+        if (posSucc2 < 0)
+            printInternalError(convertFileName(__FILE__).c_str(), __LINE__);
+        order.insert(order.begin() + posSucc2, s);
     }
 
     bool changed = false;

src/Utils/version.h

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