svf-lib 1.0.2694 → 1.0.2695

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

@@ -531,27 +531,27 @@ class SparseBitVector
             const_cast<SparseBitVector<ElementSize> *>(this)->Elements.end();
 
         if (Elements.empty())
-    {
-        CurrElementIter = Begin;
-        return CurrElementIter;
-    }
+        {
+            CurrElementIter = Begin;
+            return CurrElementIter;
+        }
 
-    // Make sure our current iterator is valid.
-    if (CurrElementIter == End)
-    {
-        --CurrElementIter;
-    }
+        // Make sure our current iterator is valid.
+        if (CurrElementIter == End)
+        {
+            --CurrElementIter;
+        }
 
-    // Search from our current iterator, either backwards or forwards,
-    // depending on what element we are looking for.
-    ElementListIter ElementIter = CurrElementIter;
-    if (CurrElementIter->index() == ElementIndex)
-    {
-        return ElementIter;
-    }
-    else if (CurrElementIter->index() > ElementIndex)
-    {
-        while (ElementIter != Begin
+        // Search from our current iterator, either backwards or forwards,
+        // depending on what element we are looking for.
+        ElementListIter ElementIter = CurrElementIter;
+        if (CurrElementIter->index() == ElementIndex)
+        {
+            return ElementIter;
+        }
+        else if (CurrElementIter->index() > ElementIndex)
+        {
+            while (ElementIter != Begin
                     && ElementIter->index() > ElementIndex)
                 --ElementIter;
         }
@@ -701,13 +701,13 @@ class SparseBitVector
         {
             // If they are both at the end, ignore the rest of the fields.
             if (AtEnd && RHS.AtEnd)
-            return true;
+                return true;
             // Otherwise they are the same if they have the same bit number and
             // bitmap.
             return AtEnd == RHS.AtEnd && RHS.BitNumber == BitNumber;
         }
 
-    bool operator!=(const SparseBitVectorIterator &RHS) const
+        bool operator!=(const SparseBitVectorIterator &RHS) const
         {
             return !(*this == RHS);
         }
@@ -750,7 +750,7 @@ public:
     bool test(unsigned Idx) const
     {
         if (Elements.empty())
-        return false;
+            return false;
 
         unsigned ElementIndex = Idx / ElementSize;
         ElementListConstIter ElementIter = FindLowerBoundConst(ElementIndex);
@@ -758,14 +758,14 @@ public:
         // If we can't find an element that is supposed to contain this bit, there
         // is nothing more to do.
         if (ElementIter == Elements.end() ||
-                    ElementIter->index() != ElementIndex)
+                ElementIter->index() != ElementIndex)
         {
             return false;
         }
-    return ElementIter->test(Idx % ElementSize);
-}
+        return ElementIter->test(Idx % ElementSize);
+    }
 
-void reset(unsigned Idx)
+    void reset(unsigned Idx)
     {
         if (Elements.empty())
             return;
@@ -1125,22 +1125,22 @@ void reset(unsigned Idx)
     int find_first() const
     {
         if (Elements.empty())
-        return -1;
+            return -1;
         const SparseBitVectorElement<ElementSize> &First = *(Elements.begin());
         return (First.index() * ElementSize) + First.find_first();
     }
 
 // Return the last set bit in the bitmap.  Return -1 if no bits are set.
-int find_last() const
+    int find_last() const
     {
         if (Elements.empty())
-        return -1;
+            return -1;
         const SparseBitVectorElement<ElementSize> &Last = *(Elements.rbegin());
         return (Last.index() * ElementSize) + Last.find_last();
     }
 
 // Return true if the SparseBitVector is empty
-bool empty() const
+    bool empty() const
     {
         return Elements.empty();
     }

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

@@ -106,10 +106,10 @@ public:
     DerivedT operator+(DifferenceTypeT n) const
     {
         static_assert(std::is_base_of<iter_facade_base, DerivedT>::value,
-        "Must pass the derived type to this template!");
+                      "Must pass the derived type to this template!");
         static_assert(
-        IsRandomAccess,
-        "The '+' operator is only defined for random access iterators.");
+            IsRandomAccess,
+            "The '+' operator is only defined for random access iterators.");
         DerivedT tmp = *static_cast<const DerivedT *>(this);
         tmp += n;
         return tmp;
@@ -124,8 +124,8 @@ public:
     DerivedT operator-(DifferenceTypeT n) const
     {
         static_assert(
-        IsRandomAccess,
-        "The '-' operator is only defined for random access iterators.");
+            IsRandomAccess,
+            "The '-' operator is only defined for random access iterators.");
         DerivedT tmp = *static_cast<const DerivedT *>(this);
         tmp -= n;
         return tmp;
@@ -170,23 +170,23 @@ public:
     bool operator>(const DerivedT &RHS) const
     {
         static_assert(
-        IsRandomAccess,
-        "Relational operators are only defined for random access iterators.");
+            IsRandomAccess,
+            "Relational operators are only defined for random access iterators.");
         return !(static_cast<const DerivedT &>(*this) < RHS) &&
-        !(static_cast<const DerivedT &>(*this) == RHS);
+               !(static_cast<const DerivedT &>(*this) == RHS);
     }
     bool operator<=(const DerivedT &RHS) const
     {
         static_assert(
-        IsRandomAccess,
-        "Relational operators are only defined for random access iterators.");
+            IsRandomAccess,
+            "Relational operators are only defined for random access iterators.");
         return !(static_cast<const DerivedT &>(*this) > RHS);
     }
     bool operator>=(const DerivedT &RHS) const
     {
         static_assert(
-        IsRandomAccess,
-        "Relational operators are only defined for random access iterators.");
+            IsRandomAccess,
+            "Relational operators are only defined for random access iterators.");
         return !(static_cast<const DerivedT &>(*this) < RHS);
     }
 
@@ -207,7 +207,7 @@ public:
     ReferenceProxy operator[](DifferenceTypeT n) const
     {
         static_assert(IsRandomAccess,
-        "Subscripting is only defined for random access iterators.");
+                      "Subscripting is only defined for random access iterators.");
         return ReferenceProxy(static_cast<const DerivedT *>(this)->operator+(n));
     }
 };
@@ -277,8 +277,8 @@ public:
     difference_type operator-(const DerivedT &RHS) const
     {
         static_assert(
-        BaseT::IsRandomAccess,
-        "The '-' operator is only defined for random access iterators.");
+            BaseT::IsRandomAccess,
+            "The '-' operator is only defined for random access iterators.");
         return I - RHS.I;
     }
 

package/SVF-osx/include/WPA/Andersen.h

@@ -252,6 +252,9 @@ public:
         return getPTDataTy()->unionPts(id,ptd);
     }
 
+    /// Collect exactly the SVFIR nodes q for which mayAlias(node, q) holds
+    virtual NodeBS getMayAliases(NodeID node);
+
 
     void dumpTopLevelPtsTo();
 
@@ -354,6 +357,13 @@ protected:
     /// SCC detection
     virtual NodeStack& SCCDetect();
 
+    /// Collect may-alias candidates. Attempts to do so from reverse points-to sets (cheaper),
+    /// and if not possible, falls back to trying every node (costlier).
+    NodeBS getMayAliasCandidates(NodeID node);
+
+    /// Also check getMayAliases on the pointers that the alias tests use
+    virtual void validateSuccessTests(std::string fun);
+
 
 
     /// Sanitize pts for field insensitive objects

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "svf-lib",
-  "version": "1.0.2694",
+  "version": "1.0.2695",
   "description": "SVF's npm support",
   "main": "index.js",
   "scripts": {