svf-lib 1.0.1276 → 1.0.1278

package/SVF-osx/include/MTA/TCT.h

@@ -51,7 +51,6 @@ typedef GenericEdge<TCTNode> GenericTCTEdgeTy;
 class TCTEdge: public GenericTCTEdgeTy
 {
 public:
-    typedef Set<const Instruction*> CallInstSet;
     enum CEDGEK
     {
         ThreadCreateEdge
@@ -140,14 +139,14 @@ class TCT: public GenericThreadCreateTreeTy
 public:
     typedef TCTEdge::ThreadCreateEdgeSet ThreadCreateEdgeSet;
     typedef ThreadCreateEdgeSet::iterator TCTNodeIter;
-    typedef Set<const Function*> FunSet;
-    typedef std::vector<const Instruction*> InstVec;
-    typedef Set<const Instruction*> InstSet;
+    typedef Set<const SVFFunction*> FunSet;
+    typedef std::vector<const SVFInstruction*> InstVec;
+    typedef Set<const SVFInstruction*> InstSet;
     typedef Set<const PTACallGraphNode*> PTACGNodeSet;
     typedef Map<CxtThread,TCTNode*> CxtThreadToNodeMap;
     typedef Map<CxtThread,CallStrCxt> CxtThreadToForkCxt;
-    typedef Map<CxtThread,const Function*> CxtThreadToFun;
-    typedef Map<const Instruction*, const Loop*> InstToLoopMap;
+    typedef Map<CxtThread,const SVFFunction*> CxtThreadToFun;
+    typedef Map<const SVFInstruction*, const Loop*> InstToLoopMap;
     typedef FIFOWorkList<CxtThreadProc> CxtThreadProcVec;
     typedef Set<CxtThreadProc> CxtThreadProcSet;
     typedef SCCDetection<PTACallGraph*> ThreadCallGraphSCC;
@@ -169,15 +168,10 @@ public:
         destroy();
     }
     /// Get CallICFGNode given inst
-    CallICFGNode* getCallICFGNode(const Instruction* inst)
+    CallICFGNode* getCallICFGNode(const SVFInstruction* inst)
     {
         return pta->getICFG()->getCallICFGNode(inst);
     }
-    /// Get SVFFuntion given Function
-    const SVFFunction* getSVFFun(const Function* fun) const
-    {
-        return LLVMModuleSet::getLLVMModuleSet()->getSVFFunction(fun);
-    }
     /// Get SVFFModule
     SVFModule* getSVFModule() const
     {
@@ -272,18 +266,14 @@ public:
         for(PTACallGraph::FunctionSet::const_iterator cit = callees.begin(),
                 ecit = callees.end(); cit!=ecit; cit++)
         {
-            if(candidateFuncSet.find((*cit)->getLLVMFun())!=candidateFuncSet.end())
+            if(candidateFuncSet.find((*cit))!=candidateFuncSet.end())
                 return true;
         }
         return false;
     }
-    inline bool isCandidateFun(const Function* fun) const
-    {
-        return candidateFuncSet.find(fun)!=candidateFuncSet.end();
-    }
     inline bool isCandidateFun(const SVFFunction* fun) const
     {
-        return isCandidateFun(fun->getLLVMFun());
+        return candidateFuncSet.find(fun)!=candidateFuncSet.end();
     }
     /// Whether two functions in the same callgraph scc
     inline bool inSameCallGraphSCC(const PTACallGraphNode* src,const PTACallGraphNode* dst)
@@ -357,7 +347,7 @@ public:
     }
 
     /// get the start routine function of a thread
-    const Function* getStartRoutineOfCxtThread(const CxtThread& ct) const
+    const SVFFunction* getStartRoutineOfCxtThread(const CxtThread& ct) const
     {
         CxtThreadToFun::const_iterator it = ctToRoutineFunMap.find(ct);
         assert(it!=ctToRoutineFunMap.end() && "Cxt Thread not found!!");
@@ -365,7 +355,7 @@ public:
     }
 
     /// Get loop for join site
-    inline const Loop* getJoinLoop(const Instruction* join)
+    inline const Loop* getJoinLoop(const SVFInstruction* join)
     {
         assert(tcg->getThreadAPI()->isTDJoin(join) && "not a join site");
         InstToLoopMap::const_iterator it = joinSiteToLoopMap.find(join);
@@ -374,24 +364,24 @@ public:
         return nullptr;
     }
     /// Return true if a join instruction must be executed inside a loop
-    bool isJoinMustExecutedInLoop(const Loop* lp,const Instruction* join);
+    bool isJoinMustExecutedInLoop(const Loop* lp,const SVFInstruction* join);
     /// Get loop for an instruction
-    const Loop* getLoop(const Instruction* inst);
+    const Loop* getLoop(const SVFInstruction* inst);
     /// Get dominator for a function
     const DominatorTree* getDT(const Function* fun);
     /// Get dominator for a function
     const PostDominatorTree* getPostDT(const Function* fun);
     /// Get loop for fork/join site
-    const Loop* getLoop(const BasicBlock* bb);
+    const Loop* getLoop(const SVFBasicBlock* bb);
     /// Get SE for function
-    ScalarEvolution* getSE(const Instruction* inst);
+    ScalarEvolution* getSE(const SVFInstruction* inst);
 
     /// Get the next instructions following control flow
-    void getNextInsts(const Instruction* inst, InstVec& instSet);
+    void getNextInsts(const SVFInstruction* inst, InstVec& instSet);
     /// Push calling context
-    void pushCxt(CallStrCxt& cxt, const Instruction* call, const Function* callee);
+    void pushCxt(CallStrCxt& cxt, const SVFInstruction* call, const SVFFunction* callee);
     /// Match context
-    bool matchCxt(CallStrCxt& cxt, const Instruction* call, const Function* callee);
+    bool matchCxt(CallStrCxt& cxt, const SVFInstruction* call, const SVFFunction* callee);
 
     inline void pushCxt(CallStrCxt& cxt, CallSiteID csId)
     {
@@ -400,7 +390,7 @@ public:
             MaxCxtSize = cxt.size();
     }
     /// Whether a join site is in recursion
-    inline bool isJoinSiteInRecursion(const Instruction* join) const
+    inline bool isJoinSiteInRecursion(const SVFInstruction* join) const
     {
         assert(tcg->getThreadAPI()->isTDJoin(join) && "not a join site");
         return inRecurJoinSites.find(join)!=inRecurJoinSites.end();
@@ -452,7 +442,7 @@ private:
     /// Mark relevant procedures that are backward reachable from any fork/join site
     //@{
     void markRelProcs();
-    void markRelProcs(const Function* fun);
+    void markRelProcs(const SVFFunction* fun);
     //@}
 
     /// Get entry functions that are neither called by other functions nor extern functions
@@ -467,17 +457,17 @@ private:
     /// collect loop info for join sites
     void collectLoopInfoForJoin();
     /// Whether a given bb is a loop head of a inloop join site
-    bool isLoopHeaderOfJoinLoop(const BasicBlock* bb);
+    bool isLoopHeaderOfJoinLoop(const SVFBasicBlock* bb);
     /// Whether a given bb is an exit of a inloop join site
-    bool isLoopExitOfJoinLoop(const BasicBlock* bb);
+    bool isLoopExitOfJoinLoop(const SVFBasicBlock* bb);
     //@}
 
     /// Multi-forked threads
     //@{
     /// Whether an instruction is in a loop
-    bool isInLoopInstruction(const Instruction* inst);
+    bool isInLoopInstruction(const SVFInstruction* inst);
     /// Whether an instruction is in a recursion
-    bool isInRecursion(const Instruction* inst) const;
+    bool isInRecursion(const SVFInstruction* inst) const;
     //@}
 
     /// Handle call relations
@@ -485,7 +475,7 @@ private:
 
     /// Get or create a tct node based on CxtThread
     //@{
-    inline TCTNode* getOrCreateTCTNode(const CallStrCxt& cxt, const CallInst* fork,const CallStrCxt& oldCxt, const Function* routine)
+    inline TCTNode* getOrCreateTCTNode(const CallStrCxt& cxt, const SVFInstruction* fork,const CallStrCxt& oldCxt, const SVFFunction* routine)
     {
         CxtThread ct(cxt,fork);
         CxtThreadToNodeMap::const_iterator it = ctpToNodeMap.find(ct);
@@ -508,8 +498,9 @@ private:
         /// non-main thread
         if(ct.getThread() != nullptr)
         {
-            ct.setInloop(isInLoopInstruction(ct.getThread()));
-            ct.setIncycle(isInRecursion(ct.getThread()));
+            const SVFInstruction* svfInst = ct.getThread();
+            ct.setInloop(isInLoopInstruction(svfInst));
+            ct.setIncycle(isInRecursion(svfInst));
         }
         /// main thread
         else
@@ -525,7 +516,7 @@ private:
         ctToForkCxtMap[ct] = cxt;
     }
     /// Add start routine function of a cxt thread
-    void addStartRoutineOfCxtThread(const Function* fun, const CxtThread& ct)
+    void addStartRoutineOfCxtThread(const SVFFunction* fun, const CxtThread& ct)
     {
         ctToRoutineFunMap[ct] = fun;
     }

package/SVF-osx/include/MemoryModel/SVFStatements.h

@@ -58,7 +58,7 @@ public:
 
 private:
     const Value* value;	///< LLVM value
-    const BasicBlock *basicBlock;   ///< LLVM BasicBlock
+    const SVFBasicBlock* basicBlock;   ///< LLVM BasicBlock
     ICFGNode *icfgNode;   ///< ICFGNode
     EdgeID edgeId;					///< Edge ID
 public:
@@ -104,11 +104,16 @@ public:
 
     /// Get/set methods for llvm instruction
     //@{
-    inline const Instruction* getInst() const
+    inline const SVFInstruction* getInst() const
     {
-        return SVFUtil::dyn_cast<Instruction>(value);
+        if(const Instruction* i = SVFUtil::dyn_cast<Instruction>(value))
+        {
+            return LLVMModuleSet::getLLVMModuleSet()->getSVFInstruction(i);
+        }
+        else
+            return nullptr;
     }
-    inline void setValue(const Value *val)
+    inline void setValue(const Value* val)
     {
         value = val;
     }
@@ -116,11 +121,11 @@ public:
     {
         return value;
     }
-    inline void setBB(const BasicBlock *bb)
+    inline void setBB(const SVFBasicBlock* bb)
     {
         basicBlock = bb;
     }
-    inline const BasicBlock* getBB() const
+    inline const SVFBasicBlock* getBB() const
     {
         return basicBlock;
     }

package/SVF-osx/include/MemoryModel/SVFVariables.h

@@ -124,16 +124,16 @@ public:
     virtual const std::string getValueName() const = 0;
 
     /// Return the function that this SVFVar resides in. Return nullptr if it is a global or constantexpr node
-    virtual inline const Function* getFunction() const
+    virtual inline const SVFFunction* getFunction() const
     {
         if(value)
         {
             if(const Instruction* inst = SVFUtil::dyn_cast<Instruction>(value))
-                return inst->getParent()->getParent();
+                return LLVMModuleSet::getLLVMModuleSet()->getSVFFunction(inst->getParent()->getParent());
             else if (const Argument* arg = SVFUtil::dyn_cast<Argument>(value))
-                return arg->getParent();
+                return LLVMModuleSet::getLLVMModuleSet()->getSVFFunction(arg->getParent());
             else if (const Function* fun = SVFUtil::dyn_cast<Function>(value))
-                return fun;
+                return LLVMModuleSet::getLLVMModuleSet()->getSVFFunction(fun);
         }
         return nullptr;
     }

package/SVF-osx/include/MemoryModel/SymbolTableInfo.h

@@ -67,17 +67,14 @@ public:
     //{@
     /// llvm value to sym id map
     /// local (%) and global (@) identifiers are pointer types which have a value node id.
-    typedef OrderedMap<const Value *, SymID> ValueToIDMapTy;
+    typedef OrderedMap<const Value*, SymID> ValueToIDMapTy;
     /// sym id to memory object map
     typedef OrderedMap<SymID,MemObj*> IDToMemMapTy;
     /// function to sym id map
-    typedef OrderedMap<const Function *, SymID> FunToIDMapTy;
+    typedef OrderedMap<const SVFFunction*, SymID> FunToIDMapTy;
     /// struct type to struct info map
     typedef OrderedMap<const Type*, StInfo*> TypeToFieldInfoMap;
     typedef Set<CallSite> CallSiteSet;
-    typedef OrderedMap<const Instruction*,CallSiteID> CallSiteToIDMapTy;
-    typedef OrderedMap<CallSiteID,const Instruction*> IDToCallSiteMapTy;
-
     //@}
 
 private:
@@ -161,15 +158,12 @@ public:
 
     /// special value
     // @{
-    static bool isNullPtrSym(const Value *val);
-    static bool isBlackholeSym(const Value *val);
-    static bool isArgOfUncalledFunction(const Value *val);
-    static bool isReturn(const Instruction *inst);
-    static bool isPtrInUncalledFunction (const Value * value);
-    static const u32_t getBBSuccessorNum(const BasicBlock *bb);
+    static bool isBlackholeSym(const Value* val);
+    static bool isArgOfUncalledFunction(const Value* val);
+    static bool isReturn(const SVFInstruction *inst);
+    static bool isPtrInUncalledFunction (const Value*  value);
+    static const u32_t getBBSuccessorNum(const SVFBasicBlock* bb);
     static const Type* getPtrElementType(const PointerType* pty);
-    static const u32_t getBBSuccessorPos(const BasicBlock *BB, const BasicBlock *Succ);
-    static const u32_t getBBPredecessorPos(const BasicBlock *BB, const BasicBlock *Pred);
 
     static inline bool isBlkPtr(NodeID id)
     {
@@ -231,11 +225,11 @@ public:
 
     /// Get different kinds of syms
     //@{
-    SymID getValSym(const Value *val);
+    SymID getValSym(const Value* val);
 
     bool hasValSym(const Value* val);
 
-    inline SymID getObjSym(const Value *val) const
+    inline SymID getObjSym(const Value* val) const
     {
         ValueToIDMapTy::const_iterator iter = objSymMap.find(SVFUtil::getGlobalRep(val));
         assert(iter!=objSymMap.end() && "obj sym not found");
@@ -249,14 +243,14 @@ public:
         return iter->second;
     }
 
-    inline SymID getRetSym(const Function *val) const
+    inline SymID getRetSym(const SVFFunction* val) const
     {
         FunToIDMapTy::const_iterator iter =  returnSymMap.find(val);
         assert(iter!=returnSymMap.end() && "ret sym not found");
         return iter->second;
     }
 
-    inline SymID getVarargSym(const Function *val) const
+    inline SymID getVarargSym(const SVFFunction* val) const
     {
         FunToIDMapTy::const_iterator iter =  varargSymMap.find(val);
         assert(iter!=varargSymMap.end() && "vararg sym not found");
@@ -382,13 +376,13 @@ private:
     /// Type information of this object
     ObjTypeInfo* typeInfo;
     /// The unique value of this symbol/variable
-    const Value *refVal;
+    const Value* refVal;
     /// The unique id to represent this symbol
     SymID symId;
 
 public:
     /// Constructor
-    MemObj(SymID id, ObjTypeInfo* ti, const Value *val = nullptr);
+    MemObj(SymID id, ObjTypeInfo* ti, const Value* val = nullptr);
 
     /// Destructor
     virtual ~MemObj()

package/SVF-osx/include/SABER/ProgSlice.h

@@ -55,7 +55,7 @@ public:
     typedef Map<const SVFGNode*, Condition> SVFGNodeToCondMap; 	///< map a SVFGNode to its condition during value-flow guard computation
 
     typedef FIFOWorkList<const SVFGNode*> VFWorkList;		    ///< worklist for value-flow guard computation
-    typedef FIFOWorkList<const BasicBlock*> CFWorkList;	///< worklist for control-flow guard computation
+    typedef FIFOWorkList<const SVFBasicBlock*> CFWorkList;	///< worklist for control-flow guard computation
 
     /// Constructor
     ProgSlice(const SVFGNode* src, SaberCondAllocator* pa, const SVFG* graph):
@@ -246,15 +246,15 @@ protected:
 
     /// Compute guards for value-flows
     //@{
-    inline Condition ComputeIntraVFGGuard(const BasicBlock* src, const BasicBlock* dst)
+    inline Condition ComputeIntraVFGGuard(const SVFBasicBlock* src, const SVFBasicBlock* dst)
     {
         return pathAllocator->ComputeIntraVFGGuard(src,dst);
     }
-    inline Condition ComputeInterCallVFGGuard(const BasicBlock* src, const BasicBlock* dst, const BasicBlock* callBB)
+    inline Condition ComputeInterCallVFGGuard(const SVFBasicBlock* src, const SVFBasicBlock* dst, const SVFBasicBlock* callBB)
     {
         return pathAllocator->ComputeInterCallVFGGuard(src,dst,callBB);
     }
-    inline Condition ComputeInterRetVFGGuard(const BasicBlock* src, const BasicBlock* dst, const BasicBlock* retBB)
+    inline Condition ComputeInterRetVFGGuard(const SVFBasicBlock* src, const SVFBasicBlock* dst, const SVFBasicBlock* retBB)
     {
         return pathAllocator->ComputeInterRetVFGGuard(src,dst,retBB);
     }
@@ -268,7 +268,7 @@ protected:
     /// Return the basic block where a SVFGNode resides in
     /// a SVFGNode may not in a basic block if it is not a program statement
     /// (e.g. PAGEdge is an global assignment or NullPtrSVFGNode)
-    inline const BasicBlock* getSVFGNodeBB(const SVFGNode* node) const
+    inline const SVFBasicBlock* getSVFGNodeBB(const SVFGNode* node) const
     {
         const ICFGNode* icfgNode = node->getICFGNode();
         if(SVFUtil::isa<NullPtrSVFGNode>(node) == false)

package/SVF-osx/include/SABER/SaberCheckerAPI.h

@@ -101,7 +101,7 @@ public:
     {
         return getType(fun) == CK_ALLOC;
     }
-    inline bool isMemAlloc(const Instruction *inst) const
+    inline bool isMemAlloc(const SVFInstruction* inst) const
     {
         return getType(SVFUtil::getCallee(inst)) == CK_ALLOC;
     }
@@ -117,7 +117,7 @@ public:
     {
         return getType(fun) == CK_FREE;
     }
-    inline bool isMemDealloc(const Instruction *inst) const
+    inline bool isMemDealloc(const SVFInstruction *inst) const
     {
         return getType(SVFUtil::getCallee(inst)) == CK_FREE;
     }
@@ -133,7 +133,7 @@ public:
     {
         return getType(fun) == CK_FOPEN;
     }
-    inline bool isFOpen(const Instruction *inst) const
+    inline bool isFOpen(const SVFInstruction* inst) const
     {
         return getType(SVFUtil::getCallee(inst)) == CK_FOPEN;
     }
@@ -149,7 +149,7 @@ public:
     {
         return getType(fun) == CK_FCLOSE;
     }
-    inline bool isFClose(const Instruction *inst) const
+    inline bool isFClose(const SVFInstruction* inst) const
     {
         return getType(SVFUtil::getCallee(inst)) == CK_FCLOSE;
     }

package/SVF-osx/include/SABER/SaberCondAllocator.h

@@ -50,13 +50,13 @@ class SaberCondAllocator
 public:
 
     typedef Z3Expr Condition;   /// z3 condition
-    typedef Map<u32_t, const Instruction *> IndexToTermInstMap; /// id to instruction map for z3
+    typedef Map<u32_t, const SVFInstruction *> IndexToTermInstMap; /// id to instruction map for z3
     typedef Map<u32_t,Condition> CondPosMap;		///< map a branch to its Condition
-    typedef Map<const BasicBlock*, CondPosMap > BBCondMap;	/// map bb to a Condition
-    typedef Set<const BasicBlock*> BasicBlockSet;
-    typedef Map<const Function*,  BasicBlockSet> FunToExitBBsMap;  ///< map a function to all its basic blocks calling program exit
-    typedef Map<const BasicBlock*, Condition> BBToCondMap;	///< map a basic block to its condition during control-flow guard computation
-    typedef FIFOWorkList<const BasicBlock*> CFWorkList;	///< worklist for control-flow guard computation
+    typedef Map<const SVFBasicBlock*, CondPosMap > BBCondMap;	/// map bb to a Condition
+    typedef Set<const SVFBasicBlock*> BasicBlockSet;
+    typedef Map<const SVFFunction*,  BasicBlockSet> FunToExitBBsMap;  ///< map a function to all its basic blocks calling program exit
+    typedef Map<const SVFBasicBlock*, Condition> BBToCondMap;	///< map a basic block to its condition during control-flow guard computation
+    typedef FIFOWorkList<const SVFBasicBlock*> CFWorkList;	///< worklist for control-flow guard computation
 
 
     /// Constructor
@@ -118,21 +118,21 @@ public:
     }
 
     /// Allocate a new condition
-    Condition newCond(const Instruction* inst);
+    Condition newCond(const SVFInstruction* inst);
 
     /// Perform path allocation
     void allocate(const SVFModule* module);
 
     /// Get/Set instruction based on Z3 expression id
     //{@
-    inline const Instruction *getCondInst(u32_t id) const
+    inline const SVFInstruction* getCondInst(u32_t id) const
     {
         IndexToTermInstMap::const_iterator it = idToTermInstMap.find(id);
         assert(it != idToTermInstMap.end() && "this should be a fresh condition");
         return it->second;
     }
 
-    inline void setCondInst(const Condition &condition, const Instruction *inst)
+    inline void setCondInst(const Condition &condition, const SVFInstruction* inst)
     {
         assert(idToTermInstMap.find(condition.id()) == idToTermInstMap.end() && "this should be a fresh condition");
         idToTermInstMap[condition.id()] = inst;
@@ -144,38 +144,35 @@ public:
         return negConds.test(id);
     }
 
-    inline bool postDominate(const BasicBlock* bbKey, const BasicBlock* bbValue) const
+    inline bool postDominate(const SVFBasicBlock* bbKey, const SVFBasicBlock* bbValue) const
     {
-        const SVFFunction*  keyFunc = LLVMModuleSet::getLLVMModuleSet()->getSVFFunction(bbKey->getParent());
-        const SVFFunction*  valueFunc = LLVMModuleSet::getLLVMModuleSet()->getSVFFunction(bbValue->getParent());
+        const SVFFunction*  keyFunc = bbKey->getParent();
+        const SVFFunction*  valueFunc = bbValue->getParent();
         bool funcEq = (keyFunc == valueFunc);
         (void)funcEq; // Suppress warning of unused variable under release build
         assert(funcEq && "two basicblocks should be in the same function!");
-
         return keyFunc->postDominate(bbKey,bbValue);
     }
 
-    inline bool dominate(const BasicBlock* bbKey, const BasicBlock* bbValue) const
+    inline bool dominate(const SVFBasicBlock* bbKey, const SVFBasicBlock* bbValue) const
     {
-        const SVFFunction*  keyFunc = LLVMModuleSet::getLLVMModuleSet()->getSVFFunction(bbKey->getParent());
-        const SVFFunction*  valueFunc = LLVMModuleSet::getLLVMModuleSet()->getSVFFunction(bbValue->getParent());
+        const SVFFunction*  keyFunc = bbKey->getParent();
+        const SVFFunction*  valueFunc = bbValue->getParent();
         bool funcEq = (keyFunc == valueFunc);
         (void)funcEq; // Suppress warning of unused variable under release build
-
         assert(funcEq && "two basicblocks should be in the same function!");
-
         return keyFunc->dominate(bbKey,bbValue);
     }
 
     /// Guard Computation for a value-flow (between two basic blocks)
     //@{
-    virtual Condition ComputeIntraVFGGuard(const BasicBlock* src, const BasicBlock* dst);
-    virtual Condition ComputeInterCallVFGGuard(const BasicBlock* src, const BasicBlock* dst, const BasicBlock* callBB);
-    virtual Condition ComputeInterRetVFGGuard(const BasicBlock* src, const BasicBlock* dst, const BasicBlock* retBB);
+    virtual Condition ComputeIntraVFGGuard(const SVFBasicBlock* src, const SVFBasicBlock* dst);
+    virtual Condition ComputeInterCallVFGGuard(const SVFBasicBlock* src, const SVFBasicBlock* dst, const SVFBasicBlock* callBB);
+    virtual Condition ComputeInterRetVFGGuard(const SVFBasicBlock* src, const SVFBasicBlock* dst, const SVFBasicBlock* retBB);
 
     /// Get complement condition (from B1 to B0) according to a complementBB (BB2) at a phi
     /// e.g., B0: dstBB; B1:incomingBB; B2:complementBB
-    virtual Condition getPHIComplementCond(const BasicBlock* BB1, const BasicBlock* BB2, const BasicBlock* BB0);
+    virtual Condition getPHIComplementCond(const SVFBasicBlock* BB1, const SVFBasicBlock* BB2, const SVFBasicBlock* BB0);
 
     inline void clearCFCond()
     {
@@ -215,7 +212,7 @@ public:
 
     /// Get/Set control-flow conditions
     //@{
-    inline bool setCFCond(const BasicBlock* bb, const Condition& cond)
+    inline bool setCFCond(const SVFBasicBlock* bb, const Condition& cond)
     {
         BBToCondMap::iterator it = bbToCondMap.find(bb);
         // until a fixed-point is reached (condition is not changed)
@@ -225,7 +222,7 @@ public:
         bbToCondMap[bb] = cond;
         return true;
     }
-    inline Condition getCFCond(const BasicBlock* bb) const
+    inline Condition getCFCond(const SVFBasicBlock* bb) const
     {
         BBToCondMap::const_iterator it = bbToCondMap.find(bb);
         if(it==bbToCondMap.end())
@@ -238,7 +235,7 @@ public:
 
 
     /// mark neg Z3 expression
-    inline void setNegCondInst(const Condition &condition, const Instruction *inst)
+    inline void setNegCondInst(const Condition &condition, const SVFInstruction* inst)
     {
         setCondInst(condition, inst);
         negConds.set(condition.id());
@@ -246,30 +243,30 @@ public:
 private:
 
     /// Allocate path condition for every basic block
-    virtual void allocateForBB(const BasicBlock& bb);
+    virtual void allocateForBB(const SVFBasicBlock& bb);
 
     /// Get/Set a branch condition, and its terminator instruction
     //@{
     /// Set branch condition
-    void setBranchCond(const BasicBlock *bb, const BasicBlock *succ, const Condition& cond);
+    void setBranchCond(const SVFBasicBlock* bb, const SVFBasicBlock* succ, const Condition& cond);
     /// Get branch condition
-    Condition getBranchCond(const BasicBlock * bb, const BasicBlock *succ) const;
+    Condition getBranchCond(const SVFBasicBlock*  bb, const SVFBasicBlock* succ) const;
     ///Get a condition, evaluate the value for conditions if necessary (e.g., testNull like express)
-    Condition getEvalBrCond(const BasicBlock * bb, const BasicBlock *succ);
+    Condition getEvalBrCond(const SVFBasicBlock*  bb, const SVFBasicBlock* succ);
     //@}
     /// Evaluate branch conditions
     //@{
     /// Evaluate the branch condtion
-    Condition evaluateBranchCond(const BasicBlock * bb, const BasicBlock *succ) ;
+    Condition evaluateBranchCond(const SVFBasicBlock*  bb, const SVFBasicBlock* succ) ;
     /// Evaluate loop exit branch
-    Condition evaluateLoopExitBranch(const BasicBlock * bb, const BasicBlock *succ);
+    Condition evaluateLoopExitBranch(const SVFBasicBlock*  bb, const SVFBasicBlock* succ);
     /// Return branch condition after evaluating test null like expression
-    Condition evaluateTestNullLikeExpr(const BranchStmt* branchStmt, const BasicBlock *succ);
+    Condition evaluateTestNullLikeExpr(const BranchStmt* branchStmt, const SVFBasicBlock* succ);
     /// Return condition when there is a branch calls program exit
-    Condition evaluateProgExit(const BranchStmt* branchStmt, const BasicBlock *succ);
+    Condition evaluateProgExit(const BranchStmt* branchStmt, const SVFBasicBlock* succ);
     /// Collect basic block contains program exit function call
-    void collectBBCallingProgExit(const BasicBlock& bb);
-    bool isBBCallsProgExit(const BasicBlock* bb);
+    void collectBBCallingProgExit(const SVFBasicBlock& bb);
+    bool isBBCallsProgExit(const SVFBasicBlock* bb);
     //@}
 
     /// Evaluate test null/not null like expressions

package/SVF-osx/include/SVF-FE/BasicTypes.h

@@ -88,6 +88,9 @@ typedef llvm::LoopInfo LoopInfo;
 typedef llvm::User User;
 
 // LLVM Instructions
+typedef llvm::CallInst CallInst;
+typedef llvm::StoreInst StoreInst;
+typedef llvm::LoadInst LoadInst;
 typedef llvm::AllocaInst AllocaInst;
 typedef llvm::AtomicCmpXchgInst AtomicCmpXchgInst;
 typedef llvm::AtomicRMWInst AtomicRMWInst;
@@ -183,6 +186,7 @@ namespace dwarf = llvm::dwarf;
 
 // Iterators.
 typedef llvm::inst_iterator inst_iterator;
+typedef llvm::const_inst_iterator const_inst_iterator;
 typedef llvm::gep_type_iterator gep_type_iterator;
 typedef llvm::bridge_gep_iterator bridge_gep_iterator;
 typedef llvm::const_inst_iterator const_inst_iterator;
@@ -204,6 +208,12 @@ typedef llvm::VectorType VectorType;
 typedef llvm::FunctionCallee FunctionCallee;
 #endif
 
+/// LLVM Iterators
+#if LLVM_VERSION_MAJOR >= 11
+typedef llvm::const_succ_iterator succ_const_iterator;
+#else
+typedef llvm::succ_const_iterator succ_const_iterator;
+#endif
 } // End namespace SVF
 
 #endif  // SVF_FE_BASIC_TYPES_H

package/SVF-osx/include/SVF-FE/CPPUtil.h

@@ -31,6 +31,7 @@
 #define CPPUtil_H_
 
 #include "Util/BasicTypes.h"
+#include "SVF-FE/BasicTypes.h"
 
 namespace SVF
 {
@@ -53,13 +54,13 @@ struct DemangledName
 struct DemangledName demangle(const std::string &name);
 
 std::string getBeforeBrackets(const std::string &name);
-bool isValVtbl(const Value *val);
+bool isValVtbl(const Value* val);
 bool isLoadVtblInst(const LoadInst *loadInst);
 bool isVirtualCallSite(CallSite cs);
-bool isConstructor(const Function *F);
-bool isDestructor(const Function *F);
-bool isCPPThunkFunction(const Function *F);
-const Function *getThunkTarget(const Function *F);
+bool isConstructor(const Function* F);
+bool isDestructor(const Function* F);
+bool isCPPThunkFunction(const Function* F);
+const Function* getThunkTarget(const Function* F);
 
 /*
  * VtableA = {&A::foo}
@@ -83,10 +84,10 @@ const Function *getThunkTarget(const Function *F);
  * getClassNameFromType(type of p) return type A
  */
 const Argument* getConstructorThisPtr(const Function* fun);
-const Value *getVCallThisPtr(CallSite cs);
-const Value *getVCallVtblPtr(CallSite cs);
+const Value* getVCallThisPtr(CallSite cs);
+const Value* getVCallVtblPtr(CallSite cs);
 u64_t getVCallIdx(CallSite cs);
-std::string getClassNameFromVtblObj(const Value *value);
+std::string getClassNameFromVtblObj(const Value* value);
 std::string getClassNameFromType(const Type *ty);
 std::string getClassNameOfThisPtr(CallSite cs);
 std::string getFunNameOfVCallSite(CallSite cs);