svf-lib 1.0.1374 → 1.0.1376

package/SVF-osx/svf/include/include/DDA/FlowDDA.h

@@ -0,0 +1,178 @@
+//===- FlowDDA.h -- Flow-sensitive demand-driven analysis -------------//
+//
+//                     SVF: Static Value-Flow Analysis
+//
+// Copyright (C) <2013->  <Yulei Sui>
+//
+
+// This program is free software: you can redistribute it and/or modify
+// it under the terms of the GNU General Public License as published by
+// the Free Software Foundation, either version 3 of the License, or
+// (at your option) any later version.
+
+// This program is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+// GNU General Public License for more details.
+
+// You should have received a copy of the GNU General Public License
+// along with this program.  If not, see <http://www.gnu.org/licenses/>.
+//
+//===----------------------------------------------------------------------===//
+
+/*
+ * FlowDDA.h
+ *
+ *  Created on: Jun 30, 2014
+ *      Author: Yulei Sui, Sen Ye
+ *
+ * The implementation is based on
+ * (1) Yulei Sui and Jingling Xue. "On-Demand Strong Update Analysis via Value-Flow Refinement".
+ * ACM SIGSOFT International Symposium on the Foundation of Software Engineering (FSE'16)
+ *
+ * (2) Yulei Sui and Jingling Xue. "Value-Flow-Based Demand-Driven Pointer Analysis for C and C++".
+ * IEEE Transactions on Software Engineering (TSE'18)
+ */
+
+#ifndef FlowDDA_H_
+#define FlowDDA_H_
+
+#include "MemoryModel/PointerAnalysisImpl.h"
+#include "Util/DPItem.h"
+#include "DDA/DDAVFSolver.h"
+
+namespace SVF
+{
+
+class DDAClient;
+typedef StmtDPItem<SVFGNode> LocDPItem;
+
+/*!
+ * Flow sensitive demand-driven analysis on value-flow graph
+ */
+class FlowDDA : public BVDataPTAImpl, public DDAVFSolver<NodeID,PointsTo,LocDPItem>
+{
+
+public:
+    typedef BVDataPTAImpl::CallSiteSet CallSiteSet;
+    typedef BVDataPTAImpl::CallEdgeMap	CallEdgeMap;
+    typedef BVDataPTAImpl::FunctionSet	FunctionSet;
+    /// Constructor
+    FlowDDA(SVFIR* _pag, DDAClient* client): BVDataPTAImpl(_pag, PointerAnalysis::FlowS_DDA),
+        DDAVFSolver<NodeID,PointsTo,LocDPItem>(),
+        _client(client)
+    {
+    }
+    /// Destructor
+    inline virtual ~FlowDDA()
+    {
+    }
+    /// dummy analyze method
+    virtual void analyze() override {}
+
+    /// Compute points-to set for all top variable
+    void computeDDAPts(NodeID id) override;
+
+    /// Handle out-of-budget dpm
+    void handleOutOfBudgetDpm(const LocDPItem& dpm);
+
+    /// Handle condition for flow analysis (backward analysis)
+    virtual bool handleBKCondition(LocDPItem& dpm, const SVFGEdge* edge) override;
+
+    /// refine indirect call edge
+    bool testIndCallReachability(LocDPItem& dpm, const SVFFunction* callee, CallSiteID csId);
+
+    /// Initialization of the analysis
+    inline virtual void initialize() override
+    {
+        BVDataPTAImpl::initialize();
+        buildSVFG(pag);
+        setCallGraph(getPTACallGraph());
+        setCallGraphSCC(getCallGraphSCC());
+        stat = setDDAStat(new DDAStat(this));
+    }
+
+    /// Finalize analysis
+    inline virtual void finalize() override
+    {
+        BVDataPTAImpl::finalize();
+    }
+
+    /// we exclude concrete heap here following the conditions:
+    /// (1) local allocated heap and
+    /// (2) not escaped to the scope outside the current function
+    /// (3) not inside loop
+    /// (4) not involved in recursion
+    virtual bool isHeapCondMemObj(const NodeID& var, const StoreSVFGNode* store) override;
+
+    /// Override parent method
+    virtual inline PointsTo getConservativeCPts(const LocDPItem& dpm) override
+    {
+        return getAndersenAnalysis()->getPts(dpm.getCurNodeID());
+    }
+    /// Override parent method
+    virtual inline NodeID getPtrNodeID(const NodeID& var) const override
+    {
+        return var;
+    }
+    /// Handle Address SVFGNode to add proper points-to
+    virtual inline void handleAddr(PointsTo& pts,const LocDPItem& dpm,const AddrSVFGNode* addr) override
+    {
+        NodeID srcID = addr->getPAGSrcNodeID();
+        /// whether this object is set field-insensitive during pre-analysis
+        if (isFieldInsensitive(srcID))
+            srcID = getFIObjVar(srcID);
+
+        addDDAPts(pts,srcID);
+        DBOUT(DDDA, SVFUtil::outs() << "\t add points-to target " << srcID << " to dpm ");
+        DBOUT(DDDA, dpm.dump());
+    }
+    /// processGep node
+    virtual PointsTo processGepPts(const GepSVFGNode* gep, const PointsTo& srcPts) override;
+
+    /// Update call graph.
+    //@{
+    virtual void updateCallGraphAndSVFG(const LocDPItem& dpm,const CallICFGNode* cs,SVFGEdgeSet& svfgEdges) override
+    {
+        CallEdgeMap newEdges;
+        resolveIndCalls(cs, getCachedPointsTo(dpm), newEdges);
+        for (CallEdgeMap::const_iterator iter = newEdges.begin(),eiter = newEdges.end(); iter != eiter; iter++)
+        {
+            const CallICFGNode* newcs = iter->first;
+            const FunctionSet & functions = iter->second;
+            for (FunctionSet::const_iterator func_iter = functions.begin(); func_iter != functions.end(); func_iter++)
+            {
+                const SVFFunction* func = *func_iter;
+                getSVFG()->connectCallerAndCallee(newcs, func, svfgEdges);
+            }
+        }
+    }
+    //@}
+
+    /// Override parent class functions to get/add cached points-to directly via PAGNode ID
+    //@{
+    virtual inline const PointsTo& getCachedTLPointsTo(const LocDPItem& dpm) override
+    {
+        return getPts(dpm.getCurNodeID());
+    }
+    //@}
+
+    /// Union pts
+    bool unionDDAPts(LocDPItem dpm, const PointsTo& targetPts) override
+    {
+        if (isTopLevelPtrStmt(dpm.getLoc())) return unionPts(dpm.getCurNodeID(), targetPts);
+        else return dpmToADCPtSetMap[dpm] |= targetPts;
+    }
+
+    virtual const std::string PTAName() const override
+    {
+        return "FlowSensitive DDA";
+    }
+
+private:
+    DDAClient* _client;				///< DDA client
+};
+
+} // End namespace SVF
+
+#endif /* FlowDDA_H_ */

package/SVF-osx/svf/include/include/FastCluster/LICENSE.TXT

@@ -0,0 +1,13 @@
+Copyright:
+  * fastcluster_dm.cpp & fastcluster_R_dm.cpp:
+     © 2011 Daniel Müllner <http://danifold.net>
+  * fastcluster.(h|cpp) & demo.cpp & plotresult.r:
+     © 2018 Christoph Dalitz <http://www.hsnr.de/ipattern/>
+All rights reserved.
+
+Redistribution and use in source and binary forms, with or without modification, are permitted provided that the following conditions are met:
+
+  * Redistributions of source code must retain the above copyright notice, this list of conditions and the following disclaimer.
+  * Redistributions in binary form must reproduce the above copyright notice, this list of conditions and the following disclaimer in the documentation and/or other materials provided with the distribution.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

package/SVF-osx/svf/include/include/FastCluster/fastcluster.h

@@ -0,0 +1,80 @@
+//
+// C++ standalone verion of fastcluster by Daniel Muellner
+//
+// Copyright: Daniel Muellner, 2011
+//            Christoph Dalitz, 2020
+// License:   BSD style license
+//            (see the file LICENSE for details)
+//
+
+#ifndef fastclustercpp_H
+#define fastclustercpp_H
+
+//
+// Assigns cluster labels (0, ..., nclust-1) to the n points such
+// that the cluster result is split into nclust clusters.
+//
+// Input arguments:
+//   n      = number of observables
+//   merge  = clustering result in R format
+//   nclust = number of clusters
+// Output arguments:
+//   labels = allocated integer array of size n for result
+//
+void cutree_k(int n, const int* merge, int nclust, int* labels);
+
+//
+// Assigns cluster labels (0, ..., nclust-1) to the n points such
+// that the hierarchical clsutering is stopped at cluster distance cdist
+//
+// Input arguments:
+//   n      = number of observables
+//   merge  = clustering result in R format
+//   height = cluster distance at each merge step
+//   cdist  = cutoff cluster distance
+// Output arguments:
+//   labels = allocated integer array of size n for result
+//
+void cutree_cdist(int n, const int* merge, double* height, double cdist, int* labels);
+
+//
+// Hierarchical clustering with one of Daniel Muellner's fast algorithms
+//
+// Input arguments:
+//   n       = number of observables
+//   distmat = condensed distance matrix, i.e. an n*(n-1)/2 array representing
+//             the upper triangle (without diagonal elements) of the distance
+//             matrix, e.g. for n=4:
+//               d00 d01 d02 d03
+//               d10 d11 d12 d13   ->  d01 d02 d03 d12 d13 d23
+//               d20 d21 d22 d23
+//               d30 d31 d32 d33
+//   method  = cluster metric (see enum hclust_fast_methods)
+// Output arguments:
+//   merge   = allocated (n-1)x2 matrix (2*(n-1) array) for storing result.
+//             Result follows R hclust convention:
+//              - observabe indices start with one
+//              - merge[i][] contains the merged nodes in step i
+//              - merge[i][j] is negative when the node is an atom
+//   height  = allocated (n-1) array with distances at each merge step
+// Return code:
+//   0 = ok
+//   1 = invalid method
+//
+int hclust_fast(int n, double* distmat, int method, int* merge, double* height);
+enum hclust_fast_methods
+{
+    // single link with the minimum spanning tree algorithm (Rohlf, 1973)
+    HCLUST_METHOD_SINGLE = 0,
+    // complete link with the nearest-neighbor-chain algorithm (Murtagh, 1984)
+    HCLUST_METHOD_COMPLETE = 1,
+    // omplete link with the nearest-neighbor-chain algorithm (Murtagh, 1984)
+    HCLUST_METHOD_AVERAGE = 2,
+    // median link with the generic algorithm (Müllner, 2011)
+    HCLUST_METHOD_MEDIAN = 3,
+    // To indicate to try all methods and pick the best.
+    HCLUST_METHOD_SVF_BEST = 4
+};
+
+
+#endif

package/SVF-osx/svf/include/include/Graphs/CFLGraph.h

@@ -0,0 +1,215 @@
+//===----- CFLGraph.h -- Graph for context-free language reachability analysis --//
+//
+//                     SVF: Static Value-Flow Analysis
+//
+// Copyright (C) <2013->  <Yulei Sui>
+//
+
+// This program is free software: you can redistribute it and/or modify
+// it under the terms of the GNU General Public License as published by
+// the Free Software Foundation, either version 3 of the License, or
+// (at your option) any later version.
+
+// This program is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+// GNU General Public License for more details.
+
+// You should have received a copy of the GNU General Public License
+// along with this program.  If not, see <http://www.gnu.org/licenses/>.
+//
+//===----------------------------------------------------------------------===//
+
+/*
+ * CFLGraph.h
+ *
+ *  Created on: March 5, 2022
+ *      Author: Yulei Sui
+ */
+
+#ifndef CFLG_H_
+#define CFLG_H_
+
+#include <fstream>
+#include <iostream>
+#include <string>
+#include <regex>
+#include "CFL/CFLGrammar.h"
+#include "Graphs/GenericGraph.h"
+#include "Graphs/ConsG.h"
+
+namespace SVF
+{
+class CFLNode;
+
+typedef GenericEdge<CFLNode> GenericCFLEdgeTy;
+
+class CFLEdge: public GenericCFLEdgeTy
+{
+public:
+    typedef GenericNode<CFLNode, CFLEdge>::GEdgeSetTy CFLEdgeSetTy;
+
+    CFLEdge(CFLNode *s, CFLNode *d, GEdgeFlag k = 0):
+        GenericCFLEdgeTy(s,d,k)
+    {
+    }
+    ~CFLEdge() override = default;
+
+    inline GEdgeKind getEdgeKind() const
+    {
+        return this->getEdgeKindWithoutMask();
+    }
+
+    inline GEdgeKind getEdgeKindWithMask() const
+    {
+        return (EdgeKindMask & this->getEdgeKindWithoutMask());
+    }
+
+    inline GEdgeKind getEdgeAttri() const
+    {
+        return (getEdgeKind() >> this->EdgeKindMaskBits);
+    }
+};
+
+
+typedef GenericNode<CFLNode,CFLEdge> GenericCFLNodeTy;
+class CFLNode: public GenericCFLNodeTy
+{
+public:
+    CFLNode (NodeID i = 0, GNodeK k = 0):
+        GenericCFLNodeTy(i, k)
+    {
+    }
+
+    ~CFLNode() override = default;
+
+    /// Different Kind(label) associated edges set
+    typedef std::map <GrammarBase::Symbol, CFLEdge::CFLEdgeSetTy> CFLEdgeDataTy;
+
+private:
+    CFLEdgeDataTy inCFLEdges;
+    CFLEdgeDataTy outCFLEdges;
+
+public:
+    inline const CFLEdge::CFLEdgeSetTy& getInEdgeWithTy(GrammarBase::Symbol s)
+    {
+        return inCFLEdges[s];
+    }
+
+    inline const CFLEdge::CFLEdgeSetTy& getOutEdgeWithTy(GrammarBase::Symbol s)
+    {
+        return outCFLEdges[s];
+    }
+
+    inline bool addInEdgeWithKind(CFLEdge* inEdge, GrammarBase::Symbol s)
+    {
+        assert(inEdge->getDstID() == this->getId());
+        bool added1 = GenericNode::addIncomingEdge(inEdge);
+        bool added2 = inCFLEdges[s].insert(inEdge).second;
+
+        return added1 && added2;
+    }
+
+    inline bool addIngoingEdge(CFLEdge* inEdge)
+    {
+        return addInEdgeWithKind(inEdge, inEdge->getEdgeKind());
+    }
+
+    inline bool addOutEdgeWithKind(CFLEdge* outEdge, GrammarBase::Symbol s)
+    {
+        assert(outEdge->getSrcID() == this->getId());
+        bool added1 = GenericNode::addOutgoingEdge(outEdge);
+        bool added2 = outCFLEdges[s].insert(outEdge).second;
+
+        return added1 && added2;
+    }
+
+    inline bool addOutgoingEdge(CFLEdge* OutEdge)
+    {
+        return addOutEdgeWithKind(OutEdge, OutEdge->getEdgeKind());
+    }
+
+    inline bool removeCFLInEdge(CFLEdge* inEdge)
+    {
+        u32_t num1 = removeIncomingEdge(inEdge);
+
+        GrammarBase::Symbol s = inEdge->getEdgeKind();
+        u32_t num2 = inCFLEdges[s].erase(inEdge);
+
+        return num1 && num2;
+    }
+
+    inline bool removeCFLOutEdge(CFLEdge* outEdge)
+    {
+        u32_t num1 = removeOutgoingEdge(outEdge);
+
+        GrammarBase::Symbol s = outEdge->getEdgeKind();
+        u32_t num2 = outCFLEdges[s].erase(outEdge);
+
+        return num1 && num2;
+    }
+};
+
+/// Edge-labeled graph for CFL Reachability analysis
+typedef GenericGraph<CFLNode,CFLEdge> GenericCFLGraphTy;
+class CFLGraph: public GenericCFLGraphTy
+{
+public:
+    typedef CFLGrammar::Symbol Symbol;
+    typedef CFLGrammar::Kind Kind;
+    typedef GenericNode<CFLNode,CFLEdge>::GEdgeSetTy CFLEdgeSet;
+    Kind startKind;
+
+    CFLGraph(Kind kind)
+    {
+        startKind = kind;
+    }
+    ~CFLGraph() override = default;
+
+    Kind getStartKind() const;
+
+    virtual void addCFLNode(NodeID id, CFLNode* node);
+
+    virtual const CFLEdge* addCFLEdge(CFLNode* src, CFLNode* dst, CFLEdge::GEdgeFlag label);
+
+    virtual const CFLEdge* hasEdge(CFLNode* src, CFLNode* dst, CFLEdge::GEdgeFlag label);
+
+    void dump(const std::string& filename);
+
+    void view();
+
+    inline const CFLEdgeSet& getCFLEdges() const
+    {
+        return cflEdgeSet;
+    }
+
+private:
+    CFLEdgeSet cflEdgeSet;
+};
+
+}
+
+namespace SVF
+{
+/* !
+ * GenericGraphTraits specializations for generic graph algorithms.
+ * Provide graph traits for traversing from a constraint node using standard graph traversals.
+ */
+template<> struct GenericGraphTraits<SVF::CFLNode*> : public GenericGraphTraits<SVF::GenericNode<SVF::CFLNode,SVF::CFLEdge>*  >
+{
+};
+
+/// Inverse GenericGraphTraits specializations for call graph node, it is used for inverse traversal.
+template<>
+struct GenericGraphTraits<Inverse<SVF::CFLNode *> > : public GenericGraphTraits<Inverse<SVF::GenericNode<SVF::CFLNode,SVF::CFLEdge>* > >
+{
+};
+
+template<> struct GenericGraphTraits<SVF::CFLGraph*> : public GenericGraphTraits<SVF::GenericGraph<SVF::CFLNode,SVF::CFLEdge>* >
+{
+    typedef SVF::CFLNode *NodeRef;
+};
+
+} // End namespace llvm
+
+#endif /* CFLG_H_ */