svf-tools 1.0.321 → 1.0.325

package/include/MemoryModel/SVFVariables.h

@@ -40,14 +40,14 @@ namespace SVF
 
 class SVFVar;
 /*
- * SVFIR node
+ * SVFIR program variables (PAGNodes)
  */
 typedef GenericNode<SVFVar,SVFStmt> GenericPAGNodeTy;
 class SVFVar : public GenericPAGNodeTy
 {
 
 public:
-    /// Nine kinds of SVFIR nodes
+    /// Nine kinds of SVFIR variables
     /// ValNode: llvm pointer value
     /// ObjNode: memory object
     /// RetNode: unique return node
@@ -76,8 +76,8 @@ public:
 
 protected:
     const Value* value; ///< value of this SVFIR node
-    SVFStmt::PAGKindToEdgeSetMapTy InEdgeKindToSetMap;
-    SVFStmt::PAGKindToEdgeSetMapTy OutEdgeKindToSetMap;
+    SVFStmt::KindToSVFStmtMapTy InEdgeKindToSetMap;
+    SVFStmt::KindToSVFStmtMapTy OutEdgeKindToSetMap;
     bool isTLPointer;	/// top-level pointer
     bool isATPointer;	/// address-taken pointer
 
@@ -157,22 +157,22 @@ public:
         return nullptr;
     }
 
-    /// Get incoming SVFIR edges
-    inline SVFStmt::PAGEdgeSetTy& getIncomingEdges(SVFStmt::PEDGEK kind)
+    /// Get incoming SVFIR statements (edges)
+    inline SVFStmt::SVFStmtSetTy& getIncomingEdges(SVFStmt::PEDGEK kind)
     {
         return InEdgeKindToSetMap[kind];
     }
 
-    /// Get outgoing SVFIR edges
-    inline SVFStmt::PAGEdgeSetTy& getOutgoingEdges(SVFStmt::PEDGEK kind)
+    /// Get outgoing SVFIR statements (edges)
+    inline SVFStmt::SVFStmtSetTy& getOutgoingEdges(SVFStmt::PEDGEK kind)
     {
         return OutEdgeKindToSetMap[kind];
     }
 
-    /// Has incoming SVFIR edges
+    /// Has incoming SVFIR statements (edges)
     inline bool hasIncomingEdges(SVFStmt::PEDGEK kind) const
     {
-        SVFStmt::PAGKindToEdgeSetMapTy::const_iterator it = InEdgeKindToSetMap.find(kind);
+        SVFStmt::KindToSVFStmtMapTy::const_iterator it = InEdgeKindToSetMap.find(kind);
         if (it != InEdgeKindToSetMap.end())
             return (!it->second.empty());
         else
@@ -182,7 +182,7 @@ public:
     /// Has incoming VariantGepEdges
     inline bool hasIncomingVariantGepEdge() const
     {
-        SVFStmt::PAGKindToEdgeSetMapTy::const_iterator it = InEdgeKindToSetMap.find(SVFStmt::VariantGep);
+        SVFStmt::KindToSVFStmtMapTy::const_iterator it = InEdgeKindToSetMap.find(SVFStmt::VariantGep);
         if (it != InEdgeKindToSetMap.end())
         {
             return (!it->second.empty());
@@ -191,25 +191,25 @@ public:
     }
 
     /// Get incoming SVFStmt iterator
-    inline SVFStmt::PAGEdgeSetTy::iterator getIncomingEdgesBegin(SVFStmt::PEDGEK kind) const
+    inline SVFStmt::SVFStmtSetTy::iterator getIncomingEdgesBegin(SVFStmt::PEDGEK kind) const
     {
-        SVFStmt::PAGKindToEdgeSetMapTy::const_iterator it = InEdgeKindToSetMap.find(kind);
+        SVFStmt::KindToSVFStmtMapTy::const_iterator it = InEdgeKindToSetMap.find(kind);
         assert(it!=InEdgeKindToSetMap.end() && "The node does not have such kind of edge");
         return it->second.begin();
     }
 
     /// Get incoming SVFStmt iterator
-    inline SVFStmt::PAGEdgeSetTy::iterator getIncomingEdgesEnd(SVFStmt::PEDGEK kind) const
+    inline SVFStmt::SVFStmtSetTy::iterator getIncomingEdgesEnd(SVFStmt::PEDGEK kind) const
     {
-        SVFStmt::PAGKindToEdgeSetMapTy::const_iterator it = InEdgeKindToSetMap.find(kind);
+        SVFStmt::KindToSVFStmtMapTy::const_iterator it = InEdgeKindToSetMap.find(kind);
         assert(it!=InEdgeKindToSetMap.end() && "The node does not have such kind of edge");
         return it->second.end();
     }
 
-    /// Has outgoing SVFIR edges
+    /// Has outgoing SVFIR statements (edges)
     inline bool hasOutgoingEdges(SVFStmt::PEDGEK kind) const
     {
-        SVFStmt::PAGKindToEdgeSetMapTy::const_iterator it = OutEdgeKindToSetMap.find(kind);
+        SVFStmt::KindToSVFStmtMapTy::const_iterator it = OutEdgeKindToSetMap.find(kind);
         if (it != OutEdgeKindToSetMap.end())
             return (!it->second.empty());
         else
@@ -217,17 +217,17 @@ public:
     }
 
     /// Get outgoing SVFStmt iterator
-    inline SVFStmt::PAGEdgeSetTy::iterator getOutgoingEdgesBegin(SVFStmt::PEDGEK kind) const
+    inline SVFStmt::SVFStmtSetTy::iterator getOutgoingEdgesBegin(SVFStmt::PEDGEK kind) const
     {
-        SVFStmt::PAGKindToEdgeSetMapTy::const_iterator it = OutEdgeKindToSetMap.find(kind);
+        SVFStmt::KindToSVFStmtMapTy::const_iterator it = OutEdgeKindToSetMap.find(kind);
         assert(it!=OutEdgeKindToSetMap.end() && "The node does not have such kind of edge");
         return it->second.begin();
     }
 
     /// Get outgoing SVFStmt iterator
-    inline SVFStmt::PAGEdgeSetTy::iterator getOutgoingEdgesEnd(SVFStmt::PEDGEK kind) const
+    inline SVFStmt::SVFStmtSetTy::iterator getOutgoingEdgesEnd(SVFStmt::PEDGEK kind) const
     {
-        SVFStmt::PAGKindToEdgeSetMapTy::const_iterator it = OutEdgeKindToSetMap.find(kind);
+        SVFStmt::KindToSVFStmtMapTy::const_iterator it = OutEdgeKindToSetMap.find(kind);
         assert(it!=OutEdgeKindToSetMap.end() && "The node does not have such kind of edge");
         return it->second.end();
     }
@@ -268,15 +268,15 @@ public:
 
 
 /*
- * Value(Pointer) node
+ * Value (Pointer) variable
  */
-class ValPN: public SVFVar
+class ValVar: public SVFVar
 {
 
 public:
     /// Methods for support type inquiry through isa, cast, and dyn_cast:
     //@{
-    static inline bool classof(const ValPN *)
+    static inline bool classof(const ValVar *)
     {
         return true;
     }
@@ -295,7 +295,7 @@ public:
     //@}
 
     /// Constructor
-    ValPN(const Value* val, NodeID i, PNODEK ty = ValNode) :
+    ValVar(const Value* val, NodeID i, PNODEK ty = ValNode) :
         SVFVar(val, i, ty)
     {
     }
@@ -312,22 +312,22 @@ public:
 
 
 /*
- * Memory Object node
+ * Memory Object variable
  */
-class ObjPN: public SVFVar
+class ObjVar: public SVFVar
 {
 
 protected:
     const MemObj* mem;	///< memory object
     /// Constructor
-    ObjPN(const Value* val, NodeID i, const MemObj* m, PNODEK ty = ObjNode) :
+    ObjVar(const Value* val, NodeID i, const MemObj* m, PNODEK ty = ObjNode) :
         SVFVar(val, i, ty), mem(m)
     {
     }
 public:
     /// Methods for support type inquiry through isa, cast, and dyn_cast:
     //@{
-    static inline bool classof(const ObjPN *)
+    static inline bool classof(const ObjVar *)
     {
         return true;
     }
@@ -377,11 +377,11 @@ public:
 
 
 /*
- * Gep Value (Pointer) node, this node can be dynamic generated for field sensitive analysis
- * e.g. memcpy, temp gep value node needs to be created
- * Each Gep Value node is connected to base value node via gep edge
+ * Gep Value (Pointer) variable, this variable can be dynamic generated for field sensitive analysis
+ * e.g. memcpy, temp gep value variable needs to be created
+ * Each Gep Value variable is connected to base value variable via gep edge
  */
-class GepValPN: public ValPN
+class GepValVar: public ValVar
 {
 
 private:
@@ -392,11 +392,11 @@ private:
 public:
     /// Methods for support type inquiry through isa, cast, and dyn_cast:
     //@{
-    static inline bool classof(const GepValPN *)
+    static inline bool classof(const GepValVar *)
     {
         return true;
     }
-    static inline bool classof(const ValPN * node)
+    static inline bool classof(const ValVar * node)
     {
         return node->getNodeKind() == SVFVar::GepValNode;
     }
@@ -411,12 +411,12 @@ public:
     //@}
 
     /// Constructor
-    GepValPN(const Value* val, NodeID i, const LocationSet& l, const Type *ty, u32_t idx) :
-        ValPN(val, i, GepValNode), ls(l), gepValType(ty), fieldIdx(idx)
+    GepValVar(const Value* val, NodeID i, const LocationSet& l, const Type *ty, u32_t idx) :
+        ValVar(val, i, GepValNode), ls(l), gepValType(ty), fieldIdx(idx)
     {
     }
 
-    /// offset of the base value node
+    /// offset of the base value variable
     inline u32_t getOffset() const
     {
         return ls.getOffset();
@@ -445,10 +445,10 @@ public:
 
 
 /*
- * Gep Obj node, this is dynamic generated for field sensitive analysis
- * Each gep obj node is one field of a MemObj (base)
+ * Gep Obj variable, this is dynamic generated for field sensitive analysis
+ * Each gep obj variable is one field of a MemObj (base)
  */
-class GepObjPN: public ObjPN
+class GepObjPN: public ObjVar
 {
 private:
     LocationSet ls;
@@ -461,7 +461,7 @@ public:
     {
         return true;
     }
-    static inline bool classof(const ObjPN * node)
+    static inline bool classof(const ObjVar * node)
     {
         return node->getNodeKind() == SVFVar::GepObjNode
                || node->getNodeKind() == SVFVar::CloneGepObjNode;
@@ -480,7 +480,7 @@ public:
 
     /// Constructor
     GepObjPN(const MemObj* mem, NodeID i, const LocationSet& l, PNODEK ty = GepObjNode) :
-        ObjPN(mem->getValue(), i, mem, ty), ls(l)
+        ObjVar(mem->getValue(), i, mem, ty), ls(l)
     {
         base = mem->getId();
     }
@@ -521,20 +521,20 @@ public:
 };
 
 /*
- * Field-insensitive Gep Obj node, this is dynamic generated for field sensitive analysis
+ * Field-insensitive Gep Obj variable, this is dynamic generated for field sensitive analysis
  * Each field-insensitive gep obj node represents all fields of a MemObj (base)
  */
-class FIObjPN: public ObjPN
+class FIObjVar: public ObjVar
 {
 public:
 
     ///  Methods for support type inquiry through isa, cast, and dyn_cast:
     //@{
-    static inline bool classof(const FIObjPN *)
+    static inline bool classof(const FIObjVar *)
     {
         return true;
     }
-    static inline bool classof(const ObjPN * node)
+    static inline bool classof(const ObjVar * node)
     {
         return node->getNodeKind() == SVFVar::FIObjNode
                || node->getNodeKind() == SVFVar::CloneFIObjNode;
@@ -552,8 +552,8 @@ public:
     //@}
 
     /// Constructor
-    FIObjPN(const Value* val, NodeID i, const MemObj* mem, PNODEK ty = FIObjNode) :
-        ObjPN(val, i, mem, ty)
+    FIObjVar(const Value* val, NodeID i, const MemObj* mem, PNODEK ty = FIObjNode) :
+        ObjVar(val, i, mem, ty)
     {
     }
 
@@ -649,15 +649,15 @@ public:
 
 
 /*
- * Dummy node
+ * Dummy variable without any LLVM value
  */
-class DummyValPN: public ValPN
+class DummyValVar: public ValVar
 {
 
 public:
 
     //@{ Methods for support type inquiry through isa, cast, and dyn_cast:
-    static inline bool classof(const DummyValPN *)
+    static inline bool classof(const DummyValVar *)
     {
         return true;
     }
@@ -672,7 +672,7 @@ public:
     //@}
 
     /// Constructor
-    DummyValPN(NodeID i) : ValPN(nullptr, i, DummyValNode)
+    DummyValVar(NodeID i) : ValVar(nullptr, i, DummyValNode)
     {
     }
 
@@ -688,15 +688,15 @@ public:
 
 
 /*
- * Dummy node
+ * Dummy object variable
  */
-class DummyObjPN: public ObjPN
+class DummyObjVar: public ObjVar
 {
 
 public:
 
     //@{ Methods for support type inquiry through isa, cast, and dyn_cast:
-    static inline bool classof(const DummyObjPN *)
+    static inline bool classof(const DummyObjVar *)
     {
         return true;
     }
@@ -713,8 +713,8 @@ public:
     //@}
 
     /// Constructor
-    DummyObjPN(NodeID i,const MemObj* m, PNODEK ty = DummyObjNode)
-        : ObjPN(nullptr, i, m, ty)
+    DummyObjVar(NodeID i,const MemObj* m, PNODEK ty = DummyObjNode)
+        : ObjVar(nullptr, i, m, ty)
     {
     }
 
@@ -730,11 +730,11 @@ public:
 /*
  * Clone object node for dummy objects.
  */
-class CloneDummyObjPN: public DummyObjPN
+class CloneDummyObjVar: public DummyObjVar
 {
 public:
     //@{ Methods to support type inquiry through isa, cast, and dyn_cast:
-    static inline bool classof(const CloneDummyObjPN *)
+    static inline bool classof(const CloneDummyObjVar *)
     {
         return true;
     }
@@ -749,15 +749,15 @@ public:
     //@}
 
     /// Constructor
-    CloneDummyObjPN(NodeID i, const MemObj* m, PNODEK ty = CloneDummyObjNode)
-        : DummyObjPN(i, m, ty)
+    CloneDummyObjVar(NodeID i, const MemObj* m, PNODEK ty = CloneDummyObjNode)
+        : DummyObjVar(i, m, ty)
     {
     }
 
     /// Return name of this node
     inline const std::string getValueName() const
     {
-        return "clone of " + ObjPN::getValueName();
+        return "clone of " + ObjVar::getValueName();
     }
 
     virtual const std::string toString() const;
@@ -766,11 +766,11 @@ public:
 /*
  * Clone object for GEP objects.
  */
-class CloneGepObjPN : public GepObjPN
+class CloneGepObjVar : public GepObjPN
 {
 public:
     //@{ Methods to support type inquiry through isa, cast, and dyn_cast:
-    static inline bool classof(const CloneGepObjPN *)
+    static inline bool classof(const CloneGepObjVar *)
     {
         return true;
     }
@@ -785,7 +785,7 @@ public:
     //@}
 
     /// Constructor
-    CloneGepObjPN(const MemObj* mem, NodeID i, const LocationSet& l, PNODEK ty = CloneGepObjNode) :
+    CloneGepObjVar(const MemObj* mem, NodeID i, const LocationSet& l, PNODEK ty = CloneGepObjNode) :
         GepObjPN(mem, i, l, ty)
     {
     }
@@ -802,11 +802,11 @@ public:
 /*
  * Clone object for FI objects.
  */
-class CloneFIObjPN : public FIObjPN
+class CloneFIObjVar : public FIObjVar
 {
 public:
     //@{ Methods to support type inquiry through isa, cast, and dyn_cast:
-    static inline bool classof(const CloneFIObjPN *)
+    static inline bool classof(const CloneFIObjVar *)
     {
         return true;
     }
@@ -821,15 +821,15 @@ public:
     //@}
 
     /// Constructor
-    CloneFIObjPN(const Value* val, NodeID i, const MemObj* mem, PNODEK ty = CloneFIObjNode) :
-        FIObjPN(val, i, mem, ty)
+    CloneFIObjVar(const Value* val, NodeID i, const MemObj* mem, PNODEK ty = CloneFIObjNode) :
+        FIObjVar(val, i, mem, ty)
     {
     }
 
     /// Return name of this node
     inline const std::string getValueName() const
     {
-        return "clone (FI) of " + FIObjPN::getValueName();
+        return "clone (FI) of " + FIObjVar::getValueName();
     }
 
     virtual const std::string toString() const;

package/include/SVF-FE/SVFIRBuilder.h

@@ -269,56 +269,56 @@ public:
 
 public:
 
-    NodeID getGepValNode(const Value* val, const LocationSet& ls, const Type *baseType, u32_t fieldidx);
+    NodeID getGepValVar(const Value* val, const LocationSet& ls, const Type *baseType, u32_t fieldidx);
 
     void setCurrentBBAndValueForPAGEdge(PAGEdge* edge);
 
     inline PAGEdge* addBlackHoleAddrEdge(NodeID node)
     {
-        PAGEdge *edge = pag->addBlackHoleAddrPE(node);
+        PAGEdge *edge = pag->addBlackHoleAddrStmt(node);
         setCurrentBBAndValueForPAGEdge(edge);
         return edge;
     }
 
     /// Add Address edge
-    inline AddrPE* addAddrEdge(NodeID src, NodeID dst)
+    inline AddrStmt* addAddrEdge(NodeID src, NodeID dst)
     {
-        AddrPE *edge = pag->addAddrPE(src, dst);
+        AddrStmt *edge = pag->addAddrStmt(src, dst);
         setCurrentBBAndValueForPAGEdge(edge);
         return edge;
     }
     /// Add Copy edge
-    inline CopyPE* addCopyEdge(NodeID src, NodeID dst)
+    inline CopyStmt* addCopyEdge(NodeID src, NodeID dst)
     {
-        CopyPE *edge = pag->addCopyPE(src, dst);
+        CopyStmt *edge = pag->addCopyStmt(src, dst);
         setCurrentBBAndValueForPAGEdge(edge);
         return edge;
     }
     /// Add Copy edge
-    inline PhiPE* addPhiNode(NodeID res, NodeID opnd)
+    inline PhiStmt* addPhiStmt(NodeID res, NodeID opnd)
     {
-        PhiPE *edge = pag->addPhiNode(res,opnd);
+        PhiStmt *edge = pag->addPhiStmt(res,opnd);
         setCurrentBBAndValueForPAGEdge(edge);
         return edge;
     }
     /// Add Copy edge
-    inline CmpPE* addCmpEdge(NodeID op1, NodeID op2, NodeID dst, u32_t opcode)
+    inline CmpStmt* addCmpEdge(NodeID op1, NodeID op2, NodeID dst, u32_t predict)
     {
-        CmpPE *edge = pag->addCmpPE(op1, op2, dst, opcode);
+        CmpStmt *edge = pag->addCmpStmt(op1, op2, dst, predict);
         setCurrentBBAndValueForPAGEdge(edge);
         return edge;
     }
     /// Add Copy edge
-    inline BinaryOPPE* addBinaryOPEdge(NodeID op1, NodeID op2, NodeID dst, u32_t opcode)
+    inline BinaryOPStmt* addBinaryOPEdge(NodeID op1, NodeID op2, NodeID dst, u32_t opcode)
     {
-        BinaryOPPE *edge = pag->addBinaryOPPE(op1, op2, dst, opcode);
+        BinaryOPStmt *edge = pag->addBinaryOPStmt(op1, op2, dst, opcode);
         setCurrentBBAndValueForPAGEdge(edge);
         return edge;
     }
     /// Add Unary edge
-    inline UnaryOPPE* addUnaryOPEdge(NodeID src, NodeID dst, u32_t opcode)
+    inline UnaryOPStmt* addUnaryOPEdge(NodeID src, NodeID dst, u32_t opcode)
     {
-        UnaryOPPE *edge = pag->addUnaryOPPE(src, dst, opcode);
+        UnaryOPStmt *edge = pag->addUnaryOPStmt(src, dst, opcode);
         setCurrentBBAndValueForPAGEdge(edge);
         return edge;
     }
@@ -329,21 +329,21 @@ public:
         return edge;
     }
     /// Add Load edge
-    inline LoadPE* addLoadEdge(NodeID src, NodeID dst)
+    inline LoadStmt* addLoadEdge(NodeID src, NodeID dst)
     {
-        LoadPE *edge = pag->addLoadPE(src, dst);
+        LoadStmt *edge = pag->addLoadStmt(src, dst);
         setCurrentBBAndValueForPAGEdge(edge);
         return edge;
     }
     /// Add Store edge
-    inline StorePE* addStoreEdge(NodeID src, NodeID dst)
+    inline StoreStmt* addStoreEdge(NodeID src, NodeID dst)
     {
         IntraBlockNode* node;
         if(const Instruction* inst = SVFUtil::dyn_cast<Instruction>(curVal))
             node = pag->getICFG()->getIntraBlockNode(inst);
         else
             node = nullptr;
-        StorePE *edge = pag->addStorePE(src, dst, node);
+        StoreStmt *edge = pag->addStoreStmt(src, dst, node);
         setCurrentBBAndValueForPAGEdge(edge);
         return edge;
     }
@@ -362,23 +362,23 @@ public:
         return edge;
     }
     /// Add Gep edge
-    inline GepPE* addGepEdge(NodeID src, NodeID dst, const LocationSet& ls, bool constGep)
+    inline GepStmt* addGepEdge(NodeID src, NodeID dst, const LocationSet& ls, bool constGep)
     {
-        GepPE *edge = pag->addGepPE(src, dst, ls, constGep);
+        GepStmt *edge = pag->addGepStmt(src, dst, ls, constGep);
         setCurrentBBAndValueForPAGEdge(edge);
         return edge;
     }
     /// Add Offset(Gep) edge
-    inline NormalGepPE* addNormalGepEdge(NodeID src, NodeID dst, const LocationSet& ls)
+    inline NormalGepStmt* addNormalGepEdge(NodeID src, NodeID dst, const LocationSet& ls)
     {
-        NormalGepPE *edge = pag->addNormalGepPE(src, dst, ls);
+        NormalGepStmt *edge = pag->addNormalGepStmt(src, dst, ls);
         setCurrentBBAndValueForPAGEdge(edge);
         return edge;
     }
     /// Add Variant(Gep) edge
-    inline VariantGepPE* addVariantGepEdge(NodeID src, NodeID dst)
+    inline VariantGepStmt* addVariantGepEdge(NodeID src, NodeID dst)
     {
-        VariantGepPE *edge = pag->addVariantGepPE(src, dst);
+        VariantGepStmt *edge = pag->addVariantGepStmt(src, dst);
         setCurrentBBAndValueForPAGEdge(edge);
         return edge;
     }

package/include/Util/IRAnnotator.h

@@ -99,7 +99,7 @@ private:
             SVF::Size_t locationSetOffset = std::stoi(llvm::cast<llvm::MDString>(mdNode->getOperand(1))->getString().str());
 
             LocationSet locationSet = LocationSet(locationSetOffset);
-            SVF::NodeID gepnodeId = pag->getGepObjNode(baseNodeId, locationSet);
+            SVF::NodeID gepnodeId = pag->getGepObjVar(baseNodeId, locationSet);
 
             assert(nodeId == gepnodeId && "nodeId != gepnodeId");
         }

package/include/Util/Options.h

@@ -243,13 +243,15 @@ public:
     // TypeAnalysis.cpp
     static const llvm::cl::opt<bool> GenICFG;
 
-    //WPAPass.cpp
+    // WPAPass.cpp
     static const llvm::cl::opt<bool> AnderSVFG;
     static const llvm::cl::opt<bool> SABERFULLSVFG;
     static const llvm::cl::opt<bool> PrintAliases;
     static llvm::cl::bits<PointerAnalysis::PTATY> PASelected;
     static llvm::cl::bits<WPAPass::AliasCheckRule> AliasRule;
 
+    // DOTGraphTraits
+    static const llvm::cl::opt<bool> ShowHiddenNode;
 };
 }  // namespace SVF
 

package/include/Util/TypeBasedHeapCloning.h

@@ -97,8 +97,8 @@ 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 SVFIR
-    /// (through base's getGepObjNode) which will create one.
+    /// If there are no GEP objects, then getGepObjVar is called on the SVFIR
+    /// (through base's getGepObjVar) which will create one.
     const NodeBS getGepObjClones(NodeID base, unsigned offset);
 
     /// Initialise the pointees of p at loc (which is type tildet *). reuse indicates

package/include/WPA/Andersen.h

@@ -383,7 +383,7 @@ protected:
 
             for (NodeID o : fldInsenObjs)
             {
-                const NodeBS &allFields = consCG->getAllFieldsObjNode(o);
+                const NodeBS &allFields = consCG->getAllFieldsObjVars(o);
                 for (NodeID f : allFields) addPts(it->first, f);
             }
         }

package/include/WPA/FlowSensitiveTBHC.h

@@ -73,7 +73,7 @@ public:
     virtual bool processPhi(const PHISVFGNode* phi) override;
     virtual bool processCopy(const CopySVFGNode* copy) override;
 
-    virtual inline const NodeBS& getAllFieldsObjNode(NodeID id) override;
+    virtual inline const NodeBS& getAllFieldsObjVars(NodeID id) override;
 
     virtual inline bool updateInFromIn(const SVFGNode* srcStmt, NodeID srcVar, const SVFGNode* dstStmt, NodeID dstVar) override;
     virtual inline bool updateInFromOut(const SVFGNode* srcStmt, NodeID srcVar, const SVFGNode* dstStmt, NodeID dstVar) override;

package/lib/DDA/ContextDDA.cpp

@@ -140,15 +140,15 @@ CxtPtSet ContextDDA::processGepPts(const GepSVFGNode* gep, const CxtPtSet& srcPt
             tmpDstPts.set(ptd);
         else
         {
-            if (SVFUtil::isa<VariantGepPE>(gep->getPAGEdge()))
+            if (SVFUtil::isa<VariantGepStmt>(gep->getPAGEdge()))
             {
                 setObjFieldInsensitive(ptd.get_id());
-                CxtVar var(ptd.get_cond(),getFIObjNode(ptd.get_id()));
+                CxtVar var(ptd.get_cond(),getFIObjVar(ptd.get_id()));
                 tmpDstPts.set(var);
             }
-            else if (const NormalGepPE* normalGep = SVFUtil::dyn_cast<NormalGepPE>(gep->getPAGEdge()))
+            else if (const NormalGepStmt* normalGep = SVFUtil::dyn_cast<NormalGepStmt>(gep->getPAGEdge()))
             {
-                CxtVar var(ptd.get_cond(),getGepObjNode(ptd.get_id(),normalGep->getLocationSet()));
+                CxtVar var(ptd.get_cond(),getGepObjVar(ptd.get_id(),normalGep->getLocationSet()));
                 tmpDstPts.set(var);
             }
             else
@@ -319,10 +319,10 @@ bool ContextDDA::isHeapCondMemObj(const CxtVar& var, const StoreSVFGNode*)
         if (!mem->getValue()) {
             PAGNode *pnode = _pag->getGNode(getPtrNodeID(var));
             if(GepObjPN* gepobj = SVFUtil::dyn_cast<GepObjPN>(pnode)){
-                assert(SVFUtil::isa<DummyObjPN>(_pag->getGNode(gepobj->getBaseNode())) && "emtpy refVal in a gep object whose base is a non-dummy object");
+                assert(SVFUtil::isa<DummyObjVar>(_pag->getGNode(gepobj->getBaseNode())) && "emtpy refVal in a gep object whose base is a non-dummy object");
             }
             else{
-                assert((SVFUtil::isa<DummyObjPN>(pnode) || SVFUtil::isa<DummyValPN>(pnode)) && "empty refVal in non-dummy object");
+                assert((SVFUtil::isa<DummyObjVar>(pnode) || SVFUtil::isa<DummyValVar>(pnode)) && "empty refVal in non-dummy object");
             }
             return true;
         }