svf-lib 1.0.992 → 1.0.995

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

@@ -74,7 +74,10 @@ public:
     NodeID endSymbolAllocation(void);
 
     /// Returns the total number of memory objects.
-    NodeID getNumObjects(void) const { return numObjects; }
+    NodeID getNumObjects(void) const
+    {
+        return numObjects;
+    }
 
 private:
     /// Builds a node ID allocator with the strategy specified on the command line.
@@ -135,7 +138,7 @@ public:
         /// based on the points-to sets in pta accessed through keys.
         /// The second part of the keys pairs are the number of (potential) occurrences of that points-to set
         /// or a subset, depending on the client's wish.
-        /// TODO: interfaces are getting unwieldy, an initialised object may be better. 
+        /// TODO: interfaces are getting unwieldy, an initialised object may be better.
         /// TODO: kind of sucks pta can't be const here because getPts isn't.
         static std::vector<NodeID> cluster(BVDataPTAImpl *pta, const std::vector<std::pair<NodeID, unsigned>> keys, std::vector<std::pair<hclust_fast_methods, std::vector<NodeID>>> &candidates, std::string evalSubtitle="");
 
@@ -180,8 +183,8 @@ public:
 
         // From all the candidates, returns the best mapping for pointsToSets (points-to set -> # occurences).
         static inline std::pair<hclust_fast_methods, std::vector<NodeID>> determineBestMapping(
-            const std::vector<std::pair<hclust_fast_methods, std::vector<NodeID>>> &candidates,
-            Map<PointsTo, unsigned> pointsToSets, const std::string &evalSubtitle, double &evalTime);
+                    const std::vector<std::pair<hclust_fast_methods, std::vector<NodeID>>> &candidates,
+                    Map<PointsTo, unsigned> pointsToSets, const std::string &evalSubtitle, double &evalTime);
 
     };
 };

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

@@ -120,7 +120,7 @@ public:
     // Sparse value-flow graph (VFG.cpp)
     static const llvm::cl::opt<bool> DumpVFG;
 
-     // Location set for modeling abstract memory object (LocationSet.cpp)
+    // Location set for modeling abstract memory object (LocationSet.cpp)
     static const llvm::cl::opt<bool> SingleStride;
 
     // Base class of pointer analyses (PointerAnalysis.cpp)
@@ -180,8 +180,8 @@ public:
 
     // MTAResultValidator.cpp
     static const llvm::cl::opt<bool> PrintValidRes;
-	
-	static const llvm::cl::opt<bool> LockValid;
+
+    static const llvm::cl::opt<bool> LockValid;
     //MTAStat.cpp
     static const llvm::cl::opt<bool> AllPairMHP;
 

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

@@ -55,22 +55,26 @@ namespace SVF
 /// provide extra hash function for std::pair handling
 template <class T> struct Hash;
 
-template <class S, class T> struct Hash<std::pair<S, T>> {
+template <class S, class T> struct Hash<std::pair<S, T>>
+{
     // Pairing function from: http://szudzik.com/ElegantPairing.pdf
     static size_t szudzik(size_t a, size_t b)
     {
         return a > b ? b * b + a : a * a + a + b;
     }
 
-    size_t operator()(const std::pair<S, T> &t) const {
+    size_t operator()(const std::pair<S, T> &t) const
+    {
         Hash<decltype(t.first)> first;
         Hash<decltype(t.second)> second;
         return szudzik(first(t.first), second(t.second));
     }
 };
 
-template <class T> struct Hash {
-    size_t operator()(const T &t) const {
+template <class T> struct Hash
+{
+    size_t operator()(const T &t) const
+    {
         std::hash<T> h;
         return h(t);
     }
@@ -97,45 +101,46 @@ typedef PointsTo AliasSet;
 typedef unsigned PointsToID;
 
 template <typename Key, typename Hash = Hash<Key>, typename KeyEqual = std::equal_to<Key>,
-          typename Allocator = std::allocator<Key>> 
+          typename Allocator = std::allocator<Key>>
 using Set = std::unordered_set<Key, Hash, KeyEqual, Allocator>;
 
 template<typename Key, typename Value, typename Hash = Hash<Key>,
-    typename KeyEqual = std::equal_to<Key>,
-    typename Allocator = std::allocator<std::pair<const Key, Value>>>
-using Map = std::unordered_map<Key, Value, Hash, KeyEqual, Allocator>;
-
-template<typename Key, typename Compare = std::less<Key>, typename Allocator = std::allocator<Key>>
-using OrderedSet = std::set<Key, Compare, Allocator>;
-
-template<typename Key, typename Value, typename Compare = std::less<Key>,
+         typename KeyEqual = std::equal_to<Key>,
          typename Allocator = std::allocator<std::pair<const Key, Value>>>
-using OrderedMap = std::map<Key, Value, Compare, Allocator>;
-
-typedef llvm::SmallVector<llvm::BasicBlock*, 8> SmallBBVector;
-typedef std::pair<NodeID, NodeID> NodePair;
-typedef OrderedSet<NodeID> OrderedNodeSet;
-typedef Set<NodeID> NodeSet;
-typedef Set<NodePair> NodePairSet;
-typedef Map<NodePair,NodeID> NodePairMap;
-typedef std::vector<NodeID> NodeVector;
-typedef std::vector<EdgeID> EdgeVector;
-typedef std::stack<NodeID> NodeStack;
-typedef std::list<NodeID> NodeList;
-typedef std::deque<NodeID> NodeDeque;
-typedef NodeSet EdgeSet;
-typedef std::vector<u32_t> CallStrCxt;
-typedef llvm::StringMap<u32_t> StringMap;
-
-typedef unsigned Version;
-typedef Set<Version> VersionSet;
-typedef std::pair<NodeID, Version> VersionedVar;
-typedef Set<VersionedVar> VersionedVarSet;
+                 using Map = std::unordered_map<Key, Value, Hash, KeyEqual, Allocator>;
+
+         template<typename Key, typename Compare = std::less<Key>, typename Allocator = std::allocator<Key>>
+         using OrderedSet = std::set<Key, Compare, Allocator>;
+
+         template<typename Key, typename Value, typename Compare = std::less<Key>,
+                  typename Allocator = std::allocator<std::pair<const Key, Value>>>
+                          using OrderedMap = std::map<Key, Value, Compare, Allocator>;
+
+                  typedef llvm::SmallVector<llvm::BasicBlock*, 8> SmallBBVector;
+                  typedef std::pair<NodeID, NodeID> NodePair;
+                  typedef OrderedSet<NodeID> OrderedNodeSet;
+                  typedef Set<NodeID> NodeSet;
+                  typedef Set<NodePair> NodePairSet;
+                  typedef Map<NodePair,NodeID> NodePairMap;
+                  typedef std::vector<NodeID> NodeVector;
+                  typedef std::vector<EdgeID> EdgeVector;
+                  typedef std::stack<NodeID> NodeStack;
+                  typedef std::list<NodeID> NodeList;
+                  typedef std::deque<NodeID> NodeDeque;
+                  typedef NodeSet EdgeSet;
+                  typedef std::vector<u32_t> CallStrCxt;
+                  typedef llvm::StringMap<u32_t> StringMap;
+
+                  typedef unsigned Version;
+                  typedef Set<Version> VersionSet;
+                  typedef std::pair<NodeID, Version> VersionedVar;
+                  typedef Set<VersionedVar> VersionedVarSet;
 
 // TODO: be explicit that this is a pair of 32-bit unsigneds?
-template <> struct Hash<NodePair>
+                  template <> struct Hash<NodePair>
 {
-    size_t operator()(const NodePair &p) const {
+    size_t operator()(const NodePair &p) const
+    {
         // Make sure our assumptions are sound: use u32_t
         // and u64_t. If NodeID is not actually u32_t or size_t
         // is not u64_t we should be fine since we get a
@@ -278,8 +283,10 @@ public:
 } // End namespace SVF
 
 
-template <> struct std::hash<SVF::NodePair> {
-    size_t operator()(const SVF::NodePair &p) const {
+template <> struct std::hash<SVF::NodePair>
+{
+    size_t operator()(const SVF::NodePair &p) const
+    {
         // Make sure our assumptions are sound: use u32_t
         // and u64_t. If NodeID is not actually u32_t or size_t
         // is not u64_t we should be fine since we get a
@@ -294,7 +301,8 @@ template <> struct std::hash<SVF::NodePair> {
 template <unsigned N>
 struct std::hash<llvm::SparseBitVector<N>>
 {
-    size_t operator()(const llvm::SparseBitVector<N> &sbv) const {
+    size_t operator()(const llvm::SparseBitVector<N> &sbv) const
+    {
         SVF::Hash<std::pair<std::pair<size_t, size_t>, size_t>> h;
         return h(std::make_pair(std::make_pair(sbv.count(), sbv.find_first()), sbv.find_last()));
     }
@@ -303,7 +311,8 @@ struct std::hash<llvm::SparseBitVector<N>>
 template <typename T>
 struct std::hash<std::vector<T>>
 {
-    size_t operator()(const std::vector<T> &v) const {
+    size_t operator()(const std::vector<T> &v) const
+    {
         // TODO: repetition with CBV.
         size_t h = v.size();
 

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

@@ -73,11 +73,11 @@ public:
 
     ~SVFModule()
     {
-      for (auto * f : FunctionSet)
-        delete f;
-      NodeIDAllocator::unset();
-      ThreadAPI::destroy();
-      ExtAPI::destory();
+        for (auto * f : FunctionSet)
+            delete f;
+        NodeIDAllocator::unset();
+        ThreadAPI::destroy();
+        ExtAPI::destory();
     }
 
     static inline void setPagFromTXT(std::string txt)

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

@@ -170,8 +170,9 @@ inline bool isIntrinsicFun(const Function* func)
                  func->getIntrinsicID() == llvm::Intrinsic::dbg_addr ||
                  func->getIntrinsicID() == llvm::Intrinsic::dbg_declare ||
                  func->getIntrinsicID() == llvm::Intrinsic::dbg_label ||
-                 func->getIntrinsicID() == llvm::Intrinsic::dbg_value)) {
-            return true;
+                 func->getIntrinsicID() == llvm::Intrinsic::dbg_value))
+    {
+        return true;
     }
     return false;
 }
@@ -179,9 +180,11 @@ inline bool isIntrinsicFun(const Function* func)
 /// Return true if it is an intrinsic instruction
 inline bool isIntrinsicInst(const Instruction* inst)
 {
-    if (const llvm::CallBase* call = llvm::dyn_cast<llvm::CallBase>(inst)) {
+    if (const llvm::CallBase* call = llvm::dyn_cast<llvm::CallBase>(inst))
+    {
         const Function* func = call->getCalledFunction();
-        if (isIntrinsicFun(func)) {
+        if (isIntrinsicFun(func))
+        {
             return true;
         }
     }
@@ -197,10 +200,10 @@ inline bool isCallSite(const Instruction* inst)
 /// Whether an instruction is a call or invoke instruction
 inline bool isCallSite(const Value* val)
 {
-	if(const Instruction* inst = SVFUtil::dyn_cast<Instruction>(val))
-		return SVFUtil::isCallSite(inst);
-	else
-		return false;
+    if(const Instruction* inst = SVFUtil::dyn_cast<Instruction>(val))
+        return SVFUtil::isCallSite(inst);
+    else
+        return false;
 }
 /// Whether an instruction is a callsite in the application code, excluding llvm intrinsic calls
 inline bool isNonInstricCallSite(const Instruction* inst)
@@ -237,7 +240,7 @@ inline const SVFFunction* getFunction(StringRef name)
 }
 
 /// find the unique defined global across multiple modules
-inline const Value* getGlobalRep(const Value* val) 
+inline const Value* getGlobalRep(const Value* val)
 {
     if(const GlobalVariable* gvar = SVFUtil::dyn_cast<GlobalVariable>(val))
     {

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

@@ -32,202 +32,249 @@
 #include "z3++.h"
 #include "Util/SVFBasicTypes.h"
 
-namespace SVF {
+namespace SVF
+{
 
-    class Z3Expr {
-    public:
-        static z3::context *ctx;
+class Z3Expr
+{
+public:
+    static z3::context *ctx;
 
-    private:
-        z3::expr e;
+private:
+    z3::expr e;
 
-        Z3Expr(float f); // placeholder don't support floating point expression
-        Z3Expr(double f); // placeholder don't support floating point expression
+    Z3Expr(float f); // placeholder don't support floating point expression
+    Z3Expr(double f); // placeholder don't support floating point expression
 
-    public:
+public:
 
-        Z3Expr() : e(nullExpr()) {
-        }
+    Z3Expr() : e(nullExpr())
+    {
+    }
 
-        Z3Expr(const z3::expr &_e) : e(_e) {
-        }
+    Z3Expr(const z3::expr &_e) : e(_e)
+    {
+    }
 
-        Z3Expr(int i) : e(getContext().int_val(i)) {
-        }
+    Z3Expr(int i) : e(getContext().int_val(i))
+    {
+    }
 
-        Z3Expr(const Z3Expr &z3Expr) : e(z3Expr.getExpr()) {
-        }
+    Z3Expr(const Z3Expr &z3Expr) : e(z3Expr.getExpr())
+    {
+    }
 
-        virtual ~Z3Expr() = default;
+    virtual ~Z3Expr() = default;
 
-        inline Z3Expr &operator=(const Z3Expr &rhs) {
-            if (this->id() != rhs.id()) {
-                e = rhs.getExpr();
-            }
-            return *this;
+    inline Z3Expr &operator=(const Z3Expr &rhs)
+    {
+        if (this->id() != rhs.id())
+        {
+            e = rhs.getExpr();
         }
+        return *this;
+    }
 
-        const z3::expr &getExpr() const {
-            return e;
-        }
+    const z3::expr &getExpr() const
+    {
+        return e;
+    }
 
-        /// Get z3 context, singleton design here to make sure we only have one context
-        static z3::context &getContext() {
-            if (ctx == nullptr) {
-                ctx = new z3::context();
-            }
-            return *ctx;
+    /// Get z3 context, singleton design here to make sure we only have one context
+    static z3::context &getContext()
+    {
+        if (ctx == nullptr)
+        {
+            ctx = new z3::context();
         }
+        return *ctx;
+    }
 
-        /// release z3 context
-        static void releaseContext() {
-            delete ctx;
-            ctx = nullptr;
-        }
+    /// release z3 context
+    static void releaseContext()
+    {
+        delete ctx;
+        ctx = nullptr;
+    }
 
-        /// null expression
-        static z3::expr nullExpr() {
-            return getContext().int_const("null");
-        }
+    /// null expression
+    static z3::expr nullExpr()
+    {
+        return getContext().int_const("null");
+    }
 
-        /// get id
-        inline u32_t id() const {
-            return e.id();
-        }
+    /// get id
+    inline u32_t id() const
+    {
+        return e.id();
+    }
 
-        inline const std::string to_string() const {
-            return e.to_string();
-        }
+    inline const std::string to_string() const
+    {
+        return e.to_string();
+    }
 
-        inline bool is_numeral() const {
-            return e.is_numeral();
-        }
+    inline bool is_numeral() const
+    {
+        return e.is_numeral();
+    }
 
-        inline bool is_bool() const {
-            return e.is_bool();
-        }
+    inline bool is_bool() const
+    {
+        return e.is_bool();
+    }
 
-        inline Z3Expr simplify() const {
-            return e.simplify();
-        }
+    inline Z3Expr simplify() const
+    {
+        return e.simplify();
+    }
 
-        inline int64_t get_numeral_int64() const {
-            return e.get_numeral_int64();
-        }
+    inline int64_t get_numeral_int64() const
+    {
+        return e.get_numeral_int64();
+    }
 
-        inline int get_numeral_int() const {
-            return e.get_numeral_int();
-        }
+    inline int get_numeral_int() const
+    {
+        return e.get_numeral_int();
+    }
 
-        //{% reload operator
-        friend Z3Expr operator==(const Z3Expr &lhs, const Z3Expr &rhs) {
-            return lhs.getExpr() == rhs.getExpr();
-        }
+    //{% reload operator
+    friend Z3Expr operator==(const Z3Expr &lhs, const Z3Expr &rhs)
+    {
+        return lhs.getExpr() == rhs.getExpr();
+    }
 
-        friend Z3Expr operator!=(const Z3Expr &lhs, const Z3Expr &rhs) {
-            return lhs.getExpr() != rhs.getExpr();
-        }
+    friend Z3Expr operator!=(const Z3Expr &lhs, const Z3Expr &rhs)
+    {
+        return lhs.getExpr() != rhs.getExpr();
+    }
 
-        friend Z3Expr operator>(const Z3Expr &lhs, const Z3Expr &rhs) {
-            return lhs.getExpr() > rhs.getExpr();
-        }
+    friend Z3Expr operator>(const Z3Expr &lhs, const Z3Expr &rhs)
+    {
+        return lhs.getExpr() > rhs.getExpr();
+    }
 
-        friend Z3Expr operator<(const Z3Expr &lhs, const Z3Expr &rhs) {
-            return lhs.getExpr() < rhs.getExpr();
-        }
+    friend Z3Expr operator<(const Z3Expr &lhs, const Z3Expr &rhs)
+    {
+        return lhs.getExpr() < rhs.getExpr();
+    }
 
-        friend Z3Expr operator<=(const Z3Expr &lhs, const Z3Expr &rhs) {
-            return lhs.getExpr() <= rhs.getExpr();
-        }
+    friend Z3Expr operator<=(const Z3Expr &lhs, const Z3Expr &rhs)
+    {
+        return lhs.getExpr() <= rhs.getExpr();
+    }
 
-        friend Z3Expr operator>=(const Z3Expr &lhs, const Z3Expr &rhs) {
-            return lhs.getExpr() >= rhs.getExpr();
-        }
+    friend Z3Expr operator>=(const Z3Expr &lhs, const Z3Expr &rhs)
+    {
+        return lhs.getExpr() >= rhs.getExpr();
+    }
 
-        friend Z3Expr operator+(const Z3Expr &lhs, const Z3Expr &rhs) {
-            return lhs.getExpr() + rhs.getExpr();
-        }
+    friend Z3Expr operator+(const Z3Expr &lhs, const Z3Expr &rhs)
+    {
+        return lhs.getExpr() + rhs.getExpr();
+    }
 
-        friend Z3Expr operator-(const Z3Expr &lhs, const Z3Expr &rhs) {
-            return lhs.getExpr() - rhs.getExpr();
-        }
+    friend Z3Expr operator-(const Z3Expr &lhs, const Z3Expr &rhs)
+    {
+        return lhs.getExpr() - rhs.getExpr();
+    }
 
-        friend Z3Expr operator*(const Z3Expr &lhs, const Z3Expr &rhs) {
-            return lhs.getExpr() * rhs.getExpr();
-        }
+    friend Z3Expr operator*(const Z3Expr &lhs, const Z3Expr &rhs)
+    {
+        return lhs.getExpr() * rhs.getExpr();
+    }
 
-        friend Z3Expr operator/(const Z3Expr &lhs, const Z3Expr &rhs) {
-            return lhs.getExpr() / rhs.getExpr();
-        }
+    friend Z3Expr operator/(const Z3Expr &lhs, const Z3Expr &rhs)
+    {
+        return lhs.getExpr() / rhs.getExpr();
+    }
 
-        friend Z3Expr operator%(const Z3Expr &lhs, const Z3Expr &rhs) {
-            return lhs.getExpr() % rhs.getExpr();
-        }
+    friend Z3Expr operator%(const Z3Expr &lhs, const Z3Expr &rhs)
+    {
+        return lhs.getExpr() % rhs.getExpr();
+    }
 
-        friend Z3Expr operator^(const Z3Expr &lhs, const Z3Expr &rhs) {
-            return lhs.getExpr() ^ rhs.getExpr();
-        }
+    friend Z3Expr operator^(const Z3Expr &lhs, const Z3Expr &rhs)
+    {
+        return lhs.getExpr() ^ rhs.getExpr();
+    }
 
-        friend Z3Expr operator&(const Z3Expr &lhs, const Z3Expr &rhs) {
-            return lhs.getExpr() & rhs.getExpr();
-        }
+    friend Z3Expr operator&(const Z3Expr &lhs, const Z3Expr &rhs)
+    {
+        return lhs.getExpr() & rhs.getExpr();
+    }
 
-        friend Z3Expr operator|(const Z3Expr &lhs, const Z3Expr &rhs) {
-            return lhs.getExpr() | rhs.getExpr();
-        }
+    friend Z3Expr operator|(const Z3Expr &lhs, const Z3Expr &rhs)
+    {
+        return lhs.getExpr() | rhs.getExpr();
+    }
 
-        friend Z3Expr ashr(const Z3Expr &lhs, const Z3Expr &rhs) {
-            return ashr(lhs.getExpr(), rhs.getExpr());
-        }
+    friend Z3Expr ashr(const Z3Expr &lhs, const Z3Expr &rhs)
+    {
+        return ashr(lhs.getExpr(), rhs.getExpr());
+    }
 
-        friend Z3Expr shl(const Z3Expr &lhs, const Z3Expr &rhs) {
-            return shl(lhs.getExpr(), rhs.getExpr());
-        }
+    friend Z3Expr shl(const Z3Expr &lhs, const Z3Expr &rhs)
+    {
+        return shl(lhs.getExpr(), rhs.getExpr());
+    }
 
-        friend Z3Expr int2bv(u32_t n, const Z3Expr &e) {
-            return int2bv(n, e.getExpr());
-        }
+    friend Z3Expr int2bv(u32_t n, const Z3Expr &e)
+    {
+        return int2bv(n, e.getExpr());
+    }
 
-        friend Z3Expr bv2int(const Z3Expr &e, bool isSigned) {
-            return z3::bv2int(e.getExpr(), isSigned);
-        }
+    friend Z3Expr bv2int(const Z3Expr &e, bool isSigned)
+    {
+        return z3::bv2int(e.getExpr(), isSigned);
+    }
 
-        friend Z3Expr operator&&(const Z3Expr &lhs, const Z3Expr &rhs) {
-            return lhs.getExpr() && rhs.getExpr();
-        }
+    friend Z3Expr operator&&(const Z3Expr &lhs, const Z3Expr &rhs)
+    {
+        return lhs.getExpr() && rhs.getExpr();
+    }
 
-        friend Z3Expr operator||(const Z3Expr &lhs, const Z3Expr &rhs) {
-            return lhs.getExpr() || rhs.getExpr();
-        }
+    friend Z3Expr operator||(const Z3Expr &lhs, const Z3Expr &rhs)
+    {
+        return lhs.getExpr() || rhs.getExpr();
+    }
 
-        friend Z3Expr operator!(const Z3Expr &lhs) {
-            return !lhs.getExpr();
-        }
+    friend Z3Expr operator!(const Z3Expr &lhs)
+    {
+        return !lhs.getExpr();
+    }
 
-        friend Z3Expr ite(const Z3Expr& cond, const Z3Expr& lhs, const Z3Expr& rhs) {
-            return ite(cond.getExpr(), lhs.getExpr(), rhs.getExpr());
-        }
+    friend Z3Expr ite(const Z3Expr& cond, const Z3Expr& lhs, const Z3Expr& rhs)
+    {
+        return ite(cond.getExpr(), lhs.getExpr(), rhs.getExpr());
+    }
 
-        friend std::ostream &operator<<(std::ostream &out, const Z3Expr &expr) {
-            out << expr.getExpr();
-            return out;
-        }
+    friend std::ostream &operator<<(std::ostream &out, const Z3Expr &expr)
+    {
+        out << expr.getExpr();
+        return out;
+    }
 
-        friend bool eq(const Z3Expr &lhs, const Z3Expr &rhs) {
-            return eq(lhs.getExpr(), rhs.getExpr());
-        }
+    friend bool eq(const Z3Expr &lhs, const Z3Expr &rhs)
+    {
+        return eq(lhs.getExpr(), rhs.getExpr());
+    }
 
-        z3::sort get_sort() const {
-            return getExpr().get_sort();
-        }
-        //%}
-    };
+    z3::sort get_sort() const
+    {
+        return getExpr().get_sort();
+    }
+    //%}
+};
 }
 
 /// Specialise hash for AbsCxtDPItem.
 template<>
-struct std::hash<SVF::Z3Expr> {
-    size_t operator()(const SVF::Z3Expr &z3Expr) const {
+struct std::hash<SVF::Z3Expr>
+{
+    size_t operator()(const SVF::Z3Expr &z3Expr) const
+    {
         return z3Expr.id();
     }
 };