svf-tools 1.0.613 → 1.0.615

package/lib/DDA/DDAPass.cpp

@@ -115,12 +115,12 @@ void DDAPass::runPointerAnalysis(SVFIR* pag, u32_t kind)
     {
     case PointerAnalysis::Cxt_DDA:
     {
-        _pta = new ContextDDA(pag, _client);
+        _pta = std::make_unique<ContextDDA>(pag, _client);
         break;
     }
     case PointerAnalysis::FlowS_DDA:
     {
-        _pta = new FlowDDA(pag, _client);
+        _pta = std::make_unique<FlowDDA>(pag, _client);
         break;
     }
     default:
@@ -137,14 +137,14 @@ void DDAPass::runPointerAnalysis(SVFIR* pag, u32_t kind)
         ///initialize
         _pta->initialize();
         ///compute points-to
-        _client->answerQueries(_pta);
+        _client->answerQueries(_pta.get());
         ///finalize
         _pta->finalize();
         if(Options::PrintCPts)
             _pta->dumpCPts();
 
         if (_pta->printStat())
-            _client->performStat(_pta);
+            _client->performStat(_pta.get());
 
         if (Options::PrintQueryPts)
             printQueryPTS();

package/lib/Graphs/CFLGraph.cpp

@@ -54,7 +54,10 @@ const CFLEdge* CFLGraph::addCFLEdge(CFLNode* src, CFLNode* dst, CFLEdge::GEdgeFl
         return edge;
     }
     else
+    {
+        delete edge;
         return nullptr;
+    }
 }
 
 const CFLEdge* CFLGraph::hasEdge(CFLNode* src, CFLNode* dst, CFLEdge::GEdgeFlag label)

package/lib/Graphs/SVFG.cpp

@@ -197,7 +197,7 @@ FormalOUTSVFGNode::FormalOUTSVFGNode(NodeID id, const MRVer* mrVer, const FunExi
 /*!
  * Constructor
  */
-SVFG::SVFG(MemSSA* _mssa, VFGK k): VFG(_mssa->getPTA()->getPTACallGraph(),k),mssa(_mssa), pta(mssa->getPTA())
+SVFG::SVFG(std::unique_ptr<MemSSA> mssa, VFGK k): VFG(mssa->getPTA()->getPTACallGraph(),k),mssa(std::move(mssa)), pta(this->mssa->getPTA())
 {
     stat = new SVFGStat(this);
 }

package/lib/MSSA/MemSSA.cpp

@@ -357,9 +357,11 @@ MRVer* MemSSA::newSSAName(const MemRegion* mr, MSSADEF* def)
 
     MRVERSION version = mr2CounterMap[mr];
     mr2CounterMap[mr] = version + 1;
-    MRVer* mrVer = new MRVer(mr, version, def);
-    mr2VerStackMap[mr].push_back(mrVer);
-    return mrVer;
+    auto mrVer = std::make_unique<MRVer>(mr, version, def);
+    auto mrVerPtr = mrVer.get();
+    mr2VerStackMap[mr].push_back(mrVerPtr);
+    usedMRVers.push_back(std::move(mrVer));
+    return mrVerPtr;
 }
 
 /*!

package/lib/MSSA/SVFGBuilder.cpp

@@ -38,9 +38,6 @@ using namespace SVF;
 using namespace SVFUtil;
 
 
-SVFG* SVFGBuilder::globalSvfg = nullptr;
-
-
 SVFG* SVFGBuilder::buildPTROnlySVFG(BVDataPTAImpl* pta)
 {
     if(Options::OPTSVFG)
@@ -67,41 +64,26 @@ void SVFGBuilder::buildSVFG()
 SVFG* SVFGBuilder::build(BVDataPTAImpl* pta, VFG::VFGK kind)
 {
 
-    MemSSA* mssa = buildMSSA(pta, (VFG::PTRONLYSVFG==kind || VFG::PTRONLYSVFG_OPT==kind));
+    auto mssa = buildMSSA(pta, (VFG::PTRONLYSVFG==kind || VFG::PTRONLYSVFG_OPT==kind));
 
     DBOUT(DGENERAL, outs() << pasMsg("Build Sparse Value-Flow Graph \n"));
-    if(Options::SingleVFG)
-    {
-        if(globalSvfg==nullptr)
-        {
-            /// Note that we use callgraph from andersen analysis here
-            if(kind == VFG::FULLSVFG_OPT || kind == VFG::PTRONLYSVFG_OPT)
-                svfg = globalSvfg = new SVFGOPT(mssa, kind);
-            else
-                svfg = globalSvfg = new SVFG(mssa, kind);
-            buildSVFG();
-        }
-    }
+    if(kind == VFG::FULLSVFG_OPT || kind == VFG::PTRONLYSVFG_OPT)
+        svfg = std::make_unique<SVFGOPT>(std::move(mssa), kind);
     else
-    {
-        if(kind == VFG::FULLSVFG_OPT || kind == VFG::PTRONLYSVFG_OPT)
-            svfg = new SVFGOPT(mssa, kind);
-        else
-            svfg = new SVFG(mssa,kind);
-        buildSVFG();
-    }
+        svfg = std::unique_ptr<SVFG>(new SVFG(std::move(mssa),kind));
+    buildSVFG();
 
     /// Update call graph using pre-analysis results
     if(Options::SVFGWithIndirectCall || SVFGWithIndCall)
         svfg->updateCallGraph(pta);
 
-    if(mssa->getPTA()->printStat())
+    if(svfg->getMSSA()->getPTA()->printStat())
         svfg->performStat();
 
     if(Options::DumpVFG)
         svfg->dump("svfg_final");
 
-    return svfg;
+    return svfg.get();
 }
 
 /*!
@@ -112,12 +94,12 @@ void SVFGBuilder::releaseMemory()
     svfg->clearMSSA();
 }
 
-MemSSA* SVFGBuilder::buildMSSA(BVDataPTAImpl* pta, bool ptrOnlyMSSA)
+std::unique_ptr<MemSSA> SVFGBuilder::buildMSSA(BVDataPTAImpl* pta, bool ptrOnlyMSSA)
 {
 
     DBOUT(DGENERAL, outs() << pasMsg("Build Memory SSA \n"));
 
-    MemSSA* mssa = new MemSSA(pta, ptrOnlyMSSA);
+    auto mssa = std::make_unique<MemSSA>(pta, ptrOnlyMSSA);
 
     SVFModule* svfModule = mssa->getPTA()->getModule();
     for (SVFModule::const_iterator iter = svfModule->begin(), eiter = svfModule->end();

package/lib/MTA/MTA.cpp

@@ -43,7 +43,7 @@ using namespace SVFUtil;
 
 MTA::MTA() : tcg(nullptr), tct(nullptr), mhp(nullptr), lsa(nullptr)
 {
-    stat = new MTAStat();
+    stat = std::make_unique<MTAStat>();
 }
 
 MTA::~MTA()
@@ -129,7 +129,7 @@ MHP* MTA::computeMHP(SVFModule* module)
     DBOUT(DGENERAL, outs() << pasMsg("Build TCT\n"));
     DBOUT(DMTA, outs() << pasMsg("Build TCT\n"));
     DOTIMESTAT(double tctStart = stat->getClk());
-    tct = new TCT(pta);
+    tct = std::make_unique<TCT>(pta);
     tcg = tct->getThreadCallGraph();
     DOTIMESTAT(double tctEnd = stat->getClk());
     DOTIMESTAT(stat->TCTTime += (tctEnd - tctStart) / TIMEINTERVAL);
@@ -137,7 +137,7 @@ MHP* MTA::computeMHP(SVFModule* module)
     if (pta->printStat())
     {
         stat->performThreadCallGraphStat(tcg);
-        stat->performTCTStat(tct);
+        stat->performTCTStat(tct.get());
     }
 
     tcg->dump("tcg");
@@ -146,7 +146,7 @@ MHP* MTA::computeMHP(SVFModule* module)
     DBOUT(DMTA, outs() << pasMsg("MHP analysis\n"));
 
     DOTIMESTAT(double mhpStart = stat->getClk());
-    MHP* mhp = new MHP(tct);
+    MHP* mhp = new MHP(tct.get());
     mhp->analyze();
     DOTIMESTAT(double mhpEnd = stat->getClk());
     DOTIMESTAT(stat->MHPTime += (mhpEnd - mhpStart) / TIMEINTERVAL);

package/lib/MemoryModel/PointerAnalysisImpl.cpp

@@ -53,36 +53,36 @@ BVDataPTAImpl::BVDataPTAImpl(SVFIR* p, PointerAnalysis::PTATY type, bool alias_c
         // Only maintain reverse points-to when the analysis is field-sensitive, as objects turning
         // field-insensitive is all it is used for.
         bool maintainRevPts = Options::MaxFieldLimit != 0;
-        if (Options::ptDataBacking == PTBackingType::Mutable) ptD = new MutDiffPTDataTy(maintainRevPts);
-        else if (Options::ptDataBacking == PTBackingType::Persistent) ptD = new PersDiffPTDataTy(getPtCache(), maintainRevPts);
+        if (Options::ptDataBacking == PTBackingType::Mutable) ptD = std::make_unique<MutDiffPTDataTy>(maintainRevPts);
+        else if (Options::ptDataBacking == PTBackingType::Persistent) ptD = std::make_unique<PersDiffPTDataTy>(getPtCache(), maintainRevPts);
         else assert(false && "BVDataPTAImpl::BVDataPTAImpl: unexpected points-to backing type!");
     }
     else if (type == Steensgaard_WPA)
     {
         // Steensgaard is only field-insensitive (for now?), so no reverse points-to.
-        if (Options::ptDataBacking == PTBackingType::Mutable) ptD = new MutDiffPTDataTy(false);
-        else if (Options::ptDataBacking == PTBackingType::Persistent) ptD = new PersDiffPTDataTy(getPtCache(), false);
+        if (Options::ptDataBacking == PTBackingType::Mutable) ptD = std::make_unique<MutDiffPTDataTy>(false);
+        else if (Options::ptDataBacking == PTBackingType::Persistent) ptD = std::make_unique<PersDiffPTDataTy>(getPtCache(), false);
         else assert(false && "BVDataPTAImpl::BVDataPTAImpl: unexpected points-to backing type!");
     }
     else if (type == FSSPARSE_WPA)
     {
         if (Options::INCDFPTData)
         {
-            if (Options::ptDataBacking == PTBackingType::Mutable) ptD = new MutIncDFPTDataTy(false);
-            else if (Options::ptDataBacking == PTBackingType::Persistent) ptD = new PersIncDFPTDataTy(getPtCache(), false);
+            if (Options::ptDataBacking == PTBackingType::Mutable) ptD = std::make_unique<MutIncDFPTDataTy>(false);
+            else if (Options::ptDataBacking == PTBackingType::Persistent) ptD = std::make_unique<PersIncDFPTDataTy>(getPtCache(), false);
             else assert(false && "BVDataPTAImpl::BVDataPTAImpl: unexpected points-to backing type!");
         }
         else
         {
-            if (Options::ptDataBacking == PTBackingType::Mutable) ptD = new MutDFPTDataTy(false);
-            else if (Options::ptDataBacking == PTBackingType::Persistent) ptD = new PersDFPTDataTy(getPtCache(), false);
+            if (Options::ptDataBacking == PTBackingType::Mutable) ptD = std::make_unique<MutDFPTDataTy>(false);
+            else if (Options::ptDataBacking == PTBackingType::Persistent) ptD = std::make_unique<PersDFPTDataTy>(getPtCache(), false);
             else assert(false && "BVDataPTAImpl::BVDataPTAImpl: unexpected points-to backing type!");
         }
     }
     else if (type == VFS_WPA)
     {
-        if (Options::ptDataBacking == PTBackingType::Mutable) ptD = new MutVersionedPTDataTy(false);
-        else if (Options::ptDataBacking == PTBackingType::Persistent) ptD = new PersVersionedPTDataTy(getPtCache(), false);
+        if (Options::ptDataBacking == PTBackingType::Mutable) ptD = std::make_unique<MutVersionedPTDataTy>(false);
+        else if (Options::ptDataBacking == PTBackingType::Persistent) ptD = std::make_unique<PersVersionedPTDataTy>(getPtCache(), false);
         else assert(false && "BVDataPTAImpl::BVDataPTAImpl: unexpected points-to backing type!");
     }
     else assert(false && "no points-to data available");

package/lib/MemoryModel/PointsTo.cpp

@@ -10,6 +10,7 @@
  */
 
 #include <new>
+#include <utility>
 
 #include "Util/Options.h"
 #include "MemoryModel/PointsTo.h"
@@ -21,7 +22,7 @@ namespace SVF
 PointsTo::MappingPtr PointsTo::currentBestNodeMapping = nullptr;
 PointsTo::MappingPtr PointsTo::currentBestReverseNodeMapping = nullptr;
 
-PointsTo::PointsTo(void)
+PointsTo::PointsTo()
     : type(Options::PtType), nodeMapping(currentBestNodeMapping),
       reverseNodeMapping(currentBestReverseNodeMapping)
 {
@@ -42,8 +43,8 @@ PointsTo::PointsTo(const PointsTo &pt)
 }
 
 PointsTo::PointsTo(PointsTo &&pt)
-    : type(pt.type), nodeMapping(pt.nodeMapping),
-      reverseNodeMapping(pt.reverseNodeMapping)
+noexcept     : type(pt.type), nodeMapping(std::move(pt.nodeMapping)),
+    reverseNodeMapping(std::move(pt.reverseNodeMapping))
 {
     if (type == SBV) new (&sbv) SparseBitVector<>(std::move(pt.sbv));
     else if (type == CBV) new (&cbv) CoreBitVector(std::move(pt.cbv));
@@ -51,7 +52,7 @@ PointsTo::PointsTo(PointsTo &&pt)
     else assert(false && "PointsTo::PointsTo&&: unknown type");
 }
 
-PointsTo::~PointsTo(void)
+PointsTo::~PointsTo()
 {
     if (type == SBV) sbv.~SparseBitVector<>();
     else if (type == CBV) cbv.~CoreBitVector();
@@ -64,6 +65,8 @@ PointsTo::~PointsTo(void)
 
 PointsTo &PointsTo::operator=(const PointsTo &rhs)
 {
+    if (this == &rhs)
+        return *this;
     this->type = rhs.type;
     this->nodeMapping = rhs.nodeMapping;
     this->reverseNodeMapping = rhs.reverseNodeMapping;
@@ -78,6 +81,7 @@ PointsTo &PointsTo::operator=(const PointsTo &rhs)
 }
 
 PointsTo &PointsTo::operator=(PointsTo &&rhs)
+noexcept
 {
     this->type = rhs.type;
     this->nodeMapping = rhs.nodeMapping;
@@ -91,7 +95,7 @@ PointsTo &PointsTo::operator=(PointsTo &&rhs)
     return *this;
 }
 
-bool PointsTo::empty(void) const
+bool PointsTo::empty() const
 {
     if (type == CBV) return cbv.empty();
     else if (type == SBV) return sbv.empty();
@@ -116,7 +120,7 @@ u32_t PointsTo::count(void) const
     }
 }
 
-void PointsTo::clear(void)
+void PointsTo::clear()
 {
     if (type == CBV) cbv.clear();
     else if (type == SBV) sbv.clear();
@@ -196,7 +200,7 @@ bool PointsTo::intersects(const PointsTo &rhs) const
     }
 }
 
-int PointsTo::find_first(void)
+int PointsTo::find_first()
 {
     if (count() == 0) return -1;
     return *begin();
@@ -306,14 +310,14 @@ void PointsTo::intersectWithComplement(const PointsTo &lhs, const PointsTo &rhs)
     }
 }
 
-NodeBS PointsTo::toNodeBS(void) const
+NodeBS PointsTo::toNodeBS() const
 {
     NodeBS nbs;
     for (const NodeID o : *this) nbs.set(o);
     return nbs;
 }
 
-size_t PointsTo::hash(void) const
+size_t PointsTo::hash() const
 {
     if (type == CBV) return cbv.hash();
     else if (type == SBV)
@@ -330,7 +334,7 @@ size_t PointsTo::hash(void) const
     }
 }
 
-PointsTo::MappingPtr PointsTo::getNodeMapping(void) const
+PointsTo::MappingPtr PointsTo::getNodeMapping() const
 {
     return nodeMapping;
 }
@@ -354,12 +358,12 @@ bool PointsTo::metaSame(const PointsTo &pt) const
     return nodeMapping == pt.nodeMapping && reverseNodeMapping == pt.reverseNodeMapping;
 }
 
-PointsTo::MappingPtr PointsTo::getCurrentBestNodeMapping(void)
+PointsTo::MappingPtr PointsTo::getCurrentBestNodeMapping()
 {
     return currentBestNodeMapping;
 }
 
-PointsTo::MappingPtr PointsTo::getCurrentBestReverseNodeMapping(void)
+PointsTo::MappingPtr PointsTo::getCurrentBestReverseNodeMapping()
 {
     return currentBestReverseNodeMapping;
 }
@@ -367,11 +371,11 @@ PointsTo::MappingPtr PointsTo::getCurrentBestReverseNodeMapping(void)
 void PointsTo::setCurrentBestNodeMapping(MappingPtr newCurrentBestNodeMapping,
         MappingPtr newCurrentBestReverseNodeMapping)
 {
-    currentBestNodeMapping = newCurrentBestNodeMapping;
-    currentBestReverseNodeMapping = newCurrentBestReverseNodeMapping;
+    currentBestNodeMapping = std::move(newCurrentBestNodeMapping);
+    currentBestReverseNodeMapping = std::move(newCurrentBestReverseNodeMapping);
 }
 
-void PointsTo::checkAndRemap(void)
+void PointsTo::checkAndRemap()
 {
     if (nodeMapping != currentBestNodeMapping)
     {
@@ -427,7 +431,7 @@ PointsTo::PointsToIterator::PointsToIterator(const PointsToIterator &pt)
 }
 
 PointsTo::PointsToIterator::PointsToIterator(PointsToIterator &&pt)
-    : pt(pt.pt)
+noexcept     : pt(pt.pt)
 {
     if (this->pt->type == PointsTo::Type::SBV)
     {
@@ -490,7 +494,7 @@ PointsTo::PointsToIterator &PointsTo::PointsToIterator::operator=(PointsToIterat
     return *this;
 }
 
-const PointsTo::PointsToIterator &PointsTo::PointsToIterator::operator++(void)
+const PointsTo::PointsToIterator &PointsTo::PointsToIterator::operator++()
 {
     assert(!atEnd() && "PointsToIterator::++(pre): incrementing past end!");
     if (pt->type == Type::CBV) ++cbvIt;
@@ -509,7 +513,7 @@ const PointsTo::PointsToIterator PointsTo::PointsToIterator::operator++(int)
     return old;
 }
 
-NodeID PointsTo::PointsToIterator::operator*(void) const
+NodeID PointsTo::PointsToIterator::operator*() const
 {
     assert(!atEnd() && "PointsToIterator: dereferencing end!");
     if (pt->type == Type::CBV) return pt->getExternalNode(*cbvIt);
@@ -545,7 +549,7 @@ bool PointsTo::PointsToIterator::operator!=(const PointsToIterator &rhs) const
     return !(*this == rhs);
 }
 
-bool PointsTo::PointsToIterator::atEnd(void) const
+bool PointsTo::PointsToIterator::atEnd() const
 {
     assert(pt != nullptr && "PointsToIterator::atEnd: iterator iterating over nothing!");
     if (pt->type == Type::CBV) return cbvIt == pt->cbv.end();

package/lib/SVF-LLVM/LLVMLoopAnalysis.cpp

@@ -44,7 +44,7 @@ using namespace SVFUtil;
  * @param mod SVF module
  * @param llvmLoops output llvm loops
  */
-void LLVMLoopAnalysis::buildLLVMLoops(SVFModule *mod, std::vector<const Loop *> &llvmLoops)
+void LLVMLoopAnalysis::buildLLVMLoops(SVFModule *mod, std::vector<const Loop *> &llvmLoops, llvm::LoopInfoBase<llvm::BasicBlock, llvm::Loop> * loopInfo)
 {
     llvm::DominatorTree DT = llvm::DominatorTree();
     std::vector<const Loop *> loop_stack;
@@ -57,8 +57,6 @@ void LLVMLoopAnalysis::buildLLVMLoops(SVFModule *mod, std::vector<const Loop *>
             // do not analyze external call
             if (SVFUtil::isExtCall(svffun)) continue;
             DT.recalculate(const_cast<Function&>(*func));
-            auto loopInfo = new llvm::LoopInfoBase<llvm::BasicBlock, llvm::Loop>();
-            loopInfo->releaseMemory();
             loopInfo->analyze(DT);
             for (const auto &loop: *loopInfo)
             {
@@ -86,7 +84,8 @@ void LLVMLoopAnalysis::buildLLVMLoops(SVFModule *mod, std::vector<const Loop *>
 void LLVMLoopAnalysis::build(ICFG *icfg)
 {
     std::vector<const Loop *> llvmLoops;
-    buildLLVMLoops(PAG::getPAG()->getModule(), llvmLoops);
+    llvm::LoopInfoBase<llvm::BasicBlock, llvm::Loop> loopInfo;
+    buildLLVMLoops(PAG::getPAG()->getModule(), llvmLoops, &loopInfo);
     buildSVFLoops(icfg, llvmLoops);
 }
 

package/lib/SVF-LLVM/LLVMModule.cpp

@@ -83,12 +83,12 @@ LLVMModuleSet::~LLVMModuleSet()
 
 SVFModule* LLVMModuleSet::buildSVFModule(Module &mod)
 {
-    svfModule = new SVFModule(mod.getModuleIdentifier());
+    svfModule = std::make_unique<SVFModule>(mod.getModuleIdentifier());
     modules.emplace_back(mod);
 
     build();
 
-    return svfModule;
+    return svfModule.get();
 }
 
 SVFModule* LLVMModuleSet::buildSVFModule(const std::vector<std::string> &moduleNameVec)
@@ -100,9 +100,9 @@ SVFModule* LLVMModuleSet::buildSVFModule(const std::vector<std::string> &moduleN
     loadModules(moduleNameVec);
 
     if(!moduleNameVec.empty())
-        svfModule = new SVFModule(*moduleNameVec.begin());
+        svfModule = std::make_unique<SVFModule>(*moduleNameVec.begin());
     else
-        svfModule = new SVFModule();
+        svfModule = std::make_unique<SVFModule>();
 
     build();
 
@@ -115,12 +115,12 @@ SVFModule* LLVMModuleSet::buildSVFModule(const std::vector<std::string> &moduleN
         /// building symbol table
         DBOUT(DGENERAL, SVFUtil::outs() << SVFUtil::pasMsg("Building Symbol table ...\n"));
         SymbolTableBuilder builder(symInfo);
-        builder.buildMemModel(svfModule);
+        builder.buildMemModel(svfModule.get());
     }
     double endSymInfoTime = SVFStat::getClk(true);
     SVFStat::timeOfBuildingSymbolTable = (endSymInfoTime - startSymInfoTime)/TIMEINTERVAL;
 
-    return svfModule;
+    return svfModule.get();
 }
 
 void LLVMModuleSet::build()
@@ -983,18 +983,37 @@ StInfo* LLVMModuleSet::collectTypeInfo(const Type* T)
     Type2TypeInfoMap::iterator tit = Type2TypeInfo.find(T);
     if(tit!=Type2TypeInfo.end())
     {
-        stinfo = tit->second;
+        stinfo = tit->second.get();
     }
     else
     {
         if (const ArrayType* aty = SVFUtil::dyn_cast<ArrayType>(T))
+        {
             stinfo = collectArrayInfo(aty);
+            Type2TypeInfo[T] = std::unique_ptr<StInfo>(stinfo);
+        }
         else if (const StructType* sty = SVFUtil::dyn_cast<StructType>(T))
-            stinfo = collectStructInfo(sty);
+        {
+            u32_t nf;
+            stinfo = collectStructInfo(sty, nf);
+            Type2TypeInfo[T] = std::unique_ptr<StInfo>(stinfo);
+            //Record the size of the complete struct and update max_struct.
+            if (nf > symInfo->maxStSize)
+            {
+                symInfo->maxStruct = getSVFType(sty);
+                symInfo->maxStSize = nf;
+            }
+        }
         else
-            stinfo = collectSimpleTypeInfo(T);
+        {
+            /// The simple type info should not be processed before
+            auto stinfo_own = std::make_unique<StInfo>(1);
+            stinfo = stinfo_own.get();
+            Type2TypeInfo[T] = std::move(stinfo_own);
+            collectSimpleTypeInfo(stinfo, T);
+        }
+
 
-        Type2TypeInfo[T] = stinfo;
     }
     return stinfo;
 }
@@ -1081,13 +1100,13 @@ StInfo* LLVMModuleSet::collectArrayInfo(const ArrayType* ty)
  * Fill in struct_info for T.
  * Given a Struct type, we recursively extend and record its fields and types.
  */
-StInfo* LLVMModuleSet::collectStructInfo(const StructType *sty)
+StInfo* LLVMModuleSet::collectStructInfo(const StructType *sty, u32_t &nf)
 {
     /// The struct info should not be processed before
     StInfo* stinfo = new StInfo(1);
 
     // Number of fields after flattening the struct
-    u32_t nf = 0;
+    nf = 0;
     // The offset when considering array stride info
     u32_t strideOffset = 0;
     for (StructType::element_iterator it = sty->element_begin(), ie =
@@ -1129,13 +1148,6 @@ StInfo* LLVMModuleSet::collectStructInfo(const StructType *sty)
     assert(stinfo->getFlattenElementTypes().size() == strideOffset && "typeForStruct size incorrect!");
     stinfo->setNumOfFieldsAndElems(nf,strideOffset);
 
-    //Record the size of the complete struct and update max_struct.
-    if (nf > symInfo->maxStSize)
-    {
-        symInfo->maxStruct = getSVFType(sty);
-        symInfo->maxStSize = nf;
-    }
-
     return stinfo;
 }
 
@@ -1143,9 +1155,8 @@ StInfo* LLVMModuleSet::collectStructInfo(const StructType *sty)
 /*!
  * Collect simple type (non-aggregate) info
  */
-StInfo* LLVMModuleSet::collectSimpleTypeInfo(const Type* ty)
+StInfo* LLVMModuleSet::collectSimpleTypeInfo(StInfo * stinfo, const Type* ty)
 {
-    StInfo* stinfo = new StInfo(1);
     /// Only one field
     stinfo->addFldWithType(0, getSVFType(ty), 0);
 

package/lib/SVFIR/SVFIR.cpp

@@ -34,7 +34,7 @@ using namespace SVF;
 using namespace SVFUtil;
 
 
-SVFIR* SVFIR::pag = nullptr;
+std::unique_ptr<SVFIR> SVFIR::pag;
 
 SVFIR::SVFIR(bool buildFromFile) : IRGraph(buildFromFile), svfModule(nullptr), icfg(nullptr), chgraph(nullptr)
 {

package/lib/SVFIR/SymbolTableInfo.cpp

@@ -127,23 +127,12 @@ void SymbolTableInfo::destroy()
         if (iter->second)
             delete iter->second;
     }
-    Set<const StInfo*> stinfos;
-    for (SVFTypeSet::const_iterator iter = svfTypes.begin();
-            iter != svfTypes.end(); ++iter)
-    {
-        const SVFType* type = *iter;
-        stinfos.insert(type->getTypeInfo());
-        delete type;
-    }
 
-    for (const StInfo* si : stinfos)
-        delete si;
+    for (auto * type: svfTypes)
+        delete type;
+    svfTypes.clear();
 
-    if(mod)
-    {
-        delete mod;
-        mod = nullptr;
-    }
+    mod = nullptr;
 }
 
 const MemObj* SymbolTableInfo::createDummyObj(SymID symId, const SVFType* type)

package/lib/Util/Options.cpp

@@ -458,12 +458,6 @@ const llvm::cl::opt<bool> Options::SVFGWithIndirectCall(
     llvm::cl::desc("Update Indirect Calls for SVFG using pre-analysis")
 );
 
-const llvm::cl::opt<bool> Options::SingleVFG(
-    "single-vfg",
-    llvm::cl::init(false),
-    llvm::cl::desc("Create a single VFG shared by multiple analysis")
-);
-
 llvm::cl::opt<bool> Options::OPTSVFG(
     "opt-svfg",
     llvm::cl::init(false),

package/lib/WPA/AndersenSFR.cpp

@@ -45,7 +45,7 @@ void AndersenSFR::initialize()
     setDetectPWC(false);   // SCC will detect only copy edges
 
     if (!csc)
-        csc = new CSC(_graph, scc);
+        csc = new CSC(_graph, scc.get());
 
     /// Detect and collapse cycles consisting of only copy edges
     getSCCDetector()->find();

package/lib/WPA/FlowSensitive.cpp

@@ -37,7 +37,7 @@
 using namespace SVF;
 using namespace SVFUtil;
 
-FlowSensitive* FlowSensitive::fspta = nullptr;
+std::unique_ptr<FlowSensitive> FlowSensitive::fspta;
 
 /*!
  * Initialize analysis

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "svf-tools",
-  "version": "1.0.613",
+  "version": "1.0.615",
   "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": {

package/tools/CFL/cfl.cpp

@@ -64,17 +64,18 @@ int main(int argc, char ** argv)
         svfir = builder.build();
     }  // if no dot form CFLGraph is specified, we use svfir from .bc.
 
-    CFLBase* cfl;
+    std::unique_ptr<CFLBase> cfl;
     if (Options::CFLSVFG)
-        cfl = new CFLVF(svfir);
+        cfl = std::make_unique<CFLVF>(svfir);
     else
-        cfl = new CFLAlias(svfir); // if no svfg is specified, we use CFLAlias as the default one.
+        cfl = std::make_unique<CFLAlias>(svfir); // if no svfg is specified, we use CFLAlias as the default one.
     cfl->analyze();
 
-    delete cfl;
     SVFIR::releaseSVFIR();
     SVF::LLVMModuleSet::releaseLLVMModuleSet();
 
+    delete[] arg_value;
+
     return 0;
 
 }

package/tools/DDA/dda.cpp

@@ -61,9 +61,10 @@ int main(int argc, char ** argv)
     SVFIRBuilder builder(svfModule);
     SVFIR* pag = builder.build();
 
-    DDAPass *dda = new DDAPass();
-    dda->runOnModule(pag);
+    DDAPass dda;
+    dda.runOnModule(pag);
 
+    delete[] arg_value;
     return 0;
 
 }