Fixed stack call implicit arg mismatch between caller/callee.

We are asserting in AddImplicitArgs pass due to the caller and callee not having the same set of implicit args.
Since stack calls do not inherently support implicit args, we inline them in BuiltinCallGraphAnalysis pass. However, we still need to add implicit args to their function signature in order for the Resolve passes to work before the inlining occurs.

The following two changes are needed to fix the mismatch:
1. BuiltinCallGraphAnalysis itself will change the implicit arg metadata, so we need to move the callgraph pruning function, which inlines stack functions that use implicit args, to the end of the pass, where it will not get affected by the rest of the pass.
2. We cannot remove the "visaStackCall" attribute inside the pruning loop, otherwise another search path in the DFS will miss it. Instead, save all pruned functions and process them outside the loop.

Author: dlei6g

IGC/AdaptorCommon/AddImplicitArgs.cpp

@@ -519,12 +519,6 @@ bool BuiltinCallGraphAnalysis::runOnModule(Module &M)
     m_pMdUtils = getAnalysis<MetaDataUtilsWrapper>().getMetaDataUtils();
     CallGraph &CG = getAnalysis<CallGraphWrapperPass>().getCallGraph();
 
-    // Detect stack calls that use implicit args, and force inline them, since they are not supported
-    if (IGC_IS_FLAG_ENABLED(ForceInlineStackCallWithImplArg))
-    {
-        pruneCallGraphForStackCalls(CG);
-    }
-
     if (IGC_GET_FLAG_VALUE(FunctionControl) == FLAG_FCALL_FORCE_INLINE)
     {
         return false;
@@ -537,6 +531,12 @@ bool BuiltinCallGraphAnalysis::runOnModule(Module &M)
         traveseCallGraphSCC(SCCNodes);
     }
 
+    // Detect stack calls that use implicit args, and force inline them, since they are not supported
+    if (IGC_IS_FLAG_ENABLED(ForceInlineStackCallWithImplArg))
+    {
+        pruneCallGraphForStackCalls(CG);
+    }
+
     return false;
 }
 
@@ -545,6 +545,7 @@ bool BuiltinCallGraphAnalysis::runOnModule(Module &M)
 bool BuiltinCallGraphAnalysis::pruneCallGraphForStackCalls(CallGraph& CG)
 {
     bool changed = false;
+    llvm::SmallSet<Function*, 16> PrunedFuncs;
     for (auto IT = df_begin(&CG), EI = df_end(&CG); IT != EI; IT++)
     {
         Function* F = IT->getFunction();
@@ -556,22 +557,26 @@ bool BuiltinCallGraphAnalysis::pruneCallGraphForStackCalls(CallGraph& CG)
                 for (unsigned i = 0; i < IT.getPathLength(); i++)
                 {
                     Function* pFuncOnPath = IT.getPath(i)->getFunction();
-                    if (pFuncOnPath && pFuncOnPath->hasFnAttribute("visaStackCall"))
+                    if (pFuncOnPath)
                     {
                         if (pFuncOnPath->hasFnAttribute("forceRecurse"))
                         {
                             IGC_ASSERT_MESSAGE(0, "Cannot inline for recursion!");
                             return false;
                         }
-                        pFuncOnPath->removeFnAttr("visaStackCall");
-                        pFuncOnPath->removeFnAttr(llvm::Attribute::NoInline);
-                        pFuncOnPath->addFnAttr(llvm::Attribute::AlwaysInline);
+                        PrunedFuncs.insert(pFuncOnPath);
                         changed = true;
                     }
                 }
             }
         }
     }
+    for (auto pF : PrunedFuncs)
+    {
+        pF->removeFnAttr("visaStackCall");
+        pF->removeFnAttr(llvm::Attribute::NoInline);
+        pF->addFnAttr(llvm::Attribute::AlwaysInline);
+    }
     return changed;
 }