svf-tools 1.0.320 → 1.0.324

package/include/MemoryModel/SVFStatements.h

@@ -41,15 +41,15 @@ namespace SVF
 class SVFVar;
 
 /*
- * SVFIR edge between nodes
+ * SVFIR program statements (PAGEdges)
  */
 typedef GenericEdge<SVFVar> GenericPAGEdgeTy;
 class SVFStmt : public GenericPAGEdgeTy
 {
 
 public:
-    /// Thirteen kinds of SVFIR edges
-    /// Gep represents offset edge for field sensitivity
+    /// Types of SVFIR statements
+    /// Gep represents (base + offset) for field sensitivity
     /// ThreadFork/ThreadJoin is to model parameter passings between thread spawners and spawnees.
     enum PEDGEK
     {
@@ -175,9 +175,10 @@ public:
     }
     //@}
 
-    typedef GenericNode<SVFVar,SVFStmt>::GEdgeSetTy PAGEdgeSetTy;
-    typedef Map<EdgeID, PAGEdgeSetTy> PAGEdgeToSetMapTy;
-    typedef PAGEdgeToSetMapTy PAGKindToEdgeSetMapTy;
+    typedef GenericNode<SVFVar,SVFStmt>::GEdgeSetTy SVFStmtSetTy;
+    typedef Map<EdgeID, SVFStmtSetTy> PAGEdgeToSetMapTy;
+    typedef PAGEdgeToSetMapTy KindToSVFStmtMapTy;
+    typedef SVFStmtSetTy PAGEdgeSetTy;
 
 private:
     typedef Map<const ICFGNode*, u32_t> Inst2LabelMap;
@@ -191,18 +192,18 @@ private:
 
 
 /*!
- * Copy edge
+ * Address statement (memory allocations)
  */
-class AddrPE: public SVFStmt
+class AddrStmt: public SVFStmt
 {
 private:
-    AddrPE();                      ///< place holder
-    AddrPE(const AddrPE &);  ///< place holder
-    void operator=(const AddrPE &); ///< place holder
+    AddrStmt();                      ///< place holder
+    AddrStmt(const AddrStmt &);  ///< place holder
+    void operator=(const AddrStmt &); ///< place holder
 public:
     /// Methods for support type inquiry through isa, cast, and dyn_cast:
     //@{
-    static inline bool classof(const AddrPE *)
+    static inline bool classof(const AddrStmt *)
     {
         return true;
     }
@@ -217,7 +218,7 @@ public:
     //@}
 
     /// constructor
-    AddrPE(SVFVar* s, SVFVar* d) : SVFStmt(s,d,SVFStmt::Addr)
+    AddrStmt(SVFVar* s, SVFVar* d) : SVFStmt(s,d,SVFStmt::Addr)
     {
     }
 
@@ -226,18 +227,18 @@ public:
 
 
 /*!
- * Copy edge
+ * Copy statements (simple assignment and casting)
  */
-class CopyPE: public SVFStmt
+class CopyStmt: public SVFStmt
 {
 private:
-    CopyPE();                      ///< place holder
-    CopyPE(const CopyPE &);  ///< place holder
-    void operator=(const CopyPE &); ///< place holder
+    CopyStmt();                      ///< place holder
+    CopyStmt(const CopyStmt &);  ///< place holder
+    void operator=(const CopyStmt &); ///< place holder
 public:
     /// Methods for support type inquiry through isa, cast, and dyn_cast:
     //@{
-    static inline bool classof(const CopyPE *)
+    static inline bool classof(const CopyStmt *)
     {
         return true;
     }
@@ -252,13 +253,16 @@ public:
     //@}
 
     /// constructor
-    CopyPE(SVFVar* s, SVFVar* d) : SVFStmt(s,d,SVFStmt::Copy)
+    CopyStmt(SVFVar* s, SVFVar* d) : SVFStmt(s,d,SVFStmt::Copy)
     {
     }
 
     virtual const std::string toString() const override;
 };
 
+/*
+* Program statements with multiple operands including BinaryOPStmt, CmpStmt and PhiStmt
+*/
 class MultiOpndStmt : public SVFStmt{
 public:
     typedef std::vector<SVFVar*> OPVars;
@@ -323,14 +327,15 @@ public:
 };
 
 /*!
- * Phi instruction edge
+ * Phi statement (e.g., p = phi(q,r) which receives values from variables q and r from different paths)
+ * it is typically at a joint point of the control-flow graph
  */
-class PhiPE: public MultiOpndStmt
+class PhiStmt: public MultiOpndStmt
 {
 private:
-    PhiPE();                      ///< place holder
-    PhiPE(const PhiPE &);  ///< place holder
-    void operator=(const PhiPE &); ///< place holder
+    PhiStmt();                      ///< place holder
+    PhiStmt(const PhiStmt &);  ///< place holder
+    void operator=(const PhiStmt &); ///< place holder
     SVFVar* getSrcNode();  ///< place holder, not allowed since this SVFStmt has multiple operands but not a single source
     SVFVar* getDstNode();    ///< place holder, use getRes() instead
     SVFVar* getSrcID();  ///< place holder, use getOpVarID(pos) instead
@@ -339,7 +344,7 @@ private:
 public:
     /// Methods for support type inquiry through isa, cast, and dyn_cast:
     //@{
-    static inline bool classof(const PhiPE *)
+    static inline bool classof(const PhiStmt *)
     {
         return true;
     }
@@ -358,7 +363,7 @@ public:
     //@}
 
     /// constructor
-    PhiPE(SVFVar* s, const OPVars& opnds) : MultiOpndStmt(s,opnds,SVFStmt::Phi)
+    PhiStmt(SVFVar* s, const OPVars& opnds) : MultiOpndStmt(s,opnds,SVFStmt::Phi)
     {
     }
     void addOpVar(SVFVar* op){
@@ -369,24 +374,24 @@ public:
 
 
 /*!
- * Compare instruction edge
+ * Comparison statement
  */
-class CmpPE: public MultiOpndStmt
+class CmpStmt: public MultiOpndStmt
 {
 private:
-    CmpPE();                      ///< place holder
-    CmpPE(const CmpPE &);  ///< place holder
-    void operator=(const CmpPE &); ///< place holder
+    CmpStmt();                      ///< place holder
+    CmpStmt(const CmpStmt &);  ///< place holder
+    void operator=(const CmpStmt &); ///< place holder
     SVFVar* getSrcNode();  ///< place holder, not allowed since this SVFStmt has multiple operands but not a single source
     SVFVar* getDstNode();    ///< place holder, use getRes() instead
     SVFVar* getSrcID();  ///< place holder, use getOpVarID(pos) instead
     SVFVar* getDstID();    ///< place holder, use getResID() instead
 
-    u32_t opcode;
+    u32_t predicate;
 public:
     /// Methods for support type inquiry through isa, cast, and dyn_cast:
     //@{
-    static inline bool classof(const CmpPE *)
+    static inline bool classof(const CmpStmt *)
     {
         return true;
     }
@@ -405,13 +410,13 @@ public:
     //@}
 
     /// constructor
-    CmpPE(SVFVar* s, const OPVars& opnds, u32_t oc) : MultiOpndStmt(s,opnds,SVFStmt::Cmp), opcode(oc)
+    CmpStmt(SVFVar* s, const OPVars& opnds, u32_t pre) : MultiOpndStmt(s,opnds,SVFStmt::Cmp), predicate(pre)
     {
     }
 
-    u32_t getOpcode() const
+    u32_t getPredicate() const
     {
-        return opcode;
+        return predicate;
     }
     
     virtual const std::string toString() const override;
@@ -419,14 +424,14 @@ public:
 
 
 /*!
- * Binary instruction edge
+ * Binary statement
  */
-class BinaryOPPE: public MultiOpndStmt
+class BinaryOPStmt: public MultiOpndStmt
 {
 private:
-    BinaryOPPE();                      ///< place holder
-    BinaryOPPE(const BinaryOPPE &);  ///< place holder
-    void operator=(const BinaryOPPE &); ///< place holder
+    BinaryOPStmt();                      ///< place holder
+    BinaryOPStmt(const BinaryOPStmt &);  ///< place holder
+    void operator=(const BinaryOPStmt &); ///< place holder
     SVFVar* getSrcNode();  ///< place holder, not allowed since this SVFStmt has multiple operands but not a single source
     SVFVar* getDstNode();    ///< place holder, use getRes() instead
     SVFVar* getSrcID();  ///< place holder, use getOpVarID(pos) instead
@@ -437,7 +442,7 @@ private:
 public:
     /// Methods for support type inquiry through isa, cast, and dyn_cast:
     //@{
-    static inline bool classof(const BinaryOPPE *)
+    static inline bool classof(const BinaryOPStmt *)
     {
         return true;
     }
@@ -456,7 +461,7 @@ public:
     //@}
 
     /// constructor
-    BinaryOPPE(SVFVar* s, const OPVars& opnds, u32_t oc) : MultiOpndStmt(s,opnds,SVFStmt::BinaryOp), opcode(oc)
+    BinaryOPStmt(SVFVar* s, const OPVars& opnds, u32_t oc) : MultiOpndStmt(s,opnds,SVFStmt::BinaryOp), opcode(oc)
     {
     }
 
@@ -469,14 +474,14 @@ public:
 };
 
 /*!
- * Unary instruction edge
+ * Unary statement
  */
-class UnaryOPPE: public SVFStmt
+class UnaryOPStmt: public SVFStmt
 {
 private:
-    UnaryOPPE();                      ///< place holder
-    UnaryOPPE(const UnaryOPPE &);  ///< place holder
-    void operator=(const UnaryOPPE &); ///< place holder
+    UnaryOPStmt();                      ///< place holder
+    UnaryOPStmt(const UnaryOPStmt &);  ///< place holder
+    void operator=(const UnaryOPStmt &); ///< place holder
     SVFVar* getSrcNode();  ///< place holder, use getOpVar() instead
     SVFVar* getDstNode();    ///< place holder, use getRes() instead
     SVFVar* getSrcID();  ///< place holder, use getOpVarID() instead
@@ -486,7 +491,7 @@ private:
 public:
     /// Methods for support type inquiry through isa, cast, and dyn_cast:
     //@{
-    static inline bool classof(const UnaryOPPE *)
+    static inline bool classof(const UnaryOPStmt *)
     {
         return true;
     }
@@ -501,7 +506,7 @@ public:
     //@}
 
     /// constructor
-    UnaryOPPE(SVFVar* s, SVFVar* d, u32_t oc) : SVFStmt(s,d,SVFStmt::UnaryOp), opcode(oc)
+    UnaryOPStmt(SVFVar* s, SVFVar* d, u32_t oc) : SVFStmt(s,d,SVFStmt::UnaryOp), opcode(oc)
     {
     }
 
@@ -586,19 +591,19 @@ public:
 };
 
 /*!
- * Store edge
+ * Store statement
  */
-class StorePE: public SVFStmt
+class StoreStmt: public SVFStmt
 {
 private:
-    StorePE();                      ///< place holder
-    StorePE(const StorePE &);  ///< place holder
-    void operator=(const StorePE &); ///< place holder
+    StoreStmt();                      ///< place holder
+    StoreStmt(const StoreStmt &);  ///< place holder
+    void operator=(const StoreStmt &); ///< place holder
 
 public:
     /// Methods for support type inquiry through isa, cast, and dyn_cast:
     //@{
-    static inline bool classof(const StorePE *)
+    static inline bool classof(const StoreStmt *)
     {
         return true;
     }
@@ -613,7 +618,7 @@ public:
     //@}
 
     /// constructor
-    StorePE(SVFVar* s, SVFVar* d, const IntraBlockNode* st) :
+    StoreStmt(SVFVar* s, SVFVar* d, const IntraBlockNode* st) :
         SVFStmt(s, d, makeEdgeFlagWithStoreInst(SVFStmt::Store, st))
     {
     }
@@ -623,19 +628,19 @@ public:
 
 
 /*!
- * Load edge
+ * Load statement
  */
-class LoadPE: public SVFStmt
+class LoadStmt: public SVFStmt
 {
 private:
-    LoadPE();                      ///< place holder
-    LoadPE(const LoadPE &);  ///< place holder
-    void operator=(const LoadPE &); ///< place holder
+    LoadStmt();                      ///< place holder
+    LoadStmt(const LoadStmt &);  ///< place holder
+    void operator=(const LoadStmt &); ///< place holder
 
 public:
     /// Methods for support type inquiry through isa, cast, and dyn_cast:
     //@{
-    static inline bool classof(const LoadPE *)
+    static inline bool classof(const LoadStmt *)
     {
         return true;
     }
@@ -650,7 +655,7 @@ public:
     //@}
 
     /// constructor
-    LoadPE(SVFVar* s, SVFVar* d) : SVFStmt(s,d,SVFStmt::Load)
+    LoadStmt(SVFVar* s, SVFVar* d) : SVFStmt(s,d,SVFStmt::Load)
     {
     }
 
@@ -659,19 +664,19 @@ public:
 
 
 /*!
- * Gep edge
+ * Gep statement for field access and pointer arithmetic
  */
-class GepPE: public SVFStmt
+class GepStmt: public SVFStmt
 {
 private:
-    GepPE();                      ///< place holder
-    GepPE(const GepPE &);  ///< place holder
-    void operator=(const GepPE &); ///< place holder
+    GepStmt();                      ///< place holder
+    GepStmt(const GepStmt &);  ///< place holder
+    void operator=(const GepStmt &); ///< place holder
 
 public:
     /// Methods for support type inquiry through isa, cast, and dyn_cast:
     //@{
-    static inline bool classof(const GepPE *)
+    static inline bool classof(const GepStmt *)
     {
         return true;
     }
@@ -689,7 +694,7 @@ public:
 
 protected:
     /// constructor
-    GepPE(SVFVar* s, SVFVar* d, PEDGEK k) : SVFStmt(s,d,k)
+    GepStmt(SVFVar* s, SVFVar* d, PEDGEK k) : SVFStmt(s,d,k)
     {
 
     }
@@ -699,25 +704,25 @@ protected:
 
 
 /*!
- * Gep edge with a fixed offset
+ * Gep statement with a fixed offset
  */
-class NormalGepPE : public GepPE
+class NormalGepStmt : public GepStmt
 {
 private:
-    NormalGepPE(); ///< place holder
-    NormalGepPE(const NormalGepPE&); ///< place holder
-    void operator=(const NormalGepPE&); ///< place holder
+    NormalGepStmt(); ///< place holder
+    NormalGepStmt(const NormalGepStmt&); ///< place holder
+    void operator=(const NormalGepStmt&); ///< place holder
 
     LocationSet ls;	///< location set of the gep edge
 
 public:
     /// Methods for support type inquiry through isa, cast, and dyn_cast:
     //@{
-    static inline bool classof(const NormalGepPE *)
+    static inline bool classof(const NormalGepStmt *)
     {
         return true;
     }
-    static inline bool classof(const GepPE *edge)
+    static inline bool classof(const GepStmt *edge)
     {
         return edge->getEdgeKind() == SVFStmt::NormalGep;
     }
@@ -732,7 +737,7 @@ public:
     //@}
 
     /// constructor
-    NormalGepPE(SVFVar* s, SVFVar* d, const LocationSet& l) : GepPE(s,d,SVFStmt::NormalGep), ls(l)
+    NormalGepStmt(SVFVar* s, SVFVar* d, const LocationSet& l) : GepStmt(s,d,SVFStmt::NormalGep), ls(l)
     {}
 
     /// offset of the gep edge
@@ -749,23 +754,23 @@ public:
 };
 
 /*!
- * Gep edge with a variant offset
+ * Gep statement with a variant offset
  */
-class VariantGepPE : public GepPE
+class VariantGepStmt : public GepStmt
 {
 private:
-    VariantGepPE(); ///< place holder
-    VariantGepPE(const VariantGepPE&); ///< place holder
-    void operator=(const VariantGepPE&); ///< place holder
+    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 VariantGepPE *)
+    static inline bool classof(const VariantGepStmt *)
     {
         return true;
     }
-    static inline bool classof(const GepPE *edge)
+    static inline bool classof(const GepStmt *edge)
     {
         return edge->getEdgeKind() == SVFStmt::VariantGep;
     }
@@ -780,7 +785,7 @@ public:
     //@}
 
     /// constructor
-    VariantGepPE(SVFVar* s, SVFVar* d) : GepPE(s,d,SVFStmt::VariantGep) {}
+    VariantGepStmt(SVFVar* s, SVFVar* d) : GepStmt(s,d,SVFStmt::VariantGep) {}
 
     virtual const std::string toString() const override;
 
@@ -788,7 +793,7 @@ public:
 
 
 /*!
- * Call edge
+ * Call 
  */
 class CallPE: public SVFStmt
 {
@@ -840,7 +845,7 @@ public:
 
 
 /*!
- * Return edge
+ * Return 
  */
 class RetPE: public SVFStmt
 {
@@ -892,7 +897,7 @@ public:
 
 
 /*!
- * Thread Fork Edge
+ * Thread Fork 
  */
 class TDForkPE: public CallPE
 {
@@ -930,7 +935,7 @@ public:
 
 
 /*!
- * Thread Join Edge
+ * Thread Join 
  */
 class TDJoinPE: public RetPE
 {