SVF::PreAnalysis Class Reference

#include <PreAnalysis.h>

Public Types
typedef SCCDetection< CallGraph * >	CallGraphSCC

Public Member Functions
	PreAnalysis (SVFIR *pag, ICFG *icfg)
virtual	~PreAnalysis ()
AndersenWaveDiff *	getPointerAnalysis () const
	Accessors for Andersen's results.
CallGraph *	getCallGraph () const
CallGraphSCC *	getCallGraphSCC () const
void	initWTO ()
	Build WTO for each function using call graph SCC.
const Map< const FunObjVar *, const ICFGWTO * > &	getFuncToWTO () const
	Accessors for WTO data.
void	initCycleValVars ()
const Set< const ValVar * >	getCycleValVars (const ICFGCycleWTO *cycle) const

Private Attributes
SVFIR *	svfir
ICFG *	icfg
AndersenWaveDiff *	pta
CallGraph *	callGraph
CallGraphSCC *	callGraphSCC
Map< const FunObjVar *, const ICFGWTO * >	funcToWTO
Map< const ICFGCycleWTO *, Set< const ValVar * > >	cycleToValVars

Detailed Description

Definition at line 47 of file PreAnalysis.h.

Member Typedef Documentation

CallGraphSCC

typedef SCCDetection<CallGraph*> SVF::PreAnalysis::CallGraphSCC

Definition at line 50 of file PreAnalysis.h.

Constructor & Destructor Documentation

PreAnalysis()

PreAnalysis::PreAnalysis	(	SVFIR *	pag,
		ICFG *	icfg
	)

Definition at line 37 of file PreAnalysis.cpp.

    : svfir(pag), icfg(icfg), pta(nullptr), callGraph(nullptr), callGraphSCC(nullptr)
{
    pta = AndersenWaveDiff::createAndersenWaveDiff(svfir);
    callGraph = pta->getCallGraph();
    callGraphSCC = pta->getCallGraphSCC();
}

~PreAnalysis()

PreAnalysis::~PreAnalysis ( )

virtual

Definition at line 45 of file PreAnalysis.cpp.

{
    for (auto& [func, wto] : funcToWTO)
        delete wto;
}

Member Function Documentation

getCallGraph()

CallGraph * SVF::PreAnalysis::getCallGraph ( ) const

inline

Definition at line 60 of file PreAnalysis.h.

    {
        return callGraph;
    }

getCallGraphSCC()

CallGraphSCC * SVF::PreAnalysis::getCallGraphSCC ( ) const

inline

Definition at line 64 of file PreAnalysis.h.

    {
        return callGraphSCC;
    }

getCycleValVars()

const Set< const ValVar * > SVF::PreAnalysis::getCycleValVars ( const ICFGCycleWTO *  cycle ) const

inline

Look up the ValVar id set of a WTO cycle. Returns nullptr if the cycle is unknown (e.g. dense mode, where the map is never built).

Definition at line 83 of file PreAnalysis.h.

    {
        auto it = cycleToValVars.find(cycle);
        return it == cycleToValVars.end() ? Set<const ValVar*>() : it->second;
    }

getFuncToWTO()

const Map< const FunObjVar *, const ICFGWTO * > & SVF::PreAnalysis::getFuncToWTO ( ) const

inline

Accessors for WTO data.

Definition at line 72 of file PreAnalysis.h.

    {
        return funcToWTO;
    }

getPointerAnalysis()

AndersenWaveDiff * SVF::PreAnalysis::getPointerAnalysis ( ) const

inline

Accessors for Andersen's results.

Definition at line 56 of file PreAnalysis.h.

    {
        return pta;
    }

initCycleValVars()

void PreAnalysis::initCycleValVars

(

)

Walk every function's WTO and populate cycleToValVars bottom-up. Called once right after initWTO(). No-op in dense mode.

Definition at line 98 of file PreAnalysis.cpp.

{
    if (Options::AESparsity() != AbstractInterpretation::AESparsity::SemiSparse)
        return;
 
    // Step 1: Collect all cycles in top-down order using a stack-based DFS,
    // then reverse to get bottom-up order (inner cycles before outer ones).
    std::vector<const ICFGCycleWTO*> cycles;
    {
        std::vector<const ICFGWTOComp*> stack;
        for (const auto& kv : funcToWTO)
        {
            if (!kv.second) continue;
            for (const ICFGWTOComp* comp : kv.second->getWTOComponents())
                stack.push_back(comp);
        }
        while (!stack.empty())
        {
            const ICFGWTOComp* comp = stack.back();
            stack.pop_back();
            if (const ICFGCycleWTO* cycle = SVFUtil::dyn_cast<ICFGCycleWTO>(comp))
            {
                for (const ICFGWTOComp* sub : cycle->getWTOComponents())
                    stack.push_back(sub);
                cycles.push_back(cycle);
            }
        }
        std::reverse(cycles.begin(), cycles.end());
    }
 
    // Step 2: Build ValVar sets bottom-up.  Inner cycles are already in the
    // map when we reach their enclosing cycle.
    for (const ICFGCycleWTO* cycle : cycles)
    {
        Set<const ValVar*>& out = cycleToValVars[cycle];
 
        // Gather every ICFG node in this cycle (head + body singletons).
        // For nested sub-cycles, merge their already-computed sets instead.
        std::vector<const ICFGNode*> nodes;
        nodes.push_back(cycle->head()->getICFGNode());
        for (const ICFGWTOComp* comp : cycle->getWTOComponents())
        {
            if (const ICFGSingletonWTO* s = SVFUtil::dyn_cast<ICFGSingletonWTO>(comp))
                nodes.push_back(s->getICFGNode());
            else if (const ICFGCycleWTO* sub = SVFUtil::dyn_cast<ICFGCycleWTO>(comp))
                out.insert(cycleToValVars[sub].begin(), cycleToValVars[sub].end());
        }
 
        // For each node, collect LHS ValVar IDs from its statements.
        for (const ICFGNode* node : nodes)
        {
            for (const SVFStmt* stmt : node->getSVFStmts())
            {
                const ValVar* lhs = nullptr;
                if (const AssignStmt* a = SVFUtil::dyn_cast<AssignStmt>(stmt))
                    lhs = SVFUtil::dyn_cast<ValVar>(a->getLHSVar());
                else if (const MultiOpndStmt* m = SVFUtil::dyn_cast<MultiOpndStmt>(stmt))
                    lhs = m->getRes();
                if (lhs)
                    out.insert(lhs);
            }
            // FunEntryICFGNode owns ArgValVars (formal parameters) that have
            // no defining stmt at the entry — the CallPE lives on the caller
            // side.  For recursive cycles whose head is a FunEntry, we need
            // these IDs so widening/narrowing observes them across iterations.
            if (const FunEntryICFGNode* fe = SVFUtil::dyn_cast<FunEntryICFGNode>(node))
            {
                for (const SVFVar* fp : fe->getFormalParms())
                    if (const ValVar* v = SVFUtil::dyn_cast<ValVar>(fp))
                        out.insert(v);
            }
        }
    }
}

initWTO()

void PreAnalysis::initWTO

(

)

Build WTO for each function using call graph SCC.

Definition at line 51 of file PreAnalysis.cpp.

{
    callGraphSCC->find();
 
    for (auto it = callGraph->begin(); it != callGraph->end(); it++)
    {
        const FunObjVar *fun = it->second->getFunction();
        if (fun->isDeclaration())
            continue;
 
        NodeID repNodeId = callGraphSCC->repNode(it->second->getId());
        auto cgSCCNodes = callGraphSCC->subNodes(repNodeId);
 
        bool isEntry = false;
        if (it->second->getInEdges().empty())
            isEntry = true;
        for (auto inEdge: it->second->getInEdges())
        {
            NodeID srcNodeId = inEdge->getSrcID();
            if (!cgSCCNodes.test(srcNodeId))
                isEntry = true;
        }
 
        if (isEntry)
        {
            Set<const FunObjVar*> funcScc;
            for (const auto& node: cgSCCNodes)
            {
                funcScc.insert(callGraph->getGNode(node)->getFunction());
            }
            ICFGWTO* iwto = new ICFGWTO(icfg->getFunEntryICFGNode(fun), funcScc);
            iwto->init();
            funcToWTO[it->second->getFunction()] = iwto;
        }
    }
 
}

Member Data Documentation

callGraph

CallGraph* SVF::PreAnalysis::callGraph

private

Definition at line 93 of file PreAnalysis.h.

callGraphSCC

CallGraphSCC* SVF::PreAnalysis::callGraphSCC

private

Definition at line 94 of file PreAnalysis.h.

cycleToValVars

Map<const ICFGCycleWTO*, Set<const ValVar*> > SVF::PreAnalysis::cycleToValVars

private

Pre-computed (semi-sparse only) map from a WTO cycle to the IDs of every ValVar whose def-site is inside that cycle, including all nested sub-cycles. Empty in dense mode.

Definition at line 101 of file PreAnalysis.h.

funcToWTO

Map<const FunObjVar*, const ICFGWTO*> SVF::PreAnalysis::funcToWTO

private

Definition at line 96 of file PreAnalysis.h.

icfg

ICFG* SVF::PreAnalysis::icfg

private

Definition at line 91 of file PreAnalysis.h.

pta

AndersenWaveDiff* SVF::PreAnalysis::pta

private

Definition at line 92 of file PreAnalysis.h.

svfir

SVFIR* SVF::PreAnalysis::svfir

private

Definition at line 90 of file PreAnalysis.h.

---

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

• /home/runner/work/SVF/SVF/svf/include/AE/Svfexe/PreAnalysis.h
• /home/runner/work/SVF/SVF/svf/lib/AE/Svfexe/PreAnalysis.cpp