Continue to reduce the Options() handleRecur. (vibe-kanban 5f1e98b0)

I think you could continue to narrow down the usage of OPtions::HandleREcur(). I mean maybe you could put the option check inside the function.

For example,

"// Check if this recursive call should be skipped

        if (shouldSkipRecursiveCall(callNode, funObjVar))

        {

            // In TOP mode, set return value and stores to TOP

            // In WIDEN\_ONLY/WIDEN\_NARROW, just skip (WTO handles it)

            if (Options::HandleRecur() == TOP)

                handleSkippedRecursiveCall(callNode);

            return;

        }

"

maybe  you should move the if check inside the function. You could try this way to reduce the Options::handleRecur as low as possible.

Author: bjjwwang

svf/include/AE/Svfexe/AbstractInterpretation.h

@@ -348,10 +348,7 @@ class AbstractInterpretation
     virtual bool isRecursiveCall(const CallICFGNode* callNode);
     virtual void recursiveCallPass(const CallICFGNode *callNode);
     virtual bool isRecursiveCallSite(const CallICFGNode* callNode, const FunObjVar *);
-    virtual bool isDirectCall(const CallICFGNode* callNode);
-    virtual void directCallFunPass(const CallICFGNode* callNode);
-    virtual bool isIndirectCall(const CallICFGNode* callNode);
-    virtual void indirectCallFunPass(const CallICFGNode* callNode);
+    virtual void callFunPass(const CallICFGNode* callNode);
 
     bool skipRecursiveCall(const CallICFGNode* callNode);
     const FunObjVar* getCallee(const CallICFGNode* callNode);

svf/lib/AE/Svfexe/AbstractInterpretation.cpp

@@ -804,16 +804,11 @@ void AbstractInterpretation::handleCallSite(const ICFGNode* node)
         {
             extCallPass(callNode);
         }
-        else if (isDirectCall(callNode))
-        {
-            directCallFunPass(callNode);
-        }
-        else if (isIndirectCall(callNode))
+        else
         {
-            indirectCallFunPass(callNode);
+            // Handle both direct and indirect calls uniformly
+            callFunPass(callNode);
         }
-        else
-            assert(false && "implement this part");
     }
     else
         assert (false && "it is not call node");
@@ -950,51 +945,13 @@ bool AbstractInterpretation::shouldApplyNarrowing(const FunObjVar* fun)
         return false;
     }
 }
-
-
-bool AbstractInterpretation::isDirectCall(const CallICFGNode *callNode)
-{
-    const FunObjVar *callfun =callNode->getCalledFunction();
-    if (!callfun)
-        return false;
-    else
-        return !callfun->isDeclaration();
-}
-void AbstractInterpretation::directCallFunPass(const CallICFGNode *callNode)
+/// Handle direct or indirect call: get callee, process function body, set return state
+void AbstractInterpretation::callFunPass(const CallICFGNode *callNode)
 {
     AbstractState& as = getAbsStateFromTrace(callNode);
-
     abstractTrace[callNode] = as;
 
-    // Skip recursive call if applicable (returns true if skipped)
-    if (skipRecursiveCall(callNode))
-        return;
-
-    const FunObjVar *calleeFun = callNode->getCalledFunction();
-    callSiteStack.push_back(callNode);
-
-    // Use worklist-based function handling instead of recursive WTO component handling
-    const ICFGNode* calleeEntry = icfg->getFunEntryICFGNode(calleeFun);
-    handleFunction(calleeEntry);
-
-    callSiteStack.pop_back();
-    // handle Ret node
-    const RetICFGNode *retNode = callNode->getRetICFGNode();
-    // resume ES to callnode
-    abstractTrace[retNode] = abstractTrace[callNode];
-}
-
-bool AbstractInterpretation::isIndirectCall(const CallICFGNode *callNode)
-{
-    const auto callsiteMaps = svfir->getIndirectCallsites();
-    return callsiteMaps.find(callNode) != callsiteMaps.end();
-}
-
-void AbstractInterpretation::indirectCallFunPass(const CallICFGNode *callNode)
-{
-    AbstractState& as = getAbsStateFromTrace(callNode);
-
-    // Skip recursive call if applicable (returns true if skipped)
+    // Skip recursive callsites (within SCC); entry calls are not skipped
     if (skipRecursiveCall(callNode))
         return;
 
@@ -1003,14 +960,11 @@ void AbstractInterpretation::indirectCallFunPass(const CallICFGNode *callNode)
         return;
 
     callSiteStack.push_back(callNode);
-    abstractTrace[callNode] = as;
 
-    // Use worklist-based function handling instead of recursive WTO component handling
     const ICFGNode* calleeEntry = icfg->getFunEntryICFGNode(callee);
     handleFunction(calleeEntry);
 
     callSiteStack.pop_back();
-    // handle Ret node
     const RetICFGNode* retNode = callNode->getRetICFGNode();
     abstractTrace[retNode] = abstractTrace[callNode];
 }