svf-tools 1.0.976 → 1.0.978

package/svf/include/Util/CxtStmt.h

@@ -35,6 +35,7 @@
 namespace SVF
 {
 
+class ICFGNode;
 /*!
  * Context-sensitive thread statement <c,s>
  */
@@ -42,7 +43,7 @@ class CxtStmt
 {
 public:
     /// Constructor
-    CxtStmt(const CallStrCxt& c, const SVFInstruction* f) :cxt(c), inst(f)
+    CxtStmt(const CallStrCxt& c, const ICFGNode* f) :cxt(c), inst(f)
     {
     }
     /// Copy constructor
@@ -59,7 +60,7 @@ public:
         return cxt;
     }
     /// Return current statement
-    inline const SVFInstruction* getStmt() const
+    inline const ICFGNode* getStmt() const
     {
         return inst;
     }
@@ -108,12 +109,12 @@ public:
     /// Dump CxtStmt
     inline void dump() const
     {
-        SVFUtil::outs() << "[ Current Stmt: " << inst->getSourceLoc() << " " << inst->toString() << "\t Contexts: " << cxtToStr() << "  ]\n";
+        SVFUtil::outs() << "[ Current Stmt: " << inst->toString() << "\t Contexts: " << cxtToStr() << "  ]\n";
     }
 
 protected:
     CallStrCxt cxt;
-    const SVFInstruction* inst;
+    const ICFGNode* inst;
 };
 
 
@@ -124,7 +125,7 @@ class CxtThreadStmt : public CxtStmt
 {
 public:
     /// Constructor
-    CxtThreadStmt(NodeID t, const CallStrCxt& c, const SVFInstruction* f) :CxtStmt(c,f), tid(t)
+    CxtThreadStmt(NodeID t, const CallStrCxt& c, const ICFGNode* f) :CxtStmt(c,f), tid(t)
     {
     }
     /// Copy constructor
@@ -174,7 +175,7 @@ public:
     /// Dump CxtThreadStmt
     inline void dump() const
     {
-        SVFUtil::outs() << "[ Current Thread id: " << tid << "  Stmt: " << inst->getSourceLoc() << " " << inst->toString() << "\t Contexts: " << cxtToStr() << "  ]\n";
+        SVFUtil::outs() << "[ Current Thread id: " << tid << "  Stmt: " << inst->toString() << "\t Contexts: " << cxtToStr() << "  ]\n";
     }
 
 private:
@@ -189,7 +190,7 @@ class CxtThread
 {
 public:
     /// Constructor
-    CxtThread(const CallStrCxt& c, const SVFInstruction* fork) : cxt(c), forksite(fork), inloop(false), incycle(false)
+    CxtThread(const CallStrCxt& c, const ICFGNode* fork) : cxt(c), forksite(fork), inloop(false), incycle(false)
     {
     }
     /// Copy constructor
@@ -207,7 +208,7 @@ public:
         return cxt;
     }
     /// Return forksite
-    inline const SVFInstruction* getThread() const
+    inline const ICFGNode* getThread() const
     {
         return forksite;
     }
@@ -282,7 +283,7 @@ public:
 
         if(forksite)
         {
-            SVFUtil::outs() << "[ Thread: $" << forksite->getSourceLoc() << "$ "
+            SVFUtil::outs() << "[ Thread: "
                             << forksite->toString()  << "\t Contexts: " << cxtToStr()
                             << loop << cycle <<"  ]\n";
         }
@@ -294,7 +295,7 @@ public:
     }
 protected:
     CallStrCxt cxt;
-    const SVFInstruction* forksite;
+    const ICFGNode* forksite;
     bool inloop;
     bool incycle;
 };
@@ -484,8 +485,8 @@ template <> struct std::hash<SVF::CxtStmt>
 {
     size_t operator()(const SVF::CxtStmt& cs) const
     {
-        std::hash<SVF::SVFInstruction*> h;
-        SVF::SVFInstruction* inst = const_cast<SVF::SVFInstruction*> (cs.getStmt());
+        std::hash<SVF::ICFGNode*> h;
+        SVF::ICFGNode* inst = const_cast<SVF::ICFGNode*> (cs.getStmt());
         return h(inst);
     }
 };

package/svf/include/Util/Options.h

@@ -151,36 +151,17 @@ public:
     static const Option<std::string> WriteSVFG;
     static const Option<std::string> ReadSVFG;
 
-    // FSMPTA.cpp
-    static const Option<bool> UsePCG;
-    static const Option<bool> IntraLock;
-    static const Option<bool> ReadPrecisionTDEdge;
-    static const Option<u32_t> AddModelFlag;
-
     // LockAnalysis.cpp
+    static const Option<bool> IntraLock;
     static const Option<bool> PrintLockSpan;
 
     // MHP.cpp
     static const Option<bool> PrintInterLev;
     static const Option<bool> DoLockAnalysis;
 
-    // MTA.cpp
-    static const Option<bool> AndersenAnno;
-    static const Option<bool> FSAnno;
-
-    // MTAAnnotator.cpp
-    static const Option<u32_t> AnnoFlag;
-
-    // MTAResultValidator.cpp
-    static const Option<bool> PrintValidRes;
-
-    static const Option<bool> LockValid;
     //MTAStat.cpp
     static const Option<bool> AllPairMHP;
 
-    // PCG.cpp
-    //const Option<bool> TDPrint
-
     // TCT.cpp
     static const Option<bool> TCTDotGraph;
 

package/svf/include/Util/SVFUtil.h

@@ -404,7 +404,7 @@ inline bool isArgOfUncalledFunction(const SVFValue* svfval)
 //@{
 inline const SVFValue* getForkedFun(const CallSite cs)
 {
-    return ThreadAPI::getThreadAPI()->getForkedFun(cs);
+    return ThreadAPI::getThreadAPI()->getForkedFun(cs.getInstruction());
 }
 inline const SVFValue* getForkedFun(const SVFInstruction *inst)
 {
@@ -490,7 +490,7 @@ inline bool isReallocExtCall(const SVFInstruction *inst)
 ///@{
 inline bool isThreadForkCall(const CallSite cs)
 {
-    return ThreadAPI::getThreadAPI()->isTDFork(cs);
+    return ThreadAPI::getThreadAPI()->isTDFork(cs.getInstruction());
 }
 inline bool isThreadForkCall(const SVFInstruction *inst)
 {
@@ -498,23 +498,11 @@ inline bool isThreadForkCall(const SVFInstruction *inst)
 }
 //@}
 
-/// Return true if this is a hare_parallel_for call
-///@{
-inline bool isHareParForCall(const CallSite cs)
-{
-    return ThreadAPI::getThreadAPI()->isHareParFor(cs);
-}
-inline bool isHareParForCall(const SVFInstruction *inst)
-{
-    return ThreadAPI::getThreadAPI()->isHareParFor(inst);
-}
-//@}
-
 /// Return true if this is a thread join call
 ///@{
 inline bool isThreadJoinCall(const CallSite cs)
 {
-    return ThreadAPI::getThreadAPI()->isTDJoin(cs);
+    return ThreadAPI::getThreadAPI()->isTDJoin(cs.getInstruction());
 }
 inline bool isThreadJoinCall(const SVFInstruction *inst)
 {
@@ -526,7 +514,7 @@ inline bool isThreadJoinCall(const SVFInstruction *inst)
 ///@{
 inline bool isThreadExitCall(const CallSite cs)
 {
-    return ThreadAPI::getThreadAPI()->isTDExit(cs);
+    return ThreadAPI::getThreadAPI()->isTDExit(cs.getInstruction());
 }
 inline bool isThreadExitCall(const SVFInstruction *inst)
 {
@@ -538,7 +526,7 @@ inline bool isThreadExitCall(const SVFInstruction *inst)
 ///@{
 inline bool isLockAquireCall(const CallSite cs)
 {
-    return ThreadAPI::getThreadAPI()->isTDAcquire(cs);
+    return ThreadAPI::getThreadAPI()->isTDAcquire(cs.getInstruction());
 }
 inline bool isLockAquireCall(const SVFInstruction *inst)
 {
@@ -550,7 +538,7 @@ inline bool isLockAquireCall(const SVFInstruction *inst)
 ///@{
 inline bool isLockReleaseCall(const CallSite cs)
 {
-    return ThreadAPI::getThreadAPI()->isTDRelease(cs);
+    return ThreadAPI::getThreadAPI()->isTDRelease(cs.getInstruction());
 }
 inline bool isLockReleaseCall(const SVFInstruction *inst)
 {
@@ -562,7 +550,7 @@ inline bool isLockReleaseCall(const SVFInstruction *inst)
 //@{
 inline bool isBarrierWaitCall(const CallSite cs)
 {
-    return ThreadAPI::getThreadAPI()->isTDBarWait(cs);
+    return ThreadAPI::getThreadAPI()->isTDBarWait(cs.getInstruction());
 }
 inline bool isBarrierWaitCall(const SVFInstruction *inst)
 {
@@ -574,7 +562,7 @@ inline bool isBarrierWaitCall(const SVFInstruction *inst)
 //@{
 inline const SVFValue* getActualParmAtForkSite(const CallSite cs)
 {
-    return ThreadAPI::getThreadAPI()->getActualParmAtForkSite(cs);
+    return ThreadAPI::getThreadAPI()->getActualParmAtForkSite(cs.getInstruction());
 }
 inline const SVFValue* getActualParmAtForkSite(const SVFInstruction *inst)
 {
@@ -582,29 +570,6 @@ inline const SVFValue* getActualParmAtForkSite(const SVFInstruction *inst)
 }
 //@}
 
-/// Return the task function of the parallel_for routine
-//@{
-inline const SVFValue* getTaskFuncAtHareParForSite(const CallSite cs)
-{
-    return ThreadAPI::getThreadAPI()->getTaskFuncAtHareParForSite(cs);
-}
-inline const SVFValue* getTaskFuncAtHareParForSite(const SVFInstruction *inst)
-{
-    return ThreadAPI::getThreadAPI()->getTaskFuncAtHareParForSite(inst);
-}
-//@}
-
-/// Return the task data argument of the parallel_for routine
-//@{
-inline const SVFValue* getTaskDataAtHareParForSite(const CallSite cs)
-{
-    return ThreadAPI::getThreadAPI()->getTaskDataAtHareParForSite(cs);
-}
-inline const SVFValue* getTaskDataAtHareParForSite(const SVFInstruction *inst)
-{
-    return ThreadAPI::getThreadAPI()->getTaskDataAtHareParForSite(inst);
-}
-//@}
 
 inline bool isProgExitCall(const CallSite cs)
 {

package/svf/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/lib/Graphs/ThreadCallGraph.cpp

@@ -89,29 +89,6 @@ void ThreadCallGraph::updateCallGraph(PointerAnalysis* pta)
             }
         }
     }
-
-    // parallel_for sites
-    for (CallSiteSet::const_iterator it = parForSitesBegin(), eit = parForSitesEnd(); it != eit; ++it)
-    {
-        const SVFValue* forkedval = tdAPI->getTaskFuncAtHareParForSite((*it)->getCallSite());
-        if(SVFUtil::dyn_cast<SVFFunction>(forkedval)==nullptr)
-        {
-            SVFIR* pag = pta->getPAG();
-            const NodeBS targets = pta->getPts(pag->getValueNode(forkedval)).toNodeBS();
-            for (NodeBS::iterator ii = targets.begin(), ie = targets.end(); ii != ie; ii++)
-            {
-                if(ObjVar* objPN = SVFUtil::dyn_cast<ObjVar>(pag->getGNode(*ii)))
-                {
-                    const MemObj* obj = pag->getObject(objPN);
-                    if(obj->isFunction())
-                    {
-                        const SVFFunction* svfCallee = SVFUtil::cast<SVFFunction>(obj->getValue());
-                        this->addIndirectForkEdge(*it, svfCallee);
-                    }
-                }
-            }
-        }
-    }
 }
 
 
@@ -123,7 +100,7 @@ void ThreadCallGraph::updateJoinEdge(PointerAnalysis* pta)
 
     for (CallSiteSet::const_iterator it = joinsitesBegin(), eit = joinsitesEnd(); it != eit; ++it)
     {
-        const SVFValue* jointhread = tdAPI->getJoinedThread((*it)->getCallSite());
+        const SVFValue* jointhread = tdAPI->getJoinedThread(*it);
         // find its corresponding fork sites first
         CallSiteSet forkset;
         for (CallSiteSet::const_iterator it = forksitesBegin(), eit = forksitesEnd(); it != eit; ++it)
@@ -214,52 +191,3 @@ void ThreadCallGraph::addDirectJoinEdge(const CallICFGNode* cs,const CallSiteSet
         }
     }
 }
-
-/*!
- * Add a direct ParFor edges
- */
-void ThreadCallGraph::addDirectParForEdge(const CallICFGNode* cs)
-{
-
-    CallGraphNode* caller = getCallGraphNode(cs->getCaller());
-    const SVFFunction* taskFunc = SVFUtil::dyn_cast<SVFFunction>(tdAPI->getTaskFuncAtHareParForSite(cs->getCallSite()));
-    assert(taskFunc && "callee does not exist");
-
-    CallGraphNode* callee = getCallGraphNode(taskFunc);
-
-    CallSiteID csId = addCallSite(cs, callee->getFunction());
-
-    if (!hasGraphEdge(caller, callee, CallGraphEdge::TDForkEdge, csId))
-    {
-        assert(cs->getCaller() == caller->getFunction() && "callee instruction not inside caller??");
-
-        HareParForEdge* edge = new HareParForEdge(caller, callee, csId);
-        edge->addDirectCallSite(cs);
-
-        addEdge(edge);
-        addHareParForEdgeSetMap(cs, edge);
-    }
-}
-
-/*!
- * Add an indirect ParFor edge to update call graph
- */
-void ThreadCallGraph::addIndirectParForEdge(const CallICFGNode* cs, const SVFFunction* calleefun)
-{
-
-    CallGraphNode* caller = getCallGraphNode(cs->getCaller());
-    CallGraphNode* callee = getCallGraphNode(calleefun);
-
-    CallSiteID csId = addCallSite(cs, callee->getFunction());
-
-    if (!hasGraphEdge(caller, callee, CallGraphEdge::HareParForEdge,csId))
-    {
-        assert(cs->getCaller() == caller->getFunction() && "callee instruction not inside caller??");
-
-        HareParForEdge* edge = new HareParForEdge(caller, callee, csId);
-        edge->addInDirectCallSite(cs);
-
-        addEdge(edge);
-        addHareParForEdgeSetMap(cs, edge);
-    }
-}