svf-tools 1.0.587 → 1.0.589

package/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/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/include/MemoryModel/PointerAnalysis.h

@@ -99,7 +99,6 @@ public:
 
     /// Indirect call edges type, map a callsite to a set of callees
     //@{
-    typedef llvm::AliasAnalysis AliasAnalysis;
     typedef Set<const CallICFGNode*> CallSiteSet;
     typedef SVFIR::CallSiteToFunPtrMap CallSiteToFunPtrMap;
     typedef Set<const SVFFunction*> FunctionSet;

package/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/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/include/SVF-FE/BasicTypes.h

@@ -27,7 +27,13 @@
 
 #include <llvm/Support/SourceMgr.h>
 
-#include "llvm/Analysis/LoopInfo.h"
+#include <llvm/Bitcode/BitcodeWriter.h>		// for WriteBitcodeToFile
+#include <llvm/Bitcode/BitcodeReader.h>     /// for isBitcode
+#include <llvm/IRReader/IRReader.h>	// IR reader for bit file
+#include <llvm/IR/InstVisitor.h>	// for instruction visitor
+#include <llvm/IR/InstIterator.h>	// for inst iteration
+
+#include <llvm/Analysis/LoopInfo.h>
 
 namespace SVF
 {

package/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/include/Util/BasicTypes.h

@@ -33,37 +33,16 @@
 #include "Util/SVFBasicTypes.h"
 #include "Graphs/GraphPrinter.h"
 #include "Util/Casting.h"
-#include <llvm/ADT/SparseBitVector.h>
 #include <llvm/IR/Instructions.h>
-#include <llvm/IR/InstVisitor.h>	// for instruction visitor
-#include <llvm/IR/InstIterator.h>	// for inst iteration
 #include <llvm/IR/GetElementPtrTypeIterator.h>	//for gep iterator
-#include <llvm/ADT/StringExtras.h>	// for utostr_32
-#include <llvm/Analysis/AliasAnalysis.h>
-#include <llvm/Analysis/CallGraph.h>	// call graph
 #include <llvm/IR/GlobalVariable.h>	// for GlobalVariable
+#include <llvm/IR/BasicBlock.h>
 
-#include <llvm/Bitcode/BitcodeWriter.h>		// for WriteBitcodeToFile
-#include <llvm/Bitcode/BitcodeReader.h>     /// for isBitcode
-#include <llvm/IRReader/IRReader.h>	// IR reader for bit file
-#include <llvm/Analysis/DominanceFrontier.h>
-#include <llvm/Analysis/PostDominators.h>
-#include <llvm/ADT/GraphTraits.h>		// for Graphtraits
-#include <llvm/Transforms/Utils/Local.h>	// for FindDbgAddrUses
-
-#if (LLVM_VERSION_MAJOR >= 14)
-#include <llvm/BinaryFormat/Dwarf.h>
-#endif
-
-#include "llvm/IR/CFG.h"
 #include "llvm/BinaryFormat/Dwarf.h"
 
 namespace SVF
 {
 
-class BddCond;
-
-
 /// LLVM Basic classes
 typedef llvm::Type Type;
 typedef llvm::Function Function;

package/include/Util/Casting.h

@@ -28,6 +28,7 @@
 #include <cassert>
 #include <memory>
 #include <type_traits>
+#include <llvm/IR/BasicBlock.h>
 
 namespace SVF
 {

package/include/Util/SVFBasicTypes.h

@@ -31,10 +31,6 @@
 #ifndef INCLUDE_UTIL_SVFBASICTYPES_H_
 #define INCLUDE_UTIL_SVFBASICTYPES_H_
 
-// TODO: these are just for SmallBBVector.
-#include <llvm/IR/BasicBlock.h>
-#include <llvm/ADT/SmallVector.h>
-
 #include <llvm/Support/CommandLine.h>	// for command line options
 
 #include <Util/SparseBitVector.h>
@@ -116,7 +112,6 @@ template<typename Key, typename Value, typename Hash = Hash<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;

package/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/lib/DDA/ContextDDA.cpp

@@ -335,22 +335,25 @@ bool ContextDDA::isHeapCondMemObj(const CxtVar& var, const StoreSVFGNode*)
 {
     const MemObj* mem = _pag->getObject(getPtrNodeID(var));
     assert(mem && "memory object is null??");
-    if(mem->isHeap())
+    if (mem->isHeap())
     {
         if (!mem->getValue())
         {
             PAGNode *pnode = _pag->getGNode(getPtrNodeID(var));
-            if(GepObjVar* gepobj = SVFUtil::dyn_cast<GepObjVar>(pnode))
+            GepObjVar* gepobj = SVFUtil::dyn_cast<GepObjVar>(pnode);
+            if (gepobj != nullptr)
             {
-                assert(SVFUtil::isa<DummyObjVar>(_pag->getGNode(gepobj->getBaseNode())) && "emtpy refVal in a gep object whose base is a non-dummy object");
+                assert(SVFUtil::isa<DummyObjVar>(_pag->getGNode(gepobj->getBaseNode()))
+                       && "emtpy refVal in a gep object whose base is a non-dummy object");
             }
             else
             {
-                assert((SVFUtil::isa<DummyObjVar>(pnode) || SVFUtil::isa<DummyValVar>(pnode)) && "empty refVal in non-dummy object");
+                assert((SVFUtil::isa<DummyObjVar>(pnode) || SVFUtil::isa<DummyValVar>(pnode))
+                       && "empty refVal in non-dummy object");
             }
             return true;
         }
-        else if(const Instruction* mallocSite = SVFUtil::dyn_cast<Instruction>(mem->getValue()))
+        else if (const Instruction* mallocSite = SVFUtil::dyn_cast<Instruction>(mem->getValue()))
         {
             const Function* fun = mallocSite->getFunction();
             const SVFFunction* svfFun = LLVMModuleSet::getLLVMModuleSet()->getSVFFunction(fun);

package/lib/Graphs/ConsG.cpp

@@ -157,8 +157,11 @@ AddrCGEdge::AddrCGEdge(ConstraintNode* s, ConstraintNode* d, EdgeID id)
 {
     // Retarget addr edges may lead s to be a dummy node
     PAGNode* node = SVFIR::getPAG()->getGNode(s->getId());
+    (void)node; // Suppress warning of unused variable under release build
     if (!SVFModule::pagReadFromTXT())
+    {
         assert(!SVFUtil::isa<DummyValVar>(node) && "a dummy node??");
+    }
 }
 
 /*!
@@ -168,11 +171,14 @@ AddrCGEdge* ConstraintGraph::addAddrCGEdge(NodeID src, NodeID dst)
 {
     ConstraintNode* srcNode = getConstraintNode(src);
     ConstraintNode* dstNode = getConstraintNode(dst);
-    if(hasEdge(srcNode,dstNode,ConstraintEdge::Addr))
+    if (hasEdge(srcNode, dstNode, ConstraintEdge::Addr))
         return nullptr;
     AddrCGEdge* edge = new AddrCGEdge(srcNode, dstNode, edgeIndex++);
-    bool added = AddrCGEdgeSet.insert(edge).second;
-    assert(added && "not added??");
+
+    bool inserted = AddrCGEdgeSet.insert(edge).second;
+    (void)inserted; // Suppress warning of unused variable under release build
+    assert(inserted && "new AddrCGEdge not added??");
+
     srcNode->addOutgoingAddrEdge(edge);
     dstNode->addIncomingAddrEdge(edge);
     return edge;
@@ -186,13 +192,15 @@ CopyCGEdge* ConstraintGraph::addCopyCGEdge(NodeID src, NodeID dst)
 
     ConstraintNode* srcNode = getConstraintNode(src);
     ConstraintNode* dstNode = getConstraintNode(dst);
-    if(hasEdge(srcNode,dstNode,ConstraintEdge::Copy)
-            || srcNode == dstNode)
+    if (hasEdge(srcNode, dstNode, ConstraintEdge::Copy) || srcNode == dstNode)
         return nullptr;
 
     CopyCGEdge* edge = new CopyCGEdge(srcNode, dstNode, edgeIndex++);
-    bool added = directEdgeSet.insert(edge).second;
-    assert(added && "not added??");
+
+    bool inserted = directEdgeSet.insert(edge).second;
+    (void)inserted; // Suppress warning of unused variable under release build
+    assert(inserted && "new CopyCGEdge not added??");
+
     srcNode->addOutgoingCopyEdge(edge);
     dstNode->addIncomingCopyEdge(edge);
     return edge;
@@ -206,12 +214,15 @@ NormalGepCGEdge*  ConstraintGraph::addNormalGepCGEdge(NodeID src, NodeID dst, co
 {
     ConstraintNode* srcNode = getConstraintNode(src);
     ConstraintNode* dstNode = getConstraintNode(dst);
-    if(hasEdge(srcNode,dstNode,ConstraintEdge::NormalGep))
+    if (hasEdge(srcNode, dstNode, ConstraintEdge::NormalGep))
         return nullptr;
 
     NormalGepCGEdge* edge = new NormalGepCGEdge(srcNode, dstNode,ls, edgeIndex++);
-    bool added = directEdgeSet.insert(edge).second;
-    assert(added && "not added??");
+
+    bool inserted = directEdgeSet.insert(edge).second;
+    (void)inserted; // Suppress warning of unused variable under release build
+    assert(inserted && "new NormalGepCGEdge not added??");
+
     srcNode->addOutgoingGepEdge(edge);
     dstNode->addIncomingGepEdge(edge);
     return edge;
@@ -224,12 +235,15 @@ VariantGepCGEdge* ConstraintGraph::addVariantGepCGEdge(NodeID src, NodeID dst)
 {
     ConstraintNode* srcNode = getConstraintNode(src);
     ConstraintNode* dstNode = getConstraintNode(dst);
-    if(hasEdge(srcNode,dstNode,ConstraintEdge::VariantGep))
+    if (hasEdge(srcNode, dstNode, ConstraintEdge::VariantGep))
         return nullptr;
 
     VariantGepCGEdge* edge = new VariantGepCGEdge(srcNode, dstNode, edgeIndex++);
-    bool added = directEdgeSet.insert(edge).second;
-    assert(added && "not added??");
+
+    bool inserted = directEdgeSet.insert(edge).second;
+    (void)inserted; // Suppress warning of unused variable under release build
+    assert(inserted && "new VariantGepCGEdge not added??");
+
     srcNode->addOutgoingGepEdge(edge);
     dstNode->addIncomingGepEdge(edge);
     return edge;
@@ -242,12 +256,15 @@ LoadCGEdge* ConstraintGraph::addLoadCGEdge(NodeID src, NodeID dst)
 {
     ConstraintNode* srcNode = getConstraintNode(src);
     ConstraintNode* dstNode = getConstraintNode(dst);
-    if(hasEdge(srcNode,dstNode,ConstraintEdge::Load))
+    if (hasEdge(srcNode, dstNode, ConstraintEdge::Load))
         return nullptr;
 
     LoadCGEdge* edge = new LoadCGEdge(srcNode, dstNode, edgeIndex++);
-    bool added = LoadCGEdgeSet.insert(edge).second;
-    assert(added && "not added??");
+
+    bool inserted = LoadCGEdgeSet.insert(edge).second;
+    (void)inserted; // Suppress warning of unused variable under release build
+    assert(inserted && "new LoadCGEdge not added??");
+
     srcNode->addOutgoingLoadEdge(edge);
     dstNode->addIncomingLoadEdge(edge);
     return edge;
@@ -260,12 +277,15 @@ StoreCGEdge* ConstraintGraph::addStoreCGEdge(NodeID src, NodeID dst)
 {
     ConstraintNode* srcNode = getConstraintNode(src);
     ConstraintNode* dstNode = getConstraintNode(dst);
-    if(hasEdge(srcNode,dstNode,ConstraintEdge::Store))
+    if (hasEdge(srcNode, dstNode, ConstraintEdge::Store))
         return nullptr;
 
     StoreCGEdge* edge = new StoreCGEdge(srcNode, dstNode, edgeIndex++);
-    bool added = StoreCGEdgeSet.insert(edge).second;
-    assert(added && "not added??");
+
+    bool inserted = StoreCGEdgeSet.insert(edge).second;
+    (void)inserted; // Suppress warning of unused variable under release build
+    assert(inserted && "new StoreCGEdge not added??");
+
     srcNode->addOutgoingStoreEdge(edge);
     dstNode->addIncomingStoreEdge(edge);
     return edge;
@@ -369,8 +389,9 @@ void ConstraintGraph::removeAddrEdge(AddrCGEdge* edge)
     getConstraintNode(edge->getSrcID())->removeOutgoingAddrEdge(edge);
     getConstraintNode(edge->getDstID())->removeIncomingAddrEdge(edge);
     u32_t num = AddrCGEdgeSet.erase(edge);
-    delete edge;
+    (void)num; // Suppress warning of unused variable under release build
     assert(num && "edge not in the set, can not remove!!!");
+    delete edge;
 }
 
 /*!
@@ -381,8 +402,9 @@ void ConstraintGraph::removeLoadEdge(LoadCGEdge* edge)
     getConstraintNode(edge->getSrcID())->removeOutgoingLoadEdge(edge);
     getConstraintNode(edge->getDstID())->removeIncomingLoadEdge(edge);
     u32_t num = LoadCGEdgeSet.erase(edge);
-    delete edge;
+    (void)num; // Suppress warning of unused variable under release build
     assert(num && "edge not in the set, can not remove!!!");
+    delete edge;
 }
 
 /*!
@@ -393,8 +415,9 @@ void ConstraintGraph::removeStoreEdge(StoreCGEdge* edge)
     getConstraintNode(edge->getSrcID())->removeOutgoingStoreEdge(edge);
     getConstraintNode(edge->getDstID())->removeIncomingStoreEdge(edge);
     u32_t num = StoreCGEdgeSet.erase(edge);
-    delete edge;
+    (void)num; // Suppress warning of unused variable under release build
     assert(num && "edge not in the set, can not remove!!!");
+    delete edge;
 }
 
 /*!
@@ -406,7 +429,7 @@ void ConstraintGraph::removeDirectEdge(ConstraintEdge* edge)
     getConstraintNode(edge->getSrcID())->removeOutgoingDirectEdge(edge);
     getConstraintNode(edge->getDstID())->removeIncomingDirectEdge(edge);
     u32_t num = directEdgeSet.erase(edge);
-
+    (void)num; // Suppress warning of unused variable under release build
     assert(num && "edge not in the set, can not remove!!!");
     delete edge;
 }

package/lib/Graphs/ICFG.cpp

@@ -364,7 +364,8 @@ ICFGEdge* ICFG::getICFGEdge(const ICFGNode* src, const ICFGNode* dst, ICFGEdge::
 ICFGEdge* ICFG::addIntraEdge(ICFGNode* srcNode, ICFGNode* dstNode)
 {
     checkIntraEdgeParents(srcNode, dstNode);
-    if(ICFGEdge* edge = hasIntraICFGEdge(srcNode,dstNode, ICFGEdge::IntraCF))
+    ICFGEdge* edge = hasIntraICFGEdge(srcNode, dstNode, ICFGEdge::IntraCF);
+    if (edge != nullptr)
     {
         assert(edge->isIntraCFGEdge() && "this should be an intra CFG edge!");
         return nullptr;
@@ -383,7 +384,8 @@ ICFGEdge* ICFG::addConditionalIntraEdge(ICFGNode* srcNode, ICFGNode* dstNode, co
 {
 
     checkIntraEdgeParents(srcNode, dstNode);
-    if(ICFGEdge* edge = hasIntraICFGEdge(srcNode,dstNode, ICFGEdge::IntraCF))
+    ICFGEdge* edge = hasIntraICFGEdge(srcNode, dstNode, ICFGEdge::IntraCF);
+    if (edge != nullptr)
     {
         assert(edge->isIntraCFGEdge() && "this should be an intra CFG edge!");
         return nullptr;
@@ -402,7 +404,8 @@ ICFGEdge* ICFG::addConditionalIntraEdge(ICFGNode* srcNode, ICFGNode* dstNode, co
  */
 ICFGEdge* ICFG::addCallEdge(ICFGNode* srcNode, ICFGNode* dstNode, const Instruction*  cs)
 {
-    if(ICFGEdge* edge = hasInterICFGEdge(srcNode,dstNode, ICFGEdge::CallCF))
+    ICFGEdge* edge = hasInterICFGEdge(srcNode,dstNode, ICFGEdge::CallCF);
+    if (edge != nullptr)
     {
         assert(edge->isCallCFGEdge() && "this should be a call CFG edge!");
         return nullptr;
@@ -419,7 +422,8 @@ ICFGEdge* ICFG::addCallEdge(ICFGNode* srcNode, ICFGNode* dstNode, const Instruct
  */
 ICFGEdge* ICFG::addRetEdge(ICFGNode* srcNode, ICFGNode* dstNode, const Instruction*  cs)
 {
-    if(ICFGEdge* edge = hasInterICFGEdge(srcNode,dstNode, ICFGEdge::RetCF))
+    ICFGEdge* edge = hasInterICFGEdge(srcNode, dstNode, ICFGEdge::RetCF);
+    if (edge != nullptr)
     {
         assert(edge->isRetCFGEdge() && "this should be a return CFG edge!");
         return nullptr;

package/lib/Graphs/VFG.cpp

@@ -677,7 +677,8 @@ VFGEdge* VFG::addIntraDirectVFEdge(NodeID srcId, NodeID dstId)
     VFGNode* srcNode = getVFGNode(srcId);
     VFGNode* dstNode = getVFGNode(dstId);
     checkIntraEdgeParents(srcNode, dstNode);
-    if(VFGEdge* edge = hasIntraVFGEdge(srcNode,dstNode, VFGEdge::IntraDirectVF))
+    VFGEdge* edge = hasIntraVFGEdge(srcNode, dstNode, VFGEdge::IntraDirectVF);
+    if (edge != nullptr)
     {
         assert(edge->isDirectVFGEdge() && "this should be a direct value flow edge!");
         return nullptr;
@@ -701,7 +702,8 @@ VFGEdge* VFG::addCallEdge(NodeID srcId, NodeID dstId, CallSiteID csId)
 {
     VFGNode* srcNode = getVFGNode(srcId);
     VFGNode* dstNode = getVFGNode(dstId);
-    if(VFGEdge* edge = hasInterVFGEdge(srcNode,dstNode, VFGEdge::CallDirVF,csId))
+    VFGEdge* edge = hasInterVFGEdge(srcNode, dstNode, VFGEdge::CallDirVF, csId);
+    if (edge != nullptr)
     {
         assert(edge->isCallDirectVFGEdge() && "this should be a direct value flow edge!");
         return nullptr;
@@ -720,7 +722,8 @@ VFGEdge* VFG::addRetEdge(NodeID srcId, NodeID dstId, CallSiteID csId)
 {
     VFGNode* srcNode = getVFGNode(srcId);
     VFGNode* dstNode = getVFGNode(dstId);
-    if(VFGEdge* edge = hasInterVFGEdge(srcNode,dstNode, VFGEdge::RetDirVF,csId))
+    VFGEdge* edge = hasInterVFGEdge(srcNode, dstNode, VFGEdge::RetDirVF, csId);
+    if (edge != nullptr)
     {
         assert(edge->isRetDirectVFGEdge() && "this should be a direct value flow edge!");
         return nullptr;

package/lib/MSSA/MemRegion.cpp

@@ -562,6 +562,7 @@ void MRGenerator::getEscapObjviaGlobals(NodeBS& globs, const NodeBS& calleeModRe
     for(NodeBS::iterator it = calleeModRef.begin(), eit = calleeModRef.end(); it!=eit; ++it)
     {
         const MemObj* obj = pta->getPAG()->getObject(*it);
+        (void)obj; // Suppress warning of unused variable under release build
         assert(obj && "object not found!!");
         if(allGlobals.test(*it))
             globs.set(*it);

package/lib/MTA/MHP.cpp

@@ -267,7 +267,7 @@ void MHP::handleJoin(const CxtThreadStmt& cts, NodeID rootTid)
     {
         if(const Loop* joinLoop = fja->getJoinLoop(call))
         {
-            SmallBBVector exitbbs;
+            llvm::SmallVector<llvm::BasicBlock*, 8>  exitbbs;
             joinLoop->getExitBlocks(exitbbs);
             while(!exitbbs.empty())
             {
@@ -290,7 +290,7 @@ void MHP::handleJoin(const CxtThreadStmt& cts, NodeID rootTid)
     {
         if(const Loop* joinLoop = fja->getJoinLoop(call))
         {
-            SmallBBVector exitbbs;
+            llvm::SmallVector<llvm::BasicBlock*, 8>  exitbbs;
             joinLoop->getExitBlocks(exitbbs);
             while(!exitbbs.empty())
             {
@@ -853,7 +853,7 @@ void ForkJoinAnalysis::handleJoin(const CxtStmt& cts, NodeID rootTid)
         {
             if(const Loop* joinLoop = getJoinLoop(joinSite))
             {
-                SmallBBVector exitbbs;
+                llvm::SmallVector<llvm::BasicBlock*, 8>  exitbbs;
                 joinLoop->getExitBlocks(exitbbs);
                 while(!exitbbs.empty())
                 {
@@ -882,7 +882,7 @@ void ForkJoinAnalysis::handleJoin(const CxtStmt& cts, NodeID rootTid)
         {
             if(const Loop* joinLoop = getJoinLoop(joinSite))
             {
-                SmallBBVector exitbbs;
+                llvm::SmallVector<llvm::BasicBlock*, 8>  exitbbs;
                 joinLoop->getExitBlocks(exitbbs);
                 while(!exitbbs.empty())
                 {

package/lib/MTA/TCT.cpp

@@ -353,7 +353,7 @@ bool TCT::isLoopExitOfJoinLoop(const BasicBlock* bb)
 {
     for(InstToLoopMap::const_iterator it = joinSiteToLoopMap.begin(), eit = joinSiteToLoopMap.end(); it!=eit; ++it)
     {
-        SmallBBVector exitbbs;
+        llvm::SmallVector<llvm::BasicBlock*, 8>  exitbbs;
         it->second->getExitBlocks(exitbbs);
         while(!exitbbs.empty())
         {
@@ -661,6 +661,7 @@ struct DOTGraphTraits<TCT*> : public DefaultDOTGraphTraits
     {
 
         TCTEdge* edge = csThreadTree->getGraphEdge(node, *EI, TCTEdge::ThreadCreateEdge);
+        (void)edge; // Suppress warning of unused variable under release build
         assert(edge && "No edge found!!");
         /// black edge for direct call while two functions contain indirect calls will be label with red color
         return "color=black";

package/lib/MemoryModel/PointerAnalysisImpl.cpp

@@ -322,7 +322,9 @@ bool BVDataPTAImpl::readFromFile(const string& filename)
         ss >> id >> base >> offset;
 
         NodeID n = pag->getGepObjVar(base, LocationSet(offset));
-        assert(id == n && "Error adding GepObjNode into SVFIR!");
+        bool matched = (id == n);
+        (void)matched;
+        assert(matched && "Error adding GepObjNode into SVFIR!");
 
         getline(F, line);
     }

package/lib/SABER/SaberCondAllocator.cpp

@@ -309,7 +309,9 @@ SaberCondAllocator::Condition SaberCondAllocator::evaluateBranchCond(const Basic
                 {
                     const BasicBlock *succ1 = branchStmt->getSuccessor(0)->getBB();
                     const BasicBlock *succ2 = branchStmt->getSuccessor(1)->getBB();
-                    assert((succ1 == succ || succ2 == succ) && "not a successor??");
+                    bool is_succ = (succ1 == succ || succ2 == succ);
+                    (void)is_succ; // Suppress warning of unused variable under release build
+                    assert(is_succ && "not a successor??");
 
                     Condition evalLoopExit = evaluateLoopExitBranch(bb, succ);
                     if (!eq(evalLoopExit, Condition::nullExpr()))

package/lib/SVF-FE/CHGBuilder.cpp

@@ -491,8 +491,8 @@ void CHGBuilder::analyzeVTables(const Module &M)
                                     else if (const ConstantExpr *aliasconst =
                                                  SVFUtil::dyn_cast<ConstantExpr>(aliasValue))
                                     {
-                                        u32_t aliasopcode = aliasconst->getOpcode();
-                                        assert(aliasopcode == Instruction::BitCast &&
+                                        (void)aliasconst; // Suppress warning of unused variable under release build
+                                        assert(aliasconst->getOpcode() == Instruction::BitCast &&
                                                "aliased constantexpr in vtable not a bitcast");
                                         const Function* aliasbitcastfunc =
                                             SVFUtil::dyn_cast<Function>(aliasconst->getOperand(0));

package/lib/SVF-FE/SVFIRBuilder.cpp

@@ -621,7 +621,10 @@ void SVFIRBuilder::visitPHINode(PHINode &inst)
     {
         const Value* val = inst.getIncomingValue(i);
         const Instruction* incomingInst = SVFUtil::dyn_cast<Instruction>(val);
-        assert((incomingInst==nullptr) || (incomingInst->getFunction() == inst.getFunction()));
+        bool matched = (incomingInst == nullptr ||
+                        incomingInst->getFunction() == inst.getFunction());
+        (void) matched; // Suppress warning of unused variable under release build
+        assert(matched && "incomingInst's Function incorrect");
         const Instruction* predInst = &inst.getIncomingBlock(i)->back();
         const ICFGNode* icfgNode = pag->getICFG()->getICFGNode(predInst);
         NodeID src = getValueNode(val);

package/lib/WPA/AndersenSFR.cpp

@@ -139,7 +139,10 @@ void AndersenSFR::fieldExpand(NodeSet& initials, s32_t offset, NodeBS& strides,
             else if (SVFUtil::isa<FIObjVar>(initPN) || SVFUtil::isa<DummyObjVar>(initPN))
                 initOffset = 0;
             else
+            {
                 assert(false && "Not an object node!!");
+                abort();
+            }
 
             Set<s32_t> offsets;
             offsets.insert(offset);

package/lib/WPA/TypeAnalysis.cpp

@@ -85,6 +85,7 @@ void TypeAnalysis::callGraphSolveBasedOnCHA(const CallSiteToFunPtrMap& callsites
         {
             virtualCallSites.insert(cs);
             const Value *vtbl = getVCallVtblPtr(cs);
+            (void)vtbl; // Suppress warning of unused variable under release build
             assert(pag->hasValueNode(vtbl));
             VFunSet vfns;
             getVFnsFromCHA(cbn, vfns);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "svf-tools",
-  "version": "1.0.587",
+  "version": "1.0.589",
   "description": "* <b>[TypeClone](https://github.com/SVF-tools/SVF/wiki/TypeClone) published in our [ECOOP paper](https://yuleisui.github.io/publications/ecoop20.pdf) is now available in SVF </b> * <b>SVF now uses a single script for its build. Just type [`source ./build.sh`](https://github.com/SVF-tools/SVF/blob/master/build.sh) in your terminal, that's it!</b> * <b>SVF now supports LLVM-10.0.0! </b> * <b>We thank [bsauce](https://github.com/bsauce) for writing a user manual of SVF ([link1](https://www.jianshu.com/p/068a08ec749c) and [link2](https://www.jianshu.com/p/777c30d4240e)) in Chinese </b> * <b>SVF now supports LLVM-9.0.0 (Thank [Byoungyoung Lee](https://github.com/SVF-tools/SVF/issues/142) for his help!). </b> * <b>SVF now supports a set of [field-sensitive pointer analyses](https://yuleisui.github.io/publications/sas2019a.pdf). </b> * <b>[Use SVF as an external lib](https://github.com/SVF-tools/SVF/wiki/Using-SVF-as-a-lib-in-your-own-tool) for your own project (Contributed by [Hongxu Chen](https://github.com/HongxuChen)). </b> * <b>SVF now supports LLVM-7.0.0. </b> * <b>SVF now supports Docker. [Try SVF in Docker](https://github.com/SVF-tools/SVF/wiki/Try-SVF-in-Docker)! </b> * <b>SVF now supports [LLVM-6.0.0](https://github.com/svf-tools/SVF/pull/38) (Contributed by [Jack Anthony](https://github.com/jackanth)). </b> * <b>SVF now supports [LLVM-4.0.0](https://github.com/svf-tools/SVF/pull/23) (Contributed by Jared Carlson. Thank [Jared](https://github.com/jcarlson23) and [Will](https://github.com/dtzWill) for their in-depth [discussions](https://github.com/svf-tools/SVF/pull/18) about updating SVF!) </b> * <b>SVF now supports analysis for C++ programs.</b> <br />",
   "main": "index.js",
   "scripts": {