svf-lib 1.0.1277 → 1.0.1279

package/SVF-linux/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-linux/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-linux/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-linux/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-linux/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);

package/SVF-linux/include/SVF-FE/DCHG.h

@@ -172,13 +172,13 @@ public:
     }
 
     /// Returns the vector of virtual function vectors.
-    const std::vector<std::vector<const Function *>> &getVfnVectors(void) const
+    const std::vector<std::vector<const Function* >> &getVfnVectors(void) const
     {
         return vfnVectors;
     }
 
     /// Return the nth virtual function vector in the vtable.
-    std::vector<const Function *> &getVfnVector(unsigned n)
+    std::vector<const Function* > &getVfnVector(unsigned n)
     {
         if (vfnVectors.size() < n + 1)
         {
@@ -197,7 +197,7 @@ private:
     std::string typeName;
     size_t flags;
     /// The virtual functions which this class actually defines/overrides.
-    std::vector<const Function *> primaryVTable;
+    std::vector<const Function* > primaryVTable;
     /// If a vtable is split into more than one vfn vector for multiple inheritance,
     /// 0 would be the primary base + this classes virtual functions, 1 would be
     /// the second parent, 2 would be third parent, etc.
@@ -406,7 +406,7 @@ private:
     /// Retrieves the metadata associated with a *virtual* callsite.
     const DIType *getCSStaticType(CallSite cs) const
     {
-        MDNode *md = cs.getInstruction()->getMetadata(cppUtil::ctir::derefMDName);
+        MDNode *md = cs.getInstruction()->getLLVMInstruction()->getMetadata(cppUtil::ctir::derefMDName);
         assert(md != nullptr && "Missing type metadata at virtual callsite");
         DIType *diType = SVFUtil::dyn_cast<DIType>(md);
         assert(diType != nullptr && "Incorrect metadata type at virtual callsite");

package/SVF-linux/include/SVF-FE/DataFlowUtil.h

@@ -75,7 +75,7 @@ public:
     const SCEV *scev;
     const Value* start;
     const Value* step;
-    const Value *ptr;
+    const Value* ptr;
     bool inloop;
     unsigned tripcount;
 

package/SVF-linux/include/SVF-FE/GEPTypeBridgeIterator.h

@@ -95,7 +95,7 @@ public:
         return operator*();
     }
 
-    Value *getOperand() const
+    Value* getOperand() const
     {
         return const_cast<Value*>(&**OpIt);
     }

package/SVF-linux/include/SVF-FE/ICFGBuilder.h

@@ -41,14 +41,14 @@ class ICFGBuilder
 
 public:
 
-    typedef std::vector<const Instruction*> InstVec;
-    typedef Set<const Instruction*> BBSet;
+    typedef std::vector<const SVFInstruction*> InstVec;
+    typedef Set<const SVFInstruction*> BBSet;
 
 private:
     ICFG* icfg;
 
 public:
-    typedef FIFOWorkList<const Instruction*> WorkList;
+    typedef FIFOWorkList<const SVFInstruction*> WorkList;
 
     ICFGBuilder(ICFG* i): icfg(i)
     {
@@ -69,10 +69,10 @@ private:
     void connectGlobalToProgEntry(SVFModule* svfModule);
 
     /// Add/Get an inter block ICFGNode
-    InterICFGNode* getOrAddInterBlockICFGNode(const Instruction* inst);
+    InterICFGNode* getOrAddInterBlockICFGNode(const SVFInstruction* inst);
 
     /// Add/Get a basic block ICFGNode
-    inline ICFGNode* getOrAddBlockICFGNode(const Instruction* inst)
+    inline ICFGNode* getOrAddBlockICFGNode(const SVFInstruction* inst)
     {
         if(SVFUtil::isNonInstricCallSite(inst))
             return getOrAddInterBlockICFGNode(inst);
@@ -81,21 +81,21 @@ private:
     }
 
     /// Create edges between ICFG nodes across functions
-    void addICFGInterEdges(const Instruction*  cs, const SVFFunction*  callee);
+    void addICFGInterEdges(const SVFInstruction*  cs, const SVFFunction*  callee);
 
     /// Add a call node
-    inline CallICFGNode* getCallICFGNode(const Instruction*  cs)
+    inline CallICFGNode* getCallICFGNode(const SVFInstruction*  cs)
     {
         return icfg->getCallICFGNode(cs);
     }
     /// Add a return node
-    inline RetICFGNode* getRetICFGNode(const Instruction*  cs)
+    inline RetICFGNode* getRetICFGNode(const SVFInstruction*  cs)
     {
         return icfg->getRetICFGNode(cs);
     }
 
     /// Add and get IntraBlock ICFGNode
-    IntraICFGNode* getOrAddIntraBlockICFGNode(const Instruction* inst)
+    IntraICFGNode* getOrAddIntraBlockICFGNode(const SVFInstruction* inst)
     {
         return icfg->getIntraICFGNode(inst);
     }

package/SVF-linux/include/SVF-FE/IRAnnotator.h

@@ -108,17 +108,17 @@ private:
     }
 
     // Deduce the LLVM value's type, and process the metadata accordingly
-    void processPAGNode(const Value *value, SVF::NodeID nodeId, bool writeFlag)
+    void processPAGNode(const Value* value, SVF::NodeID nodeId, bool writeFlag)
     {
-        if (auto instruction = const_cast<Instruction *>(SVFUtil::dyn_cast<Instruction>(value)))
+        if (auto instruction = const_cast<Instruction* >(SVFUtil::dyn_cast<Instruction>(value)))
         {
             processInstructionNode(instruction, nodeId, writeFlag);
         }
-        else if (auto argument = const_cast<Argument *>(SVFUtil::dyn_cast<Argument>(value)))
+        else if (auto argument = const_cast<Argument* >(SVFUtil::dyn_cast<Argument>(value)))
         {
             processArgumentNode(argument, nodeId, writeFlag);
         }
-        else if (auto function = const_cast<Function *>(SVFUtil::dyn_cast<Function>(value)))
+        else if (auto function = const_cast<Function* >(SVFUtil::dyn_cast<Function>(value)))
         {
             processFunctionNode(function, nodeId, writeFlag);
         }
@@ -126,7 +126,7 @@ private:
         {
             processGlobalVarNode(globalVar, nodeId, writeFlag);
         }
-        else if (auto basicBlock = const_cast<BasicBlock *>(SVFUtil::dyn_cast<BasicBlock>(value)))
+        else if (auto basicBlock = const_cast<BasicBlock* >(SVFUtil::dyn_cast<BasicBlock>(value)))
         {
             processBasicBlockNode(basicBlock, nodeId, writeFlag);
         }
@@ -145,7 +145,7 @@ private:
         }
     }
 
-    void processInstructionNode(Instruction *instruction, const SVF::NodeID &nodeId, bool writeFlag)
+    void processInstructionNode(Instruction* instruction, const SVF::NodeID &nodeId, bool writeFlag)
     {
         std::string label = "inode-" + std::to_string(nodeId);
 
@@ -163,7 +163,7 @@ private:
         }
     }
 
-    void processArgumentNode(Argument *argument, const SVF::NodeID &nodeId, bool writeFlag)
+    void processArgumentNode(Argument* argument, const SVF::NodeID &nodeId, bool writeFlag)
     {
         std::string label = "anode-" + std::to_string(nodeId);
 
@@ -181,7 +181,7 @@ private:
         }
     }
 
-    void processFunctionNode(Function *function, const SVF::NodeID &nodeId, bool writeFlag)
+    void processFunctionNode(Function* function, const SVF::NodeID &nodeId, bool writeFlag)
     {
         std::string label = "fnode-" + std::to_string(nodeId);
 
@@ -217,7 +217,7 @@ private:
         }
     }
 
-    void processBasicBlockNode(BasicBlock *basicBlock, const SVF::NodeID &nodeId, bool writeFlag)
+    void processBasicBlockNode(BasicBlock* basicBlock, const SVF::NodeID &nodeId, bool writeFlag)
     {
         std::string label = "bnode-" + std::to_string(nodeId);