svf-tools 1.0.340 → 1.0.344

package/include/MSSA/MemRegion.h

@@ -148,14 +148,14 @@ public:
     //@{
     typedef Map<const LoadStmt*, MRSet> LoadsToMRsMap;
     typedef Map<const StoreStmt*, MRSet> StoresToMRsMap;
-    typedef Map<const CallBlockNode*, MRSet> CallSiteToMRsMap;
+    typedef Map<const CallICFGNode*, MRSet> CallSiteToMRsMap;
     //@}
 
     /// Map loads/stores/callsites to their cpts set
     //@{
     typedef Map<const LoadStmt*, NodeBS> LoadsToPointsToMap;
     typedef Map<const StoreStmt*, NodeBS> StoresToPointsToMap;
-    typedef Map<const CallBlockNode*, NodeBS> CallSiteToPointsToMap;
+    typedef Map<const CallICFGNode*, NodeBS> CallSiteToPointsToMap;
     //@}
 
     /// Maps Mod-Ref analysis
@@ -163,7 +163,7 @@ public:
     /// Map a function to its indirect refs/mods of memory objects
     typedef Map<const SVFFunction*, NodeBS> FunToNodeBSMap;
     /// Map a callsite to its indirect refs/mods of memory objects
-    typedef Map<const CallBlockNode*, NodeBS> CallSiteToNodeBSMap;
+    typedef Map<const CallICFGNode*, NodeBS> CallSiteToNodeBSMap;
     //@}
 
     typedef Map<NodeID, NodeBS> NodeToPTSSMap;
@@ -242,18 +242,18 @@ private:
     void destroy();
 
     //Get all objects might pass into callee from a callsite
-    void collectCallSitePts(const CallBlockNode* cs);
+    void collectCallSitePts(const CallICFGNode* cs);
 
     //Recursive collect points-to chain
     NodeBS& CollectPtsChain(NodeID id);
 
     /// Return the pts chain of all callsite arguments
-    inline NodeBS& getCallSiteArgsPts(const CallBlockNode* cs)
+    inline NodeBS& getCallSiteArgsPts(const CallICFGNode* cs)
     {
         return csToCallSiteArgsPtsMap[cs];
     }
     /// Return the pts chain of the return parameter of the callsite
-    inline NodeBS& getCallSiteRetPts(const CallBlockNode* cs)
+    inline NodeBS& getCallSiteRetPts(const CallICFGNode* cs)
     {
         return csToCallSiteRetPtsMap[cs];
     }
@@ -329,7 +329,7 @@ protected:
     virtual void modRefAnalysis(PTACallGraphNode* callGraphNode, WorkList& worklist);
 
     /// Get Mod-Ref of a callee function
-    virtual bool handleCallsiteModRef(NodeBS& mod, NodeBS& ref, const CallBlockNode* cs, const SVFFunction* fun);
+    virtual bool handleCallsiteModRef(NodeBS& mod, NodeBS& ref, const CallICFGNode* cs, const SVFFunction* fun);
 
 
     /// Add cpts to store/load
@@ -346,12 +346,12 @@ protected:
         funToPointsToMap[fun].insert(cpts);
         addRefSideEffectOfFunction(fun,cpts);
     }
-    inline void addCPtsToCallSiteRefs(NodeBS& cpts, const CallBlockNode* cs)
+    inline void addCPtsToCallSiteRefs(NodeBS& cpts, const CallICFGNode* cs)
     {
         callsiteToRefPointsToMap[cs] |= cpts;
         funToPointsToMap[cs->getCaller()].insert(cpts);
     }
-    inline void addCPtsToCallSiteMods(NodeBS& cpts, const CallBlockNode* cs)
+    inline void addCPtsToCallSiteMods(NodeBS& cpts, const CallICFGNode* cs)
     {
         callsiteToModPointsToMap[cs] |= cpts;
         funToPointsToMap[cs->getCaller()].insert(cpts);
@@ -376,9 +376,9 @@ protected:
     /// Add indirect def an memory object in the function
     void addModSideEffectOfFunction(const SVFFunction* fun, const NodeBS& mods);
     /// Add indirect uses an memory object in the function
-    bool addRefSideEffectOfCallSite(const CallBlockNode* cs, const NodeBS& refs);
+    bool addRefSideEffectOfCallSite(const CallICFGNode* cs, const NodeBS& refs);
     /// Add indirect def an memory object in the function
-    bool addModSideEffectOfCallSite(const CallBlockNode* cs, const NodeBS& mods);
+    bool addModSideEffectOfCallSite(const CallICFGNode* cs, const NodeBS& mods);
 
     /// Get indirect refs of a function
     inline const NodeBS& getRefSideEffectOfFunction(const SVFFunction* fun)
@@ -391,22 +391,22 @@ protected:
         return funToModsMap[fun];
     }
     /// Get indirect refs of a callsite
-    inline const NodeBS& getRefSideEffectOfCallSite(const CallBlockNode* cs)
+    inline const NodeBS& getRefSideEffectOfCallSite(const CallICFGNode* cs)
     {
         return csToRefsMap[cs];
     }
     /// Get indirect mods of a callsite
-    inline const NodeBS& getModSideEffectOfCallSite(const CallBlockNode* cs)
+    inline const NodeBS& getModSideEffectOfCallSite(const CallICFGNode* cs)
     {
         return csToModsMap[cs];
     }
     /// Has indirect refs of a callsite
-    inline bool hasRefSideEffectOfCallSite(const CallBlockNode* cs)
+    inline bool hasRefSideEffectOfCallSite(const CallICFGNode* cs)
     {
         return csToRefsMap.find(cs) != csToRefsMap.end();
     }
     /// Has indirect mods of a callsite
-    inline bool hasModSideEffectOfCallSite(const CallBlockNode* cs)
+    inline bool hasModSideEffectOfCallSite(const CallICFGNode* cs)
     {
         return csToModsMap.find(cs) != csToModsMap.end();
     }
@@ -448,19 +448,19 @@ public:
     {
         return storesToMRsMap[store];
     }
-    inline bool hasRefMRSet(const CallBlockNode* cs)
+    inline bool hasRefMRSet(const CallICFGNode* cs)
     {
         return callsiteToRefMRsMap.find(cs)!=callsiteToRefMRsMap.end();
     }
-    inline bool hasModMRSet(const CallBlockNode* cs)
+    inline bool hasModMRSet(const CallICFGNode* cs)
     {
         return callsiteToModMRsMap.find(cs)!=callsiteToModMRsMap.end();
     }
-    inline MRSet& getCallSiteRefMRSet(const CallBlockNode* cs)
+    inline MRSet& getCallSiteRefMRSet(const CallICFGNode* cs)
     {
         return callsiteToRefMRsMap[cs];
     }
-    inline MRSet& getCallSiteModMRSet(const CallBlockNode* cs)
+    inline MRSet& getCallSiteModMRSet(const CallICFGNode* cs)
     {
         return callsiteToModMRsMap[cs];
     }
@@ -473,11 +473,11 @@ public:
     /// getModRefInfo APIs
     //@{
     /// Collect mod ref for external callsite other than heap alloc external call
-    NodeBS getModInfoForCall(const CallBlockNode* cs);
-    NodeBS getRefInfoForCall(const CallBlockNode* cs);
-    ModRefInfo getModRefInfo(const CallBlockNode* cs);
-    ModRefInfo getModRefInfo(const CallBlockNode* cs, const Value* V);
-    ModRefInfo getModRefInfo(const CallBlockNode* cs1, const CallBlockNode* cs2);
+    NodeBS getModInfoForCall(const CallICFGNode* cs);
+    NodeBS getRefInfoForCall(const CallICFGNode* cs);
+    ModRefInfo getModRefInfo(const CallICFGNode* cs);
+    ModRefInfo getModRefInfo(const CallICFGNode* cs, const Value* V);
+    ModRefInfo getModRefInfo(const CallICFGNode* cs1, const CallICFGNode* cs2);
     //@}
 
 };

package/include/MSSA/MemSSA.h

@@ -73,8 +73,8 @@ public:
     //@{
     typedef Map<const LoadStmt*, MUSet> LoadToMUSetMap;
     typedef Map<const StoreStmt*, CHISet> StoreToChiSetMap;
-    typedef Map<const CallBlockNode*, MUSet> CallSiteToMUSetMap;
-    typedef Map<const CallBlockNode*, CHISet> CallSiteToCHISetMap;
+    typedef Map<const CallICFGNode*, MUSet> CallSiteToMUSetMap;
+    typedef Map<const CallICFGNode*, CHISet> CallSiteToCHISetMap;
     typedef Map<const BasicBlock*, PHISet> BBToPhiSetMap;
     //@}
 
@@ -190,12 +190,12 @@ private:
         for (MRSet::iterator iter = mrSet.begin(), eiter = mrSet.end(); iter != eiter; ++iter)
             AddStoreCHI(bb,store,*iter);
     }
-    inline void AddCallSiteMU(const CallBlockNode* cs,  const MRSet& mrSet)
+    inline void AddCallSiteMU(const CallICFGNode* cs,  const MRSet& mrSet)
     {
         for (MRSet::iterator iter = mrSet.begin(), eiter = mrSet.end(); iter != eiter; ++iter)
             AddCallSiteMU(cs,*iter);
     }
-    inline void AddCallSiteCHI(const CallBlockNode* cs,  const MRSet& mrSet)
+    inline void AddCallSiteCHI(const CallICFGNode* cs,  const MRSet& mrSet)
     {
         for (MRSet::iterator iter = mrSet.begin(), eiter = mrSet.end(); iter != eiter; ++iter)
             AddCallSiteCHI(cs,*iter);
@@ -218,13 +218,13 @@ private:
         collectRegUses(mr);
         collectRegDefs(bb,mr);
     }
-    inline void AddCallSiteMU(const CallBlockNode* cs, const MemRegion* mr)
+    inline void AddCallSiteMU(const CallICFGNode* cs, const MemRegion* mr)
     {
         CALLMU* mu = new CALLMU(cs, mr);
         callsiteToMuSetMap[cs].insert(mu);
         collectRegUses(mr);
     }
-    inline void AddCallSiteCHI(const CallBlockNode* cs, const MemRegion* mr)
+    inline void AddCallSiteCHI(const CallICFGNode* cs, const MemRegion* mr)
     {
         CALLCHI* chi = new CALLCHI(cs, mr);
         callsiteToChiSetMap[cs].insert(chi);
@@ -352,11 +352,11 @@ public:
         else
             return false;
     }
-    inline bool hasMU(const CallBlockNode* cs) const
+    inline bool hasMU(const CallICFGNode* cs) const
     {
         return callsiteToMuSetMap.find(cs)!=callsiteToMuSetMap.end();
     }
-    inline bool hasCHI(const CallBlockNode* cs) const
+    inline bool hasCHI(const CallICFGNode* cs) const
     {
         return callsiteToChiSetMap.find(cs)!=callsiteToChiSetMap.end();
     }
@@ -393,11 +393,11 @@ public:
     {
         return store2ChiSetMap[st];
     }
-    inline MUSet& getMUSet(const CallBlockNode* cs)
+    inline MUSet& getMUSet(const CallICFGNode* cs)
     {
         return callsiteToMuSetMap[cs];
     }
-    inline CHISet& getCHISet(const CallBlockNode* cs)
+    inline CHISet& getCHISet(const CallICFGNode* cs)
     {
         return callsiteToChiSetMap[cs];
     }

package/include/MTA/LockResultValidator.h

@@ -33,8 +33,8 @@ public:
 		return _mod;
 	}
 private:
-	// Get CallBlockNode
-	inline CallBlockNode* getCBN(const Instruction* inst) {
+	// Get CallICFGNode
+	inline CallICFGNode* getCBN(const Instruction* inst) {
 		return _la->getTCT()->getCallBlockNode(inst);
 	}
 	const Instruction *getPreviousMemoryAccessInst( const Instruction *I) {

package/include/MTA/MHP.h

@@ -61,8 +61,8 @@ public:
         return tct;
     }
 	
-	// Get CallBlockNode
-	inline CallBlockNode* getCBN(const Instruction* inst) {
+	// Get CallICFGNode
+	inline CallICFGNode* getCBN(const Instruction* inst) {
 		return tct->getCallBlockNode(inst);
 	}
 
@@ -379,8 +379,8 @@ private:
     {
         return tct->getPTA()->alias(getForkedThread(forkSite), getJoinedThread(joinSite)) && isSameSCEV(forkSite,joinSite);
     }
-    // Get CallBlockNode
-	inline CallBlockNode* getCBN(const Instruction* inst) {
+    // Get CallICFGNode
+	inline CallICFGNode* getCBN(const Instruction* inst) {
 		return tct->getCallBlockNode(inst);
 	}
     /// Mark thread flags for cxtStmt

package/include/MTA/PCG.h

@@ -123,7 +123,7 @@ public:
     {
     }
 	
-	CallBlockNode* getCallBlockNode(const Instruction* inst) {
+	CallICFGNode* getCallBlockNode(const Instruction* inst) {
 		return pta->getICFG()->getCallBlockNode(inst);
 	}
 	const SVFFunction* getSVFFun(const Function* fun) const {

package/include/MTA/TCT.h

@@ -147,8 +147,8 @@ public:
     {
         destroy();
     }
-    /// Get CallBlockNode given inst
-    CallBlockNode* getCallBlockNode(const Instruction* inst) {
+    /// Get CallICFGNode given inst
+    CallICFGNode* getCallBlockNode(const Instruction* inst) {
 		return pta->getICFG()->getCallBlockNode(inst);
 	}
 	/// Get SVFFuntion given Function 

package/include/MemoryModel/PointerAnalysis.h

@@ -105,10 +105,10 @@ public:
     /// Indirect call edges type, map a callsite to a set of callees
     //@{
     typedef llvm::AliasAnalysis AliasAnalysis;
-    typedef Set<const CallBlockNode*> CallSiteSet;
+    typedef Set<const CallICFGNode*> CallSiteSet;
     typedef SVFIR::CallSiteToFunPtrMap CallSiteToFunPtrMap;
     typedef Set<const SVFFunction*> FunctionSet;
-    typedef OrderedMap<const CallBlockNode*, FunctionSet> CallEdgeMap;
+    typedef OrderedMap<const CallICFGNode*, FunctionSet> CallEdgeMap;
     typedef SCCDetection<PTACallGraph*> CallGraphSCC;
     typedef Set<const GlobalValue*> VTableSet;
     typedef Set<const SVFFunction*> VFunSet;
@@ -263,7 +263,7 @@ public:
     }
 
     /// Print targets of a function pointer
-    void printIndCSTargets(const CallBlockNode* cs, const FunctionSet& targets);
+    void printIndCSTargets(const CallICFGNode* cs, const FunctionSet& targets);
 
     // Debug purpose
     //@{
@@ -282,7 +282,7 @@ protected:
         return pag->getIndirectCallsites();
     }
     /// Return function pointer PAGNode at a callsite cs
-    inline NodeID getFunPtr(const CallBlockNode* cs) const
+    inline NodeID getFunPtr(const CallICFGNode* cs) const
     {
         return pag->getFunPtr(cs);
     }
@@ -389,20 +389,20 @@ public:
     {
         return getPTACallGraph()->getIndCallMap();
     }
-    inline bool hasIndCSCallees(const CallBlockNode* cs) const
+    inline bool hasIndCSCallees(const CallICFGNode* cs) const
     {
         return getPTACallGraph()->hasIndCSCallees(cs);
     }
-    inline const FunctionSet& getIndCSCallees(const CallBlockNode* cs) const
+    inline const FunctionSet& getIndCSCallees(const CallICFGNode* cs) const
     {
         return getPTACallGraph()->getIndCSCallees(cs);
     }
     //@}
 
     /// Resolve indirect call edges
-    virtual void resolveIndCalls(const CallBlockNode* cs, const PointsTo& target, CallEdgeMap& newEdges,LLVMCallGraph* callgraph = nullptr);
+    virtual void resolveIndCalls(const CallICFGNode* cs, const PointsTo& target, CallEdgeMap& newEdges,LLVMCallGraph* callgraph = nullptr);
     /// Match arguments for callsite at caller and callee
-    bool matchArgs(const CallBlockNode* cs, const SVFFunction* callee);
+    bool matchArgs(const CallICFGNode* cs, const SVFFunction* callee);
 
     /// CallGraph SCC related methods
     //@{
@@ -446,10 +446,10 @@ public:
         return chgraph;
     }
 
-    void getVFnsFromCHA(const CallBlockNode* cs, VFunSet &vfns);
-    void getVFnsFromPts(const CallBlockNode* cs, const PointsTo &target, VFunSet &vfns);
-    void connectVCallToVFns(const CallBlockNode* cs, const VFunSet &vfns, CallEdgeMap& newEdges);
-    virtual void resolveCPPIndCalls(const CallBlockNode* cs,
+    void getVFnsFromCHA(const CallICFGNode* cs, VFunSet &vfns);
+    void getVFnsFromPts(const CallICFGNode* cs, const PointsTo &target, VFunSet &vfns);
+    void connectVCallToVFns(const CallICFGNode* cs, const VFunSet &vfns, CallEdgeMap& newEdges);
+    virtual void resolveCPPIndCalls(const CallICFGNode* cs,
                                     const PointsTo& target,
                                     CallEdgeMap& newEdges);
 

package/include/MemoryModel/SVFIR.h

@@ -49,16 +49,16 @@ friend class PAGBuilderFromFile;
 friend class TypeBasedHeapCloning;  
 
 public:
-    typedef Set<const CallBlockNode*> CallSiteSet;
-    typedef OrderedMap<const CallBlockNode*,NodeID> CallSiteToFunPtrMap;
+    typedef Set<const CallICFGNode*> CallSiteSet;
+    typedef OrderedMap<const CallICFGNode*,NodeID> CallSiteToFunPtrMap;
     typedef Map<NodeID,CallSiteSet> FunPtrToCallSitesMap;
     typedef Map<NodeID,NodeBS> MemObjToFieldsMap;
     typedef std::vector<const SVFStmt*> SVFStmtList;
     typedef std::vector<const SVFVar*> SVFVarList;
     typedef Map<const SVFVar*,PhiStmt*> PHINodeMap;
     typedef Map<const SVFFunction*,SVFVarList> FunToArgsListMap;
-    typedef Map<const CallBlockNode*,SVFVarList> CSToArgsListMap;
-    typedef Map<const RetBlockNode*,const SVFVar*> CSToRetMap;
+    typedef Map<const CallICFGNode*,SVFVarList> CSToArgsListMap;
+    typedef Map<const RetICFGNode*,const SVFVar*> CSToRetMap;
     typedef Map<const SVFFunction*,const SVFVar*> FunToRetMap;
     typedef Map<const SVFFunction*,SVFStmtSet> FunToPAGEdgeSetMap;
     typedef Map<const ICFGNode*,SVFStmtList> ICFGNode2SVFStmtsMap;
@@ -229,7 +229,7 @@ public:
         return it->second;
     }
     /// Callsite has argument list
-    inline bool hasCallSiteArgsMap(const CallBlockNode* cs) const
+    inline bool hasCallSiteArgsMap(const CallICFGNode* cs) const
     {
         return (callSiteArgsListMap.find(cs) != callSiteArgsListMap.end());
     }
@@ -239,7 +239,7 @@ public:
         return callSiteArgsListMap;
     }
     /// Get callsite argument list
-    inline const SVFVarList& getCallSiteArgsList(const CallBlockNode* cs) const
+    inline const SVFVarList& getCallSiteArgsList(const CallICFGNode* cs) const
     {
         CSToArgsListMap::const_iterator it = callSiteArgsListMap.find(cs);
         assert(it != callSiteArgsListMap.end() && "this call site doesn't have arguments");
@@ -251,13 +251,13 @@ public:
         return callSiteRetMap;
     }
     /// Get callsite return
-    inline const SVFVar* getCallSiteRet(const RetBlockNode* cs) const
+    inline const SVFVar* getCallSiteRet(const RetICFGNode* cs) const
     {
         CSToRetMap::const_iterator it = callSiteRetMap.find(cs);
         assert(it != callSiteRetMap.end() && "this call site doesn't have return");
         return it->second;
     }
-    inline bool callsiteHasRet(const RetBlockNode* cs) const
+    inline bool callsiteHasRet(const RetICFGNode* cs) const
     {
         return callSiteRetMap.find(cs) != callSiteRetMap.end();
     }
@@ -313,7 +313,7 @@ public:
     {
         return indCallSiteToFunPtrMap;
     }
-    inline NodeID getFunPtr(const CallBlockNode* cs) const
+    inline NodeID getFunPtr(const CallICFGNode* cs) const
     {
         CallSiteToFunPtrMap::const_iterator it = indCallSiteToFunPtrMap.find(cs);
         assert(it!=indCallSiteToFunPtrMap.end() && "indirect callsite not have a function pointer?");
@@ -325,7 +325,7 @@ public:
         assert(it!=funPtrToCallSitesMap.end() && "function pointer not used at any indirect callsite?");
         return it->second;
     }
-    inline bool isIndirectCallSites(const CallBlockNode* cs) const
+    inline bool isIndirectCallSites(const CallICFGNode* cs) const
     {
         return (indCallSiteToFunPtrMap.find(cs) != indCallSiteToFunPtrMap.end());
     }
@@ -409,7 +409,7 @@ public:
     {
         const MemObj* obj = getObject(id);
         assert(obj && "not an object node?");
-        return SymbolTableInfo::isConstantObj(id) || obj->isConstant();
+        return SymbolTableInfo::isConstantObj(id) || obj->isConstDataOrConstGlobal();
     }
     inline bool isNonPointerObj(NodeID id) const
     {
@@ -493,31 +493,31 @@ private:
     /// Add function arguments
     inline void addFunArgs(const SVFFunction* fun, const SVFVar* arg)
     {
-        FunEntryBlockNode* funEntryBlockNode = icfg->getFunEntryBlockNode(fun);
+        FunEntryICFGNode* funEntryBlockNode = icfg->getFunEntryBlockNode(fun);
         funEntryBlockNode->addFormalParms(arg);
         funArgsListMap[fun].push_back(arg);
     }
     /// Add function returns
     inline void addFunRet(const SVFFunction* fun, const SVFVar* ret)
     {
-        FunExitBlockNode* funExitBlockNode = icfg->getFunExitBlockNode(fun);
+        FunExitICFGNode* funExitBlockNode = icfg->getFunExitBlockNode(fun);
         funExitBlockNode->addFormalRet(ret);
         funRetMap[fun] = ret;
     }
     /// Add callsite arguments
-    inline void addCallSiteArgs(CallBlockNode* callBlockNode,const SVFVar* arg)
+    inline void addCallSiteArgs(CallICFGNode* callBlockNode,const SVFVar* arg)
     {
         callBlockNode->addActualParms(arg);
         callSiteArgsListMap[callBlockNode].push_back(arg);
     }
     /// Add callsite returns
-    inline void addCallSiteRets(RetBlockNode* retBlockNode,const SVFVar* arg)
+    inline void addCallSiteRets(RetICFGNode* retBlockNode,const SVFVar* arg)
     {
         retBlockNode->addActualRet(arg);
         callSiteRetMap[retBlockNode]= arg;
     }
     /// Add indirect callsites
-    inline void addIndirectCallsites(const CallBlockNode* cs,NodeID funPtr)
+    inline void addIndirectCallsites(const CallICFGNode* cs,NodeID funPtr)
     {
         bool added = indCallSiteToFunPtrMap.insert(std::make_pair(cs,funPtr)).second;
         funPtrToCallSitesMap[funPtr].insert(cs);
@@ -618,7 +618,7 @@ private:
         globSVFStmtSet.insert(edge);
     }
     /// Add callsites
-    inline void addCallSite(const CallBlockNode* call)
+    inline void addCallSite(const CallICFGNode* call)
     {
         callSiteSet.insert(call);
     }
@@ -641,11 +641,11 @@ private:
     /// Add Load edge
     LoadStmt* addLoadStmt(NodeID src, NodeID dst);
     /// Add Store edge
-    StoreStmt* addStoreStmt(NodeID src, NodeID dst, const IntraBlockNode* val);
+    StoreStmt* addStoreStmt(NodeID src, NodeID dst, const IntraICFGNode* val);
     /// Add Call edge
-    CallPE* addCallPE(NodeID src, NodeID dst, const CallBlockNode* cs);
+    CallPE* addCallPE(NodeID src, NodeID dst, const CallICFGNode* cs);
     /// Add Return edge
-    RetPE* addRetPE(NodeID src, NodeID dst, const CallBlockNode* cs);
+    RetPE* addRetPE(NodeID src, NodeID dst, const CallICFGNode* cs);
     /// Add Gep edge
     GepStmt* addGepStmt(NodeID src, NodeID dst, const LocationSet& ls, bool constGep);
     /// Add Offset(Gep) edge
@@ -653,9 +653,9 @@ private:
     /// Add Variant(Gep) edge
     VariantGepStmt* addVariantGepStmt(NodeID src, NodeID dst, const LocationSet& ls);
     /// Add Thread fork edge for parameter passing
-    TDForkPE* addThreadForkPE(NodeID src, NodeID dst, const CallBlockNode* cs);
+    TDForkPE* addThreadForkPE(NodeID src, NodeID dst, const CallICFGNode* cs);
     /// Add Thread join edge for parameter passing
-    TDJoinPE* addThreadJoinPE(NodeID src, NodeID dst, const CallBlockNode* cs);
+    TDJoinPE* addThreadJoinPE(NodeID src, NodeID dst, const CallICFGNode* cs);
     //@}
 
     /// Set a pointer points-to black hole (e.g. int2ptr)

package/include/MemoryModel/SVFStatements.h

@@ -361,7 +361,7 @@ public:
     //@}
 
     /// constructor
-    StoreStmt(SVFVar* s, SVFVar* d, const IntraBlockNode* st) :
+    StoreStmt(SVFVar* s, SVFVar* d, const IntraICFGNode* st) :
         AssignStmt(s, d, makeEdgeFlagWithStoreInst(SVFStmt::Store, st))
     {
     }
@@ -546,7 +546,7 @@ private:
     CallPE(const CallPE &);  ///< place holder
     void operator=(const CallPE &); ///< place holder
 
-    const CallBlockNode* inst;		///< llvm instruction for this call
+    const CallICFGNode* inst;		///< llvm instruction for this call
 public:
     /// Methods for support type inquiry through isa, cast, and dyn_cast:
     //@{
@@ -567,18 +567,18 @@ public:
     //@}
 
     /// constructor
-    CallPE(SVFVar* s, SVFVar* d, const CallBlockNode* i, GEdgeKind k = SVFStmt::Call) :
+    CallPE(SVFVar* s, SVFVar* d, const CallICFGNode* i, GEdgeKind k = SVFStmt::Call) :
         AssignStmt(s,d,makeEdgeFlagWithCallInst(k,i)), inst(i)
     {
     }
 
     /// Get method for the call instruction
     //@{
-    inline const CallBlockNode* getCallInst() const
+    inline const CallICFGNode* getCallInst() const
     {
         return inst;
     }
-    inline const CallBlockNode* getCallSite() const
+    inline const CallICFGNode* getCallSite() const
     {
         return inst;
     }
@@ -598,7 +598,7 @@ private:
     RetPE(const RetPE &);  ///< place holder
     void operator=(const RetPE &); ///< place holder
 
-    const CallBlockNode* inst;		/// the callsite instruction return to
+    const CallICFGNode* inst;		/// the callsite instruction return to
 public:
     /// Methods for support type inquiry through isa, cast, and dyn_cast:
     //@{
@@ -619,18 +619,18 @@ public:
     //@}
 
     /// constructor
-    RetPE(SVFVar* s, SVFVar* d, const CallBlockNode* i, GEdgeKind k = SVFStmt::Ret) :
+    RetPE(SVFVar* s, SVFVar* d, const CallICFGNode* i, GEdgeKind k = SVFStmt::Ret) :
         AssignStmt(s,d,makeEdgeFlagWithCallInst(k,i)), inst(i)
     {
     }
 
     /// Get method for call instruction at caller
     //@{
-    inline const CallBlockNode* getCallInst() const
+    inline const CallICFGNode* getCallInst() const
     {
         return inst;
     }
-    inline const CallBlockNode* getCallSite() const
+    inline const CallICFGNode* getCallSite() const
     {
         return inst;
     }
@@ -999,7 +999,7 @@ public:
     //@}
 
     /// constructor
-    TDForkPE(SVFVar* s, SVFVar* d, const CallBlockNode* i) :
+    TDForkPE(SVFVar* s, SVFVar* d, const CallICFGNode* i) :
         CallPE(s,d,i,SVFStmt::ThreadFork)
     {
     }
@@ -1037,7 +1037,7 @@ public:
     //@}
 
     /// Constructor
-    TDJoinPE(SVFVar* s, SVFVar* d, const CallBlockNode* i) :
+    TDJoinPE(SVFVar* s, SVFVar* d, const CallICFGNode* i) :
         RetPE(s,d,i,SVFStmt::ThreadJoin)
     {
     }

package/include/MemoryModel/SymbolTableInfo.h

@@ -479,9 +479,10 @@ public:
     bool isArray() const;
     bool isVarStruct() const;
     bool isVarArray() const;
-    bool isConstStruct() const;
-    bool isConstArray() const;
-    bool isConstant() const;
+    bool isConstantStruct() const;
+    bool isConstantArray() const;
+    bool isConstDataOrConstGlobal() const;
+    bool isConstantData() const;
     bool hasPtrObj() const;
     bool isNonPtrFieldObj(const LocationSet& ls) const;
     //@}
@@ -591,8 +592,9 @@ public:
         VAR_ARRAY_OBJ = 0x40,  // object contains array
         CONST_STRUCT_OBJ = 0x80,  // constant struct
         CONST_ARRAY_OBJ = 0x100,  // constant array
-        CONST_OBJ = 0x200,  // constant object str e.g.
-        HASPTR_OBJ = 0x400		// non pointer object including compound type have field that is a pointer type
+        CONST_GLOBAL_OBJ = 0x200,  // global constant object
+        CONST_DATA = 0x400,  // constant object str e.g. 5, 10, 1.0
+        HASPTR_OBJ = 0x800		// the object stores a pointer address
     } MEMTYPE;
 
 private:
@@ -689,7 +691,7 @@ public:
     {
         return hasFlag(VAR_STRUCT_OBJ);
     }
-    inline bool isConstStruct()
+    inline bool isConstantStruct()
     {
         return hasFlag(CONST_STRUCT_OBJ);
     }
@@ -701,7 +703,7 @@ public:
     {
         return hasFlag(VAR_ARRAY_OBJ);
     }
-    inline bool isConstArray()
+    inline bool isConstantArray()
     {
         return  hasFlag(CONST_ARRAY_OBJ);
     }
@@ -709,9 +711,13 @@ public:
     {
         return hasFlag(VAR_ARRAY_OBJ) || hasFlag(CONST_ARRAY_OBJ);
     }
-    inline bool isConstant()
+    inline bool isConstDataOrConstGlobal()
     {
-        return hasFlag(CONST_OBJ);
+        return hasFlag(CONST_GLOBAL_OBJ) || hasFlag(CONST_DATA);
+    }
+    inline bool isConstantData()
+    {
+        return hasFlag(CONST_DATA);
     }
     inline bool hasPtrObj()
     {

package/include/SABER/LeakChecker.h

@@ -43,8 +43,8 @@ class LeakChecker : public SrcSnkDDA
 {
 
 public:
-    typedef Map<const SVFGNode*,const CallBlockNode*> SVFGNodeToCSIDMap;
-    typedef FIFOWorkList<const CallBlockNode*> CSWorkList;
+    typedef Map<const SVFGNode*,const CallICFGNode*> SVFGNodeToCSIDMap;
+    typedef FIFOWorkList<const CallICFGNode*> CSWorkList;
     typedef ProgSlice::VFWorkList WorkList;
     typedef NodeBS SVFGNodeBS;
     enum LEAK_TYPE
@@ -104,11 +104,11 @@ protected:
 
     /// Record a source to its callsite
     //@{
-    inline void addSrcToCSID(const SVFGNode* src, const CallBlockNode* cs)
+    inline void addSrcToCSID(const SVFGNode* src, const CallICFGNode* cs)
     {
         srcToCSIDMap[src] = cs;
     }
-    inline const CallBlockNode* getSrcCSID(const SVFGNode* src)
+    inline const CallICFGNode* getSrcCSID(const SVFGNode* src)
     {
         SVFGNodeToCSIDMap::iterator it =srcToCSIDMap.find(src);
         assert(it!=srcToCSIDMap.end() && "source node not at a callsite??");