src/Transformations/MoveOperators/move_operators.cpp

@@ -534,22 +534,183 @@ static map<SgStatement*, set<SgStatement*>> analyzeBasicBlockIntraDependencies(
         applyOutputEffectsFromRhs(expr->rhs(), stmt);
     };
 
+    auto analyzeProcStatCallHead = [&](SgStatement* callStmt,
+                                       SgCallStmt*& sgCall,
+                                       FuncInfo*& callee,
+                                       string& resolvedCalleeName,
+                                       bool& unknownCalleeTreatAsPureIntrinsic,
+                                       int& nArgs) -> bool
+    {
+        sgCall = nullptr;
+        callee = nullptr;
+        resolvedCalleeName.clear();
+        unknownCalleeTreatAsPureIntrinsic = false;
+        nArgs = 0;
+
+        if (!callStmt || !caller || callStmt->variant() != PROC_STAT)
+            return false;
+
+        sgCall = isSgCallStmt(callStmt);
+        if (!sgCall)
+            return false;
+
+        for (const auto& cd : caller->callsFromDetailed)
+        {
+            if (cd.pointerDetailCallsFrom.first != static_cast<void*>(callStmt))
+                continue;
+            if (cd.pointerDetailCallsFrom.second != PROC_STAT)
+                continue;
+            resolvedCalleeName = cd.detailCallsFrom.first;
+            if (!cd.detailCallsFrom.first.empty())
+                callee = getFuncInfo(funcMapByName, cd.detailCallsFrom.first);
+            break;
+        }
+
+        if (resolvedCalleeName.empty() && callStmt->symbol())
+        {
+            SgSymbol* sym = OriginalSymbol(callStmt->symbol());
+            if (sym && sym->identifier())
+                resolvedCalleeName = removeString("call ", string(sym->identifier()));
+        }
+
+        if (!callee && !resolvedCalleeName.empty())
+            callee = getFuncInfo(funcMapByName, resolvedCalleeName);
+
+        string lowerCalleeName = resolvedCalleeName;
+        for (char& c : lowerCalleeName)
+            c = static_cast<char>(tolower(static_cast<unsigned char>(c)));
+
+        unknownCalleeTreatAsPureIntrinsic =
+            !callee && !lowerCalleeName.empty() && isPureIntrinsic(lowerCalleeName);
+
+        nArgs = sgCall->numberOfArgs();
+        return true;
+    };
+
+    function<void(SgStatement*)> applyOutputEffectsFromProcStat = [&](SgStatement* callStmt)
+    {
+        SgCallStmt* sgCall = nullptr;
+        FuncInfo* callee = nullptr;
+        string resolvedCalleeName;
+        bool unknownCalleeTreatAsPureIntrinsic = false;
+        int nArgs = 0;
+        if (!analyzeProcStatCallHead(callStmt, sgCall, callee, resolvedCalleeName,
+                                     unknownCalleeTreatAsPureIntrinsic, nArgs))
+            return;
+
+        for (int i = 0; i < nArgs; ++i)
+        {
+            bool mayModify = false;
+            if (callee)
+            {
+                if (i >= callee->funcParams.countOfPars)
+                    mayModify = true;
+                else
+                    mayModify = callee->funcParams.isArgOut(i)
+                        || callee->funcParams.isArgInOut(i);
+            }
+            else if (unknownCalleeTreatAsPureIntrinsic)
+                mayModify = false;
+            else
+                mayModify = true;
+
+            if (!mayModify)
+                continue;
+
+            set<string> argKeys;
+            collectUsedKeysFromExpression(sgCall->arg(i), argKeys);
+            for (const string& k : argKeys)
+                varDeclarations[k] = callStmt;
+        }
+
+        for (int i = 0; i < nArgs; ++i)
+            applyOutputEffectsFromRhs(sgCall->arg(i), callStmt);
+    };
+
+    auto addCallUsageDependencies = [&](SgStatement* stmt,
+                                        const map<string, SgStatement*>& varUsages,
+                                        map<SgStatement*, set<SgStatement*>>& operatorsDependencies)
+    {
+        SgCallStmt* sgCall = nullptr;
+        FuncInfo* callee = nullptr;
+        string resolvedCalleeName;
+        bool unknownCalleeTreatAsPureIntrinsic = false;
+        int nArgs = 0;
+        if (!analyzeProcStatCallHead(stmt, sgCall, callee, resolvedCalleeName,
+                                     unknownCalleeTreatAsPureIntrinsic, nArgs))
+            return;
+
+        for (int i = 0; i < nArgs; ++i)
+        {
+            bool mayModify = false;
+            if (callee)
+            {
+                if (i >= callee->funcParams.countOfPars)
+                    mayModify = true;
+                else
+                    mayModify = callee->funcParams.isArgOut(i)
+                        || callee->funcParams.isArgInOut(i);
+            }
+            else if (unknownCalleeTreatAsPureIntrinsic)
+                mayModify = false;
+            else
+                mayModify = true;
+
+            if (!mayModify)
+                continue;
+
+            set<string> argKeys;
+            collectUsedKeysFromExpression(sgCall->arg(i), argKeys);
+            for (const string& k : argKeys)
+            {
+                auto itu = varUsages.find(k);
+                if (itu != varUsages.end() && itu->second && itu->second != stmt)
+                    operatorsDependencies[stmt].insert(itu->second);
+            }
+        }
+    };
+
     for (SgStatement* stmt : operatorsOrder)
     {
         set<string> usedKeys;
         if (stmt)
+        {
+            if (stmt->variant() == ASSIGN_STAT)
             {
                 collectUsedKeysFromExpression(stmt->expr(1), usedKeys);
                 collectUsedKeysFromArraySubscripts(isSgArrayRefExp(stmt->expr(0)), usedKeys);
             }
+            else if (stmt->variant() == PROC_STAT)
+            {
+                if (SgCallStmt* callSt = isSgCallStmt(stmt))
+                {
+                    for (int z = 0; z < callSt->numberOfArgs(); ++z)
+                        collectUsedKeysFromExpression(callSt->arg(z), usedKeys);
+                }
+                else
+                {
+                    for (SgExpression* par = stmt->expr(0); par; par = par->rhs())
+                        if (par->lhs())
+                            collectUsedKeysFromExpression(par->lhs(), usedKeys);
+                }
+            }
+        }
         addOperatorDependencies(stmt, usedKeys, varDeclarations, varUsages, operatorsDependencies);
 
+        if (stmt && stmt->variant() == PROC_STAT)
+            addCallUsageDependencies(stmt, varUsages, operatorsDependencies);
+
         const string declarationKey = declarationKeyFromLeftPart(stmt);
         if (!declarationKey.empty())
             varDeclarations[declarationKey] = stmt;
 
         if (stmt && caller)
+        {
+            if (stmt->variant() == ASSIGN_STAT)
                 applyOutputEffectsFromRhs(stmt->expr(1), stmt);
+            else if (stmt->variant() == PROC_STAT)
+                applyOutputEffectsFromProcStat(stmt);
+        }
 
         for (const string& key : usedKeys)
             varUsages[key] = stmt;