svf-lib 1.0.1278 → 1.0.1280

package/SVF-linux/include/DDA/DDAVFSolver.h

@@ -470,9 +470,8 @@ protected:
         assert(obj && "object not found!!");
         if(obj->isStack())
         {
-            if(const Function* fun = _pag->getGNode(id)->getFunction())
+            if(const SVFFunction* svffun = _pag->getGNode(id)->getFunction())
             {
-                const SVFFunction* svffun = LLVMModuleSet::getLLVMModuleSet()->getSVFFunction(fun);
                 return _callGraphSCC->isInCycle(_callGraph->getCallGraphNode(svffun)->getId());
             }
         }

package/SVF-linux/include/Graphs/ICFG.h

@@ -58,9 +58,9 @@ public:
 
     typedef Map<const SVFFunction*, FunEntryICFGNode *> FunToFunEntryNodeMapTy;
     typedef Map<const SVFFunction*, FunExitICFGNode *> FunToFunExitNodeMapTy;
-    typedef Map<const Instruction*, CallICFGNode *> CSToCallNodeMapTy;
-    typedef Map<const Instruction*, RetICFGNode *> CSToRetNodeMapTy;
-    typedef Map<const Instruction*, IntraICFGNode *> InstToBlockNodeMapTy;
+    typedef Map<const SVFInstruction*, CallICFGNode *> CSToCallNodeMapTy;
+    typedef Map<const SVFInstruction*, RetICFGNode *> CSToRetNodeMapTy;
+    typedef Map<const SVFInstruction*, IntraICFGNode *> InstToBlockNodeMapTy;
     typedef std::vector<const SVFLoop *> SVFLoopVec;
     typedef Map<const ICFGNode *, SVFLoopVec> ICFGNodeToSVFLoopVec;
 
@@ -122,7 +122,7 @@ public:
     }
 
     /// Whether node is in a loop
-    inline bool isInLoop(const Instruction *inst)
+    inline bool isInLoop(const SVFInstruction* inst)
     {
         return isInLoop(getICFGNode(inst));
     }
@@ -159,8 +159,8 @@ protected:
     //@{
     ICFGEdge* addIntraEdge(ICFGNode* srcNode, ICFGNode* dstNode);
     ICFGEdge* addConditionalIntraEdge(ICFGNode* srcNode, ICFGNode* dstNode, const Value* condition, s32_t branchCondVal);
-    ICFGEdge* addCallEdge(ICFGNode* srcNode, ICFGNode* dstNode, const Instruction* cs);
-    ICFGEdge* addRetEdge(ICFGNode* srcNode, ICFGNode* dstNode, const Instruction* cs);
+    ICFGEdge* addCallEdge(ICFGNode* srcNode, ICFGNode* dstNode, const SVFInstruction* cs);
+    ICFGEdge* addRetEdge(ICFGNode* srcNode, ICFGNode* dstNode, const SVFInstruction* cs);
     //@}
 
     /// sanitize Intra edges, verify that both nodes belong to the same function.
@@ -194,13 +194,13 @@ public:
     /// Get a basic block ICFGNode
     /// TODO:: need to fix the assertions
     //@{
-    ICFGNode* getICFGNode(const Instruction* inst);
+    ICFGNode* getICFGNode(const SVFInstruction* inst);
 
-    CallICFGNode* getCallICFGNode(const Instruction* inst);
+    CallICFGNode* getCallICFGNode(const SVFInstruction* inst);
 
-    RetICFGNode* getRetICFGNode(const Instruction* inst);
+    RetICFGNode* getRetICFGNode(const SVFInstruction* inst);
 
-    IntraICFGNode* getIntraICFGNode(const Instruction* inst);
+    IntraICFGNode* getIntraICFGNode(const SVFInstruction* inst);
 
     FunEntryICFGNode* getFunEntryICFGNode(const SVFFunction*  fun);
 
@@ -220,14 +220,14 @@ public:
 private:
 
     /// Get/Add IntraBlock ICFGNode
-    inline IntraICFGNode* getIntraBlock(const Instruction* inst)
+    inline IntraICFGNode* getIntraBlock(const SVFInstruction* inst)
     {
         InstToBlockNodeMapTy::const_iterator it = InstToBlockNodeMap.find(inst);
         if (it == InstToBlockNodeMap.end())
             return nullptr;
         return it->second;
     }
-    inline IntraICFGNode* addIntraBlock(const Instruction* inst)
+    inline IntraICFGNode* addIntraBlock(const SVFInstruction* inst)
     {
         IntraICFGNode* sNode = new IntraICFGNode(totalICFGNode++,inst);
         addICFGNode(sNode);
@@ -268,14 +268,14 @@ private:
     }
 
     /// Get/Add a call node
-    inline CallICFGNode* addCallBlock(const Instruction* cs)
+    inline CallICFGNode* addCallBlock(const SVFInstruction* cs)
     {
         CallICFGNode* sNode = new CallICFGNode(totalICFGNode++, cs);
         addICFGNode(sNode);
         CSToCallNodeMap[cs] = sNode;
         return sNode;
     }
-    inline CallICFGNode* getCallBlock(const Instruction* cs)
+    inline CallICFGNode* getCallBlock(const SVFInstruction* cs)
     {
         CSToCallNodeMapTy::const_iterator it = CSToCallNodeMap.find(cs);
         if (it == CSToCallNodeMap.end())
@@ -284,14 +284,14 @@ private:
     }
 
     /// Get/Add a return node
-    inline RetICFGNode* getRetBlock(const Instruction* cs)
+    inline RetICFGNode* getRetBlock(const SVFInstruction* cs)
     {
         CSToRetNodeMapTy::const_iterator it = CSToRetNodeMap.find(cs);
         if (it == CSToRetNodeMap.end())
             return nullptr;
         return it->second;
     }
-    inline RetICFGNode* addRetBlock(const Instruction* cs)
+    inline RetICFGNode* addRetBlock(const SVFInstruction* cs)
     {
         CallICFGNode* callBlockNode = getCallICFGNode(cs);
         RetICFGNode* sNode = new RetICFGNode(totalICFGNode++, cs, callBlockNode);

package/SVF-linux/include/Graphs/ICFGEdge.h

@@ -169,16 +169,16 @@ class CallCFGEdge : public ICFGEdge
 {
 
 private:
-    const Instruction*  cs;
+    const SVFInstruction*  cs;
     std::vector<const CallPE*> callPEs;
 public:
     /// Constructor
-    CallCFGEdge(ICFGNode* s, ICFGNode* d, const Instruction*  c):
+    CallCFGEdge(ICFGNode* s, ICFGNode* d, const SVFInstruction*  c):
         ICFGEdge(s,d,CallCF),cs(c)
     {
     }
     /// Return callsite ID
-    inline const Instruction*  getCallSite() const
+    inline const SVFInstruction*  getCallSite() const
     {
         return cs;
     }
@@ -217,16 +217,16 @@ class RetCFGEdge : public ICFGEdge
 {
 
 private:
-    const Instruction*  cs;
+    const SVFInstruction*  cs;
     const RetPE* retPE;
 public:
     /// Constructor
-    RetCFGEdge(ICFGNode* s, ICFGNode* d, const Instruction*  c):
+    RetCFGEdge(ICFGNode* s, ICFGNode* d, const SVFInstruction*  c):
         ICFGEdge(s,d,RetCF),cs(c),retPE(nullptr)
     {
     }
     /// Return callsite ID
-    inline const Instruction*  getCallSite() const
+    inline const SVFInstruction*  getCallSite() const
     {
         return cs;
     }

package/SVF-linux/include/Graphs/ICFGNode.h

@@ -83,7 +83,7 @@ public:
     }
 
     /// Return the function of this ICFGNode
-    virtual const BasicBlock* getBB() const
+    virtual const SVFBasicBlock* getBB() const
     {
         return bb;
     }
@@ -130,7 +130,7 @@ public:
 
 protected:
     const SVFFunction* fun;
-    const BasicBlock* bb;
+    const SVFBasicBlock* bb;
     VFGNodeList VFGNodes; //< a list of VFGNodes
     SVFStmtList pagEdges; //< a list of PAGEdges
 
@@ -175,16 +175,16 @@ public:
 class IntraICFGNode : public ICFGNode
 {
 private:
-    const Instruction *inst;
+    const SVFInstruction *inst;
 
 public:
-    IntraICFGNode(NodeID id, const Instruction *i) : ICFGNode(id, IntraBlock), inst(i)
+    IntraICFGNode(NodeID id, const SVFInstruction *i) : ICFGNode(id, IntraBlock), inst(i)
     {
-        fun = LLVMModuleSet::getLLVMModuleSet()->getSVFFunction(inst->getFunction());
+        fun = inst->getFunction();
         bb = inst->getParent();
     }
 
-    inline const Instruction *getInst() const
+    inline const SVFInstruction *getInst() const
     {
         return inst;
     }
@@ -366,18 +366,18 @@ class CallICFGNode : public InterICFGNode
 public:
     typedef std::vector<const SVFVar *> ActualParmNodeVec;
 private:
-    const Instruction* cs;
+    const SVFInstruction* cs;
     const RetICFGNode* ret;
     ActualParmNodeVec APNodes;
 public:
-    CallICFGNode(NodeID id, const Instruction* c) : InterICFGNode(id, FunCallBlock), cs(c), ret(nullptr)
+    CallICFGNode(NodeID id, const SVFInstruction* c) : InterICFGNode(id, FunCallBlock), cs(c), ret(nullptr)
     {
-        fun = LLVMModuleSet::getLLVMModuleSet()->getSVFFunction(cs->getFunction());
+        fun = cs->getFunction();
         bb = cs->getParent();
     }
 
     /// Return callsite
-    inline const Instruction* getCallSite() const
+    inline const SVFInstruction* getCallSite() const
     {
         return cs;
     }
@@ -398,11 +398,11 @@ public:
     /// Return callsite
     inline const SVFFunction* getCaller() const
     {
-        return LLVMModuleSet::getLLVMModuleSet()->getSVFFunction(cs->getFunction());
+        return cs->getFunction();
     }
 
     /// Return Basic Block
-    inline const BasicBlock* getParent() const
+    inline const SVFBasicBlock* getParent() const
     {
         return cs->getParent();
     }
@@ -459,19 +459,19 @@ class RetICFGNode : public InterICFGNode
 {
 
 private:
-    const Instruction* cs;
+    const SVFInstruction* cs;
     const SVFVar *actualRet;
     const CallICFGNode* callBlockNode;
 public:
-    RetICFGNode(NodeID id, const Instruction* c, CallICFGNode* cb) :
+    RetICFGNode(NodeID id, const SVFInstruction* c, CallICFGNode* cb) :
         InterICFGNode(id, FunRetBlock), cs(c), actualRet(nullptr), callBlockNode(cb)
     {
-        fun = LLVMModuleSet::getLLVMModuleSet()->getSVFFunction(cs->getFunction());
+        fun = cs->getFunction();
         bb = cs->getParent();
     }
 
     /// Return callsite
-    inline const Instruction* getCallSite() const
+    inline const SVFInstruction* getCallSite() const
     {
         return cs;
     }

package/SVF-linux/include/Graphs/IRGraph.h

@@ -78,7 +78,7 @@ protected:
     SVFStmt* hasLabeledEdge(SVFVar* src, SVFVar* op1, SVFStmt::PEDGEK kind, const SVFVar* op2);
 
     /// Map a value to a set of edges
-    inline void mapValueToEdge(const Value *V, SVFStmt *edge)
+    inline void mapValueToEdge(const Value* V, SVFStmt *edge)
     {
         auto inserted = valueToEdgeMap.emplace(V, SVFStmtSet{edge});
         if (!inserted.second)
@@ -108,7 +108,7 @@ public:
         return fromFile;
     }
     /// Get all SVFIR Edges that corresponds to an LLVM value
-    inline const SVFStmtSet& getValueEdges(const Value *V)
+    inline const SVFStmtSet& getValueEdges(const Value* V)
     {
         auto it = valueToEdgeMap.find(V);
         if (it == valueToEdgeMap.end())
@@ -121,7 +121,7 @@ public:
 
     /// Get SVFIR Node according to LLVM value
     ///getNode - Return the node corresponding to the specified pointer.
-    inline NodeID getValueNode(const Value *V)
+    inline NodeID getValueNode(const Value* V)
     {
         return symInfo->getValSym(V);
     }
@@ -131,19 +131,19 @@ public:
     }
     /// getObject - Return the obj node id refer to the memory object for the
     /// specified global, heap or alloca instruction according to llvm value.
-    inline NodeID getObjectNode(const Value *V)
+    inline NodeID getObjectNode(const Value* V)
     {
         return symInfo->getObjSym(V);
     }
     /// GetReturnNode - Return the unique node representing the return value of a function
     inline NodeID getReturnNode(const SVFFunction* func) const
     {
-        return symInfo->getRetSym(func->getLLVMFun());
+        return symInfo->getRetSym(func);
     }
     /// getVarargNode - Return the unique node representing the variadic argument of a variadic function.
     inline NodeID getVarargNode(const SVFFunction* func) const
     {
-        return symInfo->getVarargSym(func->getLLVMFun());
+        return symInfo->getVarargSym(func);
     }
     inline NodeID getBlackHoleNode() const
     {

package/SVF-linux/include/Graphs/ThreadCallGraph.h

@@ -163,8 +163,8 @@ class ThreadCallGraph: public PTACallGraph
 public:
     typedef Set<const CallICFGNode*> InstSet;
     typedef InstSet CallSiteSet;
-    typedef std::vector<const Instruction*> InstVector;
-    typedef Map<const Instruction*, InstSet> CallToInstMap;
+    typedef std::vector<const SVFInstruction*> InstVector;
+    typedef Map<const SVFInstruction*, InstSet> CallToInstMap;
     typedef Set<CallSiteSet*> CtxSet;
     typedef ThreadForkEdge::ForkEdgeSet ForkEdgeSet;
     typedef Map<const CallICFGNode*, ForkEdgeSet> CallInstToForkEdgesMap;

package/SVF-linux/include/Graphs/VFGNode.h

@@ -182,7 +182,7 @@ public:
                || node->getNodeKind() == Load;
     }
 
-    inline const Instruction* getInst() const
+    inline const SVFInstruction* getInst() const
     {
         /// should return a valid instruction unless it is a global PAGEdge
         return pagEdge->getInst();

package/SVF-linux/include/MSSA/MSSAMuChi.h

@@ -167,12 +167,12 @@ class LoadMU : public MSSAMU<Cond>
 
 private:
     const LoadStmt* inst;
-    const BasicBlock* bb;
+    const SVFBasicBlock* bb;
 
 public:
     /// Constructor/Destructor for MU
     //@{
-    LoadMU(const BasicBlock* b,const LoadStmt* i, const MemRegion* m, Cond c = true) :
+    LoadMU(const SVFBasicBlock* b,const LoadStmt* i, const MemRegion* m, Cond c = true) :
         MSSAMU<Cond>(MSSAMU<Cond>::LoadMSSAMU,m,c), inst(i), bb(b)
     {
     }
@@ -189,7 +189,7 @@ public:
     }
 
     /// Return basic block
-    inline const BasicBlock* getBasicBlock() const
+    inline const SVFBasicBlock* getBasicBlock() const
     {
         return bb;
     }
@@ -244,7 +244,7 @@ public:
     }
 
     /// Return basic block
-    inline const BasicBlock* getBasicBlock() const
+    inline const SVFBasicBlock* getBasicBlock() const
     {
         return callsite->getCallSite()->getParent();
     }
@@ -461,12 +461,12 @@ template<class Cond>
 class StoreCHI : public MSSACHI<Cond>
 {
 private:
-    const BasicBlock* bb;
+    const SVFBasicBlock* bb;
     const StoreStmt* inst;
 public:
     /// Constructors for StoreCHI
     //@{
-    StoreCHI(const BasicBlock* b, const StoreStmt* i, const MemRegion* m, Cond c = true) :
+    StoreCHI(const SVFBasicBlock* b, const StoreStmt* i, const MemRegion* m, Cond c = true) :
         MSSACHI<Cond>(MSSADEF::StoreMSSACHI,m,c), bb(b), inst(i)
     {
     }
@@ -476,7 +476,7 @@ public:
     //@}
 
     /// Get basic block
-    inline const BasicBlock* getBasicBlock() const
+    inline const SVFBasicBlock* getBasicBlock() const
     {
         return bb;
     }
@@ -535,7 +535,7 @@ public:
     //@}
 
     /// Return basic block
-    inline const BasicBlock* getBasicBlock() const
+    inline const SVFBasicBlock* getBasicBlock() const
     {
         return callsite->getCallSite()->getParent();
     }
@@ -632,13 +632,13 @@ class MSSAPHI : public MSSADEF
 public:
     typedef Map<u32_t,const MRVer*> OPVers;
 private:
-    const BasicBlock* bb;
+    const SVFBasicBlock* bb;
     OPVers opVers;
     Cond cond;
 public:
     /// Constructors for PHI
     //@{
-    MSSAPHI(const BasicBlock* b, const MemRegion* m, Cond c = true) :
+    MSSAPHI(const SVFBasicBlock* b, const MemRegion* m, Cond c = true) :
         MSSADEF(MSSADEF::SSAPHI,m), bb(b), cond(c)
     {
     }
@@ -681,7 +681,7 @@ public:
     //@}
 
     /// Return the basic block
-    inline const BasicBlock* getBasicBlock() const
+    inline const SVFBasicBlock* getBasicBlock() const
     {
         return bb;
     }

package/SVF-linux/include/MSSA/MemRegion.h

@@ -470,9 +470,9 @@ public:
     }
     //@}
     /// Whether this instruction has SVFIR Edge
-    bool hasSVFStmtList(const Instruction* inst);
+    bool hasSVFStmtList(const SVFInstruction* inst);
     /// Given an instruction, get all its the PAGEdge (statement) in sequence
-    SVFStmtList& getPAGEdgesFromInst(const Instruction* inst);
+    SVFStmtList& getPAGEdgesFromInst(const SVFInstruction* inst);
 
     /// getModRefInfo APIs
     //@{

package/SVF-linux/include/MSSA/MemSSA.h

@@ -81,7 +81,7 @@ public:
     typedef Map<const StoreStmt*, CHISet> StoreToChiSetMap;
     typedef Map<const CallICFGNode*, MUSet> CallSiteToMUSetMap;
     typedef Map<const CallICFGNode*, CHISet> CallSiteToCHISetMap;
-    typedef OrderedMap<const BasicBlock*, PHISet> BBToPhiSetMap;
+    typedef OrderedMap<const SVFBasicBlock*, PHISet> BBToPhiSetMap;
     //@}
 
     /// Map from fun to its entry chi set and return mu set
@@ -90,8 +90,8 @@ public:
 
     /// For phi insertion
     //@{
-    typedef std::vector<const BasicBlock*> BBList;
-    typedef Map<const BasicBlock*, MRSet> BBToMRSetMap;
+    typedef std::vector<const SVFBasicBlock*> BBList;
+    typedef Map<const SVFBasicBlock*, MRSet> BBToMRSetMap;
     typedef Map<const MemRegion*, BBList> MemRegToBBsMap;
     //@}
 
@@ -129,7 +129,7 @@ protected:
     /// SSA rename for a function
     virtual void SSARename(const SVFFunction& fun);
     /// SSA rename for a basic block
-    virtual void SSARenameBB(const BasicBlock& bb);
+    virtual void SSARenameBB(const SVFBasicBlock& bb);
 private:
     LoadToMUSetMap load2MuSetMap;
     StoreToChiSetMap store2ChiSetMap;
@@ -175,7 +175,7 @@ private:
         if (0 == varKills.count(mr))
             usedRegs.insert(mr);
     }
-    inline void collectRegDefs(const BasicBlock* bb, const MemRegion* mr)
+    inline void collectRegDefs(const SVFBasicBlock* bb, const MemRegion* mr)
     {
         varKills.insert(mr);
         reg2BBMap[mr].push_back(bb);
@@ -184,12 +184,12 @@ private:
 
     /// Add methods for mus/chis/phis
     //@{
-    inline void AddLoadMU(const BasicBlock* bb, const LoadStmt* load, const MRSet& mrSet)
+    inline void AddLoadMU(const SVFBasicBlock* bb, const LoadStmt* load, const MRSet& mrSet)
     {
         for (MRSet::iterator iter = mrSet.begin(), eiter = mrSet.end(); iter != eiter; ++iter)
             AddLoadMU(bb,load,*iter);
     }
-    inline void AddStoreCHI(const BasicBlock* bb, const StoreStmt* store, const MRSet& mrSet)
+    inline void AddStoreCHI(const SVFBasicBlock* bb, const StoreStmt* store, const MRSet& mrSet)
     {
         for (MRSet::iterator iter = mrSet.begin(), eiter = mrSet.end(); iter != eiter; ++iter)
             AddStoreCHI(bb,store,*iter);
@@ -204,18 +204,18 @@ private:
         for (MRSet::iterator iter = mrSet.begin(), eiter = mrSet.end(); iter != eiter; ++iter)
             AddCallSiteCHI(cs,*iter);
     }
-    inline void AddMSSAPHI(const BasicBlock* bb, const MRSet& mrSet)
+    inline void AddMSSAPHI(const SVFBasicBlock* bb, const MRSet& mrSet)
     {
         for (MRSet::iterator iter = mrSet.begin(), eiter = mrSet.end(); iter != eiter; ++iter)
             AddMSSAPHI(bb,*iter);
     }
-    inline void AddLoadMU(const BasicBlock* bb, const LoadStmt* load, const MemRegion* mr)
+    inline void AddLoadMU(const SVFBasicBlock* bb, const LoadStmt* load, const MemRegion* mr)
     {
         LOADMU* mu = new LOADMU(bb,load, mr);
         load2MuSetMap[load].insert(mu);
         collectRegUses(mr);
     }
-    inline void AddStoreCHI(const BasicBlock* bb, const StoreStmt* store, const MemRegion* mr)
+    inline void AddStoreCHI(const SVFBasicBlock* bb, const StoreStmt* store, const MemRegion* mr)
     {
         STORECHI* chi = new STORECHI(bb,store, mr);
         store2ChiSetMap[store].insert(chi);
@@ -235,7 +235,7 @@ private:
         collectRegUses(mr);
         collectRegDefs(chi->getBasicBlock(),mr);
     }
-    inline void AddMSSAPHI(const BasicBlock* bb, const MemRegion* mr)
+    inline void AddMSSAPHI(const SVFBasicBlock* bb, const MemRegion* mr)
     {
         bb2PhiSetMap[bb].insert(new PHI(bb, mr));
     }
@@ -392,11 +392,11 @@ public:
     {
         return callsiteToChiSetMap[cs];
     }
-    inline PHISet& getPHISet(const BasicBlock* bb)
+    inline PHISet& getPHISet(const SVFBasicBlock* bb)
     {
         return bb2PhiSetMap[bb];
     }
-    inline bool hasPHISet(const BasicBlock* bb) const
+    inline bool hasPHISet(const SVFBasicBlock* bb) const
     {
         return bb2PhiSetMap.find(bb)!=bb2PhiSetMap.end();
     }

package/SVF-linux/include/MTA/FSMPTA.h

@@ -104,7 +104,7 @@ public:
     typedef Set<const SVFGNode*> SVFGNodeSet;
     typedef std::vector<const SVFGNode*> SVFGNodeVec;
     typedef NodeBS SVFGNodeIDSet;
-    typedef Set<const Instruction*> InstSet;
+    typedef Set<const SVFInstruction*> InstSet;
     typedef std::pair<NodeID,NodeID> NodeIDPair;
     typedef Map<SVFGNodeLockSpan, bool> PairToBoolMap;