svf-tools 1.0.977 → 1.0.978

package/svf/lib/Util/Options.cpp

@@ -445,12 +445,6 @@ const Option<std::string> Options::ReadSVFG(
     ""
 );
 
-// FSMPTA.cpp
-const Option<bool> Options::UsePCG(
-    "pcg-td-edge",
-    "Use PCG lock for non-sparsely adding SVFG edges",
-    false
-);
 
 const Option<bool> Options::IntraLock(
     "intra-lock-td-edge",
@@ -458,18 +452,6 @@ const Option<bool> Options::IntraLock(
     true
 );
 
-const Option<bool> Options::ReadPrecisionTDEdge(
-    "rp-td-edge",
-    "perform read precision to refine SVFG edges",
-    false
-);
-
-const Option<u32_t> Options::AddModelFlag(
-    "add-td-edge",
-    "Add thread SVFG edges with models: 0 Non Add Edge; 1 NonSparse; 2 All Optimisation; 3 No MHP; 4 No Alias; 5 No Lock; 6 No Read Precision.",
-    0
-);
-
 
 // LockAnalysis.cpp
 const Option<bool> Options::PrintLockSpan(
@@ -493,42 +475,6 @@ const Option<bool> Options::DoLockAnalysis(
 );
 
 
-// MTA.cpp
-const Option<bool> Options::AndersenAnno(
-    "tsan-ander",
-    "Add TSan annotation according to Andersen",
-    false
-);
-
-const Option<bool> Options::FSAnno(
-    "tsan-fs",
-    "Add TSan annotation according to flow-sensitive analysis",
-    false
-);
-
-
-// MTAAnnotator.cpp
-const Option<u32_t> Options::AnnoFlag(
-    "anno",
-    "prune annotated instructions: 0001 Thread Local; 0002 Alias; 0004 MHP.",
-    0
-);
-
-
-// MTAResultValidator.cpp
-const Option<bool> Options::PrintValidRes(
-    "mhp-validation",
-    "Print MHP Validation Results",
-    false
-);
-// LockResultValidator.cpp
-const Option<bool> Options::LockValid(
-    "lock-validation",
-    "Print Lock Validation Results",
-    false
-);
-
-
 // MTAStat.cpp
 const Option<bool> Options::AllPairMHP(
     "all-pair-mhp",
@@ -537,14 +483,6 @@ const Option<bool> Options::AllPairMHP(
 );
 
 
-// PCG.cpp
-//const Option<bool> TDPrint(
-//    "print-td",
-//    "Print Thread Analysis Results",
-//    true
-//);
-
-
 // TCT.cpp
 const Option<bool> Options::TCTDotGraph(
     "dump-tct",

package/svf/lib/Util/PTAStat.cpp

@@ -28,7 +28,7 @@
  */
 
 #include <iomanip>
-#include "Graphs/PTACallGraph.h"
+#include "Graphs/CallGraph.h"
 #include "Util/PTAStat.h"
 #include "MemoryModel/PointerAnalysisImpl.h"
 #include "SVFIR/SVFIR.h"
@@ -81,7 +81,7 @@ void PTAStat::performStat()
 void PTAStat::callgraphStat()
 {
 
-    PTACallGraph* graph = pta->getPTACallGraph();
+    CallGraph* graph = pta->getCallGraph();
     PointerAnalysis::CallGraphSCC* callgraphSCC = new PointerAnalysis::CallGraphSCC(graph);
     callgraphSCC->find();
 
@@ -93,8 +93,8 @@ void PTAStat::callgraphStat()
     unsigned edgeInCycle = 0;
 
     NodeSet sccRepNodeSet;
-    PTACallGraph::iterator it = graph->begin();
-    PTACallGraph::iterator eit = graph->end();
+    CallGraph::iterator it = graph->begin();
+    CallGraph::iterator eit = graph->end();
     for (; it != eit; ++it)
     {
         totalNode++;
@@ -107,11 +107,11 @@ void PTAStat::callgraphStat()
                 maxNodeInCycle = subNodes.count();
         }
 
-        PTACallGraphNode::const_iterator edgeIt = it->second->InEdgeBegin();
-        PTACallGraphNode::const_iterator edgeEit = it->second->InEdgeEnd();
+        CallGraphNode::const_iterator edgeIt = it->second->InEdgeBegin();
+        CallGraphNode::const_iterator edgeEit = it->second->InEdgeEnd();
         for (; edgeIt != edgeEit; ++edgeIt)
         {
-            PTACallGraphEdge *edge = *edgeIt;
+            CallGraphEdge *edge = *edgeIt;
             totalEdge+= edge->getDirectCalls().size() + edge->getIndirectCalls().size();
             if(callgraphSCC->repNode(edge->getSrcID()) == callgraphSCC->repNode(edge->getDstID()))
             {

package/svf/lib/Util/ThreadAPI.cpp

@@ -132,17 +132,37 @@ void ThreadAPI::init()
 /*!
  *
  */
-const SVFFunction* ThreadAPI::getCallee(const SVFInstruction *inst) const
+const SVFFunction* ThreadAPI::getCallee(const ICFGNode *inst) const
 {
-    return SVFUtil::getCallee(inst);
+    if(const CallICFGNode* call = SVFUtil::dyn_cast<CallICFGNode>(inst))
+        return SVFUtil::getCallee(call->getCallSite());
+    else
+        return nullptr;
 }
 
 /*!
  *
  */
-const SVFFunction* ThreadAPI::getCallee(const CallSite cs) const
+const SVFFunction* ThreadAPI::getCallee(const SVFInstruction *inst) const
+{
+    return SVFUtil::getCallee(inst);
+}
+
+
+const CallSite ThreadAPI::getSVFCallSite(const ICFGNode *inst) const
+{
+    assert(SVFUtil::isa<CallICFGNode>(inst) && "not a callsite?");
+    CallSite cs(SVFUtil::cast<CallICFGNode>(inst)->getCallSite());
+    return cs;
+}
+
+const SVFValue* ThreadAPI::getLockVal(const ICFGNode *inst) const
 {
-    return SVFUtil::getCallee(cs);
+    const CallICFGNode* call = SVFUtil::dyn_cast<CallICFGNode>(inst);
+    assert(call && "not a call ICFGNode?");
+    assert((isTDAcquire(call->getCallSite()) || isTDRelease(call->getCallSite())) && "not a lock acquire or release function");
+    CallSite cs = getSVFCallSite(call->getCallSite());
+    return cs.getArgument(0);
 }
 
 /*!
@@ -153,7 +173,7 @@ const CallSite ThreadAPI::getSVFCallSite(const SVFInstruction *inst) const
     return SVFUtil::getSVFCallSite(inst);
 }
 
-const SVFValue* ThreadAPI::getJoinedThread(const SVFInstruction *inst) const
+const SVFValue* ThreadAPI::getJoinedThread(const ICFGNode *inst) const
 {
     assert(isTDJoin(inst) && "not a thread join function!");
     CallSite cs = getSVFCallSite(inst);
@@ -231,7 +251,8 @@ void ThreadAPI::performAPIStat(SVFModule* module)
                 const SVFInstruction* svfInst = *ii;
                 if (!SVFUtil::isCallSite(svfInst))
                     continue;
-                const SVFFunction* fun = getCallee(svfInst);
+
+                const SVFFunction* fun = SVFUtil::getCallee(svfInst);
                 TD_TYPE type = getType(fun);
                 switch (type)
                 {

package/svf/lib/WPA/VersionedFlowSensitive.cpp

@@ -483,9 +483,9 @@ void VersionedFlowSensitive::buildDeltaMaps(void)
         bool isDelta = false;
         if (const SVFFunction *fn = svfg->isFunEntrySVFGNode(s))
         {
-            PTACallGraphEdge::CallInstSet callsites;
+            CallGraphEdge::CallInstSet callsites;
             /// use pre-analysis call graph to approximate all potential callsites
-            ander->getPTACallGraph()->getIndCallSitesInvokingCallee(fn, callsites);
+            ander->getCallGraph()->getIndCallSitesInvokingCallee(fn, callsites);
             isDelta = !callsites.empty();
 
             if (isDelta)

package/svf-llvm/include/SVF-LLVM/SVFIRBuilder.h

@@ -201,7 +201,7 @@ public:
     //}@
 
     /// connect PAG edges based on callgraph
-    void updateCallGraph(PTACallGraph* callgraph);
+    void updateCallGraph(CallGraph* callgraph);
 
 protected:
     /// Handle globals including (global variable and functions)

package/svf-llvm/lib/SVFIRBuilder.cpp

@@ -1146,17 +1146,17 @@ void SVFIRBuilder::handleIndCall(CallBase* cs)
     pag->addIndirectCallsites(cbn,pag->getValueNode(svfcalledval));
 }
 
-void SVFIRBuilder::updateCallGraph(PTACallGraph* callgraph)
+void SVFIRBuilder::updateCallGraph(CallGraph* callgraph)
 {
-    PTACallGraph::CallEdgeMap::const_iterator iter = callgraph->getIndCallMap().begin();
-    PTACallGraph::CallEdgeMap::const_iterator eiter = callgraph->getIndCallMap().end();
+    CallGraph::CallEdgeMap::const_iterator iter = callgraph->getIndCallMap().begin();
+    CallGraph::CallEdgeMap::const_iterator eiter = callgraph->getIndCallMap().end();
     for (; iter != eiter; iter++)
     {
         const CallICFGNode* callBlock = iter->first;
         const CallBase* callbase = SVFUtil::cast<CallBase>(LLVMModuleSet::getLLVMModuleSet()->getLLVMValue(callBlock->getCallSite()));
         assert(callBlock->isIndirectCall() && "this is not an indirect call?");
-        const PTACallGraph::FunctionSet& functions = iter->second;
-        for (PTACallGraph::FunctionSet::const_iterator func_iter = functions.begin(); func_iter != functions.end(); func_iter++)
+        const CallGraph::FunctionSet& functions = iter->second;
+        for (CallGraph::FunctionSet::const_iterator func_iter = functions.begin(); func_iter != functions.end(); func_iter++)
         {
             const Function* callee = SVFUtil::cast<Function>(LLVMModuleSet::getLLVMModuleSet()->getLLVMValue(*func_iter));
 

package/svf-llvm/lib/SVFIRExtAPI.cpp

@@ -286,31 +286,5 @@ void SVFIRBuilder::handleExtCall(const CallBase* cs, const SVFFunction* svfCalle
         /// We don't connect the callgraph here, further investigation is need to handle mod-ref during SVFG construction.
     }
 
-    /// create inter-procedural SVFIR edges for hare_parallel_for calls
-    else if (isHareParForCall(svfInst))
-    {
-        if (const SVFFunction* taskFunc = SVFUtil::dyn_cast<SVFFunction>(getTaskFuncAtHareParForSite(svfInst)))
-        {
-            /// The task function of hare_parallel_for has 3 args.
-            assert((taskFunc->arg_size() == 3) && "Size of formal parameter of hare_parallel_for's task routine should be 3");
-            const SVFValue* actualParm = getTaskDataAtHareParForSite(svfInst);
-            const SVFArgument* formalParm = taskFunc->getArg(0);
-            /// Connect actual parameter to formal parameter of the start routine
-            if (actualParm->getType()->isPointerTy() && formalParm->getType()->isPointerTy())
-            {
-                CallICFGNode *icfgNode = pag->getICFG()->getCallICFGNode(svfInst);
-                FunEntryICFGNode *entry = pag->getICFG()->getFunEntryICFGNode(taskFunc);
-                addThreadForkEdge(pag->getValueNode(actualParm), pag->getValueNode(formalParm), icfgNode, entry);
-            }
-        }
-        else
-        {
-            /// handle indirect calls at hare_parallel_for (e.g., hare_parallel_for(..., fp, ...);
-            /// const Value* fun = ThreadAPI::getThreadAPI()->getForkedFun(inst);
-            /// if(!SVFUtil::isa<Function>(fun))
-            ///    pag->addIndirectCallsites(cs,pag->getValueNode(fun));
-        }
-    }
-
     /// TODO: inter-procedural SVFIR edges for thread joins
 }

package/svf-llvm/tools/AE/ae.cpp

@@ -880,7 +880,7 @@ int main(int argc, char** argv)
     SVFIRBuilder builder(svfModule);
     SVFIR* pag = builder.build();
     AndersenWaveDiff* ander = AndersenWaveDiff::createAndersenWaveDiff(pag);
-    PTACallGraph* callgraph = ander->getPTACallGraph();
+    CallGraph* callgraph = ander->getCallGraph();
     builder.updateCallGraph(callgraph);
     pag->getICFG()->updateCallGraph(callgraph);
     if (Options::ICFGMergeAdjacentNodes())

package/svf-llvm/tools/Example/svf-ex.cpp

@@ -168,7 +168,7 @@ int main(int argc, char ** argv)
 
 
     /// Call Graph
-    PTACallGraph* callgraph = ander->getPTACallGraph();
+    CallGraph* callgraph = ander->getCallGraph();
 
     /// ICFG
     ICFG* icfg = pag->getICFG();

package/svf-llvm/tools/MTA/CMakeLists.txt

@@ -1,2 +1,2 @@
-add_llvm_executable(mta mta.cpp LockResultValidator.cpp MTAResultValidator.cpp MTAAnnotator.cpp)
+add_llvm_executable(mta mta.cpp)
 target_link_libraries(mta PUBLIC ${llvm_libs} SvfLLVM)

package/svf-llvm/tools/MTA/mta.cpp

@@ -25,8 +25,6 @@
 #include "MTA/MTA.h"
 #include "Util/CommandLine.h"
 #include "Util/Options.h"
-#include "MTAResultValidator.h"
-#include "LockResultValidator.h"
 
 using namespace llvm;
 using namespace std;
@@ -53,12 +51,6 @@ int main(int argc, char ** argv)
     MTA mta;
     mta.runOnModule(pag);
 
-    MTAResultValidator MTAValidator(mta.getMHP());
-    MTAValidator.analyze();
-
-    // Initialize the validator and perform validation.
-    LockResultValidator lockvalidator(mta.getLockAnalysis());
-    lockvalidator.analyze();
     LLVMModuleSet::releaseLLVMModuleSet();
 
 

package/svf/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_ */