svf-lib 1.0.729 → 1.0.733

package/SVF-osx/include/Util/TypeBasedHeapCloning.h

@@ -11,7 +11,7 @@
  */
 
 #include "SVF-FE/DCHG.h"
-#include "Graphs/PAG.h"
+#include "MemoryModel/SVFIR.h"
 #include "MemoryModel/PointerAnalysisImpl.h"
 #include "Util/BasicTypes.h"
 
@@ -48,8 +48,8 @@ protected:
 
     /// DCHG *must* be set by extending class once the DCHG is available.
     void setDCHG(DCHGraph *dchg);
-    /// PAG *must* be set by extending class once the PAG is available.
-    void setPAG(PAG *pag);
+    /// SVFIR *must* be set by extending class once the SVFIR is available.
+    void setPAG(SVFIR *pag);
 
     /// Check if an object is a black hole obj or a constant object. Required since
     /// other implementations obviously do not account for clones.
@@ -97,7 +97,7 @@ protected:
     const NodeBS &getGepObjs(NodeID base);
 
     /// Returns the GEP object node(s) of base for ls. This may include clones.
-    /// If there are no GEP objects, then getGepObjNode is called on the PAG
+    /// If there are no GEP objects, then getGepObjNode is called on the SVFIR
     /// (through base's getGepObjNode) which will create one.
     const NodeBS getGepObjClones(NodeID base, unsigned offset);
 
@@ -109,11 +109,11 @@ protected:
     /// as a result of reuse.
     NodeID cloneObject(NodeID o, const DIType *type, bool reuse);
 
-    /// Add clone dummy object node to PAG.
+    /// Add clone dummy object node to SVFIR.
     inline NodeID addCloneDummyObjNode(const MemObj *mem);
-    /// Add clone GEP object node to PAG.
+    /// Add clone GEP object node to SVFIR.
     inline NodeID addCloneGepObjNode(const MemObj *mem, const LocationSet &l);
-    /// Add clone FI object node to PAG.
+    /// Add clone FI object node to SVFIR.
     inline NodeID addCloneFIObjNode(const MemObj *mem);
 
     /// Returns the ctir type attached to the value, nullptr if non-existant.
@@ -145,20 +145,20 @@ protected:
 private:
     /// PTA extending this class.
     BVDataPTAImpl *pta;
-    /// PAG the PTA uses. Just a shortcut for getPAG().
-    PAG *ppag = nullptr;
+    /// SVFIR the PTA uses. Just a shortcut for getPAG().
+    SVFIR *ppag = nullptr;
 
     /// Object -> its type.
     Map<NodeID, const DIType *> objToType;
     /// Object -> allocation site.
     /// The value NodeID depends on the pointer analysis (could be
-    /// an SVFG node or PAG node for example).
+    /// an SVFG node or SVFIR node for example).
     Map<NodeID, NodeID> objToAllocation;
     /// (Original) object -> set of its clones.
     Map<NodeID, NodeBS> objToClones;
     /// (Clone) object -> original object (opposite of objToclones).
     Map<NodeID, NodeID> cloneToOriginalObj;
-    /// Maps nodes (a location like a PAG node or SVFG node) to their filter set.
+    /// Maps nodes (a location like a SVFIR node or SVFG node) to their filter set.
     Map<NodeID, PointsTo> locToFilterSet;
     /// Maps objects to the GEP nodes beneath them.
     Map<NodeID, NodeBS> objToGeps;

package/SVF-osx/include/WPA/Andersen.h

@@ -33,14 +33,13 @@
 #include "MemoryModel/PointerAnalysisImpl.h"
 #include "WPA/WPAStat.h"
 #include "WPA/WPASolver.h"
-#include "Graphs/PAG.h"
+#include "MemoryModel/SVFIR.h"
 #include "Graphs/ConsG.h"
 #include "Graphs/OfflineConsG.h"
 
 namespace SVF
 {
 
-class PTAType;
 class SVFModule;
 
 /*!
@@ -53,7 +52,7 @@ class AndersenBase:  public WPAConstraintSolver, public BVDataPTAImpl
 public:
 
     /// Constructor
-    AndersenBase(PAG* _pag, PTATY type = Andersen_BASE, bool alias_check = true)
+    AndersenBase(SVFIR* _pag, PTATY type = Andersen_BASE, bool alias_check = true)
         :  BVDataPTAImpl(_pag, type, alias_check), consCG(nullptr)
     {
         iterationForPrintStat = OnTheFlyIterBudgetForStat;
@@ -156,7 +155,7 @@ public:
     typedef OrderedMap<CallSite, NodeID> CallSite2DummyValPN;
 
     /// Constructor
-    Andersen(PAG* _pag, PTATY type = Andersen_WPA, bool alias_check = true)
+    Andersen(SVFIR* _pag, PTATY type = Andersen_WPA, bool alias_check = true)
         :  AndersenBase(_pag, type, alias_check), pwcOpt(false), diffOpt(true)
     {
     }
@@ -425,10 +424,10 @@ private:
     static AndersenWaveDiff* diffWave; // static instance
 
 public:
-    AndersenWaveDiff(PAG* _pag, PTATY type = AndersenWaveDiff_WPA, bool alias_check = true): Andersen(_pag, type, alias_check) {}
+    AndersenWaveDiff(SVFIR* _pag, PTATY type = AndersenWaveDiff_WPA, bool alias_check = true): Andersen(_pag, type, alias_check) {}
 
     /// Create an singleton instance directly instead of invoking llvm pass manager
-    static AndersenWaveDiff* createAndersenWaveDiff(PAG* _pag)
+    static AndersenWaveDiff* createAndersenWaveDiff(SVFIR* _pag)
     {
         if(diffWave==nullptr)
         {
@@ -464,94 +463,6 @@ protected:
 };
 
 
-
-/**
- * Wave propagation with diff points-to set with type filter.
- */
-class AndersenWaveDiffWithType : public AndersenWaveDiff
-{
-
-private:
-
-    typedef Map<NodeID, Set<const GepCGEdge*>> TypeMismatchedObjToEdgeTy;
-
-    TypeMismatchedObjToEdgeTy typeMismatchedObjToEdges;
-
-    void recordTypeMismatchedGep(NodeID obj, const GepCGEdge* gepEdge)
-    {
-        TypeMismatchedObjToEdgeTy::iterator it = typeMismatchedObjToEdges.find(obj);
-        if (it != typeMismatchedObjToEdges.end())
-        {
-            Set<const GepCGEdge*> &edges = it->second;
-            edges.insert(gepEdge);
-        }
-        else
-        {
-            Set<const GepCGEdge*> edges;
-            edges.insert(gepEdge);
-            typeMismatchedObjToEdges[obj] = edges;
-        }
-    }
-
-    static AndersenWaveDiffWithType* diffWaveWithType; // static instance
-
-    /// Handle diff points-to set.
-    //@{
-    virtual inline void computeDiffPts(NodeID id)
-    {
-        NodeID rep = sccRepNode(id);
-        getDiffPTDataTy()->computeDiffPts(rep, getDiffPTDataTy()->getPts(rep));
-    }
-    virtual inline const PointsTo& getDiffPts(NodeID id)
-    {
-        NodeID rep = sccRepNode(id);
-        return getDiffPTDataTy()->getDiffPts(rep);
-    }
-    //@}
-
-public:
-    AndersenWaveDiffWithType(PAG* _pag, PTATY type = AndersenWaveDiffWithType_WPA): AndersenWaveDiff(_pag,type)
-    {
-        assert(getTypeSystem()!=nullptr && "a type system is required for this pointer analysis");
-    }
-
-    /// Create an singleton instance directly instead of invoking llvm pass manager
-    static AndersenWaveDiffWithType* createAndersenWaveDiffWithType(PAG* p)
-    {
-        if(diffWaveWithType==nullptr)
-        {
-            diffWaveWithType = new AndersenWaveDiffWithType(p);
-            diffWaveWithType->analyze();
-            return diffWaveWithType;
-        }
-        return diffWaveWithType;
-    }
-    static void releaseAndersenWaveDiffWithType()
-    {
-        if (diffWaveWithType)
-            delete diffWaveWithType;
-        diffWaveWithType = nullptr;
-    }
-
-protected:
-    /// SCC detection
-    virtual NodeStack& SCCDetect();
-    /// merge types of nodes in a cycle
-    void mergeTypeOfNodes(const NodeBS &nodes);
-    /// process "bitcast" CopyCGEdge
-    virtual void processCast(const ConstraintEdge *edge);
-    /// update type of objects when process "bitcast" CopyCGEdge
-    void updateObjType(const Type *type, const PointsTo &objs);
-    /// process mismatched gep edges
-    void processTypeMismatchedGep(NodeID obj, const Type *type);
-    /// match types for Gep Edges
-    virtual bool matchType(NodeID ptrid, NodeID objid, const NormalGepCGEdge *normalGepEdge);
-    /// add type for newly created GepObjNode
-    virtual void addTypeForGepObjNode(NodeID id, const NormalGepCGEdge* normalGepEdge);
-};
-
-
-
 /*
  * Lazy Cycle Detection Based Andersen Analysis
  */
@@ -564,13 +475,13 @@ private:
     NodeSet lcdCandidates;
 
 public:
-    AndersenLCD(PAG* _pag, PTATY type = AndersenLCD_WPA) :
+    AndersenLCD(SVFIR* _pag, PTATY type = AndersenLCD_WPA) :
         Andersen(_pag, type), metEdges({}), lcdCandidates( {})
     {
     }
 
     /// Create an singleton instance directly instead of invoking llvm pass manager
-    static AndersenLCD* createAndersenLCD(PAG* _pag)
+    static AndersenLCD* createAndersenLCD(SVFIR* _pag)
     {
         if (lcdAndersen == nullptr)
         {
@@ -646,13 +557,13 @@ private:
     OfflineConsG* oCG;
 
 public:
-    AndersenHCD(PAG* _pag, PTATY type = AndersenHCD_WPA) :
+    AndersenHCD(SVFIR* _pag, PTATY type = AndersenHCD_WPA) :
         Andersen(_pag, type), oCG(nullptr)
     {
     }
 
     /// Create an singleton instance directly instead of invoking llvm pass manager
-    static AndersenHCD *createAndersenHCD(PAG* _pag)
+    static AndersenHCD *createAndersenHCD(SVFIR* _pag)
     {
         if (hcdAndersen == nullptr)
         {
@@ -717,13 +628,13 @@ private:
     static AndersenHLCD* hlcdAndersen;
 
 public:
-    AndersenHLCD(PAG* _pag, PTATY type = AndersenHLCD_WPA) :
+    AndersenHLCD(SVFIR* _pag, PTATY type = AndersenHLCD_WPA) :
         Andersen(_pag, type), AndersenHCD(_pag, type), AndersenLCD(_pag, type)
     {
     }
 
     /// Create an singleton instance directly instead of invoking llvm pass manager
-    static AndersenHLCD *createAndersenHLCD(PAG* _pag)
+    static AndersenHLCD *createAndersenHLCD(SVFIR* _pag)
     {
         if (hlcdAndersen == nullptr)
         {

package/SVF-osx/include/WPA/AndersenSFR.h

@@ -52,13 +52,13 @@ protected:
     NodeToNodeMap pwcReps;
 
 public:
-    AndersenSCD(PAG* _pag, PTATY type = AndersenSCD_WPA) :
+    AndersenSCD(SVFIR* _pag, PTATY type = AndersenSCD_WPA) :
         Andersen(_pag,type)
     {
     }
 
     /// Create an singleton instance directly instead of invoking llvm pass manager
-    static AndersenSCD *createAndersenSCD(PAG* _pag)
+    static AndersenSCD *createAndersenSCD(SVFIR* _pag)
     {
         if (scdAndersen == nullptr)
         {
@@ -114,13 +114,13 @@ private:
     FieldReps fieldReps;
 
 public:
-    AndersenSFR(PAG* _pag, PTATY type = AndersenSFR_WPA) :
+    AndersenSFR(SVFIR* _pag, PTATY type = AndersenSFR_WPA) :
         AndersenSCD(_pag, type), csc(nullptr)
     {
     }
 
     /// Create an singleton instance directly instead of invoking llvm pass manager
-    static AndersenSFR *createAndersenSFR(PAG* _pag)
+    static AndersenSFR *createAndersenSFR(SVFIR* _pag)
     {
         if (sfrAndersen == nullptr)
         {

package/SVF-osx/include/WPA/FlowSensitive.h

@@ -58,7 +58,7 @@ public:
     typedef BVDataPTAImpl::MutDFPTDataTy::PtsMap PtsMap;
 
     /// Constructor
-    FlowSensitive(PAG* _pag, PTATY type = FSSPARSE_WPA) : WPASVFGFSSolver(), BVDataPTAImpl(_pag, type)
+    FlowSensitive(SVFIR* _pag, PTATY type = FSSPARSE_WPA) : WPASVFGFSSolver(), BVDataPTAImpl(_pag, type)
     {
         svfg = nullptr;
         solveTime = sccTime = processTime = propagationTime = updateTime = 0;
@@ -81,7 +81,7 @@ public:
     }
 
     /// Create signle instance of flow-sensitive pointer analysis
-    static FlowSensitive* createFSWPA(PAG* _pag)
+    static FlowSensitive* createFSWPA(SVFIR* _pag)
     {
         if (fspta == nullptr)
         {

package/SVF-osx/include/WPA/FlowSensitiveTBHC.h

@@ -33,7 +33,7 @@ public:
     static const MDNode *getRawCTirMetadata(const SVFGNode *);
 
     /// Constructor
-    FlowSensitiveTBHC(PAG* _pag, PTATY type = FSTBHC_WPA);
+    FlowSensitiveTBHC(SVFIR* _pag, PTATY type = FSTBHC_WPA);
 
     /// Destructor
     virtual ~FlowSensitiveTBHC() { };

package/SVF-osx/include/WPA/Steensgaard.h

@@ -26,13 +26,13 @@ public:
     typedef Map<NodeID, Set<NodeID>> NodeToSubsMap;
 
     /// Constructor
-    Steensgaard(PAG* _pag)
+    Steensgaard(SVFIR* _pag)
         :  AndersenBase(_pag, Steensgaard_WPA, true)
     {
     }
 
     /// Create an singleton instance
-    static Steensgaard* createSteensgaard(PAG* _pag)
+    static Steensgaard* createSteensgaard(SVFIR* _pag)
     {
         if(steens==nullptr)
         {

package/SVF-osx/include/WPA/TypeAnalysis.h

@@ -40,7 +40,7 @@ class TypeAnalysis:  public AndersenBase
 
 public:
     /// Constructor
-    TypeAnalysis(PAG* pag)
+    TypeAnalysis(SVFIR* pag)
         :  AndersenBase(pag, TypeCPP_WPA)
     {
     }

package/SVF-osx/include/WPA/VersionedFlowSensitive.h

@@ -47,7 +47,7 @@ public:
     static VersionedVar atKey(NodeID, Version);
 
     /// Constructor
-    VersionedFlowSensitive(PAG *_pag, PTATY type = VFS_WPA);
+    VersionedFlowSensitive(SVFIR *_pag, PTATY type = VFS_WPA);
 
     /// Initialize analysis
     virtual void initialize() override;
@@ -74,7 +74,7 @@ public:
     //@}
 
     /// Create single instance of versioned flow-sensitive points-to analysis.
-    static VersionedFlowSensitive *createVFSWPA(PAG *_pag)
+    static VersionedFlowSensitive *createVFSWPA(SVFIR *_pag)
     {
         if (vfspta == nullptr)
         {

package/SVF-osx/include/WPA/WPAStat.h

@@ -39,9 +39,8 @@ namespace SVF
 {
 
 class AndersenBase;
-class PAG;
+class SVFIR;
 class ConstraintGraph;
-class PAGNode;
 
 /*!
  * Statistics of Andersen's analysis

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "svf-lib",
-  "version": "1.0.729",
+  "version": "1.0.733",
   "description": "SVF's npm support",
   "main": "index.js",
   "scripts": {