SVF::SingleSlicer Class Reference

#include <MTASlicer.h>

Inheritance diagram for SVF::SingleSlicer:

Public Member Functions
	SingleSlicer (SVFIR *svfIr, AndersenBase *pta, MHP *mhp, LockAnalysis *lockAnalysis, SVFG *vfg=nullptr)
OrderedSet< const ICFGNode * >	runSlicing (const OrderedSet< const SVFStmt * > &vulnerableStatements)
Public Member Functions inherited from SVF::MTASlicerBase
	MTASlicerBase (SVFIR *svfIr, AndersenBase *pta, MHP *mhp, LockAnalysis *lockAnalysis, SVFG *vfg=nullptr)
virtual	~MTASlicerBase ()

Additional Inherited Members
Protected Member Functions inherited from SVF::MTASlicerBase
OrderedSet< const ICFGNode * >	sliceDataDependenceOverVFG (const OrderedSet< const SVFStmt * > &seeds, SVFG *vfg)
OrderedSet< const VFGNode * >	computeDataDependenceSVFGNodes (const OrderedSet< const SVFStmt * > &seeds, SVFG *vfg)
OrderedSet< const ICFGNode * >	svfgNodesToICFGNodes (const OrderedSet< const VFGNode * > &nodes, const OrderedSet< const SVFStmt * > &seeds)
	Project the retained VFG nodes (plus the seeds) onto their ICFG nodes.
OrderedSet< const SVFStmt * >	getDependentThreadCreate (const SVFStmt *stmt)
OrderedSet< const TCTNode * >	getTCTNodeSetFromNode (const ICFGNode *node)
OrderedSet< const ICFGNode * >	getLockSet (const ICFGNode *node)
OrderedSet< const CallICFGNode * >	collectPthreadStatements (const OrderedSet< const SVFStmt * > &vulnerableStmts)
OrderedSet< const CallICFGNode * >	collectMutexStatements (const OrderedSet< const SVFStmt * > &vulnerableStmts)
std::pair< OrderedSet< const CallICFGNode * >, OrderedSet< const CallICFGNode * > >	collectCommonThreadStatements (const OrderedSet< const SVFStmt * > &vulnerableStatements)
OrderedSet< const ICFGNode * >	buildBackwardICFGNodeSet (const OrderedSet< const ICFGNode * > &vulnerableNodes)
OrderedSet< const ICFGNode * >	expandCallDependence (const OrderedSet< const ICFGNode * > &nodes)
OrderedSet< const ICFGNode * >	runDualSlicing (const OrderedSet< const ICFGNode * > &slicedNodes)
Protected Attributes inherited from SVF::MTASlicerBase
SVFIR *	svfIr
AndersenBase *	pta
MHP *	mhp
LockAnalysis *	lockAnalysis
CallGraph *	callGraph
SVFG *	vfg
	thread-aware VFG_pre (PTA/Single slicers; null for MTA)

Detailed Description

SingleSlicer - Unified slicer combining synchronization, data, and call dependence into ONE slice (the single-pass baseline, MSli §3/§5.4: the transitive closure of the target statements under the combined dependence graph). Both ILA and FSPTA run on this single slice, so V_ILA, V_PTA subset V_Single. Used by the differential-slicing ablation (-mta-slicing-single).

Iteratively applies data dependence (over the thread-aware VFG_pre) and call dependence until convergence, then a single dual-slicing pass.

Definition at line 258 of file MTASlicer.h.

Constructor & Destructor Documentation

SingleSlicer()

SVF::SingleSlicer::SingleSlicer	(	SVFIR *	svfIr,
		AndersenBase *	pta,
		MHP *	mhp,
		LockAnalysis *	lockAnalysis,
		SVFG *	vfg = nullptr
	)

Definition at line 1046 of file MTASlicer.cpp.

    : MTASlicerBase(svfIr, pta, mhp, lockAnalysis, vfg)
{
}

Member Function Documentation

runSlicing()

OrderedSet< const ICFGNode * > SVF::SingleSlicer::runSlicing

(

const OrderedSet< const SVFStmt * > &

vulnerableStatements

)

Perform unified slicing combining synchronization, data, and call dependence.

Parameters

vulnerableStatements

Set of vulnerable statements to start slicing from

Returns

Set of ICFG nodes in the slice (including call/ret and entry/exit nodes)

Definition at line 1055 of file MTASlicer.cpp.

{
 
    // Step 1: Synchronization dependence -- the relevant pthread (fork/join) and
    // mutex (lock/unlock) statements for the targets.
    auto commonStmts = collectCommonThreadStatements(vulnerableStatements);
    const OrderedSet<const CallICFGNode*>& pthreadCallNodes = commonStmts.first;
    const OrderedSet<const CallICFGNode*>& mutexCallNodes = commonStmts.second;
 
    // Step 2: Seed the working set with the synchronization statements (and their
    // return nodes) and the target statements themselves.
    OrderedSet<const ICFGNode*> currentNodes;
    currentNodes.insert(pthreadCallNodes.begin(), pthreadCallNodes.end());
    for (const CallICFGNode* pthreadCallNode : pthreadCallNodes)
        currentNodes.insert(pthreadCallNode->getRetICFGNode());
    currentNodes.insert(mutexCallNodes.begin(), mutexCallNodes.end());
    for (const CallICFGNode* mutexCallNode : mutexCallNodes)
        currentNodes.insert(mutexCallNode->getRetICFGNode());
    collectLockFunctionMarkers(mutexCallNodes, currentNodes);
    for (const SVFStmt* stmt : vulnerableStatements)
        currentNodes.insert(stmt->getICFGNode());
 
    // Step 3: Close over data dependence (the thread-aware VFG_pre value flow --
    // direct + indirect + interference, the same model the FSPTA stage uses) and call
    // dependence (function expansion), alternately, until the node set converges.
    bool changed = true;
    int iteration = 0;
    const int maxIterations = 100; // safety bound against non-convergence
    while (changed && iteration < maxIterations)
    {
        iteration++;
        OrderedSet<const ICFGNode*> previousNodes = currentNodes;
 
        OrderedSet<const SVFStmt*> currentStatements;
        for (const ICFGNode* node : currentNodes)
        {
            const ICFGNode::SVFStmtList& stmts = node->getSVFStmts();
            currentStatements.insert(stmts.begin(), stmts.end());
        }
 
        OrderedSet<const ICFGNode*> dataDepNodes =
            sliceDataDependenceOverVFG(currentStatements, vfg);
        currentNodes.insert(dataDepNodes.begin(), dataDepNodes.end());
 
        currentNodes = expandCallDependence(currentNodes);
 
        changed = (currentNodes != previousNodes);
    }
 
    if (iteration >= maxIterations)
        SVFUtil::writeWrnMsg("SingleSlicer reached max iterations, may not have converged");
 
    // Step 4: One dual-slicing (temporal) pass at the end.
    return runDualSlicing(currentNodes);
}

---

The documentation for this class was generated from the following files:

• /home/runner/work/SVF/SVF/svf/include/MTA/MTASlicer.h
• /home/runner/work/SVF/SVF/svf/lib/MTA/MTASlicer.cpp