svf-tools 1.0.351 → 1.0.355

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/MemoryModel/SymbolTableInfo.h

@@ -364,7 +364,11 @@ public:
     }
 
     ///Get a reference to the components of struct_info.
-    const std::vector<u32_t>& getFlattenedFieldIdxVec(const Type *T);
+    /// Flatterned full offset information of a struct including its array fields 
+    const std::vector<u32_t>& getFlattenedOffsetVec(const StructType *T);
+    /// Flatterned field index information of a struct ignoring any array field
+    const std::vector<u32_t>& getFlattenedFieldIdxVec(const StructType *T);
+
     const std::vector<FlattenedFieldInfo>& getFlattenedFieldInfoVec(const Type *T);
 
     ///  struct A { int id; int salary; }; struct B { char name[20]; struct A a;}   B b;
@@ -501,25 +505,32 @@ public:
 
 
 /*!
- * Struct information
+ * Flatterned type information of StructType, ArrayType and SingleValueType
  */
 class StInfo
 {
 
 private:
-    /// flattened field indices of a struct
+    /// flattened field indices of a struct (ignoring arrays)
     std::vector<u32_t> fldIdxVec;
+    /// flattened full offset (including array strides)
+    std::vector<u32_t> fullOffsetVec;
     /// Types of all fields of a struct
     Map<u32_t, const Type*> fldIdx2TypeMap;
     /// All field infos after flattening a struct
     std::vector<FlattenedFieldInfo> finfo;
-
+    /// stride represents the number of repetitive elements if this StInfo represent an ArrayType. stride is 1 by default.
+    u32_t stride; 
     /// Max field limit
     static u32_t maxFieldLimit;
 
+    StInfo(); ///< place holder
+    StInfo(const StInfo& st); ///< place holder
+    void operator=(const StInfo&); ///< place holder
+
 public:
     /// Constructor
-    StInfo()
+    StInfo(u32_t s) : stride(s)
     {
     }
     /// Destructor
@@ -560,6 +571,10 @@ public:
     {
         return fldIdxVec;
     }
+    inline std::vector<u32_t>& getFlattenedOffsetVec()
+    {
+        return fullOffsetVec;
+    }
     inline std::vector<FlattenedFieldInfo>& getFlattenedFieldInfoVec()
     {
         return finfo;
@@ -567,11 +582,17 @@ public:
     //@}
 
     /// Add field (index and offset) with its corresponding type
-    inline void addFldWithType(u32_t fldIdx, const Type* type)
+    inline void addFldWithType(u32_t fldIdx, const Type* type, u32_t fullOffset)
     {
         fldIdxVec.push_back(fldIdx);
+        fullOffsetVec.push_back(fullOffset);
         fldIdx2TypeMap[fldIdx] = type;
     }
+
+    /// Array Type can have 
+    inline u32_t getStride() const {
+        return stride;
+    }
 };
 
 /*!

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);
     // @}
 
@@ -331,7 +331,7 @@ public:
         return edge;
     }
     /// Add Branch statement 
-    inline BranchStmt* addBranchStmt(NodeID br, NodeID cond, const std::vector<const ICFGNode*> succs){
+    inline BranchStmt* addBranchStmt(NodeID br, NodeID cond, const BranchStmt::SuccAndCondPairVec& succs){
         BranchStmt *edge = pag->addBranchStmt(br, cond, succs);
         setCurrentBBAndValueForPAGEdge(edge);
         return edge;
@@ -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/ICFG.cpp

@@ -452,6 +452,10 @@ void ICFG::updateCallGraph(PTACallGraph* callgraph)
                 removeICFGEdge(edge);
         }
     }
+    // dump ICFG
+    if (Options::DumpICFG){
+		dump("icfg_final");
+    }
 }
 
 /*!

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);

package/lib/Graphs/VFG.cpp

@@ -336,16 +336,16 @@ void VFG::addVFGNodes()
     addNullPtrVFGNode(pag->getGNode(pag->getNullPtr()));
 
     // initialize address nodes
-    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)
     {
         addAddrVFGNode(SVFUtil::cast<AddrStmt>(*iter));
     }
 
     // initialize copy nodes
-    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);
@@ -354,38 +354,31 @@ void VFG::addVFGNodes()
     }
 
     // initialize gep nodes
-    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)
     {
-        addGepVFGNode(SVFUtil::cast<NormalGepStmt>(*iter));
-    }
-
-    PAGEdge::SVFStmtSetTy& vgeps = getPAGEdgeSet(PAGEdge::VariantGep);
-    for (PAGEdge::SVFStmtSetTy::iterator iter = vgeps.begin(), eiter =
-                vgeps.end(); iter != eiter; ++iter)
-    {
-        addGepVFGNode(SVFUtil::cast<VariantGepStmt>(*iter));
+        addGepVFGNode(SVFUtil::cast<GepStmt>(*iter));
     }
 
     // initialize load nodes
-    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)
     {
         addLoadVFGNode(SVFUtil::cast<LoadStmt>(*iter));
     }
 
     // initialize store nodes
-    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)
     {
         addStoreVFGNode(SVFUtil::cast<StoreStmt>(*iter));
     }
 
-    PAGEdge::SVFStmtSetTy& forks = getPAGEdgeSet(PAGEdge::ThreadFork);
-    for (PAGEdge::SVFStmtSetTy::iterator iter = forks.begin(), eiter =
+    SVFStmt::SVFStmtSetTy& forks = getPAGEdgeSet(SVFStmt::ThreadFork);
+    for (SVFStmt::SVFStmtSetTy::iterator iter = forks.begin(), eiter =
                 forks.end(); iter != eiter; ++iter)
     {
         TDForkPE* forkedge = SVFUtil::cast<TDForkPE>(*iter);
@@ -429,10 +422,10 @@ void VFG::addVFGNodes()
                 continue;
 
             CallPESet callPEs;
-            if (param->hasIncomingEdges(PAGEdge::Call))
+            if (param->hasIncomingEdges(SVFStmt::Call))
             {
-                for (PAGEdge::SVFStmtSetTy::const_iterator cit = param->getIncomingEdgesBegin(PAGEdge::Call), ecit =
-                            param->getIncomingEdgesEnd(PAGEdge::Call); cit != ecit; ++cit)
+                for (SVFStmt::SVFStmtSetTy::const_iterator cit = param->getIncomingEdgesBegin(SVFStmt::Call), ecit =
+                            param->getIncomingEdgesEnd(SVFStmt::Call); cit != ecit; ++cit)
                 {
                     CallPE* callPE = SVFUtil::cast<CallPE>(*cit);
                     if (isInterestedPAGNode(callPE->getRHSVar()))
@@ -449,10 +442,10 @@ void VFG::addVFGNodes()
                 continue;
 
             CallPESet callPEs;
-            if (varParam->hasIncomingEdges(PAGEdge::Call))
+            if (varParam->hasIncomingEdges(SVFStmt::Call))
             {
-                for(PAGEdge::SVFStmtSetTy::const_iterator cit = varParam->getIncomingEdgesBegin(PAGEdge::Call),
-                        ecit = varParam->getIncomingEdgesEnd(PAGEdge::Call); cit!=ecit; ++cit)
+                for(SVFStmt::SVFStmtSetTy::const_iterator cit = varParam->getIncomingEdgesBegin(SVFStmt::Call),
+                        ecit = varParam->getIncomingEdgesEnd(SVFStmt::Call); cit!=ecit; ++cit)
                 {
                     CallPE* callPE = SVFUtil::cast<CallPE>(*cit);
                     if(isInterestedPAGNode(callPE->getRHSVar()))
@@ -471,10 +464,10 @@ void VFG::addVFGNodes()
         const PAGNode* uniqueFunRetNode = it->second;
 
         RetPESet retPEs;
-        if (uniqueFunRetNode->hasOutgoingEdges(PAGEdge::Ret))
+        if (uniqueFunRetNode->hasOutgoingEdges(SVFStmt::Ret))
         {
-            for (PAGEdge::SVFStmtSetTy::const_iterator cit = uniqueFunRetNode->getOutgoingEdgesBegin(PAGEdge::Ret),
-                    ecit = uniqueFunRetNode->getOutgoingEdgesEnd(PAGEdge::Ret);
+            for (SVFStmt::SVFStmtSetTy::const_iterator cit = uniqueFunRetNode->getOutgoingEdgesBegin(SVFStmt::Ret),
+                    ecit = uniqueFunRetNode->getOutgoingEdgesEnd(SVFStmt::Ret);
                     cit != ecit; ++cit)
             {
                 const RetPE* retPE = SVFUtil::cast<RetPE>(*cit);
@@ -488,8 +481,8 @@ void VFG::addVFGNodes()
     }
 
     // initialize llvm phi nodes (phi of top level pointers)
-    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);
@@ -497,8 +490,8 @@ void VFG::addVFGNodes()
             addIntraPHIVFGNode(edge);
     }
     // initialize llvm binary nodes (binary operators)
-    PAGEdge::SVFStmtSetTy& binaryops = getPAGEdgeSet(PAGEdge::BinaryOp);
-    for (PAGEdge::SVFStmtSetTy::iterator iter = binaryops.begin(), eiter =
+    SVFStmt::SVFStmtSetTy& binaryops = getPAGEdgeSet(SVFStmt::BinaryOp);
+    for (SVFStmt::SVFStmtSetTy::iterator iter = binaryops.begin(), eiter =
                 binaryops.end(); iter != eiter; ++iter)
     {
         const BinaryOPStmt* edge = SVFUtil::cast<BinaryOPStmt>(*iter);
@@ -506,8 +499,8 @@ void VFG::addVFGNodes()
             addBinaryOPVFGNode(edge);
     }
     // initialize llvm unary nodes (unary operators)
-    PAGEdge::SVFStmtSetTy& unaryops = getPAGEdgeSet(PAGEdge::UnaryOp);
-    for (PAGEdge::SVFStmtSetTy::iterator iter = unaryops.begin(), eiter =
+    SVFStmt::SVFStmtSetTy& unaryops = getPAGEdgeSet(SVFStmt::UnaryOp);
+    for (SVFStmt::SVFStmtSetTy::iterator iter = unaryops.begin(), eiter =
                 unaryops.end(); iter != eiter; ++iter)
     {
         const UnaryOPStmt* edge = SVFUtil::cast<UnaryOPStmt>(*iter);
@@ -515,8 +508,8 @@ void VFG::addVFGNodes()
             addUnaryOPVFGNode(edge);
     }
     // initialize llvm unary nodes (unary operators)
-    PAGEdge::SVFStmtSetTy& brs = getPAGEdgeSet(PAGEdge::Branch);
-    for (PAGEdge::SVFStmtSetTy::iterator iter = brs.begin(), eiter =
+    SVFStmt::SVFStmtSetTy& brs = getPAGEdgeSet(SVFStmt::Branch);
+    for (SVFStmt::SVFStmtSetTy::iterator iter = brs.begin(), eiter =
                 brs.end(); iter != eiter; ++iter)
     {
         const BranchStmt* edge = SVFUtil::cast<BranchStmt>(*iter);
@@ -524,8 +517,8 @@ void VFG::addVFGNodes()
             addBranchVFGNode(edge);
     }
     // initialize llvm cmp nodes (comparision)
-    PAGEdge::SVFStmtSetTy& cmps = getPAGEdgeSet(PAGEdge::Cmp);
-    for (PAGEdge::SVFStmtSetTy::iterator iter = cmps.begin(), eiter =
+    SVFStmt::SVFStmtSetTy& cmps = getPAGEdgeSet(SVFStmt::Cmp);
+    for (SVFStmt::SVFStmtSetTy::iterator iter = cmps.begin(), eiter =
                 cmps.end(); iter != eiter; ++iter)
     {
         const CmpStmt* edge = SVFUtil::cast<CmpStmt>(*iter);
@@ -692,8 +685,8 @@ void VFG::connectDirectVFGEdges()
     /// connect direct value-flow edges (parameter passing) for thread fork/join
     if(Options::EnableThreadCallGraph){
         /// add fork edge
-        PAGEdge::SVFStmtSetTy& forks = getPAGEdgeSet(PAGEdge::ThreadFork);
-        for (PAGEdge::SVFStmtSetTy::iterator iter = forks.begin(), eiter =
+        SVFStmt::SVFStmtSetTy& forks = getPAGEdgeSet(SVFStmt::ThreadFork);
+        for (SVFStmt::SVFStmtSetTy::iterator iter = forks.begin(), eiter =
                 forks.end(); iter != eiter; ++iter)
         {
             TDForkPE* forkedge = SVFUtil::cast<TDForkPE>(*iter);
@@ -702,8 +695,8 @@ void VFG::connectDirectVFGEdges()
             addInterEdgeFromAPToFP(acutalParm,formalParm,getCallSiteID(forkedge->getCallSite(), formalParm->getFun()));
         }
         /// add join edge
-        PAGEdge::SVFStmtSetTy& joins = getPAGEdgeSet(PAGEdge::ThreadJoin);
-        for (PAGEdge::SVFStmtSetTy::iterator iter = joins.begin(), eiter =
+        SVFStmt::SVFStmtSetTy& joins = getPAGEdgeSet(SVFStmt::ThreadJoin);
+        for (SVFStmt::SVFStmtSetTy::iterator iter = joins.begin(), eiter =
                 joins.end(); iter != eiter; ++iter)
         {
             TDJoinPE* joinedge = SVFUtil::cast<TDJoinPE>(*iter);

package/lib/MSSA/SVFGBuilder.cpp

@@ -43,20 +43,13 @@ SVFG* SVFGBuilder::globalSvfg = nullptr;
 
 SVFG* SVFGBuilder::buildPTROnlySVFG(BVDataPTAImpl* pta)
 {
-    return build(pta, VFG::PTRONLYSVFG_OPT);
-}
-
-SVFG* SVFGBuilder::buildPTROnlySVFGWithoutOPT(BVDataPTAImpl* pta)
-{
-    return build(pta, VFG::PTRONLYSVFG);
+    if(Options::OPTSVFG)
+        return build(pta, VFG::PTRONLYSVFG_OPT);
+    else
+        return build(pta, VFG::PTRONLYSVFG);
 }
 
 SVFG* SVFGBuilder::buildFullSVFG(BVDataPTAImpl* pta)
-{
-    return build(pta, VFG::FULLSVFG_OPT);
-}
-
-SVFG* SVFGBuilder::buildFullSVFGWithoutOPT(BVDataPTAImpl* pta)
 {
     return build(pta, VFG::FULLSVFG);
 }

package/lib/MTA/MTAAnnotator.cpp

@@ -122,8 +122,8 @@ void MTAAnnotator::pruneThreadLocal(PointerAnalysis* pta)
     PointsTo worklist;
 
     /// find fork arguments' objects
-    const PAGEdge::SVFStmtSetTy& forkedges = pag->getPTASVFStmtSet(PAGEdge::ThreadFork);
-    for (PAGEdge::SVFStmtSetTy::const_iterator it = forkedges.begin(), eit = forkedges.end(); it != eit; ++it)
+    const SVFStmt::SVFStmtSetTy& forkedges = pag->getPTASVFStmtSet(SVFStmt::ThreadFork);
+    for (SVFStmt::SVFStmtSetTy::const_iterator it = forkedges.begin(), eit = forkedges.end(); it != eit; ++it)
     {
         PAGEdge* edge = *it;
         worklist |= pta->getPts(edge->getDstID());
@@ -135,7 +135,7 @@ void MTAAnnotator::pruneThreadLocal(PointerAnalysis* pta)
     for (SVFIR::SVFStmtSet::const_iterator it = globaledges.begin(), eit = globaledges.end(); it != eit; ++it)
     {
         const PAGEdge* edge = *it;
-        if (edge->getEdgeKind() == PAGEdge::Addr)
+        if (edge->getEdgeKind() == SVFStmt::Addr)
         {
             worklist.set(edge->getSrcID());
         }