svf-lib 1.0.2079 → 1.0.2080

package/SVF-osx/Release-build/include/Util/ThreadAPI.h

@@ -36,6 +36,7 @@ namespace SVF
 {
 
 class SVFModule;
+class ICFGNode;
 
 /*
  * ThreadAPI class contains interfaces for pthread programs
@@ -119,32 +120,21 @@ public:
 
     /// Return the callee/callsite/func
     //@{
+    const SVFFunction* getCallee(const ICFGNode *inst) const;
     const SVFFunction* getCallee(const SVFInstruction *inst) const;
-    const SVFFunction* getCallee(const CallSite cs) const;
     const CallSite getSVFCallSite(const SVFInstruction *inst) const;
+    const CallSite getSVFCallSite(const ICFGNode *inst) const;
     //@}
 
     /// Return true if this call create a new thread
     //@{
-    inline bool isTDFork(const SVFInstruction *inst) const
+    inline bool isTDFork(const ICFGNode *inst) const
     {
         return getType(getCallee(inst)) == TD_FORK;
     }
-    inline bool isTDFork(CallSite cs) const
+    inline bool isTDFork(const SVFInstruction* cs) const
     {
-        return isTDFork(cs.getInstruction());
-    }
-    //@}
-
-    /// Return true if this call proceeds a hare_parallel_for
-    //@{
-    inline bool isHareParFor(const SVFInstruction *inst) const
-    {
-        return getType(getCallee(inst)) == HARE_PAR_FOR;
-    }
-    inline bool isHareParFor(CallSite cs) const
-    {
-        return isTDFork(cs.getInstruction());
+        return getType(getCallee(cs)) == TD_FORK;
     }
     //@}
 
@@ -152,81 +142,59 @@ public:
     //@{
     /// Return the first argument of the call,
     /// Note that, it is the pthread_t pointer
-    inline const SVFValue* getForkedThread(const SVFInstruction *inst) const
+    inline const SVFValue* getForkedThread(const ICFGNode *inst) const
     {
         assert(isTDFork(inst) && "not a thread fork function!");
         CallSite cs = getSVFCallSite(inst);
         return cs.getArgument(0);
     }
-    inline const SVFValue* getForkedThread(CallSite cs) const
+    inline const SVFValue* getForkedThread(const SVFInstruction* inst) const
     {
-        return getForkedThread(cs.getInstruction());
+        assert(isTDFork(inst) && "not a thread fork function!");
+        CallSite cs = getSVFCallSite(inst);
+        return cs.getArgument(0);
     }
 
     /// Return the third argument of the call,
     /// Note that, it could be function type or a void* pointer
-    inline const SVFValue* getForkedFun(const SVFInstruction *inst) const
+    inline const SVFValue* getForkedFun(const ICFGNode *inst) const
     {
         assert(isTDFork(inst) && "not a thread fork function!");
         CallSite cs = getSVFCallSite(inst);
         return cs.getArgument(2);
     }
-    inline const SVFValue* getForkedFun(CallSite cs) const
+    inline const SVFValue* getForkedFun(const SVFInstruction* inst) const
     {
-        return getForkedFun(cs.getInstruction());
+        assert(isTDFork(inst) && "not a thread fork function!");
+        CallSite cs = getSVFCallSite(inst);
+        return cs.getArgument(2);
     }
 
     /// Return the forth argument of the call,
     /// Note that, it is the sole argument of start routine ( a void* pointer )
-    inline const SVFValue* getActualParmAtForkSite(const SVFInstruction *inst) const
+    inline const SVFValue* getActualParmAtForkSite(const ICFGNode *inst) const
     {
         assert(isTDFork(inst) && "not a thread fork function!");
         CallSite cs = getSVFCallSite(inst);
         return cs.getArgument(3);
     }
-    inline const SVFValue* getActualParmAtForkSite(CallSite cs) const
-    {
-        return getActualParmAtForkSite(cs.getInstruction());
-    }
-    //@}
-
-    /// Get the task function (i.e., the 5th parameter) of the hare_parallel_for call
-    //@{
-    inline const SVFValue* getTaskFuncAtHareParForSite(const SVFInstruction *inst) const
-    {
-        assert(isHareParFor(inst) && "not a hare_parallel_for function!");
-        CallSite cs = getSVFCallSite(inst);
-        return cs.getArgument(4);
-    }
-    inline const SVFValue* getTaskFuncAtHareParForSite(CallSite cs) const
-    {
-        return getTaskFuncAtHareParForSite(cs.getInstruction());
-    }
-    //@}
-
-    /// Get the task data (i.e., the 6th parameter) of the hare_parallel_for call
-    //@{
-    inline const SVFValue* getTaskDataAtHareParForSite(const SVFInstruction *inst) const
+    inline const SVFValue* getActualParmAtForkSite(const SVFInstruction* inst) const
     {
-        assert(isHareParFor(inst) && "not a hare_parallel_for function!");
+        assert(isTDFork(inst) && "not a thread fork function!");
         CallSite cs = getSVFCallSite(inst);
-        return cs.getArgument(5);
-    }
-    inline const SVFValue* getTaskDataAtHareParForSite(CallSite cs) const
-    {
-        return getTaskDataAtHareParForSite(cs.getInstruction());
+        return cs.getArgument(3);
     }
     //@}
 
     /// Return true if this call wait for a worker thread
     //@{
-    inline bool isTDJoin(const SVFInstruction *inst) const
+    inline bool isTDJoin(const ICFGNode *inst) const
     {
         return getType(getCallee(inst)) == TD_JOIN;
     }
-    inline bool isTDJoin(CallSite cs) const
+    inline bool isTDJoin(const SVFInstruction* inst) const
     {
-        return isTDJoin(cs.getInstruction());
+        return getType(getCallee(inst)) == TD_JOIN;
     }
     //@}
 
@@ -234,90 +202,79 @@ public:
     //@{
     /// Return the first argument of the call,
     /// Note that, it is the pthread_t pointer
-    const SVFValue* getJoinedThread(const SVFInstruction *inst) const;
-    inline const SVFValue* getJoinedThread(CallSite cs) const
-    {
-        return getJoinedThread(cs.getInstruction());
-    }
+    const SVFValue* getJoinedThread(const ICFGNode *inst) const;
     /// Return the send argument of the call,
     /// Note that, it is the pthread_t pointer
-    inline const SVFValue* getRetParmAtJoinedSite(const SVFInstruction *inst) const
+    inline const SVFValue* getRetParmAtJoinedSite(const ICFGNode *inst) const
     {
         assert(isTDJoin(inst) && "not a thread join function!");
         CallSite cs = getSVFCallSite(inst);
         return cs.getArgument(1);
     }
-    inline const SVFValue* getRetParmAtJoinedSite(CallSite cs) const
+    inline const SVFValue* getRetParmAtJoinedSite(const SVFInstruction* inst) const
     {
-        return getRetParmAtJoinedSite(cs.getInstruction());
+        assert(isTDJoin(inst) && "not a thread join function!");
+        CallSite cs = getSVFCallSite(inst);
+        return cs.getArgument(1);
     }
     //@}
 
 
     /// Return true if this call exits/terminate a thread
     //@{
-    inline bool isTDExit(const SVFInstruction *inst) const
+    inline bool isTDExit(const ICFGNode *inst) const
     {
         return getType(getCallee(inst)) == TD_EXIT;
     }
 
-    inline bool isTDExit(CallSite cs) const
+    inline bool isTDExit(const SVFInstruction* inst) const
     {
-        return getType(getCallee(cs)) == TD_EXIT;
+        return getType(getCallee(inst)) == TD_EXIT;
     }
     //@}
 
     /// Return true if this call acquire a lock
     //@{
-    inline bool isTDAcquire(const SVFInstruction *inst) const
+    inline bool isTDAcquire(const ICFGNode* inst) const
     {
         return getType(getCallee(inst)) == TD_ACQUIRE;
     }
 
-    inline bool isTDAcquire(CallSite cs) const
+    inline bool isTDAcquire(const SVFInstruction* inst) const
     {
-        return getType(getCallee(cs)) == TD_ACQUIRE;
+        return getType(getCallee(inst)) == TD_ACQUIRE;
     }
     //@}
 
     /// Return true if this call release a lock
     //@{
-    inline bool isTDRelease(const SVFInstruction *inst) const
+    inline bool isTDRelease(const ICFGNode *inst) const
     {
         return getType(getCallee(inst)) == TD_RELEASE;
     }
 
-    inline bool isTDRelease(CallSite cs) const
+    inline bool isTDRelease(const SVFInstruction* inst) const
     {
-        return getType(getCallee(cs)) == TD_RELEASE;
+        return getType(getCallee(inst)) == TD_RELEASE;
     }
     //@}
 
     /// Return lock value
     //@{
     /// First argument of pthread_mutex_lock/pthread_mutex_unlock
-    inline const SVFValue* getLockVal(const SVFInstruction *inst) const
-    {
-        assert((isTDAcquire(inst) || isTDRelease(inst)) && "not a lock acquire or release function");
-        CallSite cs = getSVFCallSite(inst);
-        return cs.getArgument(0);
-    }
-    inline const SVFValue* getLockVal(CallSite cs) const
-    {
-        return getLockVal(cs.getInstruction());
-    }
+    const SVFValue* getLockVal(const ICFGNode *inst) const;
     //@}
 
     /// Return true if this call waits for a barrier
     //@{
-    inline bool isTDBarWait(const SVFInstruction *inst) const
+    inline bool isTDBarWait(const ICFGNode *inst) const
     {
         return getType(getCallee(inst)) == TD_BAR_WAIT;
     }
 
-    inline bool isTDBarWait(CallSite cs) const
+    inline bool isTDBarWait(const SVFInstruction* inst) const
     {
-        return getType(getCallee(cs)) == TD_BAR_WAIT;
+        return getType(getCallee(inst)) == TD_BAR_WAIT;
     }
     //@}
 

package/package.json

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

package/SVF-osx/Release-build/include/MTA/FSMPTA.h

@@ -1,270 +0,0 @@
-//===- FSMPTA.h -- Flow-sensitive analysis of multithreaded programs-------------//
-//
-//                     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 Affero 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 Affero General Public License for more details.
-
-// You should have received a copy of the GNU Affero General Public License
-// along with this program.  If not, see <http://www.gnu.org/licenses/>.
-//
-//===----------------------------------------------------------------------===//
-
-/*
- * FSMPTA.h
- *
- *  Created on: Jul 29, 2015
- *      Author: Yulei Sui, Peng Di
- *
- * The implementation is based on
- * Yulei Sui, Peng Di, and Jingling Xue. "Sparse Flow-Sensitive Pointer Analysis for Multithreaded Programs".
- * 2016 International Symposium on Code Generation and Optimization (CGO'16)
- */
-
-#ifndef FSPTANALYSIS_H_
-#define FSPTANALYSIS_H_
-
-
-#include "WPA/FlowSensitive.h"
-#include "MSSA/SVFGBuilder.h"
-#include "MTA/LockAnalysis.h"
-#include "MemoryModel/PointsTo.h"
-#include "MTA/MHP.h"
-
-namespace SVF
-{
-
-class MHP;
-class LockAnalysis;
-
-
-class SVFGNodeLockSpan
-{
-public:
-    SVFGNodeLockSpan(const StmtSVFGNode* SVFGnode, LockAnalysis::LockSpan lockspan) :
-        SVFGNode(SVFGnode), lockSpan(lockspan) {}
-    virtual ~SVFGNodeLockSpan() {}
-
-    inline bool operator< (const SVFGNodeLockSpan& rhs) const
-    {
-        if (SVFGNode != rhs.getSVFGNode())
-            return SVFGNode < rhs.getSVFGNode();
-        return lockSpan.size() < rhs.getLockSpan().size();
-    }
-    inline SVFGNodeLockSpan& operator= (const SVFGNodeLockSpan& rhs)
-    {
-        if(*this != rhs)
-        {
-            SVFGNode = rhs.getSVFGNode();
-            lockSpan = rhs.getLockSpan();
-        }
-        return *this;
-    }
-    inline bool operator== (const SVFGNodeLockSpan& rhs) const
-    {
-        return (SVFGNode == rhs.getSVFGNode() && lockSpan == rhs.getLockSpan());
-    }
-    inline bool operator!= (const SVFGNodeLockSpan& rhs) const
-    {
-        return !(*this == rhs);
-    }
-    inline const StmtSVFGNode* getSVFGNode() const
-    {
-        return SVFGNode;
-    }
-    inline const LockAnalysis::LockSpan getLockSpan() const
-    {
-        return lockSpan;
-    }
-private:
-    const StmtSVFGNode* SVFGNode;
-    LockAnalysis::LockSpan lockSpan;
-};
-
-/*!
- * SVFG builder for DDA
- */
-class MTASVFGBuilder : public SVFGBuilder
-{
-
-public:
-    typedef PointerAnalysis::CallSiteSet CallSiteSet;
-    typedef PointerAnalysis::CallEdgeMap CallEdgeMap;
-    typedef PointerAnalysis::FunctionSet FunctionSet;
-    typedef Set<const SVFGNode*> SVFGNodeSet;
-    typedef std::vector<const SVFGNode*> SVFGNodeVec;
-    typedef NodeBS SVFGNodeIDSet;
-    typedef Set<const SVFInstruction*> InstSet;
-    typedef std::pair<NodeID,NodeID> NodeIDPair;
-    typedef Map<SVFGNodeLockSpan, bool> PairToBoolMap;
-
-    /// Constructor
-    MTASVFGBuilder(MHP* m, LockAnalysis* la) : SVFGBuilder(), mhp(m), lockana(la)
-    {
-    }
-
-    /// Destructor
-    virtual ~MTASVFGBuilder() {}
-
-    /// Number of newly added SVFG edges
-    static u32_t numOfNewSVFGEdges;
-    static u32_t numOfRemovedSVFGEdges;
-    static u32_t numOfRemovedPTS;
-
-protected:
-    /// Re-write create SVFG method
-    virtual void buildSVFG();
-
-private:
-    /// Record edges
-    bool recordEdge(NodeID id1, NodeID id2, PointsTo pts);
-    bool recordAddingEdge(NodeID id1, NodeID id2, PointsTo pts);
-    bool recordRemovingEdge(NodeID id1, NodeID id2, PointsTo pts);
-    /// perform adding/removing MHP Edges in value flow graph
-    void performAddingMHPEdges();
-    void performRemovingMHPEdges();
-    SVFGEdge* addTDEdges(NodeID srcId, NodeID dstId, PointsTo& pts);
-    /// Connect MHP indirect value-flow edges for two nodes that may-happen-in-parallel
-    void connectMHPEdges(PointerAnalysis* pta);
-
-    void handleStoreLoadNonSparse(const StmtSVFGNode* n1,const StmtSVFGNode* n2, PointerAnalysis* pta);
-    void handleStoreStoreNonSparse(const StmtSVFGNode* n1,const StmtSVFGNode* n2, PointerAnalysis* pta);
-
-    void handleStoreLoad(const StmtSVFGNode* n1,const StmtSVFGNode* n2, PointerAnalysis* pta);
-    void handleStoreStore(const StmtSVFGNode* n1,const StmtSVFGNode* n2, PointerAnalysis* pta);
-
-    void handleStoreLoadWithLockPrecisely(const StmtSVFGNode* n1,const StmtSVFGNode* n2, PointerAnalysis* pta);
-    void handleStoreStoreWithLockPrecisely(const StmtSVFGNode* n1,const StmtSVFGNode* n2, PointerAnalysis* pta);
-
-    void mergeSpan(NodeBS comlocks, InstSet& res);
-    void readPrecision();
-
-    SVFGNodeIDSet getPrevNodes(const StmtSVFGNode* n);
-    SVFGNodeIDSet getSuccNodes(const StmtSVFGNode* n);
-    SVFGNodeIDSet getSuccNodes(const StmtSVFGNode* n, NodeID o);
-
-    bool isHeadofSpan(const StmtSVFGNode* n, LockAnalysis::LockSpan lspan);
-    bool isTailofSpan(const StmtSVFGNode* n, LockAnalysis::LockSpan lspan);
-    bool isHeadofSpan(const StmtSVFGNode* n, InstSet mergespan);
-    bool isTailofSpan(const StmtSVFGNode* n, InstSet mergespan);
-    bool isHeadofSpan(const StmtSVFGNode* n);
-    bool isTailofSpan(const StmtSVFGNode* n);
-    /// Collect all loads/stores SVFGNodes
-    void collectLoadStoreSVFGNodes();
-
-    /// all stores/loads SVFGNodes
-    SVFGNodeSet stnodeSet;
-    SVFGNodeSet ldnodeSet;
-
-    /// MHP class
-    MHP* mhp;
-    LockAnalysis* lockana;
-
-    Set<NodeIDPair> recordedges;
-    Map<NodeIDPair, PointsTo> edge2pts;
-
-
-    Map<const StmtSVFGNode*, SVFGNodeIDSet> prevset;
-    Map<const StmtSVFGNode*, SVFGNodeIDSet> succset;
-
-    Map<const StmtSVFGNode*, bool> headmap;
-    Map<const StmtSVFGNode*, bool> tailmap;
-
-    PairToBoolMap pairheadmap;
-    PairToBoolMap pairtailmap;
-
-
-    static const u32_t ADDEDGE_NOEDGE= 0;
-    static const u32_t ADDEDGE_NONSPARSE= 1;
-    static const u32_t ADDEDGE_ALLOPT= 2;
-    static const u32_t ADDEDGE_NOMHP= 3;
-    static const u32_t ADDEDGE_NOALIAS= 4;
-    static const u32_t ADDEDGE_NOLOCK= 5;
-    static const u32_t ADDEDGE_NORP= 6;
-//    static const u32_t ADDEDGE_PRECISELOCK= 5;
-
-};
-
-
-/*!
- * Flow-sensitive pointer analysis for multithreaded programs
- */
-class FSMPTA : public FlowSensitive
-{
-
-
-public:
-
-    /// Constructor
-    FSMPTA(MHP* m, LockAnalysis* la) : FlowSensitive(m->getTCT()->getPTA()->getPAG()), mhp(m), lockana(la)
-    {
-    }
-
-    /// Destructor
-    ~FSMPTA()
-    {
-    }
-
-    /// Initialize analysis
-    void initialize(SVFModule* module);
-
-    inline SVFIR* getPAG()
-    {
-        return mhp->getTCT()->getPTA()->getPAG();
-    }
-
-    /// Create single instance of flow-sensitive pointer analysis
-    static FSMPTA* createFSMPTA(SVFModule* module, MHP* m, LockAnalysis* la)
-    {
-        if (mfspta == nullptr)
-        {
-            mfspta = new FSMPTA(m,la);
-            mfspta->analyze();
-        }
-        return mfspta;
-    }
-
-    /// Release flow-sensitive pointer analysis
-    static void releaseFSMPTA()
-    {
-        if (mfspta)
-            delete mfspta;
-        mfspta = nullptr;
-    }
-
-    /// Get MHP
-    inline MHP* getMHP() const
-    {
-        return mhp;
-    }
-
-private:
-    static FSMPTA* mfspta;
-    MHP* mhp;
-    LockAnalysis* lockana;
-    using FlowSensitive::initialize;
-};
-
-} // End namespace SVF
-
-template <> struct std::hash<SVF::SVFGNodeLockSpan>
-{
-    size_t operator()(const SVF::SVFGNodeLockSpan &cs) const
-    {
-        std::hash<SVF::StmtSVFGNode* >h;
-        SVF::StmtSVFGNode* node = const_cast<SVF::StmtSVFGNode* > (cs.getSVFGNode());
-        return h(node);
-    }
-};
-
-#endif /* FSPTANALYSIS_H_ */