SVF::FlowSensitiveStat Class Reference

#include <WPAStat.h>

Inheritance diagram for SVF::FlowSensitiveStat:

Public Types
typedef FlowSensitive::DFInOutMap	DFInOutMap
typedef FlowSensitive::PtsMap	PtsMap
Public Types inherited from SVF::SVFStat
enum	ClockType { Wall , CPU }
typedef OrderedMap< std::string, u32_t >	NUMStatMap
typedef OrderedMap< std::string, double >	TIMEStatMap

Public Member Functions
	FlowSensitiveStat (FlowSensitive *pta)
virtual	~FlowSensitiveStat ()
virtual void	performStat ()
Public Member Functions inherited from SVF::PTAStat
	PTAStat (PointerAnalysis *p)
virtual	~PTAStat ()
void	setMemUsageBefore (u32_t vmrss, u32_t vmsize)
void	setMemUsageAfter (u32_t vmrss, u32_t vmsize)
void	performStat () override
void	callgraphStat () override
Public Member Functions inherited from SVF::SVFStat
	SVFStat ()
virtual	~SVFStat ()
virtual void	startClk ()
virtual void	endClk ()
virtual void	printStat (std::string str="")
virtual void	performStatPerQuery (NodeID)
virtual void	printStatPerQuery (NodeID, const PointsTo &)

Public Attributes
FlowSensitive *	fspta
Public Attributes inherited from SVF::PTAStat
NodeBS	localVarInRecursion
Public Attributes inherited from SVF::SVFStat
NUMStatMap	generalNumMap
NUMStatMap	PTNumStatMap
TIMEStatMap	timeStatMap
double	startTime
double	endTime

Private Types
enum	ENUM_INOUT { IN_SET , OUT_SET }

Private Member Functions
void	clearStat ()
void	statNullPtr ()
void	statPtsSize ()
void	statAddrVarPtsSize ()
void	calculateAddrVarPts (NodeID pointer, const SVFGNode *node)
void	statInOutPtsSize (const DFInOutMap &data, ENUM_INOUT inOrOut)

Private Attributes
u32_t	_NumOfNullPtr
u32_t	_NumOfConstantPtr
u32_t	_NumOfBlackholePtr
u32_t	_NumOfSVFGNodesHaveInOut [2]
	number of SVFG nodes which have IN/OUT set.
u32_t	_NumOfFormalInSVFGNodesHaveInOut [2]
u32_t	_NumOfFormalOutSVFGNodesHaveInOut [2]
u32_t	_NumOfActualInSVFGNodesHaveInOut [2]
u32_t	_NumOfActualOutSVFGNodesHaveInOut [2]
u32_t	_NumOfLoadSVFGNodesHaveInOut [2]
u32_t	_NumOfStoreSVFGNodesHaveInOut [2]
u32_t	_NumOfMSSAPhiSVFGNodesHaveInOut [2]
u32_t	_NumOfVarHaveINOUTPts [2]
	number of pag nodes which have points-to set in IN/OUT set.
u32_t	_NumOfVarHaveEmptyINOUTPts [2]
u32_t	_NumOfVarHaveINOUTPtsInFormalIn [2]
u32_t	_NumOfVarHaveINOUTPtsInFormalOut [2]
u32_t	_NumOfVarHaveINOUTPtsInActualIn [2]
u32_t	_NumOfVarHaveINOUTPtsInActualOut [2]
u32_t	_NumOfVarHaveINOUTPtsInLoad [2]
u32_t	_NumOfVarHaveINOUTPtsInStore [2]
u32_t	_NumOfVarHaveINOUTPtsInMSSAPhi [2]
u32_t	_PotentialNumOfVarHaveINOUTPts [2]
u32_t	_MaxPtsSize
	sizes of points-to set
u32_t	_MaxTopLvlPtsSize
	max points-to set size in top-level pointers.
u32_t	_MaxInOutPtsSize [2]
	max points-to set size in IN/OUT set.
u32_t	_TotalPtsSize
	total points-to set size.
double	_AvgPtsSize
	average points-to set size.
double	_AvgTopLvlPtsSize
	average points-to set size in top-level pointers.
double	_AvgInOutPtsSize [2]
	average points-to set size in IN set.
double	_AvgAddrTakenVarPtsSize
	average points-to set size of addr-taken variables.
u32_t	_MaxAddrTakenVarPts
	max points-to set size of addr-taken variables.
u32_t	_NumOfAddrTakeVar
	number of occurrences of addr-taken variables in load/store.

Additional Inherited Members
Static Public Member Functions inherited from SVF::SVFStat
static double	getClk (bool mark=false)
Static Public Attributes inherited from SVF::SVFStat
static bool	printGeneralStats = true
	SVF's general statistics are only printed once even if you run multiple anayses.
static double	timeOfBuildingLLVMModule = 0
static double	timeOfBuildingSymbolTable = 0
static double	timeOfBuildingSVFIR = 0
Protected Attributes inherited from SVF::PTAStat
PointerAnalysis *	pta
u32_t	_vmrssUsageBefore
u32_t	_vmrssUsageAfter
u32_t	_vmsizeUsageBefore
u32_t	_vmsizeUsageAfter

Detailed Description

Statistics of flow-sensitive analysis

Definition at line 85 of file WPAStat.h.

Member Typedef Documentation

DFInOutMap

typedef FlowSensitive::DFInOutMap SVF::FlowSensitiveStat::DFInOutMap

Definition at line 88 of file WPAStat.h.

PtsMap

typedef FlowSensitive::PtsMap SVF::FlowSensitiveStat::PtsMap

Definition at line 89 of file WPAStat.h.

Member Enumeration Documentation

ENUM_INOUT

enum SVF::FlowSensitiveStat::ENUM_INOUT

private

Enumerator
IN_SET
OUT_SET

Definition at line 105 of file WPAStat.h.

    {
        IN_SET,
        OUT_SET
    };

Constructor & Destructor Documentation

FlowSensitiveStat()

SVF::FlowSensitiveStat::FlowSensitiveStat ( FlowSensitive *  pta )

inline

Definition at line 93 of file WPAStat.h.

                                         : PTAStat(pta)
    {
        fspta = pta;
        clearStat();
        startClk();
    }

~FlowSensitiveStat()

virtual SVF::FlowSensitiveStat::~FlowSensitiveStat ( )

inlinevirtual

Definition at line 100 of file WPAStat.h.

{}

Member Function Documentation

calculateAddrVarPts()

void FlowSensitiveStat::calculateAddrVarPts ( NodeID  pointer, const SVFGNode *  svfg_node  )

private

Points-to size

Definition at line 492 of file FlowSensitiveStat.cpp.

{
    const PointsTo& pts = fspta->getPts(pointer);
    _NumOfAddrTakeVar += pts.count();
    PointsTo::iterator ptsIt = pts.begin();
    PointsTo::iterator ptsEit = pts.end();
    for (; ptsIt != ptsEit; ++ptsIt)
    {
        const NodeID ptd = *ptsIt;
 
        const PointsTo& cpts = fspta->getDFOutPtsSet(svfg_node, ptd);
        _AvgAddrTakenVarPtsSize += cpts.count();
        if (cpts.count() > _MaxAddrTakenVarPts)
            _MaxAddrTakenVarPts = cpts.count();
    }
}

clearStat()

void FlowSensitiveStat::clearStat ( )

private

Clear statistics

SVFG nodes

SVFIR nodes.

Definition at line 41 of file FlowSensitiveStat.cpp.

{
    _NumOfNullPtr = 0;
    _NumOfConstantPtr = 0;
    _NumOfBlackholePtr = 0;
    _MaxPtsSize = _MaxTopLvlPtsSize = 0;
    _AvgPtsSize = _AvgTopLvlPtsSize = 0;
    _AvgAddrTakenVarPtsSize = _NumOfAddrTakeVar = 0;
    _MaxAddrTakenVarPts = 0;
    _TotalPtsSize = 0;
 
    for (int i= IN_SET; i<= OUT_SET; i++)
    {
        _NumOfSVFGNodesHaveInOut[i] = 0;
        _NumOfFormalInSVFGNodesHaveInOut[i] = 0;
        _NumOfFormalOutSVFGNodesHaveInOut[i] = 0;
        _NumOfActualInSVFGNodesHaveInOut[i] = 0;
        _NumOfActualOutSVFGNodesHaveInOut[i] = 0;
        _NumOfLoadSVFGNodesHaveInOut[i] = 0;
        _NumOfStoreSVFGNodesHaveInOut[i] = 0;
        _NumOfMSSAPhiSVFGNodesHaveInOut[i] = 0;
 
        _NumOfVarHaveINOUTPts[i] = 0;
        _NumOfVarHaveEmptyINOUTPts[i] = 0;
        _NumOfVarHaveINOUTPtsInFormalIn[i] = 0;
        _NumOfVarHaveINOUTPtsInFormalOut[i] = 0;;
        _NumOfVarHaveINOUTPtsInActualIn[i] = 0;
        _NumOfVarHaveINOUTPtsInActualOut[i] = 0;
        _NumOfVarHaveINOUTPtsInLoad[i] = 0;
        _NumOfVarHaveINOUTPtsInStore[i] = 0;
        _NumOfVarHaveINOUTPtsInMSSAPhi[i] = 0;
        _PotentialNumOfVarHaveINOUTPts[i] = 0;
 
        _MaxInOutPtsSize[i] = 0;
        _AvgInOutPtsSize[i] = 0;
    }
}

performStat()

void FlowSensitiveStat::performStat ( )

virtual

Start statistics

SVFG nodes.

Implements SVF::SVFStat.

Definition at line 84 of file FlowSensitiveStat.cpp.

{
    assert(SVFUtil::isa<FlowSensitive>(fspta) && "not an flow-sensitive pta pass!! what else??");
    endClk();
 
    clearStat();
 
    SVFIR* pag = fspta->getPAG();
 
    // stat null ptr number
    statNullPtr();
 
    // stat points-to set information
    statPtsSize();
 
    // stat address-taken variables' points-to
    statAddrVarPtsSize();
 
    u32_t fiObjNumber = 0;
    u32_t fsObjNumber = 0;
    Set<NodeID> nodeSet;
    for (SVFIR::const_iterator nodeIt = pag->begin(), nodeEit = pag->end(); nodeIt != nodeEit; nodeIt++)
    {
        NodeID nodeId = nodeIt->first;
        PAGNode* pagNode = nodeIt->second;
        if(SVFUtil::isa<ObjVar>(pagNode))
        {
            const BaseObjVar* baseObj = pag->getBaseObject(nodeId);
            NodeID baseId = baseObj->getId();
            if (nodeSet.insert(baseId).second)
            {
                if (baseObj->isFieldInsensitive())
                    fiObjNumber++;
                else
                    fsObjNumber++;
            }
        }
    }
 
    PTNumStatMap["FIObjNum"] = fiObjNumber;
    PTNumStatMap["FSObjNum"] = fsObjNumber;
 
    unsigned numOfCopy = 0;
    unsigned numOfStore = 0;
    SVFG::iterator svfgNodeIt = fspta->svfg->begin();
    SVFG::iterator svfgNodeEit = fspta->svfg->end();
    for (; svfgNodeIt != svfgNodeEit; ++svfgNodeIt)
    {
        SVFGNode* svfgNode = svfgNodeIt->second;
        if (SVFUtil::isa<CopySVFGNode>(svfgNode))
            numOfCopy++;
        else if (SVFUtil::isa<StoreSVFGNode>(svfgNode))
            numOfStore++;
    }
 
    PTAStat::performStat();
 
    timeStatMap["TotalTime"] = (endTime - startTime)/TIMEINTERVAL;
    timeStatMap["SolveTime"] = fspta->solveTime;
    timeStatMap["SCCTime"] = fspta->sccTime;
    timeStatMap["ProcessTime"] = fspta->processTime;
    timeStatMap["PropagationTime"] = fspta->propagationTime;
    timeStatMap["DirectPropaTime"] = fspta->directPropaTime;
    timeStatMap["IndirectPropaTime"] = fspta->indirectPropaTime;
    timeStatMap["Strong/WeakUpdTime"] = fspta->updateTime;
    timeStatMap["AddrTime"] = fspta->addrTime;
    timeStatMap["CopyTime"] = fspta->copyTime;
    timeStatMap["GepTime"] = fspta->gepTime;
    timeStatMap["LoadTime"] = fspta->loadTime;
    timeStatMap["StoreTime"] = fspta->storeTime;
    timeStatMap["UpdateCGTime"] = fspta->updateCallGraphTime;
    timeStatMap["PhiTime"] = fspta->phiTime;
 
    PTNumStatMap["TotalPointers"] = pag->getValueNodeNum();
    PTNumStatMap["TotalObjects"] = pag->getObjectNodeNum();
 
    PTNumStatMap["Pointers"] = pag->getValueNodeNum();
    PTNumStatMap["MemObjects"] = pag->getObjectNodeNum();
    PTNumStatMap["DummyFieldPtrs"] = pag->getFieldValNodeNum();
    PTNumStatMap["FieldObjs"] = pag->getFieldObjNodeNum();
 
    PTNumStatMap["CopysNum"] = numOfCopy;
    PTNumStatMap["StoresNum"] = numOfStore;
 
    PTNumStatMap["SolveIterations"] = fspta->numOfIteration;
 
    PTNumStatMap["IndEdgeSolved"] = fspta->getNumOfResolvedIndCallEdge();
 
    PTNumStatMap["NullPointer"] = _NumOfNullPtr;
    PTNumStatMap["PointsToConstPtr"] = _NumOfConstantPtr;
    PTNumStatMap["PointsToBlkPtr"] = _NumOfBlackholePtr;
 
    PTNumStatMap["StrongUpdates"] = fspta->svfgHasSU.count();
 
    PTNumStatMap["SNodesHaveIN"] = _NumOfSVFGNodesHaveInOut[IN_SET];
    PTNumStatMap["SNodesHaveOUT"] = _NumOfSVFGNodesHaveInOut[OUT_SET];
 
    PTNumStatMap["FI_SNodesHaveIN"] = _NumOfFormalInSVFGNodesHaveInOut[IN_SET];
    PTNumStatMap["FI_SNodesHaveOUT"] = _NumOfFormalInSVFGNodesHaveInOut[OUT_SET];
 
    PTNumStatMap["FO_SNodesHaveIN"] = _NumOfFormalOutSVFGNodesHaveInOut[IN_SET];
    PTNumStatMap["FO_SNodesHaveOUT"] = _NumOfFormalOutSVFGNodesHaveInOut[OUT_SET];
 
    PTNumStatMap["AI_SNodesHaveIN"] = _NumOfActualInSVFGNodesHaveInOut[IN_SET];
    PTNumStatMap["AI_SNodesHaveOUT"] = _NumOfActualInSVFGNodesHaveInOut[OUT_SET];
 
    PTNumStatMap["AO_SNodesHaveIN"] = _NumOfActualOutSVFGNodesHaveInOut[IN_SET];
    PTNumStatMap["AO_SNodesHaveOUT"] = _NumOfActualOutSVFGNodesHaveInOut[OUT_SET];
 
    PTNumStatMap["LD_SNodesHaveIN"] = _NumOfLoadSVFGNodesHaveInOut[IN_SET];
    PTNumStatMap["LD_SNodesHaveOUT"] = _NumOfLoadSVFGNodesHaveInOut[OUT_SET];
 
    PTNumStatMap["ST_SNodesHaveIN"] = _NumOfStoreSVFGNodesHaveInOut[IN_SET];
    PTNumStatMap["ST_SNodesHaveOUT"] = _NumOfStoreSVFGNodesHaveInOut[OUT_SET];
 
    PTNumStatMap["PHI_SNodesHaveIN"] = _NumOfMSSAPhiSVFGNodesHaveInOut[IN_SET];
    PTNumStatMap["PHI_SNodesHaveOUT"] = _NumOfMSSAPhiSVFGNodesHaveInOut[OUT_SET];
 
    /*-----------------------------------------------------*/
    // SVFIR nodes.
    PTNumStatMap["VarHaveIN"] = _NumOfVarHaveINOUTPts[IN_SET];
    PTNumStatMap["VarHaveOUT"] = _NumOfVarHaveINOUTPts[OUT_SET];
 
    PTNumStatMap["PotentialVarHaveIN"] = _PotentialNumOfVarHaveINOUTPts[IN_SET];
    PTNumStatMap["PotentialVarHaveOUT"] = _PotentialNumOfVarHaveINOUTPts[OUT_SET];
 
    PTNumStatMap["VarHaveEmptyIN"] = _NumOfVarHaveEmptyINOUTPts[IN_SET];
    PTNumStatMap["VarHaveEmptyOUT"] = _NumOfVarHaveEmptyINOUTPts[OUT_SET];
 
    PTNumStatMap["VarHaveIN_FI"] = _NumOfVarHaveINOUTPtsInFormalIn[IN_SET];
    PTNumStatMap["VarHaveOUT_FI"] = _NumOfVarHaveINOUTPtsInFormalIn[OUT_SET];
 
    PTNumStatMap["VarHaveIN_FO"] = _NumOfVarHaveINOUTPtsInFormalOut[IN_SET];
    PTNumStatMap["VarHaveOUT_FO"] = _NumOfVarHaveINOUTPtsInFormalOut[OUT_SET];
 
    PTNumStatMap["VarHaveIN_AI"] = _NumOfVarHaveINOUTPtsInActualIn[IN_SET];
    PTNumStatMap["VarHaveOUT_AI"] = _NumOfVarHaveINOUTPtsInActualIn[OUT_SET];
 
    PTNumStatMap["VarHaveIN_AO"] = _NumOfVarHaveINOUTPtsInActualOut[IN_SET];
    PTNumStatMap["VarHaveOUT_AO"] = _NumOfVarHaveINOUTPtsInActualOut[OUT_SET];
 
    PTNumStatMap["VarHaveIN_LD"] = _NumOfVarHaveINOUTPtsInLoad[IN_SET];
    PTNumStatMap["VarHaveOUT_LD"] = _NumOfVarHaveINOUTPtsInLoad[OUT_SET];
 
    PTNumStatMap["VarHaveIN_ST"] = _NumOfVarHaveINOUTPtsInStore[IN_SET];
    PTNumStatMap["VarHaveOUT_ST"] = _NumOfVarHaveINOUTPtsInStore[OUT_SET];
 
    PTNumStatMap["VarHaveIN_PHI"] = _NumOfVarHaveINOUTPtsInMSSAPhi[IN_SET];
    PTNumStatMap["VarHaveOUT_PHI"] = _NumOfVarHaveINOUTPtsInMSSAPhi[OUT_SET];
 
    PTNumStatMap["MaxPtsSize"] = _MaxPtsSize;
    PTNumStatMap["MaxTopLvlPtsSize"] = _MaxTopLvlPtsSize;
    PTNumStatMap["MaxINPtsSize"] = _MaxInOutPtsSize[IN_SET];
    PTNumStatMap["MaxOUTPtsSize"] = _MaxInOutPtsSize[OUT_SET];
 
    timeStatMap["AvgPtsSize"] = _AvgPtsSize;
    timeStatMap["AvgTopLvlPtsSize"] = _AvgTopLvlPtsSize;
 
    PTNumStatMap["NumOfAddrTakenVar"] = _NumOfAddrTakeVar;
    timeStatMap["AvgAddrTakenVarPts"] = (_NumOfAddrTakeVar == 0) ?
                                        0 : ((double)_AvgAddrTakenVarPtsSize / _NumOfAddrTakeVar);
    PTNumStatMap["MaxAddrTakenVarPts"] = _MaxAddrTakenVarPts;
 
    timeStatMap["AvgINPtsSize"] = _AvgInOutPtsSize[IN_SET];
    timeStatMap["AvgOUTPtsSize"] = _AvgInOutPtsSize[OUT_SET];
 
    PTNumStatMap["ProcessedAddr"] = fspta->numOfProcessedAddr;
    PTNumStatMap["ProcessedCopy"] = fspta->numOfProcessedCopy;
    PTNumStatMap["ProcessedGep"] = fspta->numOfProcessedGep;
    PTNumStatMap["ProcessedLoad"] = fspta->numOfProcessedLoad;
    PTNumStatMap["ProcessedStore"] = fspta->numOfProcessedStore;
    PTNumStatMap["ProcessedPhi"] = fspta->numOfProcessedPhi;
    PTNumStatMap["ProcessedAParam"] = fspta->numOfProcessedActualParam;
    PTNumStatMap["ProcessedFRet"] = fspta->numOfProcessedFormalRet;
    PTNumStatMap["ProcessedMSSANode"] = fspta->numOfProcessedMSSANode;
 
    PTNumStatMap["NumOfNodesInSCC"] = fspta->numOfNodesInSCC;
    PTNumStatMap["MaxSCCSize"] = fspta->maxSCCSize;
    PTNumStatMap["NumOfSCC"] = fspta->numOfSCC;
    timeStatMap["AverageSCCSize"] = (fspta->numOfSCC == 0) ? 0 :
                                    ((double)fspta->numOfNodesInSCC / fspta->numOfSCC);
 
    PTAStat::printStat("Flow-Sensitive Pointer Analysis Statistics");
}

statAddrVarPtsSize()

void FlowSensitiveStat::statAddrVarPtsSize ( )

private

Points-to size

Definition at line 475 of file FlowSensitiveStat.cpp.

{
    SVFG::SVFGNodeIDToNodeMapTy::const_iterator it = fspta->svfg->begin();
    SVFG::SVFGNodeIDToNodeMapTy::const_iterator eit = fspta->svfg->end();
    for (; it != eit; ++it)
    {
        const SVFGNode* node = it->second;
        if (const StoreSVFGNode* store = SVFUtil::dyn_cast<StoreSVFGNode>(node))
        {
            calculateAddrVarPts(store->getPAGDstNodeID(), store);
        }
    }
}

statInOutPtsSize()

void FlowSensitiveStat::statInOutPtsSize ( const DFInOutMap &  data, ENUM_INOUT  inOrOut  )

private

points-to target number

Definition at line 360 of file FlowSensitiveStat.cpp.

{
    // Get number of nodes which have IN/OUT set
    _NumOfSVFGNodesHaveInOut[inOrOut] = data.size();
 
    u32_t inOutPtsSize = 0;
    DFInOutMap::const_iterator it = data.begin();
    DFInOutMap::const_iterator eit = data.end();
    for (; it != eit; ++it)
    {
        const SVFGNode* node = fspta->svfg->getSVFGNode(it->first);
 
        // Count number of SVFG nodes have IN/OUT set.
        if (SVFUtil::isa<FormalINSVFGNode>(node))
            _NumOfFormalInSVFGNodesHaveInOut[inOrOut]++;
        else if (SVFUtil::isa<FormalOUTSVFGNode>(node))
            _NumOfFormalOutSVFGNodesHaveInOut[inOrOut]++;
        else if (SVFUtil::isa<ActualINSVFGNode>(node))
            _NumOfActualInSVFGNodesHaveInOut[inOrOut]++;
        else if (SVFUtil::isa<ActualOUTSVFGNode>(node))
            _NumOfActualOutSVFGNodesHaveInOut[inOrOut]++;
        else if (SVFUtil::isa<LoadSVFGNode>(node))
            _NumOfLoadSVFGNodesHaveInOut[inOrOut]++;
        else if (SVFUtil::isa<StoreSVFGNode>(node))
            _NumOfStoreSVFGNodesHaveInOut[inOrOut]++;
        else if (SVFUtil::isa<MSSAPHISVFGNode>(node))
            _NumOfMSSAPhiSVFGNodesHaveInOut[inOrOut]++;
        else
            assert(false && "unexpected node have IN/OUT set");
 
        /*-----------------------------------------------------*/
 
        // Count SVFIR nodes and their points-to set size.
        const PtsMap& cptsMap = it->second;
        PtsMap::const_iterator ptsIt = cptsMap.begin();
        PtsMap::const_iterator ptsEit = cptsMap.end();
        for (; ptsIt != ptsEit; ++ptsIt)
        {
            if (ptsIt->second.empty())
            {
                _NumOfVarHaveEmptyINOUTPts[inOrOut]++;
                continue;
            }
 
            u32_t ptsNum = ptsIt->second.count();   
 
            // Only node with non-empty points-to set are counted.
            _NumOfVarHaveINOUTPts[inOrOut]++;
 
            if (SVFUtil::isa<FormalINSVFGNode>(node))
                _NumOfVarHaveINOUTPtsInFormalIn[inOrOut]++;
            else if (SVFUtil::isa<FormalOUTSVFGNode>(node))
                _NumOfVarHaveINOUTPtsInFormalOut[inOrOut]++;
            else if (SVFUtil::isa<ActualINSVFGNode>(node))
                _NumOfVarHaveINOUTPtsInActualIn[inOrOut]++;
            else if (SVFUtil::isa<ActualOUTSVFGNode>(node))
                _NumOfVarHaveINOUTPtsInActualOut[inOrOut]++;
            else if (SVFUtil::isa<LoadSVFGNode>(node))
                _NumOfVarHaveINOUTPtsInLoad[inOrOut]++;
            else if (SVFUtil::isa<StoreSVFGNode>(node))
                _NumOfVarHaveINOUTPtsInStore[inOrOut]++;
            else if (SVFUtil::isa<MSSAPHISVFGNode>(node))
                _NumOfVarHaveINOUTPtsInMSSAPhi[inOrOut]++;
            else
                assert(false && "unexpected node have IN/OUT set");
 
            inOutPtsSize += ptsNum;
 
            if (ptsNum > _MaxInOutPtsSize[inOrOut])
                _MaxInOutPtsSize[inOrOut] = ptsNum;
 
            if (ptsNum > _MaxPtsSize) _MaxPtsSize = ptsNum;
        }
    }
 
    if (_NumOfVarHaveINOUTPts[inOrOut] != 0)
        _AvgInOutPtsSize[inOrOut] = (double)inOutPtsSize / _NumOfVarHaveINOUTPts[inOrOut];
 
    _TotalPtsSize += inOutPtsSize;
 
    // How many IN_SET/OUT_SET PTSs could we have *potentially* had?
    // l'-o->l, l''-o->l, ..., means there is a possibility of 1 IN_SET PTS.
    // *p = q && { o } in pts_ander(p) means there is a possibility of 1 OUT_SET PTS.
    // For OUTs at stores, we must also account for WU/SUs.
    const SVFG *svfg = fspta->svfg;
    for (SVFG::const_iterator it = svfg->begin(); it != svfg->end(); ++it)
    {
        const SVFGNode *sn = it->second;
 
        // Unique objects coming into s.
        NodeBS incomingObjects;
        for (const SVFGEdge *e : sn->getInEdges())
        {
            const IndirectSVFGEdge *ie = SVFUtil::dyn_cast<IndirectSVFGEdge>(e);
            if (!ie) continue;
            for (NodeID o : ie->getPointsTo()) incomingObjects.set(o);
        }
 
        _PotentialNumOfVarHaveINOUTPts[IN_SET] += incomingObjects.count();
 
        if (const StoreSVFGNode *store = SVFUtil::dyn_cast<StoreSVFGNode>(sn))
        {
            NodeID p = store->getPAGDstNodeID();
            // Reuse incomingObjects; what's already in there will be propagated forwarded
            // as a WU/SU, and what's not (first defined at the store), will be added.
            for (NodeID o : fspta->ander->getPts(p)) incomingObjects.set(o);
 
            _PotentialNumOfVarHaveINOUTPts[OUT_SET] += incomingObjects.count();
        }
    }
}

statNullPtr()

void FlowSensitiveStat::statNullPtr ( )

private

TODO: change the condition here to fetch the points-to set

Definition at line 270 of file FlowSensitiveStat.cpp.

{
    _NumOfNullPtr = 0;
    for (SVFIR::iterator iter = fspta->getPAG()->begin(), eiter = fspta->getPAG()->end();
            iter != eiter; ++iter)
    {
        NodeID pagNodeId = iter->first;
        PAGNode* pagNode = iter->second;
        SVFStmt::SVFStmtSetTy& inComingStore = pagNode->getIncomingEdges(SVFStmt::Store);
        SVFStmt::SVFStmtSetTy& outGoingLoad = pagNode->getOutgoingEdges(SVFStmt::Load);
        if (inComingStore.empty()==false || outGoingLoad.empty()==false)
        {
            const PointsTo& pts = fspta->getPts(pagNodeId);
            if(fspta->containBlackHoleNode(pts))
            {
                _NumOfConstantPtr++;
            }
            if(fspta->containConstantNode(pts))
            {
                _NumOfBlackholePtr++;
            }
            if(pts.empty())
            {
                std::string str;
                std::stringstream  rawstr(str);
                if (!SVFUtil::isa<DummyValVar>(pagNode) && !SVFUtil::isa<DummyObjVar>(pagNode))
                {
                    // if a pointer is in dead function, we do not care
                    if(pagNode->ptrInUncalledFunction() == false)
                    {
                        _NumOfNullPtr++;
                        rawstr << "##Null Pointer : (NodeID " << pagNode->getId()
                               << ") PtrName:" << pagNode->getName();
                        writeWrnMsg(rawstr.str());
                    }
                }
                else
                {
                    _NumOfNullPtr++;
                    rawstr << "##Null Pointer : (NodeID " << pagNode->getId();
                    writeWrnMsg(rawstr.str());
                }
            }
        }
    }
}

statPtsSize()

void FlowSensitiveStat::statPtsSize ( )

private

Points-to size

get points-to set size information for top-level pointers.

Definition at line 321 of file FlowSensitiveStat.cpp.

{
    // TODO: needs to be made to work for persistent.
    if (SVFUtil::isa<FlowSensitive::MutDFPTDataTy>(fspta->getPTDataTy()))
    {
        // stat of IN set
        statInOutPtsSize(fspta->getDFInputMap(), IN_SET);
        // stat of OUT set
        statInOutPtsSize(fspta->getDFOutputMap(), OUT_SET);
    }
 
    u32_t totalValidTopLvlPointers = 0;
    u32_t topTopLvlPtsSize = 0;
    for (SVFIR::iterator iter = fspta->getPAG()->begin(), eiter = fspta->getPAG()->end();
            iter != eiter; ++iter)
    {
        NodeID node = iter->first;
        if (fspta->getPAG()->isValidTopLevelPtr(iter->second) == false)
            continue;
        u32_t size = fspta->getPts(node).count();
 
        totalValidTopLvlPointers++;
        topTopLvlPtsSize+=size;
 
        if(size > _MaxPtsSize)  _MaxPtsSize = size;
 
        if (size > _MaxTopLvlPtsSize)   _MaxTopLvlPtsSize = size;
    }
 
    if (totalValidTopLvlPointers != 0)
        _AvgTopLvlPtsSize = (double)topTopLvlPtsSize/totalValidTopLvlPointers;
 
    _TotalPtsSize += topTopLvlPtsSize;
    u32_t totalPointer = totalValidTopLvlPointers + _NumOfVarHaveINOUTPts[IN_SET] + _NumOfVarHaveINOUTPts[OUT_SET];
    if (totalPointer != 0)
        _AvgPtsSize = (double) _TotalPtsSize / totalPointer;
}

Member Data Documentation

_AvgAddrTakenVarPtsSize

double SVF::FlowSensitiveStat::_AvgAddrTakenVarPtsSize

private

average points-to set size of addr-taken variables.

Definition at line 159 of file WPAStat.h.

_AvgInOutPtsSize

double SVF::FlowSensitiveStat::_AvgInOutPtsSize[2]

private

average points-to set size in IN set.

Definition at line 158 of file WPAStat.h.

_AvgPtsSize

double SVF::FlowSensitiveStat::_AvgPtsSize

private

average points-to set size.

Definition at line 156 of file WPAStat.h.

_AvgTopLvlPtsSize

double SVF::FlowSensitiveStat::_AvgTopLvlPtsSize

private

average points-to set size in top-level pointers.

Definition at line 157 of file WPAStat.h.

_MaxAddrTakenVarPts

u32_t SVF::FlowSensitiveStat::_MaxAddrTakenVarPts

private

max points-to set size of addr-taken variables.

Definition at line 161 of file WPAStat.h.

_MaxInOutPtsSize

u32_t SVF::FlowSensitiveStat::_MaxInOutPtsSize[2]

private

max points-to set size in IN/OUT set.

Definition at line 152 of file WPAStat.h.

_MaxPtsSize

u32_t SVF::FlowSensitiveStat::_MaxPtsSize

private

sizes of points-to set

max points-to set size.

Definition at line 150 of file WPAStat.h.

_MaxTopLvlPtsSize

u32_t SVF::FlowSensitiveStat::_MaxTopLvlPtsSize

private

max points-to set size in top-level pointers.

Definition at line 151 of file WPAStat.h.

_NumOfActualInSVFGNodesHaveInOut

u32_t SVF::FlowSensitiveStat::_NumOfActualInSVFGNodesHaveInOut[2]

private

Definition at line 131 of file WPAStat.h.

_NumOfActualOutSVFGNodesHaveInOut

u32_t SVF::FlowSensitiveStat::_NumOfActualOutSVFGNodesHaveInOut[2]

private

Definition at line 132 of file WPAStat.h.

_NumOfAddrTakeVar

u32_t SVF::FlowSensitiveStat::_NumOfAddrTakeVar

private

number of occurrences of addr-taken variables in load/store.

Definition at line 162 of file WPAStat.h.

_NumOfBlackholePtr

u32_t SVF::FlowSensitiveStat::_NumOfBlackholePtr

private

Definition at line 125 of file WPAStat.h.

_NumOfConstantPtr

u32_t SVF::FlowSensitiveStat::_NumOfConstantPtr

private

Definition at line 124 of file WPAStat.h.

_NumOfFormalInSVFGNodesHaveInOut

u32_t SVF::FlowSensitiveStat::_NumOfFormalInSVFGNodesHaveInOut[2]

private

Definition at line 129 of file WPAStat.h.

_NumOfFormalOutSVFGNodesHaveInOut

u32_t SVF::FlowSensitiveStat::_NumOfFormalOutSVFGNodesHaveInOut[2]

private

Definition at line 130 of file WPAStat.h.

_NumOfLoadSVFGNodesHaveInOut

u32_t SVF::FlowSensitiveStat::_NumOfLoadSVFGNodesHaveInOut[2]

private

Definition at line 133 of file WPAStat.h.

_NumOfMSSAPhiSVFGNodesHaveInOut

u32_t SVF::FlowSensitiveStat::_NumOfMSSAPhiSVFGNodesHaveInOut[2]

private

Definition at line 135 of file WPAStat.h.

_NumOfNullPtr

u32_t SVF::FlowSensitiveStat::_NumOfNullPtr

private

Definition at line 123 of file WPAStat.h.

_NumOfStoreSVFGNodesHaveInOut

u32_t SVF::FlowSensitiveStat::_NumOfStoreSVFGNodesHaveInOut[2]

private

Definition at line 134 of file WPAStat.h.

_NumOfSVFGNodesHaveInOut

u32_t SVF::FlowSensitiveStat::_NumOfSVFGNodesHaveInOut[2]

private

number of SVFG nodes which have IN/OUT set.

Definition at line 128 of file WPAStat.h.

_NumOfVarHaveEmptyINOUTPts

u32_t SVF::FlowSensitiveStat::_NumOfVarHaveEmptyINOUTPts[2]

private

Definition at line 139 of file WPAStat.h.

_NumOfVarHaveINOUTPts

u32_t SVF::FlowSensitiveStat::_NumOfVarHaveINOUTPts[2]

private

number of pag nodes which have points-to set in IN/OUT set.

Definition at line 138 of file WPAStat.h.

_NumOfVarHaveINOUTPtsInActualIn

u32_t SVF::FlowSensitiveStat::_NumOfVarHaveINOUTPtsInActualIn[2]

private

Definition at line 142 of file WPAStat.h.

_NumOfVarHaveINOUTPtsInActualOut

u32_t SVF::FlowSensitiveStat::_NumOfVarHaveINOUTPtsInActualOut[2]

private

Definition at line 143 of file WPAStat.h.

_NumOfVarHaveINOUTPtsInFormalIn

u32_t SVF::FlowSensitiveStat::_NumOfVarHaveINOUTPtsInFormalIn[2]

private

Definition at line 140 of file WPAStat.h.

_NumOfVarHaveINOUTPtsInFormalOut

u32_t SVF::FlowSensitiveStat::_NumOfVarHaveINOUTPtsInFormalOut[2]

private

Definition at line 141 of file WPAStat.h.

_NumOfVarHaveINOUTPtsInLoad

u32_t SVF::FlowSensitiveStat::_NumOfVarHaveINOUTPtsInLoad[2]

private

Definition at line 144 of file WPAStat.h.

_NumOfVarHaveINOUTPtsInMSSAPhi

u32_t SVF::FlowSensitiveStat::_NumOfVarHaveINOUTPtsInMSSAPhi[2]

private

Definition at line 146 of file WPAStat.h.

_NumOfVarHaveINOUTPtsInStore

u32_t SVF::FlowSensitiveStat::_NumOfVarHaveINOUTPtsInStore[2]

private

Definition at line 145 of file WPAStat.h.

_PotentialNumOfVarHaveINOUTPts

u32_t SVF::FlowSensitiveStat::_PotentialNumOfVarHaveINOUTPts[2]

private

Definition at line 147 of file WPAStat.h.

_TotalPtsSize

u32_t SVF::FlowSensitiveStat::_TotalPtsSize

private

total points-to set size.

Definition at line 154 of file WPAStat.h.

fspta

FlowSensitive* SVF::FlowSensitiveStat::fspta

Definition at line 91 of file WPAStat.h.

---

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

• /home/runner/work/SVF/SVF/svf/include/WPA/WPAStat.h
• /home/runner/work/SVF/SVF/svf/lib/WPA/FlowSensitiveStat.cpp