svf-lib 1.0.992 → 1.0.995

package/SVF-linux/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-linux/include/Util/ExtAPI.h

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

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