svf-lib 1.0.992 → 1.0.995

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

@@ -83,10 +83,11 @@ public:
     SVFModule* buildSVFModule(Module &mod);
     SVFModule* buildSVFModule(const std::vector<std::string> &moduleNameVec);
 
-	inline SVFModule* getSVFModule() {
-		assert(svfModule && "svfModule has not been built yet!");
-		return svfModule;
-	}
+    inline SVFModule* getSVFModule()
+    {
+        assert(svfModule && "svfModule has not been built yet!");
+        return svfModule;
+    }
 
     void preProcessBCs(std::vector<std::string> &moduleNameVec);
 
@@ -148,15 +149,15 @@ public:
 
     bool hasDeclaration(const SVFFunction *fun) const
     {
-    	if(fun->isDeclaration() && !hasDefinition(fun))
-    		return false;
+        if(fun->isDeclaration() && !hasDefinition(fun))
+            return false;
 
-    	const SVFFunction* funDef = fun;
+        const SVFFunction* funDef = fun;
         if(fun->isDeclaration() && hasDefinition(fun))
-        	funDef = getDefinition(fun);
+            funDef = getDefinition(fun);
 
-    	FunDefToDeclsMapTy::const_iterator it = FunDefToDeclsMap.find(funDef);
-    	return it != FunDefToDeclsMap.end();
+        FunDefToDeclsMapTy::const_iterator it = FunDefToDeclsMap.find(funDef);
+        return it != FunDefToDeclsMap.end();
     }
 
     const FunctionSetType& getDeclaration(const Function *fun) const
@@ -166,9 +167,9 @@ public:
 
     const FunctionSetType& getDeclaration(const SVFFunction *fun) const
     {
-    	const SVFFunction* funDef = fun;
+        const SVFFunction* funDef = fun;
         if(fun->isDeclaration() && hasDefinition(fun))
-        	funDef = getDefinition(fun);
+            funDef = getDefinition(fun);
 
         FunDefToDeclsMapTy::const_iterator it = FunDefToDeclsMap.find(funDef);
         assert(it != FunDefToDeclsMap.end() && "does not have a function definition (body)?");

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

@@ -406,10 +406,10 @@ bool isObject (const Value * ref);
 /// Return true if the value refers to constant data, e.g., i32 0
 inline bool isConstantData(const Value* val)
 {
-	return SVFUtil::isa<ConstantData>(val)
-			|| SVFUtil::isa<ConstantAggregate>(val)
-			|| SVFUtil::isa<MetadataAsValue>(val)
-			|| SVFUtil::isa<BlockAddress>(val);
+    return SVFUtil::isa<ConstantData>(val)
+           || SVFUtil::isa<ConstantAggregate>(val)
+           || SVFUtil::isa<MetadataAsValue>(val)
+           || SVFUtil::isa<BlockAddress>(val);
 }
 
 /// Method for dead function, which does not have any possible caller

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

@@ -130,8 +130,9 @@ public:
     {
         visitCallSite(&II);
     }
-    void visitCallBrInst(CallBrInst &I) {
-      return visitCallSite(&I);
+    void visitCallBrInst(CallBrInst &I)
+    {
+        return visitCallSite(&I);
     }
     void visitCallSite(CallSite cs);
     void visitReturnInst(ReturnInst &I);
@@ -155,9 +156,9 @@ public:
     /// TODO: var arguments need to be handled.
     /// https://llvm.org/docs/LangRef.html#id1911
     void visitVAArgInst(VAArgInst&);
-    void visitVACopyInst(VACopyInst&){}
-    void visitVAEndInst(VAEndInst&){}
-    void visitVAStartInst(VAStartInst&){}
+    void visitVACopyInst(VACopyInst&) {}
+    void visitVAEndInst(VAEndInst&) {}
+    void visitVAStartInst(VAStartInst&) {}
 
     /// <result> = freeze ty <val>
     /// If <val> is undef or poison, ‘freeze’ returns an arbitrary, but fixed value of type `ty`
@@ -293,7 +294,8 @@ protected:
     /// Add Address edge
     inline AddrStmt* addAddrEdge(NodeID src, NodeID dst)
     {
-        if(AddrStmt *edge = pag->addAddrStmt(src, dst)){
+        if(AddrStmt *edge = pag->addAddrStmt(src, dst))
+        {
             setCurrentBBAndValueForPAGEdge(edge);
             return edge;
         }
@@ -302,7 +304,8 @@ protected:
     /// Add Copy edge
     inline CopyStmt* addCopyEdge(NodeID src, NodeID dst)
     {
-        if(CopyStmt *edge = pag->addCopyStmt(src, dst)){
+        if(CopyStmt *edge = pag->addCopyStmt(src, dst))
+        {
             setCurrentBBAndValueForPAGEdge(edge);
             return edge;
         }
@@ -339,8 +342,9 @@ protected:
         if(UnaryOPStmt *edge = pag->addUnaryOPStmt(src, dst, opcode))
             setCurrentBBAndValueForPAGEdge(edge);
     }
-    /// Add Branch statement 
-    inline void addBranchStmt(NodeID br, NodeID cond, const BranchStmt::SuccAndCondPairVec& succs){
+    /// Add Branch statement
+    inline void addBranchStmt(NodeID br, NodeID cond, const BranchStmt::SuccAndCondPairVec& succs)
+    {
         if(BranchStmt *edge = pag->addBranchStmt(br, cond, succs))
             setCurrentBBAndValueForPAGEdge(edge);
     }

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

@@ -39,7 +39,7 @@
 namespace SVF
 {
 
-class SymbolTableBuilder 
+class SymbolTableBuilder
 {
 
 private:
@@ -47,7 +47,8 @@ private:
 
 public:
     /// Constructor
-    SymbolTableBuilder(SymbolTableInfo* si): symInfo(si){
+    SymbolTableBuilder(SymbolTableInfo* si): symInfo(si)
+    {
     }
 
     /// Start building memory model

package/SVF-osx/include/Util/BDDExpr.h

@@ -36,9 +36,11 @@
 #include "CUDD/cuddInt.h"
 #include "z3++.h"
 
-namespace SVF {
+namespace SVF
+{
 
-class BDDExprManager {
+class BDDExprManager
+{
 public:
     typedef DdNode BDDExpr;
     typedef Map<u32_t, BDDExpr *> IndexToBDDExpr;
@@ -47,11 +49,13 @@ private:
     IndexToBDDExpr indexToBddCondMap;
     DdManager *m_bdd_mgr;
 
-    inline BDDExpr *BddOne() const {
+    inline BDDExpr *BddOne() const
+    {
         return Cudd_ReadOne(m_bdd_mgr);
     }
 
-    inline BDDExpr *BddZero() const {
+    inline BDDExpr *BddZero() const
+    {
         return Cudd_ReadLogicZero(m_bdd_mgr);
     }
 
@@ -65,7 +69,8 @@ public:
     //@{
     static BDDExprManager *getBDDExprMgr();
 
-    static void releaseBDDExprMgr() {
+    static void releaseBDDExprMgr()
+    {
         delete bddExprMgr;
         bddExprMgr = nullptr;
     }
@@ -74,7 +79,8 @@ public:
     /// Destructor
     virtual ~BDDExprManager();
 
-    BDDExpr *createCond(u32_t i) {
+    BDDExpr *createCond(u32_t i)
+    {
         assert(indexToBddCondMap.find(i) == indexToBddCondMap.end() &&
                "This should be fresh index to create new BDD");
         BDDExpr *bddCond = Cudd_bddIthVar(m_bdd_mgr, i);
@@ -85,18 +91,21 @@ public:
     virtual BDDExpr *createFreshBranchCond(const Instruction *inst);
 
     /// Return the number of condition expressions
-    virtual inline u32_t getCondNumber() {
+    virtual inline u32_t getCondNumber()
+    {
         return Cudd_ReadNodeCount(m_bdd_mgr);
     }
 
 
     /// Return the unique true condition
-    inline BDDExpr *getTrueCond() const {
+    inline BDDExpr *getTrueCond() const
+    {
         return trueCond;
     }
 
     /// Return the unique false condition
-    inline BDDExpr *getFalseCond() const {
+    inline BDDExpr *getFalseCond() const
+    {
         return falseCond;
     }
 
@@ -109,17 +118,20 @@ public:
     virtual BDDExpr *NEG(BDDExpr *lhs);
     //@}
 
-    virtual bool isNegCond(const BDDExpr *cond) {
+    virtual bool isNegCond(const BDDExpr *cond)
+    {
         return false;
     }
 
     /// Whether the condition is satisfiable
-    virtual bool isSatisfiable(const BDDExpr *cond) {
+    virtual bool isSatisfiable(const BDDExpr *cond)
+    {
         return cond != getFalseCond();
     }
 
     /// Whether lhs and rhs are equivalent branch conditions
-    virtual bool isEquivalentBranchCond(const BDDExpr *lhs, const BDDExpr *rhs){
+    virtual bool isEquivalentBranchCond(const BDDExpr *lhs, const BDDExpr *rhs)
+    {
         return lhs == rhs;
     }
 
@@ -127,7 +139,8 @@ public:
     bool isAllPathReachable(const BDDExpr *e);
 
     /// Get condition using condition id (z3 ast id)
-    virtual BDDExpr *getCond(u32_t id) {
+    virtual BDDExpr *getCond(u32_t id)
+    {
         auto it = indexToBddCondMap.find(id);
         assert(it != indexToBddCondMap.end() && "condition not found!");
         return it->second;
@@ -135,13 +148,15 @@ public:
 
     /// Get/Set llvm conditional expression
     //{@
-    inline const Instruction *getCondInst(const BDDExpr *cond) const {
+    inline const Instruction *getCondInst(const BDDExpr *cond) const
+    {
         CondToTermInstMap::const_iterator it = condToInstMap.find(cond);
         assert(it != condToInstMap.end() && "this should be a fresh condition");
         return it->second;
     }
 
-    inline void setCondInst(const BDDExpr *cond, const Instruction *inst) {
+    inline void setCondInst(const BDDExpr *cond, const Instruction *inst)
+    {
         assert(condToInstMap.find(cond) == condToInstMap.end() && "this should be a fresh condition");
         condToInstMap[cond] = inst;
     }
@@ -161,7 +176,8 @@ public:
 
     std::string dumpStr(const BDDExpr *e) const;
 
-    inline std::string getMemUsage() {
+    inline std::string getMemUsage()
+    {
         return std::to_string(Cudd_ReadMemoryInUse(m_bdd_mgr));
     }
 

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

@@ -84,9 +84,9 @@ typedef llvm::Use Use;
 typedef llvm::Loop Loop;
 typedef llvm::LoopInfo LoopInfo;
 #if LLVM_VERSION_MAJOR >= 12
-    typedef llvm::UnifyFunctionExitNodesLegacyPass UnifyFunctionExitNodes;
+typedef llvm::UnifyFunctionExitNodesLegacyPass UnifyFunctionExitNodes;
 #else
-    typedef llvm::UnifyFunctionExitNodes UnifyFunctionExitNodes;
+typedef llvm::UnifyFunctionExitNodes UnifyFunctionExitNodes;
 #endif
 typedef llvm::ModulePass ModulePass;
 
@@ -150,9 +150,9 @@ typedef llvm::LoopInfoWrapperPass LoopInfoWrapperPass;
 /// LLVM Iterators
 typedef llvm::inst_iterator inst_iterator;
 #if LLVM_VERSION_MAJOR >= 11
-    typedef llvm::const_succ_iterator succ_const_iterator;
+typedef llvm::const_succ_iterator succ_const_iterator;
 #else
-    typedef llvm::succ_const_iterator succ_const_iterator;
+typedef llvm::succ_const_iterator succ_const_iterator;
 #endif
 typedef llvm::const_inst_iterator const_inst_iterator;
 typedef llvm::const_pred_iterator const_pred_iterator;
@@ -251,32 +251,82 @@ public:
 
 };
 
-class CallSite {
+class CallSite
+{
 private:
     CallBase *CB;
 public:
     CallSite(Instruction *I) : CB(SVFUtil::dyn_cast<CallBase>(I)) {}
     CallSite(Value *I) : CB(SVFUtil::dyn_cast<CallBase>(I)) {}
 
-    CallBase *getInstruction() const { return CB; }
+    CallBase *getInstruction() const
+    {
+        return CB;
+    }
     using arg_iterator = User::const_op_iterator;
-    Value *getArgument(unsigned ArgNo) const { return CB->getArgOperand(ArgNo);}
-    Type *getType() const { return CB->getType(); }
-    User::const_op_iterator arg_begin() const { return CB->arg_begin();}
-    User::const_op_iterator arg_end() const { return CB->arg_end();}
-    unsigned arg_size() const { return CB->arg_size(); }
-    bool arg_empty() const { return CB->arg_empty(); }
-    Value *getArgOperand(unsigned i) const { return CB->getArgOperand(i); }
-    unsigned getNumArgOperands() const { return CB->arg_size(); }
-    Function *getCalledFunction() const { return CB->getCalledFunction(); }
-    Value *getCalledValue() const { return CB->getCalledOperand(); }
-    Function *getCaller() const { return CB->getCaller(); }
-    FunctionType *getFunctionType() const { return CB->getFunctionType(); }
-    bool paramHasAttr(unsigned ArgNo, llvm::Attribute::AttrKind Kind) const { return CB->paramHasAttr(ArgNo, Kind); }
-
-    bool operator==(const CallSite &CS) const { return CB == CS.CB; }
-    bool operator!=(const CallSite &CS) const { return CB != CS.CB; }
-    bool operator<(const CallSite &CS) const {
+    Value *getArgument(unsigned ArgNo) const
+    {
+        return CB->getArgOperand(ArgNo);
+    }
+    Type *getType() const
+    {
+        return CB->getType();
+    }
+    User::const_op_iterator arg_begin() const
+    {
+        return CB->arg_begin();
+    }
+    User::const_op_iterator arg_end() const
+    {
+        return CB->arg_end();
+    }
+    unsigned arg_size() const
+    {
+        return CB->arg_size();
+    }
+    bool arg_empty() const
+    {
+        return CB->arg_empty();
+    }
+    Value *getArgOperand(unsigned i) const
+    {
+        return CB->getArgOperand(i);
+    }
+    unsigned getNumArgOperands() const
+    {
+        return CB->arg_size();
+    }
+    Function *getCalledFunction() const
+    {
+        return CB->getCalledFunction();
+    }
+    Value *getCalledValue() const
+    {
+        return CB->getCalledOperand();
+    }
+    Function *getCaller() const
+    {
+        return CB->getCaller();
+    }
+    FunctionType *getFunctionType() const
+    {
+        return CB->getFunctionType();
+    }
+    bool paramHasAttr(unsigned ArgNo, llvm::Attribute::AttrKind Kind) const
+    {
+        return CB->paramHasAttr(ArgNo, Kind);
+    }
+
+    bool operator==(const CallSite &CS) const
+    {
+        return CB == CS.CB;
+    }
+    bool operator!=(const CallSite &CS) const
+    {
+        return CB != CS.CB;
+    }
+    bool operator<(const CallSite &CS) const
+    {
         return getInstruction() < CS.getInstruction();
     }
 
@@ -292,8 +342,10 @@ OutStream& operator<< (OutStream &o, const std::pair<F, S> &var)
 } // End namespace SVF
 
 /// Specialise hash for CallSites.
-template <> struct std::hash<SVF::CallSite> {
-    size_t operator()(const SVF::CallSite &cs) const {
+template <> struct std::hash<SVF::CallSite>
+{
+    size_t operator()(const SVF::CallSite &cs) const
+    {
         std::hash<SVF::Instruction *> h;
         return h(cs.getInstruction());
     }

package/SVF-osx/include/Util/CoreBitVector.h

@@ -203,7 +203,8 @@ private:
 template <>
 struct Hash<CoreBitVector>
 {
-    size_t operator()(const CoreBitVector &cbv) const {
+    size_t operator()(const CoreBitVector &cbv) const
+    {
         return cbv.hash();
     }
 };

package/SVF-osx/include/Util/CxtStmt.h

@@ -455,36 +455,46 @@ private:
 
 } // End namespace SVF
 // Specialise has for class defined in this header file
-template <> struct std::hash<SVF::CxtThread> {
-	size_t operator()(const SVF::CxtThread& cs) const {
-		std::hash<SVF::CallStrCxt> h;
-		return h(cs.getContext());
-	}
+template <> struct std::hash<SVF::CxtThread>
+{
+    size_t operator()(const SVF::CxtThread& cs) const
+    {
+        std::hash<SVF::CallStrCxt> h;
+        return h(cs.getContext());
+    }
 };
-template <> struct std::hash<SVF::CxtThreadProc> {
-	size_t operator()(const SVF::CxtThreadProc& ctp) const {
-		std::hash<SVF::NodeID> h;
-		return h(ctp.getTid());
-	}
+template <> struct std::hash<SVF::CxtThreadProc>
+{
+    size_t operator()(const SVF::CxtThreadProc& ctp) const
+    {
+        std::hash<SVF::NodeID> h;
+        return h(ctp.getTid());
+    }
 };
-template <> struct std::hash<SVF::CxtThreadStmt> {
-	size_t operator()(const SVF::CxtThreadStmt& cts) const {
-		std::hash<SVF::NodeID> h;
-		return h(cts.getTid());
-	}
+template <> struct std::hash<SVF::CxtThreadStmt>
+{
+    size_t operator()(const SVF::CxtThreadStmt& cts) const
+    {
+        std::hash<SVF::NodeID> h;
+        return h(cts.getTid());
+    }
 };
-template <> struct std::hash<SVF::CxtStmt> {
-	size_t operator()(const SVF::CxtStmt& cs) const {
-		std::hash<SVF::Instruction*> h;
-		SVF::Instruction* inst = const_cast<SVF::Instruction*> (cs.getStmt());
-		return h(inst);
-	}
+template <> struct std::hash<SVF::CxtStmt>
+{
+    size_t operator()(const SVF::CxtStmt& cs) const
+    {
+        std::hash<SVF::Instruction*> h;
+        SVF::Instruction* inst = const_cast<SVF::Instruction*> (cs.getStmt());
+        return h(inst);
+    }
 };
-template <> struct std::hash<SVF::CxtProc> {
-	size_t operator()(const SVF::CxtProc& cs) const {
-		std::hash<SVF::SVFFunction*> h;
-		SVF::SVFFunction* fun = const_cast<SVF::SVFFunction*> (cs.getProc());
-		return h(fun);
-	}
+template <> struct std::hash<SVF::CxtProc>
+{
+    size_t operator()(const SVF::CxtProc& cs) const
+    {
+        std::hash<SVF::SVFFunction*> h;
+        SVF::SVFFunction* fun = const_cast<SVF::SVFFunction*> (cs.getProc());
+        return h(fun);
+    }
 };
 #endif /* INCLUDE_UTIL_CXTSTMT_H_ */

package/SVF-osx/include/Util/ExeState.h

@@ -31,12 +31,14 @@
 #include "Util/Z3Expr.h"
 #include "MemoryModel/SVFVariables.h"
 
-namespace SVF {
+namespace SVF
+{
 
 #define AddressMask 0x7f000000
 #define FlippedAddressMask (AddressMask^0xffffffff)
 
-class ExeState {
+class ExeState
+{
 public:
     typedef Map<u32_t, Z3Expr> VarToValMap;
     typedef VarToValMap LocToValMap;
@@ -50,11 +52,12 @@ public:
     ExeState() : pathConstraint(getContext().bool_val(true)) {}
 
     ExeState(const Z3Expr &_pc, VarToValMap &_varToValMap, LocToValMap &_locToValMap) : varToVal(_varToValMap),
-                                                                                        locToVal(_locToValMap),
-                                                                                        pathConstraint(_pc) {}
+        locToVal(_locToValMap),
+        pathConstraint(_pc) {}
 
     ExeState(const ExeState &rhs) : varToVal(rhs.getVarToVal()), locToVal(rhs.getLocToVal()),
-                                    pathConstraint(rhs.getPathConstraint()) {
+        pathConstraint(rhs.getPathConstraint())
+    {
 
     }
 
@@ -66,7 +69,8 @@ public:
     bool operator==(const ExeState &rhs) const;
 
     /// Overloading Operator!=
-    inline bool operator!=(const ExeState &rhs) const {
+    inline bool operator!=(const ExeState &rhs) const
+    {
         return !(*this == rhs);
     }
 
@@ -75,27 +79,33 @@ public:
 
 
 
-    z3::context &getContext() {
+    z3::context &getContext()
+    {
         return Z3Expr::getContext();
     }
 
-    const VarToValMap &getVarToVal() const {
+    const VarToValMap &getVarToVal() const
+    {
         return varToVal;
     }
 
-    const LocToValMap &getLocToVal() const {
+    const LocToValMap &getLocToVal() const
+    {
         return locToVal;
     }
 
-    const Z3Expr &getPathConstraint() const {
+    const Z3Expr &getPathConstraint() const
+    {
         return pathConstraint;
     }
 
-    void setPathConstraint(const Z3Expr &pc) {
+    void setPathConstraint(const Z3Expr &pc)
+    {
         pathConstraint = pc.simplify();
     }
 
-    inline Z3Expr &operator[](u32_t varId) {
+    inline Z3Expr &operator[](u32_t varId)
+    {
         return getZ3Expr(varId);
     }
 
@@ -115,22 +125,26 @@ public:
     Z3Expr &load(const Z3Expr &loc);
 
     /// The physical address starts with 0x7f...... + idx
-    inline u32_t getVirtualMemAddress(u32_t idx) const {
+    inline u32_t getVirtualMemAddress(u32_t idx) const
+    {
         return AddressMask + idx;
     }
 
     /// Check bit value of val start with 0x7F000000, filter by 0xFF000000
-    inline bool isVirtualMemAddress(u32_t val) {
+    inline bool isVirtualMemAddress(u32_t val)
+    {
         return (val & 0xff000000) == AddressMask;
     }
 
     /// Return the internal index if idx is an address otherwise return the value of idx
-    inline u32_t getInternalID(u32_t idx) const {
+    inline u32_t getInternalID(u32_t idx) const
+    {
         return (idx & FlippedAddressMask);
     }
 
     /// Return int value from an expression if it is a numeral, otherwise return an approximate value
-    inline s32_t z3Expr2NumValue(const Z3Expr &e) {
+    inline s32_t z3Expr2NumValue(const Z3Expr &e)
+    {
         assert(e.is_numeral() && "not numeral?");
         return e.get_numeral_int64();
     }
@@ -142,30 +156,36 @@ private:
     bool eqVarToValMap(const VarToValMap &lhs, const VarToValMap &rhs) const;
     bool lessThanVarToValMap(const VarToValMap &lhs, const VarToValMap &rhs) const;
 protected:
-    inline void store(u32_t objId, const Z3Expr &z3Expr) {
+    inline void store(u32_t objId, const Z3Expr &z3Expr)
+    {
         locToVal[objId] = z3Expr.simplify();
     }
 
-    inline Z3Expr &load(u32_t objId) {
+    inline Z3Expr &load(u32_t objId)
+    {
         return locToVal[objId];
     }
 };
 }
 
 template<>
-struct std::hash<SVF::ExeState> {
-    size_t operator()(const SVF::ExeState &exeState) const {
+struct std::hash<SVF::ExeState>
+{
+    size_t operator()(const SVF::ExeState &exeState) const
+    {
 
         size_t h = exeState.getVarToVal().size() * 2;
         SVF::Hash<SVF::u32_t> hf;
-        for (const auto &t: exeState.getVarToVal()) {
+        for (const auto &t: exeState.getVarToVal())
+        {
             h ^= hf(t.first) + 0x9e3779b9 + (h << 6) + (h >> 2);
             h ^= hf(t.second.id()) + 0x9e3779b9 + (h << 6) + (h >> 2);
         }
 
         size_t h2 = exeState.getVarToVal().size() * 2;
 
-        for (const auto &t: exeState.getLocToVal()) {
+        for (const auto &t: exeState.getLocToVal())
+        {
             h2 ^= hf(t.first) + 0x9e3779b9 + (h2 << 6) + (h2 >> 2);
             h2 ^= hf(t.second.id()) + 0x9e3779b9 + (h2 << 6) + (h2 >> 2);
         }

package/SVF-osx/include/Util/ExtAPI.h

@@ -122,7 +122,7 @@ public:
     }
 
     static void destory()
-    {   
+    {
         if (extAPI != nullptr)
         {
             delete extAPI;