svf-tools 1.0.284 → 1.0.285

package/include/MSSA/MemRegion.h

@@ -30,10 +30,12 @@
 #ifndef MEMORYREGION_H_
 #define MEMORYREGION_H_
 
-#include "MemoryModel/PointerAnalysisImpl.h"
+#include "Graphs/PAG.h"
 #include "Graphs/PTACallGraph.h"
+#include "Util/SCC.h"
 #include "Util/WorkList.h"
 #include "Graphs/ICFG.h"
+#include "MemoryModel/PointerAnalysisImpl.h"
 
 #include <set>
 
@@ -54,11 +56,11 @@ private:
     /// region ID 0 is reserved
     static Size_t totalMRNum;
     MRID rid;
-    const PointsTo cptsSet;
+    const NodeBS cptsSet;
 
 public:
     /// Constructor
-    MemRegion(const PointsTo& cp) :
+    MemRegion(const NodeBS& cp) :
         rid(++totalMRNum), cptsSet(cp)
     {
     }
@@ -73,7 +75,7 @@ public:
         return rid;
     }
     /// Return points-to
-    inline const PointsTo &getPointsTo() const
+    inline const NodeBS &getPointsTo() const
     {
         return cptsSet;
     }
@@ -87,7 +89,7 @@ public:
     {
         std::string str;
         str += "pts{";
-        for (PointsTo::iterator ii = cptsSet.begin(), ie = cptsSet.end();
+        for (NodeBS::iterator ii = cptsSet.begin(), ie = cptsSet.end();
                 ii != ie; ii++)
         {
             char int2str[16];
@@ -106,17 +108,9 @@ public:
     {
         bool operator()(const MemRegion* lhs, const MemRegion* rhs) const
         {
-            return SVFUtil::cmpPts(lhs->getPointsTo(), rhs->getPointsTo());
+            return SVFUtil::cmpNodeBS(lhs->getPointsTo(), rhs->getPointsTo());
         }
     } equalMemRegion;
-
-    typedef struct equalPointsTo
-    {
-        bool operator()(const PointsTo& lhs, const PointsTo& rhs) const
-        {
-            return SVFUtil::cmpPts(lhs, rhs);
-        }
-    } equalPointsTo;
     //@}
 
     /// Return memory object number inside a region
@@ -141,9 +135,10 @@ public:
     ///Define mem region set
     typedef OrderedSet<const MemRegion*, MemRegion::equalMemRegion> MRSet;
     typedef Map<const PAGEdge*, const SVFFunction*> PAGEdgeToFunMap;
-    typedef OrderedSet<PointsTo, SVFUtil::equalPointsTo> PointsToList;
-    typedef Map<const SVFFunction*, PointsToList > FunToPointsToMap;
-    typedef OrderedMap<PointsTo, PointsTo, SVFUtil::equalPointsTo > PtsToRepPtsSetMap;
+    typedef OrderedSet<NodeBS, SVFUtil::equalNodeBS> PointsToList;
+    typedef Map<const SVFFunction*, NodeBS> FunToPointsToMap;
+    typedef Map<const SVFFunction*, PointsToList> FunToPointsTosMap;
+    typedef OrderedMap<NodeBS, NodeBS, SVFUtil::equalNodeBS> PtsToRepPtsSetMap;
 
     /// Map a function to its region set
     typedef Map<const SVFFunction*, MRSet> FunToMRsMap;
@@ -157,9 +152,9 @@ public:
 
     /// Map loads/stores/callsites to their cpts set
     //@{
-    typedef Map<const LoadPE*, PointsTo> LoadsToPointsToMap;
-    typedef Map<const StorePE*, PointsTo> StoresToPointsToMap;
-    typedef Map<const CallBlockNode*, PointsTo> CallSiteToPointsToMap;
+    typedef Map<const LoadPE*, NodeBS> LoadsToPointsToMap;
+    typedef Map<const StorePE*, NodeBS> StoresToPointsToMap;
+    typedef Map<const CallBlockNode*, NodeBS> CallSiteToPointsToMap;
     //@}
 
     /// Maps Mod-Ref analysis
@@ -183,14 +178,14 @@ public:
     }
 
     /// Get superset cpts set
-    inline const PointsTo& getRepPointsTo(const PointsTo& cpts) const
+    inline const NodeBS& getRepPointsTo(const NodeBS& cpts) const
     {
         PtsToRepPtsSetMap::const_iterator it = cptsToRepCPtsMap.find(cpts);
         assert(it!=cptsToRepCPtsMap.end() && "can not find superset of cpts??");
         return it->second;
     }
     /// Get a memory region according to cpts
-    const MemRegion* getMR(const PointsTo& cpts) const;
+    const MemRegion* getMR(const NodeBS& cpts) const;
 
 private:
 
@@ -219,22 +214,22 @@ private:
     CallSiteToPointsToMap callsiteToModPointsToMap;
 
     /// Map a function to all of its conditional points-to sets
-    FunToPointsToMap funToPointsToMap;
+    FunToPointsTosMap funToPointsToMap;
     /// Map a PAGEdge to its fun
     PAGEdgeToFunMap pagEdgeToFunMap;
 
     /// Map a function to its indirect uses of memory objects
-    FunToNodeBSMap funToRefsMap;
+    FunToPointsToMap funToRefsMap;
     /// Map a function to its indirect defs of memory objects
-    FunToNodeBSMap funToModsMap;
+    FunToPointsToMap funToModsMap;
     /// Map a callsite to its indirect uses of memory objects
-    CallSiteToNodeBSMap csToRefsMap;
+    CallSiteToPointsToMap csToRefsMap;
     /// Map a callsite to its indirect defs of memory objects
-    CallSiteToNodeBSMap csToModsMap;
+    CallSiteToPointsToMap csToModsMap;
     /// Map a callsite to all its object might pass into its callees
-    CallSiteToNodeBSMap csToCallSiteArgsPtsMap;
+    CallSiteToPointsToMap csToCallSiteArgsPtsMap;
     /// Map a callsite to all its object might return from its callees
-    CallSiteToNodeBSMap csToCallSiteRetPtsMap;
+    CallSiteToPointsToMap csToCallSiteRetPtsMap;
 
     /// Map a pointer to its cached points-to chain;
     NodeToPTSSMap cachedPtsChainMap;
@@ -272,12 +267,7 @@ private:
     void getCallGraphSCCRevTopoOrder(WorkList& worklist);
 
 protected:
-    MRGenerator(BVDataPTAImpl* p, bool ptrOnly) :
-        pta(p), ptrOnlyMSSA(ptrOnly)
-    {
-        callGraph = pta->getPTACallGraph();
-        callGraphSCC = new SCC(callGraph);
-    }
+    MRGenerator(BVDataPTAImpl* p, bool ptrOnly);
 
     /// A set of All memory regions
     MRSet memRegSet;
@@ -285,7 +275,7 @@ protected:
     PtsToRepPtsSetMap cptsToRepCPtsMap;
 
     /// Generate a memory region and put in into functions which use it
-    void createMR(const SVFFunction* fun, const PointsTo& cpts);
+    void createMR(const SVFFunction* fun, const NodeBS& cpts);
 
     /// Collect all global variables for later escape analysis
     void collectGlobals();
@@ -303,15 +293,15 @@ protected:
     virtual void updateAliasMRs();
 
     /// Given a condition pts, insert into cptsToRepCPtsMap for region generation
-    virtual void sortPointsTo(const PointsTo& cpts);
+    virtual void sortPointsTo(const NodeBS& cpts);
 
     /// Whether a region is aliased with a conditional points-to
-    virtual inline bool isAliasedMR(const PointsTo& cpts, const MemRegion* mr)
+    virtual inline bool isAliasedMR(const NodeBS& cpts, const MemRegion* mr)
     {
         return mr->getPointsTo().intersects(cpts);
     }
     /// Get all aliased mem regions from function fun according to cpts
-    virtual inline void getAliasMemRegions(MRSet& aliasMRs, const PointsTo& cpts, const SVFFunction* fun)
+    virtual inline void getAliasMemRegions(MRSet& aliasMRs, const NodeBS& cpts, const SVFFunction* fun)
     {
         for(MRSet::const_iterator it = funToMRsMap[fun].begin(), eit = funToMRsMap[fun].end(); it!=eit; ++it)
         {
@@ -321,14 +311,14 @@ protected:
     }
 
     /// Get memory regions for a load statement according to cpts.
-    virtual inline void getMRsForLoad(MRSet& aliasMRs, const PointsTo& cpts, const SVFFunction*)
+    virtual inline void getMRsForLoad(MRSet& aliasMRs, const NodeBS& cpts, const SVFFunction*)
     {
         const MemRegion* mr = getMR(cpts);
         aliasMRs.insert(mr);
     }
 
     /// Get memory regions for call site ref according to cpts.
-    virtual inline void getMRsForCallSiteRef(MRSet& aliasMRs, const PointsTo& cpts, const SVFFunction*)
+    virtual inline void getMRsForCallSiteRef(MRSet& aliasMRs, const NodeBS& cpts, const SVFFunction*)
     {
         const MemRegion* mr = getMR(cpts);
         aliasMRs.insert(mr);
@@ -343,24 +333,24 @@ protected:
 
     /// Add cpts to store/load
     //@{
-    inline void addCPtsToStore(PointsTo& cpts, const StorePE *st, const SVFFunction* fun)
+    inline void addCPtsToStore(NodeBS& cpts, const StorePE *st, const SVFFunction* fun)
     {
         storesToPointsToMap[st] = cpts;
         funToPointsToMap[fun].insert(cpts);
         addModSideEffectOfFunction(fun,cpts);
     }
-    inline void addCPtsToLoad(PointsTo& cpts, const LoadPE *ld, const SVFFunction* fun)
+    inline void addCPtsToLoad(NodeBS& cpts, const LoadPE *ld, const SVFFunction* fun)
     {
         loadsToPointsToMap[ld] = cpts;
         funToPointsToMap[fun].insert(cpts);
         addRefSideEffectOfFunction(fun,cpts);
     }
-    inline void addCPtsToCallSiteRefs(PointsTo& cpts, const CallBlockNode* cs)
+    inline void addCPtsToCallSiteRefs(NodeBS& cpts, const CallBlockNode* cs)
     {
         callsiteToRefPointsToMap[cs] |= cpts;
         funToPointsToMap[cs->getCaller()].insert(cpts);
     }
-    inline void addCPtsToCallSiteMods(PointsTo& cpts, const CallBlockNode* cs)
+    inline void addCPtsToCallSiteMods(NodeBS& cpts, const CallBlockNode* cs)
     {
         callsiteToModPointsToMap[cs] |= cpts;
         funToPointsToMap[cs->getCaller()].insert(cpts);
@@ -373,7 +363,7 @@ protected:
     {
         return funToPointsToMap[fun];
     }
-    inline FunToPointsToMap& getFunToPointsToList()
+    inline FunToPointsTosMap& getFunToPointsToList()
     {
         return funToPointsToMap;
     }
@@ -475,29 +465,15 @@ public:
     }
     //@}
     /// Whether this instruction has PAG Edge
-    inline bool hasPAGEdgeList(const Instruction* inst)
-    {
-        PAG* pag = pta->getPAG();
-        if (ptrOnlyMSSA)
-            return pag->hasPTAPAGEdgeList(pag->getICFG()->getBlockICFGNode(inst));
-        else
-            return pag->hasPAGEdgeList(pag->getICFG()->getBlockICFGNode(inst));
-    }
+    bool hasPAGEdgeList(const Instruction* inst);
     /// Given an instruction, get all its the PAGEdge (statement) in sequence
-    inline PAGEdgeList& getPAGEdgesFromInst(const Instruction* inst)
-    {
-        PAG* pag = pta->getPAG();
-        if (ptrOnlyMSSA)
-            return pag->getInstPTAPAGEdgeList(pag->getICFG()->getBlockICFGNode(inst));
-        else
-            return pag->getInstPAGEdgeList(pag->getICFG()->getBlockICFGNode(inst));
-    }
+    PAGEdgeList& getPAGEdgesFromInst(const Instruction* inst);
 
     /// getModRefInfo APIs
     //@{
     /// Collect mod ref for external callsite other than heap alloc external call
-    PointsTo getModInfoForCall(const CallBlockNode* cs);
-    PointsTo getRefInfoForCall(const CallBlockNode* cs);
+    NodeBS getModInfoForCall(const CallBlockNode* cs);
+    NodeBS getRefInfoForCall(const CallBlockNode* cs);
     ModRefInfo getModRefInfo(const CallBlockNode* cs);
     ModRefInfo getModRefInfo(const CallBlockNode* cs, const Value* V);
     ModRefInfo getModRefInfo(const CallBlockNode* cs1, const CallBlockNode* cs2);

package/include/MSSA/MemSSA.h

@@ -310,10 +310,7 @@ public:
         destroy();
     }
     /// Return PAG
-    inline PAG* getPAG()
-    {
-        return pta->getPAG();
-    }
+    inline PAG* getPAG();
     /// Return PTA
     inline BVDataPTAImpl* getPTA() const
     {

package/include/MSSA/SVFGBuilder.h

@@ -30,6 +30,7 @@
 #ifndef ANDERSENMEMSSA_H_
 #define ANDERSENMEMSSA_H_
 
+#include "MemoryModel/PointerAnalysis.h"
 #include "Graphs/SVFGOPT.h"
 
 namespace SVF

package/include/MemoryModel/LocationSet.h

@@ -230,8 +230,8 @@ public:
     /// Check relations of two location sets
     static inline LSRelation checkRelation(const LocationSet& LHS, const LocationSet& RHS)
     {
-        PointsTo lhsLocations = LHS.computeAllLocations();
-        PointsTo rhsLocations = RHS.computeAllLocations();
+        NodeBS lhsLocations = LHS.computeAllLocations();
+        NodeBS rhsLocations = RHS.computeAllLocations();
         if (lhsLocations.intersects(rhsLocations))
         {
             if (lhsLocations == rhsLocations)
@@ -273,7 +273,7 @@ private:
     bool increaseIfNotReachUpperBound(std::vector<NodeID>& indices,	const ElemNumStridePairVec& pairVec) const;
 
     /// Compute all possible locations according to offset and number-stride pairs.
-    PointsTo computeAllLocations() const;
+    NodeBS computeAllLocations() const;
 
     /// Return greatest common divisor
     inline unsigned gcd (unsigned n1, unsigned n2) const

package/include/MemoryModel/PersistentPointsToCache.h

@@ -37,10 +37,10 @@ public:
     static PointsToID emptyPointsToId(void) { return 0; };
 
 public:
-    PersistentPointsToCache(const Data &emptyData) : idCounter(1)
+    PersistentPointsToCache(void) : idCounter(1)
     {
-        idToPts.push_back(new Data(emptyData));
-        ptsToId[emptyData] = emptyPointsToId();
+        idToPts.push_back(new Data());
+        ptsToId[Data()] = emptyPointsToId();
 
         initStats();
     }
@@ -48,14 +48,13 @@ public:
     /// Resets the cache removing everything except the emptyData it was initialised with.
     void reset(void)
     {
-        const Data *emptyData = idToPts[emptyPointsToId()];
-        for (const Data *d : idToPts) free(d);
+        for (const Data *d : idToPts) delete d;
         idToPts.clear();
         ptsToId.clear();
 
         // Put the empty data back in.
-        ptsToId[*emptyData] = emptyPointsToId();
-        idToPts.push_back(emptyData);
+        ptsToId[Data()] = emptyPointsToId();
+        idToPts.push_back(new Data());
 
         unionCache.clear();
         complementCache.clear();
@@ -305,6 +304,17 @@ public:
         std::cout.flush();
     }
 
+    /// Returns all points-to sets stored by this cache as keys to a map.
+    /// Values are all 1. We use the map to be more compatible with getAllPts
+    /// in the various PTDatas. Performance is a non-issue (for now) since this
+    /// is just used for evaluation's sake.
+    Map<Data, unsigned> getAllPts(void)
+    {
+        Map<Data, unsigned> allPts;
+        for (const Data *d : idToPts) allPts[*d] = 1;
+        return allPts;
+    }
+
     // TODO: ref count API for garbage collection.
 
 private:
@@ -378,7 +388,8 @@ private:
     /// Reverse of idToPts.
     /// Elements are only added through push_back, so the number of elements
     /// stored is the size of the vector.
-    std::vector<const Data *> idToPts;
+    /// Not const so we can remap.
+    std::vector<Data *> idToPts;
     /// Maps points-to sets to their corresponding ID.
     PTSToIDMap ptsToId;
 

package/include/MemoryModel/PointerAnalysisImpl.h

@@ -67,9 +67,6 @@ public:
         Persistent,
     };
 
-    // TODO: make this not static?
-    static PersistentPointsToCache<PointsTo> ptCache;
-
     /// Constructor
     BVDataPTAImpl(PAG* pag, PointerAnalysis::PTATY type, bool alias_check = true);
 
@@ -79,7 +76,7 @@ public:
         destroy();
     }
 
-    static inline PersistentPointsToCache<PointsTo> &getPtCache(void)
+    inline PersistentPointsToCache<PointsTo> &getPtCache(void)
     {
         return ptCache;
     }
@@ -215,6 +212,8 @@ private:
     /// Points-to data
     PTDataTy* ptD;
 
+    PersistentPointsToCache<PointsTo> ptCache;
+
 public:
     /// Interface expose to users of our pointer analysis, given Location infos
     virtual AliasResult alias(const MemoryLocation  &LocA,

package/include/Util/SVFUtil.h

@@ -117,6 +117,24 @@ inline bool cmpPts (const PointsTo& lpts,const PointsTo& rpts)
     }
 }
 
+inline bool cmpNodeBS(const NodeBS& lpts,const NodeBS& rpts)
+{
+    if (lpts.count() != rpts.count())
+        return (lpts.count() < rpts.count());
+    else
+    {
+        NodeBS::iterator bit = lpts.begin(), eit = lpts.end();
+        NodeBS::iterator rbit = rpts.begin(), reit = rpts.end();
+        for (; bit != eit && rbit != reit; bit++, rbit++)
+        {
+            if (*bit != *rbit)
+                return (*bit < *rbit);
+        }
+
+        return false;
+    }
+}
+
 typedef struct equalPointsTo
 {
     bool operator()(const PointsTo& lhs, const PointsTo& rhs) const
@@ -125,7 +143,22 @@ typedef struct equalPointsTo
     }
 } equalPointsTo;
 
-typedef OrderedSet<PointsTo, equalPointsTo> PointsToList;
+typedef struct equalNodeBS
+{
+    bool operator()(const NodeBS& lhs, const NodeBS& rhs) const
+    {
+        return SVFUtil::cmpNodeBS(lhs, rhs);
+    }
+} equalNodeBS;
+
+inline NodeBS ptsToNodeBS(const PointsTo &pts)
+{
+    NodeBS nbs;
+    for (const NodeID o : pts) nbs.set(o);
+    return nbs;
+}
+
+typedef OrderedSet<PointsTo, equalNodeBS> PointsToList;
 void dumpPointsToList(const PointsToList& ptl);
 
 inline bool isIntrinsicFun(const Function* func)
@@ -241,6 +274,16 @@ std::string  getSourceLocOfFunction(const Function *F);
 const std::string value2String(const Value* value);
 //@}
 
+/// Given a map mapping points-to sets to a count, adds from into to.
+template <typename Data>
+void mergePtsOccMaps(Map<Data, unsigned> &to, const Map<Data, unsigned> from)
+{
+    for (const typename Map<Data, unsigned>::value_type &ptocc : from)
+    {
+        to[ptocc.first] += ptocc.second;
+    }
+}
+
 /// Inserts an element into a Set/CondSet (with ::insert).
 template <typename Key, typename KeySet>
 inline void insertKey(const Key &key, KeySet &keySet)

package/lib/Graphs/SVFG.cpp

@@ -33,6 +33,7 @@
 #include "Graphs/SVFGOPT.h"
 #include "Graphs/SVFGStat.h"
 #include "Graphs/ICFG.h"
+#include "MemoryModel/PointerAnalysisImpl.h"
 #include <fstream>
 
 
@@ -420,14 +421,13 @@ void SVFG::connectFromGlobalToProgEntry()
         if (const StoreSVFGNode* store = SVFUtil::dyn_cast<StoreSVFGNode>(*storeIt))
         {
             /// connect this store to main function entry
-            const PointsTo& storePts = mssa->getPTA()->getPts(
-                                           store->getPAGDstNodeID());
+            const NodeBS& storePts = mssa->getPTA()->getPts(store->getPAGDstNodeID());
 
-            for (NodeBS::iterator fiIt = formalIns.begin(), fiEit =
+            for (FormalINSVFGNodeSet::iterator fiIt = formalIns.begin(), fiEit =
                         formalIns.end(); fiIt != fiEit; ++fiIt)
             {
                 NodeID formalInID = *fiIt;
-                PointsTo formalInPts = ((FormalINSVFGNode*) getSVFGNode(formalInID))->getPointsTo();
+                NodeBS formalInPts = ((FormalINSVFGNode*) getSVFGNode(formalInID))->getPointsTo();
 
                 formalInPts &= storePts;
                 if (formalInPts.empty())
@@ -443,7 +443,7 @@ void SVFG::connectFromGlobalToProgEntry()
 /*
  *  Add def-use edges of a memory region between two statements
  */
-SVFGEdge* SVFG::addIntraIndirectVFEdge(NodeID srcId, NodeID dstId, const PointsTo& cpts)
+SVFGEdge* SVFG::addIntraIndirectVFEdge(NodeID srcId, NodeID dstId, const NodeBS& cpts)
 {
     SVFGNode* srcNode = getSVFGNode(srcId);
     SVFGNode* dstNode = getSVFGNode(dstId);
@@ -465,7 +465,7 @@ SVFGEdge* SVFG::addIntraIndirectVFEdge(NodeID srcId, NodeID dstId, const PointsT
 /*!
  * Add def-use edges of a memory region between two may-happen-in-parallel statements for multithreaded program
  */
-SVFGEdge* SVFG::addThreadMHPIndirectVFEdge(NodeID srcId, NodeID dstId, const PointsTo& cpts)
+SVFGEdge* SVFG::addThreadMHPIndirectVFEdge(NodeID srcId, NodeID dstId, const NodeBS& cpts)
 {
     SVFGNode* srcNode = getSVFGNode(srcId);
     SVFGNode* dstNode = getSVFGNode(dstId);
@@ -485,7 +485,7 @@ SVFGEdge* SVFG::addThreadMHPIndirectVFEdge(NodeID srcId, NodeID dstId, const Poi
 /*
  *  Add def-use call edges of a memory region between two statements
  */
-SVFGEdge* SVFG::addCallIndirectVFEdge(NodeID srcId, NodeID dstId, const PointsTo& cpts,CallSiteID csId)
+SVFGEdge* SVFG::addCallIndirectVFEdge(NodeID srcId, NodeID dstId, const NodeBS& cpts,CallSiteID csId)
 {
     SVFGNode* srcNode = getSVFGNode(srcId);
     SVFGNode* dstNode = getSVFGNode(dstId);
@@ -505,7 +505,7 @@ SVFGEdge* SVFG::addCallIndirectVFEdge(NodeID srcId, NodeID dstId, const PointsTo
 /*
  *  Add def-use return edges of a memory region between two statements
  */
-SVFGEdge* SVFG::addRetIndirectVFEdge(NodeID srcId, NodeID dstId, const PointsTo& cpts,CallSiteID csId)
+SVFGEdge* SVFG::addRetIndirectVFEdge(NodeID srcId, NodeID dstId, const NodeBS& cpts,CallSiteID csId)
 {
     SVFGNode* srcNode = getSVFGNode(srcId);
     SVFGNode* dstNode = getSVFGNode(dstId);
@@ -527,8 +527,8 @@ SVFGEdge* SVFG::addRetIndirectVFEdge(NodeID srcId, NodeID dstId, const PointsTo&
  */
 SVFGEdge* SVFG::addInterIndirectVFCallEdge(const ActualINSVFGNode* src, const FormalINSVFGNode* dst,CallSiteID csId)
 {
-    PointsTo cpts1 = src->getPointsTo();
-    PointsTo cpts2 = dst->getPointsTo();
+    NodeBS cpts1 = src->getPointsTo();
+    NodeBS cpts2 = dst->getPointsTo();
     if(cpts1.intersects(cpts2))
     {
         cpts1 &= cpts2;
@@ -543,8 +543,8 @@ SVFGEdge* SVFG::addInterIndirectVFCallEdge(const ActualINSVFGNode* src, const Fo
 SVFGEdge* SVFG::addInterIndirectVFRetEdge(const FormalOUTSVFGNode* src, const ActualOUTSVFGNode* dst,CallSiteID csId)
 {
 
-    PointsTo cpts1 = src->getPointsTo();
-    PointsTo cpts2 = dst->getPointsTo();
+    NodeBS cpts1 = src->getPointsTo();
+    NodeBS cpts2 = dst->getPointsTo();
     if(cpts1.intersects(cpts2))
     {
         cpts1 &= cpts2;

package/lib/Graphs/SVFGOPT.cpp

@@ -65,7 +65,7 @@ void SVFGOPT::buildSVFG()
 /*!
  *
  */
-SVFGEdge* SVFGOPT::addCallIndirectSVFGEdge(NodeID srcId, NodeID dstId, CallSiteID csid, const PointsTo& cpts)
+SVFGEdge* SVFGOPT::addCallIndirectSVFGEdge(NodeID srcId, NodeID dstId, CallSiteID csid, const NodeBS& cpts)
 {
     if (Options::ContextInsensitive)
         return addIntraIndirectVFEdge(srcId, dstId, cpts);
@@ -76,7 +76,7 @@ SVFGEdge* SVFGOPT::addCallIndirectSVFGEdge(NodeID srcId, NodeID dstId, CallSiteI
 /*!
  *
  */
-SVFGEdge* SVFGOPT::addRetIndirectSVFGEdge(NodeID srcId, NodeID dstId, CallSiteID csid, const PointsTo& cpts)
+SVFGEdge* SVFGOPT::addRetIndirectSVFGEdge(NodeID srcId, NodeID dstId, CallSiteID csid, const NodeBS& cpts)
 {
     if (Options::ContextInsensitive)
         return addIntraIndirectVFEdge(srcId, dstId, cpts);
@@ -207,7 +207,7 @@ void SVFGOPT::retargetEdgesOfAInFOut(SVFGNode* node)
     assert(node->getInEdges().size() == 1 && "actual-in/formal-out can only have one incoming edge as its def size");
 
     SVFGNode* def = nullptr;
-    PointsTo inPointsTo;
+    NodeBS inPointsTo;
 
     SVFGNode::const_iterator it = node->InEdgeBegin();
     SVFGNode::const_iterator eit = node->InEdgeEnd();
@@ -227,7 +227,7 @@ void SVFGOPT::retargetEdgesOfAInFOut(SVFGNode* node)
     for (; it != eit; ++it)
     {
         const IndirectSVFGEdge* outEdge = SVFUtil::cast<IndirectSVFGEdge>(*it);
-        PointsTo intersection = inPointsTo;
+        NodeBS intersection = inPointsTo;
         intersection &= outEdge->getPointsTo();
 
         if (intersection.empty())
@@ -263,7 +263,7 @@ void SVFGOPT::retargetEdgesOfAOutFIn(SVFGNode* node)
         {
             const IndirectSVFGEdge* outEdge = SVFUtil::cast<IndirectSVFGEdge>(*outIt);
 
-            PointsTo intersection = inEdge->getPointsTo();
+            NodeBS intersection = inEdge->getPointsTo();
             intersection &= outEdge->getPointsTo();
             if (intersection.empty())
                 continue;
@@ -530,7 +530,7 @@ bool SVFGOPT::addNewSVFGEdge(NodeID srcId, NodeID dstId, const SVFGEdge* preEdge
     const IndirectSVFGEdge* preIndEdge = SVFUtil::cast<IndirectSVFGEdge>(preEdge);
     const IndirectSVFGEdge* succIndEdge = SVFUtil::cast<IndirectSVFGEdge>(succEdge);
 
-    PointsTo intersection = preIndEdge->getPointsTo();
+    NodeBS intersection = preIndEdge->getPointsTo();
     intersection &= succIndEdge->getPointsTo();
 
     if (intersection.empty())