svf-tools 1.0.613 → 1.0.614

package/include/MemoryModel/PointerAnalysisImpl.h

@@ -71,12 +71,9 @@ public:
     BVDataPTAImpl(SVFIR* pag, PointerAnalysis::PTATY type, bool alias_check = true);
 
     /// Destructor
-    virtual ~BVDataPTAImpl()
-    {
-        destroy();
-    }
+    ~BVDataPTAImpl() override = default;
 
-    inline PersistentPointsToCache<PointsTo> &getPtCache(void)
+    inline PersistentPointsToCache<PointsTo> &getPtCache()
     {
         return ptCache;
     }
@@ -86,21 +83,13 @@ public:
         return pta->getImplTy() == BVDataImpl;
     }
 
-    /// Release memory
-    inline void destroy()
-    {
-        delete ptD;
-        ptD = nullptr;
-        ptCache.clear();
-    }
-
     /// Get points-to and reverse points-to
     ///@{
-    virtual inline const PointsTo& getPts(NodeID id)
+    inline const PointsTo& getPts(NodeID id) override
     {
         return ptD->getPts(id);
     }
-    virtual inline const NodeSet& getRevPts(NodeID nodeId)
+    inline const NodeSet& getRevPts(NodeID nodeId) override
     {
         return ptD->getRevPts(nodeId);
     }
@@ -161,12 +150,12 @@ protected:
     /// Get points-to data structure
     inline PTDataTy* getPTDataTy() const
     {
-        return ptD;
+        return ptD.get();
     }
 
 
     /// Finalization of pointer analysis, and normalize points-to information to Bit Vector representation
-    virtual void finalize();
+    void finalize() override;
 
     /// Update callgraph. This should be implemented by its subclass.
     virtual inline bool updateCallGraph(const CallSiteToFunPtrMap&)
@@ -177,28 +166,28 @@ protected:
 
     inline DiffPTDataTy* getDiffPTDataTy() const
     {
-        DiffPTDataTy* diff = SVFUtil::dyn_cast<DiffPTDataTy>(ptD);
+        DiffPTDataTy* diff = SVFUtil::dyn_cast<DiffPTDataTy>(ptD.get());
         assert(diff && "BVDataPTAImpl::getDiffPTDataTy: not a DiffPTDataTy!");
         return diff;
     }
 
     inline DFPTDataTy* getDFPTDataTy() const
     {
-        DFPTDataTy* df = SVFUtil::dyn_cast<DFPTDataTy>(ptD);
+        DFPTDataTy* df = SVFUtil::dyn_cast<DFPTDataTy>(ptD.get());
         assert(df && "BVDataPTAImpl::getDFPTDataTy: not a DFPTDataTy!");
         return df;
     }
 
     inline MutDFPTDataTy* getMutDFPTDataTy() const
     {
-        MutDFPTDataTy* mdf = SVFUtil::dyn_cast<MutDFPTDataTy>(ptD);
+        MutDFPTDataTy* mdf = SVFUtil::dyn_cast<MutDFPTDataTy>(ptD.get());
         assert(mdf && "BVDataPTAImpl::getMutDFPTDataTy: not a MutDFPTDataTy!");
         return mdf;
     }
 
     inline VersionedPTDataTy* getVersionedPTDataTy() const
     {
-        VersionedPTDataTy* v = SVFUtil::dyn_cast<VersionedPTDataTy>(ptD);
+        VersionedPTDataTy* v = SVFUtil::dyn_cast<VersionedPTDataTy>(ptD.get());
         assert(v && "BVDataPTAImpl::getVersionedPTDataTy: not a VersionedPTDataTy!");
         return v;
     }
@@ -212,31 +201,31 @@ protected:
 
 private:
     /// Points-to data
-    PTDataTy* ptD;
+    std::unique_ptr<PTDataTy> ptD;
 
     PersistentPointsToCache<PointsTo> ptCache;
 
 public:
     /// Interface expose to users of our pointer analysis, given Value infos
-    virtual AliasResult alias(const SVFValue* V1,
-                              const SVFValue* V2);
+    AliasResult alias(const SVFValue* V1,
+                      const SVFValue* V2) override;
 
     /// Interface expose to users of our pointer analysis, given PAGNodeID
-    virtual AliasResult alias(NodeID node1, NodeID node2);
+    AliasResult alias(NodeID node1, NodeID node2) override;
 
     /// Interface expose to users of our pointer analysis, given two pts
     virtual AliasResult alias(const PointsTo& pts1, const PointsTo& pts2);
 
     /// dump and debug, print out conditional pts
     //@{
-    virtual void dumpCPts()
+    void dumpCPts() override
     {
         ptD->dumpPTData();
     }
 
-    virtual void dumpTopLevelPtsTo();
+    void dumpTopLevelPtsTo() override;
 
-    virtual void dumpAllPts();
+    void dumpAllPts() override;
     //@}
 };
 

package/include/MemoryModel/PointsTo.h

@@ -43,28 +43,28 @@ public:
 
 public:
     /// Construct empty points-to set.
-    PointsTo(void);
-    /// Copy costructor.
+    PointsTo();
+    /// Copy constructor.
     PointsTo(const PointsTo &pt);
     /// Move constructor.
-    PointsTo(PointsTo &&pt);
+    PointsTo(PointsTo &&pt) noexcept ;
 
-    ~PointsTo(void);
+    ~PointsTo();
 
     /// Copy assignment.
     PointsTo &operator=(const PointsTo &rhs);
 
     /// Move assignment.
-    PointsTo &operator=(PointsTo &&rhs);
+    PointsTo &operator=(PointsTo &&rhs) noexcept ;
 
     /// Returns true if set is empty.
-    bool empty(void) const;
+    bool empty() const;
 
     /// Returns number of elements.
-    u32_t count(void) const;
+    u32_t count() const;
 
     /// Empty the set.
-    void clear(void);
+    void clear();
 
     /// Returns true if n is in this set.
     bool test(u32_t n) const;
@@ -87,7 +87,7 @@ public:
 
     /// Returns the first element the set. Returns -1 when the set is empty.
     /// TODO: should we diverge from LLVM about the int return?
-    int find_first(void);
+    int find_first();
 
     /// Returns true if this set and rhs contain exactly the same elements.
     bool operator==(const PointsTo &rhs) const;
@@ -116,28 +116,28 @@ public:
     void intersectWithComplement(const PointsTo &lhs, const PointsTo &rhs);
 
     /// Returns this points-to set as a NodeBS.
-    NodeBS toNodeBS(void) const;
+    NodeBS toNodeBS() const;
 
     /// Return a hash of this set.
-    size_t hash(void) const;
+    size_t hash() const;
 
     /// Checks if this points-to set is using the current best mapping.
     /// If not, remaps.
-    void checkAndRemap(void);
+    void checkAndRemap();
 
-    const_iterator begin(void) const
+    const_iterator begin() const
     {
         return PointsToIterator(this);
     }
-    const_iterator end(void) const
+    const_iterator end() const
     {
         return PointsToIterator(this, true);
     }
 
-    MappingPtr getNodeMapping(void) const;
+    MappingPtr getNodeMapping() const;
 
-    static MappingPtr getCurrentBestNodeMapping(void);
-    static MappingPtr getCurrentBestReverseNodeMapping(void);
+    static MappingPtr getCurrentBestNodeMapping();
+    static MappingPtr getCurrentBestReverseNodeMapping();
     static void setCurrentBestNodeMapping(MappingPtr newCurrentBestNodeMapping,
                                           MappingPtr newCurrentBestReverseNodeMapping);
 
@@ -188,25 +188,25 @@ public:
         using reference = u32_t &;
 
         /// Deleted because we don't want iterators with null pt.
-        PointsToIterator(void) = delete;
+        PointsToIterator() = delete;
         PointsToIterator(const PointsToIterator &pt);
-        PointsToIterator(PointsToIterator &&pt);
+        PointsToIterator(PointsToIterator &&pt) noexcept ;
 
         /// Returns an iterator to the beginning of pt if end is false, and to
         /// the end of pt if end is true.
-        PointsToIterator(const PointsTo *pt, bool end=false);
+        explicit PointsToIterator(const PointsTo *pt, bool end=false);
 
         PointsToIterator &operator=(const PointsToIterator &rhs);
-        PointsToIterator &operator=(PointsToIterator &&rhs);
+        PointsToIterator &operator=(PointsToIterator &&rhs) noexcept ;
 
         /// Pre-increment: ++it.
-        const PointsToIterator &operator++(void);
+        const PointsToIterator &operator++();
 
         /// Post-increment: it++.
         const PointsToIterator operator++(int);
 
         /// Dereference: *it.
-        u32_t operator*(void) const;
+        u32_t operator*() const;
 
         /// Equality: *this == rhs.
         bool operator==(const PointsToIterator &rhs) const;
@@ -215,7 +215,7 @@ public:
         bool operator!=(const PointsToIterator &rhs) const;
 
     private:
-        bool atEnd(void) const;
+        bool atEnd() const;
 
     private:
         /// PointsTo we are iterating over.

package/include/SABER/SrcSnkDDA.h

@@ -69,7 +69,7 @@ private:
     ProgSlice* _curSlice;		/// current program slice
     SVFGNodeSet sources;		/// source nodes
     SVFGNodeSet sinks;		/// source nodes
-    SaberCondAllocator* saberCondAllocator;
+    std::unique_ptr<SaberCondAllocator> saberCondAllocator;
     SVFGNodeToDPItemsMap nodeToDPItemsMap;	///<  record forward visited dpitems
     SVFGNodeSet visitedSet;	///<  record backward visited nodes
 
@@ -83,17 +83,14 @@ public:
     /// Constructor
     SrcSnkDDA() : _curSlice(nullptr), svfg(nullptr), ptaCallGraph(nullptr)
     {
-        saberCondAllocator = new SaberCondAllocator();
+        saberCondAllocator = std::make_unique<SaberCondAllocator>();
     }
     /// Destructor
-    virtual ~SrcSnkDDA()
+    ~SrcSnkDDA() override
     {
-        if (svfg != nullptr)
-            delete svfg;
         svfg = nullptr;
 
-        if (_curSlice != nullptr)
-            delete _curSlice;
+        delete _curSlice;
         _curSlice = nullptr;
 
         /// the following shared by multiple checkers, thus can not be released.
@@ -242,12 +239,12 @@ public:
     /// Get saber condition allocator
     SaberCondAllocator* getSaberCondAllocator() const
     {
-        return saberCondAllocator;
+        return saberCondAllocator.get();
     }
 
 protected:
     /// Forward traverse
-    virtual inline void FWProcessCurNode(const DPIm& item)
+    inline void FWProcessCurNode(const DPIm& item) override
     {
         const SVFGNode* node = getNode(item.getCurNodeID());
         if(isSink(node))
@@ -259,7 +256,7 @@ protected:
             addToCurForwardSlice(node);
     }
     /// Backward traverse
-    virtual inline void BWProcessCurNode(const DPIm& item)
+    inline void BWProcessCurNode(const DPIm& item) override
     {
         const SVFGNode* node = getNode(item.getCurNodeID());
         if(isInCurForwardSlice(node))
@@ -268,9 +265,9 @@ protected:
         }
     }
     /// Propagate information forward by matching context
-    virtual void FWProcessOutgoingEdge(const DPIm& item, SVFGEdge* edge);
+    void FWProcessOutgoingEdge(const DPIm& item, SVFGEdge* edge) override;
     /// Propagate information backward without matching context, as forward analysis already did it
-    virtual void BWProcessIncomingEdge(const DPIm& item, SVFGEdge* edge);
+    void BWProcessIncomingEdge(const DPIm& item, SVFGEdge* edge) override;
     /// Whether has been visited or not, in order to avoid recursion on SVFG
     //@{
     inline bool forwardVisited(const SVFGNode* node, const DPIm& item)
@@ -321,4 +318,4 @@ protected:
 
 } // End namespace SVF
 
-#endif /* SRCSNKDDA_H_ */
+#endif /* SRCSNKANALYSIS_H_ */

package/include/SVF-LLVM/LLVMLoopAnalysis.h

@@ -46,7 +46,8 @@ public:
     virtual ~LLVMLoopAnalysis() = default;
 
     /// Build llvm loops based on LoopInfo analysis
-    virtual void buildLLVMLoops(SVFModule *mod, std::vector<const Loop *> &llvmLoops);
+    virtual void buildLLVMLoops(SVFModule *mod, std::vector<const Loop *> &llvmLoops,
+                                llvm::LoopInfoBase<llvm::BasicBlock, llvm::Loop> * loopInfo);
 
     /// Start from here
     virtual void build(ICFG *icfg);

package/include/SVF-LLVM/LLVMModule.h

@@ -58,12 +58,12 @@ public:
     typedef Map<const Value*, SVFOtherValue*> LLVMValue2SVFOtherValueMap;
     typedef Map<const SVFValue*, const Value*> SVFValue2LLVMValueMap;
     typedef Map<const Type*, SVFType*> LLVMType2SVFTypeMap;
-    typedef Map<const Type*, StInfo*> Type2TypeInfoMap;
+    typedef Map<const Type*, std::unique_ptr<StInfo>> Type2TypeInfoMap;
 
 private:
     static LLVMModuleSet* llvmModuleSet;
     SymbolTableInfo *symInfo;
-    SVFModule* svfModule;
+    std::unique_ptr<SVFModule> svfModule;
     std::unique_ptr<LLVMContext> cxts;
     std::vector<std::unique_ptr<Module>> owned_modules;
     std::vector<std::reference_wrapper<Module>> modules;
@@ -112,7 +112,7 @@ public:
     inline SVFModule* getSVFModule()
     {
         assert(svfModule && "svfModule has not been built yet!");
-        return svfModule;
+        return svfModule.get();
     }
 
     void preProcessBCs(std::vector<std::string>& moduleNameVec);
@@ -329,12 +329,12 @@ private:
     SVFType* addSVFTypeInfo(const Type* t);
     /// Collect a type info
     StInfo* collectTypeInfo(const Type* ty);
-    /// Collect the struct info
-    StInfo* collectStructInfo(const StructType *T);
+    /// Collect the struct info; nf contains the number of fields after flattening
+    StInfo* collectStructInfo(const StructType *T, u32_t& nf);
     /// Collect the array info
     StInfo* collectArrayInfo(const ArrayType* T);
     /// Collect simple type (non-aggregate) info
-    StInfo* collectSimpleTypeInfo(const Type* T);
+    StInfo* collectSimpleTypeInfo(StInfo * info, const Type* T);
 
     std::vector<const Function*> getLLVMGlobalFunctions(const GlobalVariable* global);
 

package/include/SVFIR/SVFIR.h

@@ -84,7 +84,7 @@ private:
     CSToArgsListMap callSiteArgsListMap;	///< Map a callsite to a list of all its actual parameters
     CSToRetMap callSiteRetMap;	///< Map a callsite to its callsite returns PAGNodes
     FunToRetMap funRetMap;	///< Map a function to its unique function return PAGNodes
-    static SVFIR* pag;	///< Singleton pattern here to enable instance of SVFIR can only be created once.
+    static std::unique_ptr<SVFIR> pag;	///< Singleton pattern here to enable instance of SVFIR can only be created once.
     CallSiteToFunPtrMap indCallSiteToFunPtrMap; ///< Map an indirect callsite to its function pointer
     FunPtrToCallSitesMap funPtrToCallSitesMap;	///< Map a function pointer to the callsites where it is used
     /// Valid pointers for pointer analysis resolution connected by SVFIR edges (constraints)
@@ -108,14 +108,12 @@ public:
     {
         if (pag == nullptr)
         {
-            pag = new SVFIR(buildFromFile);
+            pag = std::unique_ptr<SVFIR>(new SVFIR(buildFromFile));
         }
-        return pag;
+        return pag.get();
     }
     static void releaseSVFIR()
     {
-        if (pag)
-            delete pag;
         pag = nullptr;
     }
     //@}

package/include/SVFIR/SVFType.h

@@ -150,19 +150,17 @@ private:
     std::vector<const SVFType*> flattenElementTypes;
     /// Max field limit
 
-    StInfo(); ///< place holder
-    StInfo(const StInfo& st); ///< place holder
-    void operator=(const StInfo&); ///< place holder
-
 public:
+    StInfo() = delete;
+    StInfo(const StInfo& st) = delete;
+    void operator=(const StInfo&) = delete;
+
     /// Constructor
-    StInfo(u32_t s) : stride(s), numOfFlattenElements(s), numOfFlattenFields(s)
+    explicit StInfo(u32_t s) : stride(s), numOfFlattenElements(s), numOfFlattenFields(s)
     {
     }
     /// Destructor
-    ~StInfo()
-    {
-    }
+    ~StInfo() = default;
 
     ///  struct A { int id; int salary; }; struct B { char name[20]; struct A a;}   B b;
     ///  OriginalFieldType of b with field_idx 1 : Struct A

package/include/SVFIR/SVFValue.h

@@ -198,7 +198,7 @@ protected:
     }
     ///@}
 public:
-    SVFValue(void) = delete;
+    SVFValue() = delete;
     virtual ~SVFValue() = default;
 
     /// Get the type of this SVFValue
@@ -501,8 +501,8 @@ protected:
 
 public:
     SVFBasicBlock(const std::string& b, const SVFType* ty, const SVFFunction* f);
-    SVFBasicBlock(void) = delete;
-    virtual ~SVFBasicBlock();
+    SVFBasicBlock() = delete;
+    ~SVFBasicBlock() override;
 
     static inline bool classof(const SVFValue *node)
     {

package/include/Util/Options.h

@@ -156,7 +156,6 @@ public:
 
     // SVFG builder (SVFGBuilder.cpp)
     static const llvm::cl::opt<bool> SVFGWithIndirectCall;
-    static const llvm::cl::opt<bool> SingleVFG;
     static llvm::cl::opt<bool> OPTSVFG;
 
     static const llvm::cl::opt<std :: string> WriteSVFG;

package/include/Util/SparseBitVector.h

@@ -228,21 +228,13 @@ public:
 
 private:
     // Index of Element in terms of where first bit starts.
-    unsigned ElementIndex;
-    BitWord Bits[BITWORDS_PER_ELEMENT];
+    unsigned ElementIndex = 0;
+    BitWord Bits[BITWORDS_PER_ELEMENT] = {0};
 
-    SparseBitVectorElement()
-    {
-        ElementIndex = ~0U;
-        memset(&Bits[0], 0, sizeof (BitWord) * BITWORDS_PER_ELEMENT);
-    }
+    SparseBitVectorElement() = default;
 
 public:
-    explicit SparseBitVectorElement(unsigned Idx)
-    {
-        ElementIndex = Idx;
-        memset(&Bits[0], 0, sizeof (BitWord) * BITWORDS_PER_ELEMENT);
-    }
+    explicit SparseBitVectorElement(unsigned Idx) :  ElementIndex(Idx) {}
 
     // Comparison.
     bool operator==(const SparseBitVectorElement &RHS) const
@@ -619,7 +611,7 @@ class SparseBitVector
         }
 
     public:
-        SparseBitVectorIterator() = default;
+        SparseBitVectorIterator() = delete;
 
         SparseBitVectorIterator(const SparseBitVector<ElementSize> *RHS,
                                 bool end = false):BitVector(RHS)
@@ -679,7 +671,7 @@ public:
     SparseBitVector(const SparseBitVector &RHS)
         : Elements(RHS.Elements), CurrElementIter(Elements.begin()) {}
     SparseBitVector(SparseBitVector &&RHS)
-        : Elements(std::move(RHS.Elements)), CurrElementIter(Elements.begin()) {}
+    noexcept         : Elements(std::move(RHS.Elements)), CurrElementIter(Elements.begin()) {}
 
     // Clear.
     void clear()

package/include/WPA/FlowSensitive.h

@@ -58,7 +58,7 @@ public:
     typedef BVDataPTAImpl::MutDFPTDataTy::PtsMap PtsMap;
 
     /// Constructor
-    FlowSensitive(SVFIR* _pag, PTATY type = FSSPARSE_WPA) : WPASVFGFSSolver(), BVDataPTAImpl(_pag, type)
+    explicit FlowSensitive(SVFIR* _pag, PTATY type = FSSPARSE_WPA) : WPASVFGFSSolver(), BVDataPTAImpl(_pag, type)
     {
         svfg = nullptr;
         solveTime = sccTime = processTime = propagationTime = updateTime = 0;
@@ -73,29 +73,22 @@ public:
     }
 
     /// Destructor
-    virtual ~FlowSensitive()
-    {
-        if (svfg != nullptr)
-            delete svfg;
-        svfg = nullptr;
-    }
+    ~FlowSensitive() override = default;
 
     /// Create signle instance of flow-sensitive pointer analysis
     static FlowSensitive* createFSWPA(SVFIR* _pag)
     {
         if (fspta == nullptr)
         {
-            fspta = new FlowSensitive(_pag);
+            fspta = std::unique_ptr<FlowSensitive>(new FlowSensitive(_pag));
             fspta->analyze();
         }
-        return fspta;
+        return fspta.get();
     }
 
     /// Release flow-sensitive pointer analysis
     static void releaseFSWPA()
     {
-        if (fspta)
-            delete fspta;
         fspta = nullptr;
     }
 
@@ -106,16 +99,16 @@ public:
     }
 
     /// Flow sensitive analysis
-    virtual void analyze();
+    void analyze() override;
 
     /// Initialize analysis
-    virtual void initialize();
+    void initialize() override;
 
     /// Finalize analysis
-    virtual void finalize();
+    void finalize() override;
 
     /// Get PTA name
-    virtual const std::string PTAName() const
+    const std::string PTAName() const override
     {
         return "FlowSensitive";
     }
@@ -140,12 +133,12 @@ public:
 
 protected:
     /// SCC detection
-    virtual NodeStack& SCCDetect();
+    NodeStack& SCCDetect() override;
 
     /// Propagation
     //@{
     /// Propagate points-to information from an edge's src node to its dst node.
-    virtual bool propFromSrcToDst(SVFGEdge* edge);
+    bool propFromSrcToDst(SVFGEdge* edge) override;
     /// Propagate points-to information along a DIRECT SVFG edge.
     virtual bool propAlongDirectEdge(const DirectSVFGEdge* edge);
     /// Propagate points-to information along an INDIRECT SVFG edge.
@@ -217,7 +210,7 @@ protected:
 
     /// Handle various constraints
     //@{
-    virtual void processNode(NodeID nodeId);
+    void processNode(NodeID nodeId) override;
     bool processSVFGNode(SVFGNode* node);
     virtual bool processAddr(const AddrSVFGNode* addr);
     virtual bool processCopy(const CopySVFGNode* copy);
@@ -230,7 +223,7 @@ protected:
     /// Update call graph
     //@{
     /// Update call graph.
-    bool updateCallGraph(const CallSiteToFunPtrMap& callsites);
+    bool updateCallGraph(const CallSiteToFunPtrMap& callsites) override;
     /// Connect nodes in SVFG.
     void connectCallerAndCallee(const CallEdgeMap& newEdges, SVFGEdgeSetTy& edges);
     /// Update nodes connected during updating call graph.
@@ -275,7 +268,7 @@ protected:
     /// Sets the global best mapping as a plain mapping, i.e. n -> n.
     virtual void plainMap(void) const;
 
-    static FlowSensitive* fspta;
+    static std::unique_ptr<FlowSensitive> fspta;
     SVFGBuilder memSSA;
     AndersenWaveDiff *ander;
 

package/include/WPA/WPASolver.h

@@ -57,20 +57,16 @@ public:
 protected:
 
     /// Constructor
-    WPASolver(): reanalyze(false), iterationForPrintStat(1000), _graph(nullptr), scc(nullptr), numOfIteration(0)
+    WPASolver(): reanalyze(false), iterationForPrintStat(1000), _graph(nullptr), numOfIteration(0)
     {
     }
     /// Destructor
-    virtual ~WPASolver()
-    {
-        delete scc;
-        scc = nullptr;
-    }
+    virtual ~WPASolver() = default;
 
     /// Get SCC detector
     inline SCC* getSCCDetector() const
     {
-        return scc;
+        return scc.get();
     }
 
     /// Get/Set graph methods
@@ -82,7 +78,7 @@ protected:
     inline void setGraph(GraphType g)
     {
         _graph = g;
-        scc = new SCC(_graph);
+        scc = std::make_unique<SCC>(_graph);
     }
     //@}
 
@@ -194,7 +190,7 @@ protected:
     GraphType _graph;
 
     /// SCC
-    SCC* scc;
+    std::unique_ptr<SCC> scc;
 
     /// Worklist for resolution
     WorkList worklist;

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();