svf-tools 1.0.351 → 1.0.352

package/include/MemoryModel/SVFStatements.h

@@ -53,7 +53,7 @@ public:
     /// ThreadFork/ThreadJoin is to model parameter passings between thread spawners and spawnees.
     enum PEDGEK
     {
-        Addr, Copy, Store, Load, Call, Ret, NormalGep, VariantGep, Phi, Cmp, BinaryOp, UnaryOp, Branch, ThreadFork, ThreadJoin
+        Addr, Copy, Store, Load, Call, Ret, Gep, Phi, Cmp, BinaryOp, UnaryOp, Branch, ThreadFork, ThreadJoin
     };
 
 private:
@@ -85,8 +85,7 @@ public:
                edge->getEdgeKind() == SVFStmt::Load ||
                edge->getEdgeKind() == SVFStmt::Call ||
                edge->getEdgeKind() == SVFStmt::Ret ||
-               edge->getEdgeKind() == SVFStmt::NormalGep ||
-               edge->getEdgeKind() == SVFStmt::VariantGep ||
+               edge->getEdgeKind() == SVFStmt::Gep ||
                edge->getEdgeKind() == SVFStmt::Cmp ||
                edge->getEdgeKind() == SVFStmt::BinaryOp ||
                edge->getEdgeKind() == SVFStmt::UnaryOp  ||
@@ -227,8 +226,7 @@ public:
                edge->getEdgeKind() == SVFStmt::Load ||
                edge->getEdgeKind() == SVFStmt::Call ||
                edge->getEdgeKind() == SVFStmt::Ret ||
-               edge->getEdgeKind() == SVFStmt::NormalGep ||
-               edge->getEdgeKind() == SVFStmt::VariantGep ||
+               edge->getEdgeKind() == SVFStmt::Gep ||
                edge->getEdgeKind() == SVFStmt::ThreadFork ||
                edge->getEdgeKind() == SVFStmt::ThreadJoin;
     }
@@ -240,8 +238,7 @@ public:
                edge->getEdgeKind() == SVFStmt::Load ||
                edge->getEdgeKind() == SVFStmt::Call ||
                edge->getEdgeKind() == SVFStmt::Ret ||
-               edge->getEdgeKind() == SVFStmt::NormalGep ||
-               edge->getEdgeKind() == SVFStmt::VariantGep ||
+               edge->getEdgeKind() == SVFStmt::Gep ||
                edge->getEdgeKind() == SVFStmt::ThreadFork ||
                edge->getEdgeKind() == SVFStmt::ThreadJoin;
     }
@@ -417,7 +414,7 @@ private:
     void operator=(const GepStmt &); ///< place holder
 
     LocationSet ls;	///< location set of the gep edge
-
+    bool variantField;  ///< Gep statement with a variant field index (pointer arithmetic) for struct field access (e.g., p = &(q + f), where f is a variable)
 public:
     /// Methods for support type inquiry through isa, cast, and dyn_cast:
     //@{
@@ -427,111 +424,37 @@ public:
     }
     static inline bool classof(const SVFStmt *edge)
     {
-        return 	edge->getEdgeKind() == SVFStmt::NormalGep ||
-                edge->getEdgeKind() == SVFStmt::VariantGep;
+        return 	edge->getEdgeKind() == SVFStmt::Gep;
     }
     static inline bool classof(const GenericPAGEdgeTy *edge)
     {
-        return	edge->getEdgeKind() == SVFStmt::NormalGep ||
-                edge->getEdgeKind() == SVFStmt::VariantGep;
+        return	edge->getEdgeKind() == SVFStmt::Gep;
     }
     //@}
 
     inline const LocationSet& getLocationSet() const
     {
+        assert(isVariantFieldGep()==false && "Can't retrieve the LocationSet if using a variable field index (pointer arithmetic) for struct field access ");
         return ls;
     }
 
-protected:
-    /// constructor
-    GepStmt(SVFVar* s, SVFVar* d, const LocationSet& l, PEDGEK k) : AssignStmt(s,d,k), ls(l)
-    {
-    }
-
-    virtual const std::string toString() const;
-
-};
-
-
-/*!
- * Gep statement with a fixed field index for struct field access 
- */
-class NormalGepStmt : public GepStmt
-{
-private:
-    NormalGepStmt(); ///< place holder
-    NormalGepStmt(const NormalGepStmt&); ///< place holder
-    void operator=(const NormalGepStmt&); ///< place holder
-
-public:
-    /// Methods for support type inquiry through isa, cast, and dyn_cast:
-    //@{
-    static inline bool classof(const NormalGepStmt *)
+    /// offset of the gep statement
+    inline s64_t getConstantFieldIdx() const
     {
-        return true;
-    }
-    static inline bool classof(const GepStmt *edge)
-    {
-        return edge->getEdgeKind() == SVFStmt::NormalGep;
-    }
-    static inline bool classof(const SVFStmt *edge)
-    {
-        return edge->getEdgeKind() == SVFStmt::NormalGep;
+        return getLocationSet().accumulateConstantFieldIdx();
     }
-    static inline bool classof(const GenericPAGEdgeTy *edge)
+    /// Gep statement with a variant field index (pointer arithmetic) for struct field access 
+    inline bool isVariantFieldGep() const
     {
-        return edge->getEdgeKind() == SVFStmt::NormalGep;
-    }
-    //@}
+        return variantField;
+    }   
 
     /// constructor
-    NormalGepStmt(SVFVar* s, SVFVar* d, const LocationSet& l) : GepStmt(s,d,l, SVFStmt::NormalGep)
-    {}
-
-    /// offset of the gep edge
-    inline s64_t getFieldOffset() const
+    GepStmt(SVFVar* s, SVFVar* d, const LocationSet& l, bool varfld=false) : AssignStmt(s,d,SVFStmt::Gep), ls(l), variantField(varfld)
     {
-        return getLocationSet().accumulateConstantFieldIdx();
     }
 
-    virtual const std::string toString() const override;
-};
-
-/*!
- * Gep statement with a variant field index for struct field access 
- */
-class VariantGepStmt : public GepStmt
-{
-private:
-    VariantGepStmt(); ///< place holder
-    VariantGepStmt(const VariantGepStmt&); ///< place holder
-    void operator=(const VariantGepStmt&); ///< place holder
-
-public:
-    /// Methods for support type inquiry through isa, cast, and dyn_cast:
-    //@{
-    static inline bool classof(const VariantGepStmt *)
-    {
-        return true;
-    }
-    static inline bool classof(const GepStmt *edge)
-    {
-        return edge->getEdgeKind() == SVFStmt::VariantGep;
-    }
-    static inline bool classof(const SVFStmt *edge)
-    {
-        return edge->getEdgeKind() == SVFStmt::VariantGep;
-    }
-    static inline bool classof(const GenericPAGEdgeTy *edge)
-    {
-        return edge->getEdgeKind() == SVFStmt::VariantGep;
-    }
-    //@}
-
-    /// constructor
-    VariantGepStmt(SVFVar* s, SVFVar* d, const LocationSet& l) : GepStmt(s,d,l, SVFStmt::VariantGep) {}
-
-    virtual const std::string toString() const override;
+    virtual const std::string toString() const;
 
 };
 

package/include/MemoryModel/SVFVariables.h

@@ -241,10 +241,13 @@ private:
     /// Has incoming VariantGepEdges
     inline bool hasIncomingVariantGepEdge() const
     {
-        SVFStmt::KindToSVFStmtMapTy::const_iterator it = InEdgeKindToSetMap.find(SVFStmt::VariantGep);
+        SVFStmt::KindToSVFStmtMapTy::const_iterator it = InEdgeKindToSetMap.find(SVFStmt::Gep);
         if (it != InEdgeKindToSetMap.end())
         {
-            return (!it->second.empty());
+            for(auto gep : it->second){
+                if(SVFUtil::cast<GepStmt>(gep)->isVariantFieldGep())
+                    return true;
+            }
         }
         return false;
     }
@@ -422,7 +425,7 @@ public:
     }
 
     /// offset of the base value variable
-    inline s64_t getFieldOffset() const
+    inline s64_t getConstantFieldIdx() const
     {
         return ls.accumulateConstantFieldIdx();
     }
@@ -431,8 +434,8 @@ public:
     inline const std::string getValueName() const
     {
         if (value && value->hasName())
-            return value->getName().str() + "_" + llvm::utostr(getFieldOffset());
-        return "offset_" + llvm::utostr(getFieldOffset());
+            return value->getName().str() + "_" + llvm::utostr(getConstantFieldIdx());
+        return "offset_" + llvm::utostr(getConstantFieldIdx());
     }
 
     inline const Type* getType() const
@@ -497,7 +500,7 @@ public:
     }
 
     /// offset of the mem object
-    inline s64_t getFieldOffset() const
+    inline s64_t getConstantFieldIdx() const
     {
         return ls.accumulateConstantFieldIdx();
     }

package/include/SVF-FE/DCHG.h

@@ -46,7 +46,7 @@ public:
     {
     }
 
-    u32_t getFieldOffset(void) const
+    u32_t getConstantFieldIdx(void) const
     {
         return offset;
     }

package/include/SVF-FE/SVFIRBuilder.h

@@ -72,7 +72,7 @@ public:
     /// Initialize nodes and edges
     //@{
     void initialiseNodes();
-    void addEdge(NodeID src, NodeID dst, PAGEdge::PEDGEK kind,
+    void addEdge(NodeID src, NodeID dst, SVFStmt::PEDGEK kind,
                  s64_t offset = 0, Instruction* cs = nullptr);
     // @}
 
@@ -377,16 +377,16 @@ public:
         return edge;
     }
     /// Add Offset(Gep) edge
-    inline NormalGepStmt* addNormalGepEdge(NodeID src, NodeID dst, const LocationSet& ls)
+    inline GepStmt* addNormalGepEdge(NodeID src, NodeID dst, const LocationSet& ls)
     {
-        NormalGepStmt *edge = pag->addNormalGepStmt(src, dst, ls);
+        GepStmt *edge = pag->addNormalGepStmt(src, dst, ls);
         setCurrentBBAndValueForPAGEdge(edge);
         return edge;
     }
     /// Add Variant(Gep) edge
-    inline VariantGepStmt* addVariantGepEdge(NodeID src, NodeID dst, const LocationSet& ls)
+    inline GepStmt* addVariantGepEdge(NodeID src, NodeID dst, const LocationSet& ls)
     {
-        VariantGepStmt *edge = pag->addVariantGepStmt(src, dst, ls);
+        GepStmt *edge = pag->addVariantGepStmt(src, dst, ls);
         setCurrentBBAndValueForPAGEdge(edge);
         return edge;
     }

package/include/Util/IRAnnotator.h

@@ -64,7 +64,7 @@ private:
     void writePAGgepNode(SVF::NodeID nodeId, GepObjVar* gepNode)
     {
         auto baseNodeId = gepNode->getBaseNode();
-        auto locationSetOffset = gepNode->getFieldOffset();
+        auto locationSetOffset = gepNode->getConstantFieldIdx();
 
         LLVMContext &context = mainModule->getContext();
         llvm::SmallVector<llvm::Metadata *, 32> operands;

package/lib/DDA/ContextDDA.cpp

@@ -140,19 +140,18 @@ CxtPtSet ContextDDA::processGepPts(const GepSVFGNode* gep, const CxtPtSet& srcPt
             tmpDstPts.set(ptd);
         else
         {
-            if (SVFUtil::isa<VariantGepStmt>(gep->getPAGEdge()))
+            const GepStmt* gepStmt = SVFUtil::cast<GepStmt>(gep->getPAGEdge());
+            if (gepStmt->isVariantFieldGep())
             {
                 setObjFieldInsensitive(ptd.get_id());
                 CxtVar var(ptd.get_cond(),getFIObjVar(ptd.get_id()));
                 tmpDstPts.set(var);
             }
-            else if (const NormalGepStmt* normalGep = SVFUtil::dyn_cast<NormalGepStmt>(gep->getPAGEdge()))
+            else
             {
-                CxtVar var(ptd.get_cond(),getGepObjVar(ptd.get_id(),normalGep->getLocationSet()));
+                CxtVar var(ptd.get_cond(),getGepObjVar(ptd.get_id(),gepStmt->getLocationSet()));
                 tmpDstPts.set(var);
             }
-            else
-                assert(false && "new gep edge?");
         }
     }
 

package/lib/DDA/DDAClient.cpp

@@ -155,8 +155,8 @@ void FunptrDDAClient::performStat(PointerAnalysis* pta)
 OrderedNodeSet& AliasDDAClient::collectCandidateQueries(SVFIR* pag)
 {
     setPAG(pag);
-    PAGEdge::SVFStmtSetTy& loads = pag->getSVFStmtSet(PAGEdge::Load);
-    for (PAGEdge::SVFStmtSetTy::iterator iter = loads.begin(), eiter =
+    SVFStmt::SVFStmtSetTy& loads = pag->getSVFStmtSet(SVFStmt::Load);
+    for (SVFStmt::SVFStmtSetTy::iterator iter = loads.begin(), eiter =
                 loads.end(); iter != eiter; ++iter)
     {
         PAGNode* loadsrc = (*iter)->getSrcNode();
@@ -164,16 +164,16 @@ OrderedNodeSet& AliasDDAClient::collectCandidateQueries(SVFIR* pag)
         addCandidate(loadsrc->getId());
     }
 
-    PAGEdge::SVFStmtSetTy& stores = pag->getSVFStmtSet(PAGEdge::Store);
-    for (PAGEdge::SVFStmtSetTy::iterator iter = stores.begin(), eiter =
+    SVFStmt::SVFStmtSetTy& stores = pag->getSVFStmtSet(SVFStmt::Store);
+    for (SVFStmt::SVFStmtSetTy::iterator iter = stores.begin(), eiter =
                 stores.end(); iter != eiter; ++iter)
     {
         PAGNode* storedst = (*iter)->getDstNode();
         storeDstNodes.insert(storedst);
         addCandidate(storedst->getId());
     }
-    PAGEdge::SVFStmtSetTy& geps = pag->getSVFStmtSet(PAGEdge::NormalGep);
-    for (PAGEdge::SVFStmtSetTy::iterator iter = geps.begin(), eiter =
+    SVFStmt::SVFStmtSetTy& geps = pag->getSVFStmtSet(SVFStmt::Gep);
+    for (SVFStmt::SVFStmtSetTy::iterator iter = geps.begin(), eiter =
                 geps.end(); iter != eiter; ++iter)
     {
         PAGNode* gepsrc = (*iter)->getSrcNode();

package/lib/DDA/DDAStat.cpp

@@ -242,7 +242,7 @@ void DDAStat::performStat()
     PTNumStatMap["PointsToBlkPtr"] = _NumOfBlackholePtr;
     PTNumStatMap["NumOfMustAA"] = _TotalNumOfMustAliases;
     PTNumStatMap["NumOfInfePath"] = _TotalNumOfInfeasiblePath;
-    PTNumStatMap["NumOfStore"] = SVFIR::getPAG()->getPTASVFStmtSet(PAGEdge::Store).size();
+    PTNumStatMap["NumOfStore"] = SVFIR::getPAG()->getPTASVFStmtSet(SVFStmt::Store).size();
     PTNumStatMap["MemoryUsageVmrss"] = _vmrssUsageAfter - _vmrssUsageBefore;
     PTNumStatMap["MemoryUsageVmsize"] = _vmsizeUsageAfter - _vmsizeUsageBefore;
 

package/lib/DDA/FlowDDA.cpp

@@ -126,18 +126,17 @@ PointsTo FlowDDA::processGepPts(const GepSVFGNode* gep, const PointsTo& srcPts)
             tmpDstPts.set(ptd);
         else
         {
-            if (SVFUtil::isa<VariantGepStmt>(gep->getPAGEdge()))
+            const GepStmt* gepStmt = SVFUtil::cast<GepStmt>(gep->getPAGEdge());
+            if (gepStmt->isVariantFieldGep())
             {
                 setObjFieldInsensitive(ptd);
                 tmpDstPts.set(getFIObjVar(ptd));
             }
-            else if (const NormalGepStmt* normalGep = SVFUtil::dyn_cast<NormalGepStmt>(gep->getPAGEdge()))
+            else
             {
-                NodeID fieldSrcPtdNode = getGepObjVar(ptd,	normalGep->getLocationSet());
+                NodeID fieldSrcPtdNode = getGepObjVar(ptd,	gepStmt->getLocationSet());
                 tmpDstPts.set(fieldSrcPtdNode);
             }
-            else
-                assert(false && "new gep edge?");
         }
     }
     DBOUT(DDDA, outs() << "\t return created gep objs {");

package/lib/Graphs/ConsG.cpp

@@ -49,24 +49,24 @@ void ConstraintGraph::buildCG()
     }
 
     // initialize edges
-    PAGEdge::SVFStmtSetTy& addrs = getPAGEdgeSet(PAGEdge::Addr);
-    for (PAGEdge::SVFStmtSetTy::iterator iter = addrs.begin(), eiter =
+    SVFStmt::SVFStmtSetTy& addrs = getPAGEdgeSet(SVFStmt::Addr);
+    for (SVFStmt::SVFStmtSetTy::iterator iter = addrs.begin(), eiter =
                 addrs.end(); iter != eiter; ++iter)
     {
         const AddrStmt* edge = SVFUtil::cast<AddrStmt>(*iter);
         addAddrCGEdge(edge->getRHSVarID(),edge->getLHSVarID());
     }
 
-    PAGEdge::SVFStmtSetTy& copys = getPAGEdgeSet(PAGEdge::Copy);
-    for (PAGEdge::SVFStmtSetTy::iterator iter = copys.begin(), eiter =
+    SVFStmt::SVFStmtSetTy& copys = getPAGEdgeSet(SVFStmt::Copy);
+    for (SVFStmt::SVFStmtSetTy::iterator iter = copys.begin(), eiter =
                 copys.end(); iter != eiter; ++iter)
     {
         const CopyStmt* edge = SVFUtil::cast<CopyStmt>(*iter);
         addCopyCGEdge(edge->getRHSVarID(),edge->getLHSVarID());
     }
 
-    PAGEdge::SVFStmtSetTy& phis = getPAGEdgeSet(PAGEdge::Phi);
-    for (PAGEdge::SVFStmtSetTy::iterator iter = phis.begin(), eiter =
+    SVFStmt::SVFStmtSetTy& phis = getPAGEdgeSet(SVFStmt::Phi);
+    for (SVFStmt::SVFStmtSetTy::iterator iter = phis.begin(), eiter =
                 phis.end(); iter != eiter; ++iter)
     {
         const PhiStmt* edge = SVFUtil::cast<PhiStmt>(*iter);
@@ -74,64 +74,59 @@ void ConstraintGraph::buildCG()
             addCopyCGEdge(opVar->getId(),edge->getResID());
     }
 
-    PAGEdge::SVFStmtSetTy& calls = getPAGEdgeSet(PAGEdge::Call);
-    for (PAGEdge::SVFStmtSetTy::iterator iter = calls.begin(), eiter =
+    SVFStmt::SVFStmtSetTy& calls = getPAGEdgeSet(SVFStmt::Call);
+    for (SVFStmt::SVFStmtSetTy::iterator iter = calls.begin(), eiter =
                 calls.end(); iter != eiter; ++iter)
     {
         const CallPE* edge = SVFUtil::cast<CallPE>(*iter);
         addCopyCGEdge(edge->getRHSVarID(),edge->getLHSVarID());
     }
 
-    PAGEdge::SVFStmtSetTy& rets = getPAGEdgeSet(PAGEdge::Ret);
-    for (PAGEdge::SVFStmtSetTy::iterator iter = rets.begin(), eiter =
+    SVFStmt::SVFStmtSetTy& rets = getPAGEdgeSet(SVFStmt::Ret);
+    for (SVFStmt::SVFStmtSetTy::iterator iter = rets.begin(), eiter =
                 rets.end(); iter != eiter; ++iter)
     {
         const RetPE* edge = SVFUtil::cast<RetPE>(*iter);
         addCopyCGEdge(edge->getRHSVarID(),edge->getLHSVarID());
     }
 
-    PAGEdge::SVFStmtSetTy& tdfks = getPAGEdgeSet(PAGEdge::ThreadFork);
-    for (PAGEdge::SVFStmtSetTy::iterator iter = tdfks.begin(), eiter =
+    SVFStmt::SVFStmtSetTy& tdfks = getPAGEdgeSet(SVFStmt::ThreadFork);
+    for (SVFStmt::SVFStmtSetTy::iterator iter = tdfks.begin(), eiter =
                 tdfks.end(); iter != eiter; ++iter)
     {
         const TDForkPE* edge = SVFUtil::cast<TDForkPE>(*iter);
         addCopyCGEdge(edge->getRHSVarID(),edge->getLHSVarID());
     }
 
-    PAGEdge::SVFStmtSetTy& tdjns = getPAGEdgeSet(PAGEdge::ThreadJoin);
-    for (PAGEdge::SVFStmtSetTy::iterator iter = tdjns.begin(), eiter =
+    SVFStmt::SVFStmtSetTy& tdjns = getPAGEdgeSet(SVFStmt::ThreadJoin);
+    for (SVFStmt::SVFStmtSetTy::iterator iter = tdjns.begin(), eiter =
                 tdjns.end(); iter != eiter; ++iter)
     {
         const TDJoinPE* edge = SVFUtil::cast<TDJoinPE>(*iter);
         addCopyCGEdge(edge->getRHSVarID(),edge->getLHSVarID());
     }
 
-    PAGEdge::SVFStmtSetTy& ngeps = getPAGEdgeSet(PAGEdge::NormalGep);
-    for (PAGEdge::SVFStmtSetTy::iterator iter = ngeps.begin(), eiter =
+    SVFStmt::SVFStmtSetTy& ngeps = getPAGEdgeSet(SVFStmt::Gep);
+    for (SVFStmt::SVFStmtSetTy::iterator iter = ngeps.begin(), eiter =
                 ngeps.end(); iter != eiter; ++iter)
     {
-        NormalGepStmt* edge = SVFUtil::cast<NormalGepStmt>(*iter);
-        addNormalGepCGEdge(edge->getRHSVarID(),edge->getLHSVarID(),edge->getLocationSet());
-    }
-
-    PAGEdge::SVFStmtSetTy& vgeps = getPAGEdgeSet(PAGEdge::VariantGep);
-    for (PAGEdge::SVFStmtSetTy::iterator iter = vgeps.begin(), eiter =
-                vgeps.end(); iter != eiter; ++iter)
-    {
-        VariantGepStmt* edge = SVFUtil::cast<VariantGepStmt>(*iter);
-        addVariantGepCGEdge(edge->getRHSVarID(),edge->getLHSVarID());
+        GepStmt* edge = SVFUtil::cast<GepStmt>(*iter);
+        if(edge->isVariantFieldGep())
+                addVariantGepCGEdge(edge->getRHSVarID(),edge->getLHSVarID());
+        else
+            addNormalGepCGEdge(edge->getRHSVarID(),edge->getLHSVarID(),edge->getLocationSet());
     }
 
-    PAGEdge::SVFStmtSetTy& loads = getPAGEdgeSet(PAGEdge::Load);
-    for (PAGEdge::SVFStmtSetTy::iterator iter = loads.begin(), eiter =
+    SVFStmt::SVFStmtSetTy& loads = getPAGEdgeSet(SVFStmt::Load);
+    for (SVFStmt::SVFStmtSetTy::iterator iter = loads.begin(), eiter =
                 loads.end(); iter != eiter; ++iter)
     {
         LoadStmt* edge = SVFUtil::cast<LoadStmt>(*iter);
         addLoadCGEdge(edge->getRHSVarID(),edge->getLHSVarID());
     }
 
-    PAGEdge::SVFStmtSetTy& stores = getPAGEdgeSet(PAGEdge::Store);
-    for (PAGEdge::SVFStmtSetTy::iterator iter = stores.begin(), eiter =
+    SVFStmt::SVFStmtSetTy& stores = getPAGEdgeSet(SVFStmt::Store);
+    for (SVFStmt::SVFStmtSetTy::iterator iter = stores.begin(), eiter =
                 stores.end(); iter != eiter; ++iter)
     {
         StoreStmt* edge = SVFUtil::cast<StoreStmt>(*iter);
@@ -562,7 +557,7 @@ void ConstraintGraph::print()
         }
         else if (NormalGepCGEdge* ngep = SVFUtil::dyn_cast<NormalGepCGEdge>(*iter))
         {
-            outs() << ngep->getSrcID() << " -- NormalGep (" << ngep->getFieldOffset()
+            outs() << ngep->getSrcID() << " -- NormalGep (" << ngep->getConstantFieldIdx()
                    << ") --> " << ngep->getDstID() << "\n";
         }
         else if (VariantGepCGEdge* vgep = SVFUtil::dyn_cast<VariantGepCGEdge>(*iter))

package/lib/Graphs/SVFG.cpp

@@ -224,8 +224,8 @@ void SVFG::addSVFGNodesForAddrTakenVars()
 {
 
     // set defs for address-taken vars defined at store statements
-    PAGEdge::SVFStmtSetTy& stores = getPAGEdgeSet(PAGEdge::Store);
-    for (PAGEdge::SVFStmtSetTy::iterator iter = stores.begin(), eiter =
+    SVFStmt::SVFStmtSetTy& stores = getPAGEdgeSet(SVFStmt::Store);
+    for (SVFStmt::SVFStmtSetTy::iterator iter = stores.begin(), eiter =
                 stores.end(); iter != eiter; ++iter)
     {
         StoreStmt* store = SVFUtil::cast<StoreStmt>(*iter);