svf-lib 1.0.1276 → 1.0.1277

package/SVF-linux/include/Graphs/ConsGNode.h

@@ -259,56 +259,68 @@ public:
         storeInEdges.insert(inEdge);
         addIncomingEdge(inEdge);
     }
-    inline void addIncomingDirectEdge(ConstraintEdge* inEdge)
+    inline bool addIncomingDirectEdge(ConstraintEdge* inEdge)
     {
         assert(inEdge->getDstID() == this->getId());
         bool added1 = directInEdges.insert(inEdge).second;
         bool added2 = addIncomingEdge(inEdge);
-        assert(added1 && added2 && "edge not added, duplicated adding!!");
+        bool both_added = added1 & added2;
+        assert(both_added && "edge not added, duplicated adding!!");
+        return both_added;
     }
     inline void addOutgoingAddrEdge(AddrCGEdge* outEdge)
     {
         addressOutEdges.insert(outEdge);
         addOutgoingEdge(outEdge);
     }
-    inline void addOutgoingLoadEdge(LoadCGEdge* outEdge)
+    inline bool addOutgoingLoadEdge(LoadCGEdge* outEdge)
     {
         bool added1 = loadOutEdges.insert(outEdge).second;
         bool added2 = addOutgoingEdge(outEdge);
-        assert(added1 && added2 && "edge not added, duplicated adding!!");
+        bool both_added = added1 & added2;
+        assert(both_added && "edge not added, duplicated adding!!");
+        return both_added;
     }
-    inline void addOutgoingStoreEdge(StoreCGEdge* outEdge)
+    inline bool addOutgoingStoreEdge(StoreCGEdge* outEdge)
     {
         bool added1 = storeOutEdges.insert(outEdge).second;
         bool added2 = addOutgoingEdge(outEdge);
-        assert(added1 && added2 && "edge not added, duplicated adding!!");
+        bool both_added = added1 & added2;
+        assert(both_added && "edge not added, duplicated adding!!");
+        return both_added;
     }
-    inline void addOutgoingDirectEdge(ConstraintEdge* outEdge)
+    inline bool addOutgoingDirectEdge(ConstraintEdge* outEdge)
     {
         assert(outEdge->getSrcID() == this->getId());
         bool added1 = directOutEdges.insert(outEdge).second;
         bool added2 = addOutgoingEdge(outEdge);
-        assert(added1 && added2 && "edge not added, duplicated adding!!");
+        bool both_added = added1 & added2;
+        assert(both_added && "edge not added, duplicated adding!!");
+        return both_added;
     }
     //@}
 
     /// Remove constraint graph edges
     //{@
-    inline void removeOutgoingAddrEdge(AddrCGEdge* outEdge)
+    inline bool removeOutgoingAddrEdge(AddrCGEdge* outEdge)
     {
         u32_t num1 = addressOutEdges.erase(outEdge);
         u32_t num2 = removeOutgoingEdge(outEdge);
-        assert((num1 && num2) && "edge not in the set, can not remove!!!");
+        bool removed = (num1 > 0) & (num2 > 0);
+        assert(removed && "edge not in the set, can not remove!!!");
+        return removed;
     }
 
-    inline void removeIncomingAddrEdge(AddrCGEdge* inEdge)
+    inline bool removeIncomingAddrEdge(AddrCGEdge* inEdge)
     {
         u32_t num1 = addressInEdges.erase(inEdge);
         u32_t num2 = removeIncomingEdge(inEdge);
-        assert((num1 && num2) && "edge not in the set, can not remove!!!");
+        bool removed = (num1 > 0) & (num2 > 0);
+        assert(removed && "edge not in the set, can not remove!!!");
+        return removed;
     }
 
-    inline void removeOutgoingDirectEdge(ConstraintEdge* outEdge)
+    inline bool removeOutgoingDirectEdge(ConstraintEdge* outEdge)
     {
         if (SVFUtil::isa<GepCGEdge>(outEdge))
             gepOutEdges.erase(outEdge);
@@ -316,10 +328,12 @@ public:
             copyOutEdges.erase(outEdge);
         u32_t num1 = directOutEdges.erase(outEdge);
         u32_t num2 = removeOutgoingEdge(outEdge);
-        assert((num1 && num2) && "edge not in the set, can not remove!!!");
+        bool removed = (num1 > 0) & (num2 > 0);
+        assert(removed && "edge not in the set, can not remove!!!");
+        return removed;
     }
 
-    inline void removeIncomingDirectEdge(ConstraintEdge* inEdge)
+    inline bool removeIncomingDirectEdge(ConstraintEdge* inEdge)
     {
         if (SVFUtil::isa<GepCGEdge>(inEdge))
             gepInEdges.erase(inEdge);
@@ -327,35 +341,45 @@ public:
             copyInEdges.erase(inEdge);
         u32_t num1 = directInEdges.erase(inEdge);
         u32_t num2 = removeIncomingEdge(inEdge);
-        assert((num1 && num2) && "edge not in the set, can not remove!!!");
+        bool removed = (num1 > 0) & (num2 > 0);
+        assert(removed && "edge not in the set, can not remove!!!");
+        return removed;
     }
 
-    inline void removeOutgoingLoadEdge(LoadCGEdge* outEdge)
+    inline bool removeOutgoingLoadEdge(LoadCGEdge* outEdge)
     {
         u32_t num1 = loadOutEdges.erase(outEdge);
         u32_t num2 = removeOutgoingEdge(outEdge);
-        assert((num1 && num2) && "edge not in the set, can not remove!!!");
+        bool removed = (num1 > 0) & (num2 > 0);
+        assert(removed && "edge not in the set, can not remove!!!");
+        return removed;
     }
 
-    inline void removeIncomingLoadEdge(LoadCGEdge* inEdge)
+    inline bool removeIncomingLoadEdge(LoadCGEdge* inEdge)
     {
         u32_t num1 = loadInEdges.erase(inEdge);
         u32_t num2 = removeIncomingEdge(inEdge);
-        assert((num1 && num2) && "edge not in the set, can not remove!!!");
+        bool removed = (num1 > 0) & (num2 > 0);
+        assert(removed && "edge not in the set, can not remove!!!");
+        return removed;
     }
 
-    inline void removeOutgoingStoreEdge(StoreCGEdge* outEdge)
+    inline bool removeOutgoingStoreEdge(StoreCGEdge* outEdge)
     {
         u32_t num1 = storeOutEdges.erase(outEdge);
         u32_t num2 = removeOutgoingEdge(outEdge);
-        assert((num1 && num2) && "edge not in the set, can not remove!!!");
+        bool removed = (num1 > 0) & (num2 > 0);
+        assert(removed && "edge not in the set, can not remove!!!");
+        return removed;
     }
 
-    inline void removeIncomingStoreEdge(StoreCGEdge* inEdge)
+    inline bool removeIncomingStoreEdge(StoreCGEdge* inEdge)
     {
         u32_t num1 = storeInEdges.erase(inEdge);
         u32_t num2 = removeIncomingEdge(inEdge);
-        assert((num1 && num2) && "edge not in the set, can not remove!!!");
+        bool removed = (num1 > 0) & (num2 > 0);
+        assert(removed && "edge not in the set, can not remove!!!");
+        return removed;
     }
     //@}
 

package/SVF-linux/include/Graphs/GenericGraph.h

@@ -292,13 +292,15 @@ public:
     {
         iterator it = InEdges.find(edge);
         assert(it != InEdges.end() && "can not find in edge in SVFG node");
-        return InEdges.erase(edge);
+        InEdges.erase(it);
+        return 1;
     }
     inline u32_t removeOutgoingEdge(EdgeType* edge)
     {
         iterator it = OutEdges.find(edge);
         assert(it != OutEdges.end() && "can not find out edge in SVFG node");
-        return OutEdges.erase(edge);
+        OutEdges.erase(it);
+        return 1;
     }
     ///@}
 

package/SVF-linux/include/Graphs/ICFG.h

@@ -179,8 +179,9 @@ protected:
     {
         bool added1 = edge->getDstNode()->addIncomingEdge(edge);
         bool added2 = edge->getSrcNode()->addOutgoingEdge(edge);
-        assert(added1 && added2 && "edge not added??");
-        return true;
+        bool all_added = added1 && added2;
+        assert(all_added && "ICFGEdge not added?");
+        return all_added;
     }
 
     /// Add a ICFG node

package/SVF-linux/include/Graphs/SVFGOPT.h

@@ -261,23 +261,23 @@ private:
     {
         PAGNodeToDefMapTy::iterator it = PAGNodeToDefMap.find(pagNode);
         assert(it != PAGNodeToDefMap.end() && "a SVFIR node doesn't have definition before");
-        PAGNodeToDefMap[pagNode] = node->getId();
+        it->second = node->getId();
     }
 
     /// Set def-site of actual-in/formal-out.
     ///@{
     inline void setActualINDef(NodeID ai, NodeID def)
     {
-        NodeIDToNodeIDMap::const_iterator it = actualInToDefMap.find(ai);
-        assert(it == actualInToDefMap.end() && "can not set actual-in's def twice");
-        actualInToDefMap[ai] = def;
+        bool inserted = actualInToDefMap.emplace(ai, def).second;
+        (void)inserted; // Suppress warning of unused variable under release build
+        assert(inserted && "can not set actual-in's def twice");
         defNodes.set(def);
     }
     inline void setFormalOUTDef(NodeID fo, NodeID def)
     {
-        NodeIDToNodeIDMap::const_iterator it = formalOutToDefMap.find(fo);
-        assert(it == formalOutToDefMap.end() && "can not set formal-out's def twice");
-        formalOutToDefMap[fo] = def;
+        bool inserted = formalOutToDefMap.emplace(fo, def).second;
+        (void) inserted;
+        assert(inserted && "can not set formal-out's def twice");
         defNodes.set(def);
     }
     ///@}

package/SVF-linux/include/Graphs/VFG.h

@@ -340,8 +340,9 @@ public:
     {
         bool added1 = edge->getDstNode()->addIncomingEdge(edge);
         bool added2 = edge->getSrcNode()->addOutgoingEdge(edge);
-        assert(added1 && added2 && "edge not added??");
-        return true;
+        bool both_added = added1 & added2;
+        assert(both_added && "VFGEdge not added??");
+        return both_added;
     }
 
 protected:

package/SVF-linux/include/MSSA/MemSSA.h

@@ -324,9 +324,9 @@ public:
     {
         if (const LoadStmt* load = SVFUtil::dyn_cast<LoadStmt>(inst))
         {
-            assert(0 != load2MuSetMap.count(load)
-                   && "not associated with mem region!");
-            return true;
+            bool hasMu = load2MuSetMap.count(load) != 0;
+            assert(hasMu && "not associated with mem region!");
+            return hasMu;
         }
         else
             return false;
@@ -336,9 +336,9 @@ public:
         if (const StoreStmt* store = SVFUtil::dyn_cast<StoreStmt>(
                                          inst))
         {
-            assert(0 != store2ChiSetMap.count(store)
-                   && "not associated with mem region!");
-            return true;
+            bool has_store = store2ChiSetMap.count(store) != 0;
+            assert(has_store && "not associated with mem region!");
+            return has_store;
         }
         else
             return false;

package/SVF-linux/include/MemoryModel/PersistentPointsToDS.h

@@ -363,7 +363,7 @@ public:
     virtual inline const KeySet& getRevPts(const Data&) override
     {
         assert(false && "PersistentDFPTData::getRevPts: not supported yet!");
-        return *(KeySet*)nullptr; // suppress -Werror=return-type
+        abort();
     }
 
     virtual inline bool unionPts(const Key& dstKey, const Key& srcKey) override

package/SVF-linux/include/MemoryModel/SVFIR.h

@@ -456,6 +456,7 @@ private:
     inline void addToStmt2TypeMap(SVFStmt* edge)
     {
         bool added = KindToSVFStmtSetMap[edge->getEdgeKind()].insert(edge).second;
+        (void)added; // Suppress warning of unused variable under release build
         assert(added && "duplicated edge, not added!!!");
         if (edge->isPTAEdge())
         {
@@ -494,7 +495,8 @@ private:
     /// Add indirect callsites
     inline void addIndirectCallsites(const CallICFGNode* cs,NodeID funPtr)
     {
-        bool added = indCallSiteToFunPtrMap.insert(std::make_pair(cs,funPtr)).second;
+        bool added = indCallSiteToFunPtrMap.emplace(cs, funPtr).second;
+        (void) added;
         funPtrToCallSitesMap[funPtr].insert(cs);
         assert(added && "adding the same indirect callsite twice?");
     }

package/SVF-linux/include/SABER/SaberCondAllocator.h

@@ -148,7 +148,9 @@ public:
     {
         const SVFFunction*  keyFunc = LLVMModuleSet::getLLVMModuleSet()->getSVFFunction(bbKey->getParent());
         const SVFFunction*  valueFunc = LLVMModuleSet::getLLVMModuleSet()->getSVFFunction(bbValue->getParent());
-        assert((keyFunc == valueFunc) && "two basicblocks should be in the same function!");
+        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);
     }
@@ -157,7 +159,10 @@ public:
     {
         const SVFFunction*  keyFunc = LLVMModuleSet::getLLVMModuleSet()->getSVFFunction(bbKey->getParent());
         const SVFFunction*  valueFunc = LLVMModuleSet::getLLVMModuleSet()->getSVFFunction(bbValue->getParent());
-        assert((keyFunc == valueFunc) && "two basicblocks should be in the same function!");
+        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);
     }

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

@@ -101,7 +101,9 @@ private:
             LocationSet locationSet = LocationSet(locationSetOffset);
             SVF::NodeID gepnodeId = pag->getGepObjVar(baseNodeId, locationSet);
 
-            assert(nodeId == gepnodeId && "nodeId != gepnodeId");
+            bool idEq = (nodeId == gepnodeId);
+            (void)idEq; // Suppress warning of unused variable under release build
+            assert(idEq && "nodeId is not equal to gepnodeId?");
         }
     }
 

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

@@ -321,6 +321,7 @@ public:
             if (Bits[i] != 0)
                 return i * BITWORD_SIZE + countTrailingZeros(Bits[i]);
         assert(false && "SBV: find_first: SBV cannot be empty");
+        abort();
     }
 
     /// find_last - Returns the index of the last set bit.
@@ -334,6 +335,7 @@ public:
                        countLeadingZeros(Bits[Idx]) - 1;
         }
         assert(false && "SBV: find_last: SBV cannot be empty");
+        abort();
     }
 
     /// find_next - Returns the index of the next set bit starting from the

package/package.json

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