svf-lib 1.0.2080 → 1.0.2082

package/SVF-linux/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/SVF-osx/Release-build/include/Graphs/IRGraph.h

@@ -61,7 +61,7 @@ protected:
     bool fromFile; ///< Whether the SVFIR is built according to user specified data from a txt file
     NodeID nodeNumAfterPAGBuild; ///< initial node number after building SVFIR, excluding later added nodes, e.g., gepobj nodes
     u32_t totalPTAPAGEdge;
-    ValueToEdgeMap valueToEdgeMap; ///< Map SVFValues (e.g., SVFInstruction) to all corresponding PAGEdges
+    ValueToEdgeMap valueToEdgeMap; ///< Map SVFValues (e.g., ICFGNodes) to all corresponding PAGEdges
     SymbolTableInfo* symInfo;
 
     /// Add a node into the graph

package/SVF-osx/Release-build/include/Graphs/ThreadCallGraph.h

@@ -163,8 +163,6 @@ class ThreadCallGraph: public CallGraph
 public:
     typedef Set<const CallICFGNode*> InstSet;
     typedef InstSet CallSiteSet;
-    typedef std::vector<const SVFInstruction*> InstVector;
-    typedef Map<const SVFInstruction*, InstSet> CallToInstMap;
     typedef Set<CallSiteSet*> CtxSet;
     typedef ThreadForkEdge::ForkEdgeSet ForkEdgeSet;
     typedef Map<const CallICFGNode*, ForkEdgeSet> CallInstToForkEdgesMap;

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

@@ -47,8 +47,6 @@ class MHP
 
 public:
     typedef Set<const SVFFunction*> FunSet;
-    typedef Set<const SVFInstruction*> InstSet;
-    typedef std::vector<const SVFInstruction*> InstVec;
     typedef FIFOWorkList<CxtThreadStmt> CxtThreadStmtWorkList;
     typedef Set<CxtThreadStmt> CxtThreadStmtSet;
     typedef Map<CxtThreadStmt,NodeBS> ThreadStmtToThreadInterleav;

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

@@ -57,9 +57,6 @@ class MTA
 {
 
 public:
-    typedef Set<const SVFInstruction*> LoadSet;
-    typedef Set<const SVFInstruction*> StoreSet;
-
     /// Constructor
     MTA();
 

package/SVF-osx/Release-build/include/SABER/SaberCheckerAPI.h

@@ -101,13 +101,9 @@ public:
     {
         return getType(fun) == CK_ALLOC;
     }
-    inline bool isMemAlloc(const SVFInstruction* inst) const
-    {
-        return getType(SVFUtil::getCallee(inst)) == CK_ALLOC;
-    }
     inline bool isMemAlloc(const CallICFGNode* cs) const
     {
-        return isMemAlloc(cs->getCallSite());
+        return isMemAlloc(SVFUtil::getCallee(cs->getCallSite()));
     }
     //@}
 
@@ -117,13 +113,9 @@ public:
     {
         return getType(fun) == CK_FREE;
     }
-    inline bool isMemDealloc(const SVFInstruction *inst) const
-    {
-        return getType(SVFUtil::getCallee(inst)) == CK_FREE;
-    }
     inline bool isMemDealloc(const CallICFGNode* cs) const
     {
-        return isMemDealloc(cs->getCallSite());
+        return isMemDealloc(SVFUtil::getCallee(cs->getCallSite()));
     }
     //@}
 
@@ -133,13 +125,9 @@ public:
     {
         return getType(fun) == CK_FOPEN;
     }
-    inline bool isFOpen(const SVFInstruction* inst) const
-    {
-        return getType(SVFUtil::getCallee(inst)) == CK_FOPEN;
-    }
     inline bool isFOpen(const CallICFGNode* cs) const
     {
-        return isFOpen(cs->getCallSite());
+        return isFOpen(SVFUtil::getCallee(cs->getCallSite()));
     }
     //@}
 
@@ -149,13 +137,9 @@ public:
     {
         return getType(fun) == CK_FCLOSE;
     }
-    inline bool isFClose(const SVFInstruction* inst) const
-    {
-        return getType(SVFUtil::getCallee(inst)) == CK_FCLOSE;
-    }
     inline bool isFClose(const CallICFGNode* cs) const
     {
-        return isFClose(cs->getCallSite());
+        return isFClose(SVFUtil::getCallee(cs->getCallSite()));
     }
     //@}
 

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

@@ -203,7 +203,7 @@ inline CallSite getSVFCallSite(const SVFInstruction* inst)
 /// Match arguments for callsite at caller and callee
 /// if the arg size does not match then we do not need to connect this parameter
 /// unless the callee is a variadic function (the first parameter of variadic function is its parameter number)
-bool matchArgs(const SVFInstruction* cs, const SVFFunction* callee);
+bool matchArgs(const CallSite cs, const SVFFunction* callee);
 
 /// Return LLVM callsite given a value
 inline CallSite getSVFCallSite(const SVFValue* value)
@@ -466,11 +466,6 @@ inline int getHeapAllocHoldingArgPosition(const CallSite cs)
 {
     return getHeapAllocHoldingArgPosition(getCallee(cs));
 }
-
-inline int getHeapAllocHoldingArgPosition(const SVFInstruction *inst)
-{
-    return getHeapAllocHoldingArgPosition(getCallee(inst));
-}
 //@}
 
 inline bool isReallocExtCall(const CallSite cs)
@@ -478,12 +473,6 @@ inline bool isReallocExtCall(const CallSite cs)
     bool isPtrTy = cs.getInstruction()->getType()->isPointerTy();
     return isPtrTy && isReallocExtFun(getCallee(cs));
 }
-
-inline bool isReallocExtCall(const SVFInstruction *inst)
-{
-    bool isPtrTy = inst->getType()->isPointerTy();
-    return isPtrTy && isReallocExtFun(getCallee(inst));
-}
 //@}
 
 /// Return true if this is a thread creation call
@@ -504,10 +493,6 @@ inline bool isThreadJoinCall(const CallSite cs)
 {
     return ThreadAPI::getThreadAPI()->isTDJoin(cs.getInstruction());
 }
-inline bool isThreadJoinCall(const SVFInstruction *inst)
-{
-    return ThreadAPI::getThreadAPI()->isTDJoin(inst);
-}
 //@}
 
 /// Return true if this is a thread exit call
@@ -516,10 +501,6 @@ inline bool isThreadExitCall(const CallSite cs)
 {
     return ThreadAPI::getThreadAPI()->isTDExit(cs.getInstruction());
 }
-inline bool isThreadExitCall(const SVFInstruction *inst)
-{
-    return ThreadAPI::getThreadAPI()->isTDExit(inst);
-}
 //@}
 
 /// Return true if this is a lock acquire call
@@ -528,10 +509,6 @@ inline bool isLockAquireCall(const CallSite cs)
 {
     return ThreadAPI::getThreadAPI()->isTDAcquire(cs.getInstruction());
 }
-inline bool isLockAquireCall(const SVFInstruction *inst)
-{
-    return ThreadAPI::getThreadAPI()->isTDAcquire(inst);
-}
 //@}
 
 /// Return true if this is a lock acquire call
@@ -540,10 +517,6 @@ inline bool isLockReleaseCall(const CallSite cs)
 {
     return ThreadAPI::getThreadAPI()->isTDRelease(cs.getInstruction());
 }
-inline bool isLockReleaseCall(const SVFInstruction *inst)
-{
-    return ThreadAPI::getThreadAPI()->isTDRelease(inst);
-}
 //@}
 
 /// Return true if this is a barrier wait call
@@ -552,10 +525,6 @@ inline bool isBarrierWaitCall(const CallSite cs)
 {
     return ThreadAPI::getThreadAPI()->isTDBarWait(cs.getInstruction());
 }
-inline bool isBarrierWaitCall(const SVFInstruction *inst)
-{
-    return ThreadAPI::getThreadAPI()->isTDBarWait(inst);
-}
 //@}
 
 /// Return sole argument of the thread routine
@@ -564,10 +533,6 @@ inline const SVFValue* getActualParmAtForkSite(const CallSite cs)
 {
     return ThreadAPI::getThreadAPI()->getActualParmAtForkSite(cs.getInstruction());
 }
-inline const SVFValue* getActualParmAtForkSite(const SVFInstruction *inst)
-{
-    return ThreadAPI::getThreadAPI()->getActualParmAtForkSite(inst);
-}
 //@}
 
 
@@ -576,10 +541,6 @@ inline bool isProgExitCall(const CallSite cs)
     return isProgExitFunction(getCallee(cs));
 }
 
-inline bool isProgExitCall(const SVFInstruction *inst)
-{
-    return isProgExitFunction(getCallee(inst));
-}
 
 template<typename T>
 constexpr typename std::remove_reference<T>::type &&

package/package.json

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