svf-tools 1.0.539 → 1.0.540

package/include/Util/Options.h

@@ -5,7 +5,7 @@
 
 #include <sstream>
 #include "FastCluster/fastcluster.h"
-#include "MemoryModel/PTAStat.h"
+#include "Util/PTAStat.h"
 #include "MemoryModel/PointerAnalysisImpl.h"
 #include "Util/NodeIDAllocator.h"
 #include "MSSA/MemSSA.h"
@@ -253,6 +253,8 @@ public:
     static const llvm::cl::opt<std::string> CFLGraph;
     static const llvm::cl::opt<bool> PrintCFL;
     static const llvm::cl::opt<bool> FlexSymMap;
+    static const llvm::cl::opt<bool>  PEGTransfer;
+    static const llvm::cl::opt<bool> NullDummyNode;
 
     // Loop Analysis
     static const llvm::cl::opt<bool> LoopAnalysis;

package/include/WPA/Andersen.h

@@ -27,8 +27,8 @@
  *      Author: Yulei Sui
  */
 
-#ifndef ANDERSENPASS_H_
-#define ANDERSENPASS_H_
+#ifndef INCLUDE_WPA_ANDERSEN_H_
+#define INCLUDE_WPA_ANDERSEN_H_
 
 #include "MemoryModel/PointerAnalysisImpl.h"
 #include "WPA/WPAStat.h"
@@ -433,4 +433,4 @@ public:
 
 } // End namespace SVF
 
-#endif /* ANDERSENPASS_H_ */
+#endif /* INCLUDE_WPA_ANDERSEN_H_ */

package/include/WPA/WPAStat.h

@@ -31,7 +31,7 @@
 #ifndef FLOWSENSITIVESTAT_H_
 #define FLOWSENSITIVESTAT_H_
 
-#include "MemoryModel/PTAStat.h"
+#include "Util/PTAStat.h"
 #include "WPA/FlowSensitive.h"
 #include "WPA/VersionedFlowSensitive.h"
 

package/lib/CFL/CFLAlias.cpp

@@ -206,7 +206,15 @@ void CFLAlias::analyze()
         PointerAnalysis::initialize();
         GrammarBase *grammarBase = grammarBuilder.build();
         ConstraintGraph *consCG = new ConstraintGraph(svfir);
-        graph = cflGraphBuilder.buildBigraph(consCG, grammarBase->getStartKind(), grammarBase);
+        if (Options::PEGTransfer)
+        {
+            graph = cflGraphBuilder.buildBiPEGgraph(consCG, grammarBase->getStartKind(), grammarBase, svfir);
+        }
+        else
+        {
+            graph = cflGraphBuilder.buildBigraph(consCG, grammarBase->getStartKind(), grammarBase);
+        }
+
         cflChecker.check(grammarBase, &cflGraphBuilder, graph);
         grammar = normalizer.normalize(grammarBase);
         cflChecker.check(grammar, &cflGraphBuilder, graph);
@@ -228,12 +236,9 @@ void CFLAlias::analyze()
         solver->solve();
     if(Options::PrintCFL == true)
     {
-        std::string svfirName = Options::CFLGraph.c_str();
-        svfir->dump(svfirName.append("_IR"));
-        std::string grammarName = Options::CFLGraph.c_str();
-        grammar->dump(grammarName.append("_Grammar"));
-        std::string CFLGraphFileName = Options::CFLGraph.c_str();
-        graph->dump(CFLGraphFileName.append("_CFL"));
+        svfir->dump("IR");
+        grammar->dump("Grammar");
+        graph->dump("CFLGraph");
     }
     if (Options::CFLGraph.empty())
     {

package/lib/CFL/CFLGraphBuilder.cpp

@@ -222,4 +222,139 @@ CFLGraph* AliasCFLGraphBuilder::buildBigraph(ConstraintGraph *graph, Kind startK
     return cflGraph;
 }
 
+CFLGraph* AliasCFLGraphBuilder::buildBiPEGgraph(ConstraintGraph *graph, Kind startKind, GrammarBase *grammar, SVFIR* pag)
+{
+    CFLGraph *cflGraph = new CFLGraph(startKind);
+    externMap = true;
+    for(auto pairV : grammar->getTerminals())
+    {
+        if(label2KindMap.find(pairV.first) == label2KindMap.end())
+        {
+            label2KindMap.insert(pairV);
+        }
+        if(kind2LabelMap.find(pairV.second) == kind2LabelMap.end())
+        {
+            kind2LabelMap.insert(make_pair(pairV.second, pairV.first));
+        }
+    }
+    for(auto pairV : grammar->getNonterminals())
+    {
+        if(label2KindMap.find(pairV.first) == label2KindMap.end())
+        {
+            label2KindMap.insert(pairV);
+        }
+        if(kind2LabelMap.find(pairV.second) == kind2LabelMap.end())
+        {
+            kind2LabelMap.insert(make_pair(pairV.second, pairV.first));
+        }
+    }
+    for(auto it = graph->begin(); it!= graph->end(); it++)
+    {
+        CFLNode* node = new CFLNode((*it).first);
+        cflGraph->addCFLNode((*it).first, node);
+    }
+    for(auto it = graph->begin(); it!= graph->end(); it++)
+    {
+        ConstraintNode* node = (*it).second;
+        for(ConstraintEdge* edge : node->getOutEdges())
+        {
+            /// Process Store
+            if (edge->getEdgeKind() == ConstraintEdge::Store)
+            {
+                if (pag->isNullPtr(edge->getSrcID()) && (Options::NullDummyNode == false))
+                    continue;
+                /// Check Dst of Store Dereference Node
+                ConstraintNode* Dst = edge->getDstNode();
+                ConstraintNode* DerefNode = nullptr;
+                CFLNode* CFLDerefNode = nullptr;
+                for (ConstraintEdge* DstInEdge : Dst->getInEdges())
+                {
+                    if (DstInEdge->getEdgeKind() == ConstraintEdge::Addr)
+                    {
+                        DerefNode = DstInEdge->getSrcNode();
+                        CFLDerefNode = cflGraph->getGNode(DstInEdge->getSrcID());
+                        break;
+                    }
+                }
+                if (DerefNode == nullptr)
+                {
+
+                    NodeID refId = pag->addDummyValNode();
+                    CFLDerefNode = new CFLNode(refId);
+                    cflGraph->addCFLNode(refId, CFLDerefNode);
+                    /// Add Addr Edge
+                    cflGraph->addCFLEdge(CFLDerefNode, cflGraph->getGNode(edge->getDstID()), ConstraintEdge::Addr);
+                    std::string key = kind2LabelMap[ConstraintEdge::Addr];
+                    key.append("bar");
+                    cflGraph->addCFLEdge(cflGraph->getGNode(edge->getDstID()), CFLDerefNode, label2KindMap[key]);
+                }
+                /// Add Copy Edge
+                cflGraph->addCFLEdge(cflGraph->getGNode(edge->getSrcID()), cflGraph->getGNode(CFLDerefNode->getId()), ConstraintEdge::Copy);
+                std::string key = kind2LabelMap[ConstraintEdge::Copy];
+                key.append("bar");
+                cflGraph->addCFLEdge(cflGraph->getGNode(CFLDerefNode->getId()), cflGraph->getGNode(edge->getSrcID()), label2KindMap[key]);
+            }
+            /// Process Load
+            else if ( edge->getEdgeKind() == ConstraintEdge::Load)
+            {
+                /// Check Src of Load Dereference Node
+                ConstraintNode* Src = edge->getSrcNode();
+                ConstraintNode* DerefNode = nullptr;
+                CFLNode* CFLDerefNode = nullptr;
+                for (ConstraintEdge* SrcInEdge : Src->getInEdges())
+                {
+                    if (SrcInEdge->getEdgeKind() == ConstraintEdge::Addr)
+                    {
+                        DerefNode = SrcInEdge->getSrcNode();
+                        CFLDerefNode = cflGraph->getGNode(SrcInEdge->getSrcID());
+                    }
+                }
+                if (DerefNode == nullptr)
+                {
+                    NodeID refId = pag->addDummyValNode();
+                    CFLDerefNode = new CFLNode(refId);
+                    cflGraph->addCFLNode(refId, CFLDerefNode);
+                    /// Add Addr Edge
+                    cflGraph->addCFLEdge(CFLDerefNode, cflGraph->getGNode(edge->getSrcID()), ConstraintEdge::Addr);
+                    std::string key = kind2LabelMap[ConstraintEdge::Addr];
+                    key.append("bar");
+                    cflGraph->addCFLEdge(cflGraph->getGNode(edge->getSrcID()), CFLDerefNode, label2KindMap[key]);
+                }
+                /// Add Copy Edge
+                cflGraph->addCFLEdge(cflGraph->getGNode(CFLDerefNode->getId()), cflGraph->getGNode(edge->getDstID()),  ConstraintEdge::Copy);
+                std::string key = kind2LabelMap[ConstraintEdge::Copy];
+                key.append("bar");
+                cflGraph->addCFLEdge(cflGraph->getGNode(edge->getDstID()), cflGraph->getGNode(CFLDerefNode->getId()),  label2KindMap[key]);
+            }
+            else
+            {
+                CFLGrammar::Kind edgeLabel = edge->getEdgeKind();
+                // Need to get the offset from the Const Edge
+                // The offset present edge is only from Normal Gep CG at moment
+                if(NormalGepCGEdge::classof(edge))
+                {
+                    NormalGepCGEdge *nGepEdge = SVFUtil::dyn_cast<NormalGepCGEdge>(edge);
+                    CFLGrammar::Attribute attr =  nGepEdge->getConstantFieldIdx();
+                    addAttribute(edgeLabel, attr);
+                    edgeLabel = CFLGrammar::getAttributedKind(attr, edgeLabel);
+                    cflGraph->addCFLEdge(cflGraph->getGNode(edge->getSrcID()), cflGraph->getGNode(edge->getDstID()), edgeLabel);
+                    std::string key = kind2LabelMap[edge->getEdgeKind()];
+                    key.append("bar");   // for example Gep_i should be Gepbar_i, not Gep_ibar
+                    cflGraph->addCFLEdge(cflGraph->getGNode(edge->getDstID()), cflGraph->getGNode(edge->getSrcID()), CFLGrammar::getAttributedKind(attr, label2KindMap[key]));
+                    addAttribute(label2KindMap[key], attr);
+                }
+                else
+                {
+                    cflGraph->addCFLEdge(cflGraph->getGNode(edge->getSrcID()), cflGraph->getGNode(edge->getDstID()), edgeLabel);
+                    std::string key = kind2LabelMap[edge->getEdgeKind()];
+                    key.append("bar");
+                    cflGraph->addCFLEdge(cflGraph->getGNode(edge->getDstID()), cflGraph->getGNode(edge->getSrcID()), label2KindMap[key]);
+                }
+            }
+        }
+    }
+    return cflGraph;
+}
+
+
 } // end of SVF namespace

package/lib/CFL/GrammarBuilder.cpp

@@ -42,6 +42,7 @@ const inline std::string GrammarBuilder::parseProductionsString() const
     std::string lineString;
     std::string lines = "";
     std::string startString;
+    std::string symbolString;
     const std::string WHITESPACE = " \n\r\t\f\v";
     int lineNum = 0;
     while (getline(textFile, lineString))
@@ -50,25 +51,28 @@ const inline std::string GrammarBuilder::parseProductionsString() const
         {
             startString = stripSpace(lineString);
         }
+        if(lineNum == 3)
+        {
+            symbolString = lineString.substr(lineString.find_first_not_of(WHITESPACE), lineString.find_last_not_of(WHITESPACE)+1);
+        }
 
         lines.append(lineString.substr(lineString.find_first_not_of(WHITESPACE), lineString.find_last_not_of(WHITESPACE)+1));
         lineNum++;
     }
 
-    std::regex reg("Start:([\\s\\S]*)Terminal:([\\s\\S]*)Productions:([\\s\\S]*)");
+    std::regex reg("Start:([\\s\\S]*)Terminal:(.*)Productions:([\\s\\S]*)");
     std::smatch matches;
     if (std::regex_search(lines, matches, reg))
     {
         lines = matches.str(3);
     }
-    std::string terminalString = matches.str(2);
-    std::string symbolString;
-    size_t pos;
-    while ((pos = terminalString.find(" ")) != std::string::npos)
+    std::string sString;
+    size_t pos = 0;
+    while ((pos = symbolString.find(" ")) != std::string::npos)
     {
-        symbolString = stripSpace(terminalString.substr(0, pos));
-        terminalString.erase(0, pos + 1); //Capital is Nonterminal, Otherwise is terminal
-        grammar->insertSymbol(symbolString);
+        sString = stripSpace(symbolString.substr(0, pos));
+        symbolString.erase(0, pos + 1); //Capital is Nonterminal, Otherwise is terminal
+        grammar->insertSymbol(sString);
     }
     grammar->insertSymbol(symbolString);
     grammar->setStartKind(grammar->insertSymbol(startString));

package/lib/MTA/LockAnalysis.cpp

@@ -10,7 +10,7 @@
 #include "MTA/MTA.h"
 #include "MTA/MTAResultValidator.h"
 #include "Util/SVFUtil.h"
-#include "MemoryModel/PTAStat.h"
+#include "Util/PTAStat.h"
 #include "MTA/LockResultValidator.h"
 
 

package/lib/MTA/MHP.cpp

@@ -11,7 +11,7 @@
 #include "MTA/LockAnalysis.h"
 #include "MTA/MTAResultValidator.h"
 #include "Util/SVFUtil.h"
-#include "MemoryModel/PTAStat.h"
+#include "Util/PTAStat.h"
 #include "SVF-FE/BasicTypes.h"
 
 using namespace SVF;

package/lib/MemoryModel/PointerAnalysis.cpp

@@ -37,7 +37,7 @@
 
 #include "MemoryModel/PointerAnalysisImpl.h"
 #include "MemoryModel/PAGBuilderFromFile.h"
-#include "MemoryModel/PTAStat.h"
+#include "Util/PTAStat.h"
 #include "Graphs/ThreadCallGraph.h"
 #include "Graphs/ICFG.h"
 

package/lib/SVF-FE/CHGBuilder.cpp

@@ -43,7 +43,7 @@
 #include "Util/SVFUtil.h"
 #include "SVF-FE/LLVMUtil.h"
 #include "Util/SVFModule.h"
-#include "MemoryModel/PTAStat.h"
+#include "Util/PTAStat.h"
 
 using namespace SVF;
 using namespace SVFUtil;

package/lib/Util/NodeIDAllocator.cpp

@@ -6,7 +6,7 @@
 
 #include "FastCluster/fastcluster.h"
 #include "MemoryModel/PointerAnalysisImpl.h"
-#include "MemoryModel/PTAStat.h"
+#include "Util/PTAStat.h"
 #include "Util/NodeIDAllocator.h"
 #include "Util/BasicTypes.h"
 #include "Util/SVFBasicTypes.h"

package/lib/Util/Options.cpp

@@ -790,25 +790,37 @@ const llvm::cl::opt<std::string> Options::GrammarFilename(
 const llvm::cl::opt<std::string> Options::CFLGraph(
     "cflgraph",
     llvm::cl::init(""),
-    llvm::cl::desc("<dot file as the CFLGraph input>")
+    llvm::cl::desc("<Dot file as the CFLGraph input>")
 );
 
 const llvm::cl::opt<bool> Options::PrintCFL(
     "print-cfl",
     llvm::cl::init(false),
-    llvm::cl::desc("print ir, grammar and cflgraph for debug.")
+    llvm::cl::desc("Print ir, grammar and cflgraph for debug.")
 );
 
 const llvm::cl::opt<bool> Options::FlexSymMap(
     "flex-symmap",
     llvm::cl::init(false),
-    llvm::cl::desc("extend exist sym map while read graph from dot if sym not in map.")
+    llvm::cl::desc("Extend exist sym map while read graph from dot if sym not in map.")
+);
+
+const llvm::cl::opt<bool> Options::PEGTransfer(
+    "peg-transfer",
+    llvm::cl::init(false),
+    llvm::cl::desc("When explicit to true, cfl graph builder will transfer PAG load and store edges to copy and addr.")
+);
+
+const llvm::cl::opt<bool> Options::NullDummyNode(
+    "null-dummy",
+    llvm::cl::init(true),
+    llvm::cl::desc("When explicit to false, ir graph builder will skip null poiner assignment instead of generate new DummyValVarNode.")
 );
 
 const llvm::cl::opt<bool> Options::LoopAnalysis(
     "loop-analysis",
     llvm::cl::init(true),
-    llvm::cl::desc("analyze every func and get loop info and loop bounds.")
+    llvm::cl::desc("Analyze every func and get loop info and loop bounds.")
 );
 
 const llvm::cl::opt<unsigned> Options::LoopBound(

package/lib/Util/PTAStat.cpp

@@ -29,20 +29,20 @@
 
 #include <iomanip>
 #include "Graphs/PTACallGraph.h"
-#include "MemoryModel/PTAStat.h"
+#include "Util/PTAStat.h"
 #include "MemoryModel/PointerAnalysisImpl.h"
 #include "MemoryModel/SVFIR.h"
 #include "Util/Options.h"
 
 using namespace SVF;
 
-const char* PTAStat:: TotalAnalysisTime = "TotalTime";	///< SVFIR value nodes
+const char* PTAStat:: TotalAnalysisTime = "TotalTime";	///< SVFIR value nodes ？？
 const char* PTAStat:: SCCDetectionTime = "SCCDetectTime"; ///< Total SCC detection time
 const char* PTAStat:: SCCMergeTime = "SCCMergeTime"; ///< Total SCC merge time
 
 const char* PTAStat:: ProcessLoadStoreTime = "LoadStoreTime";	///< process load and store time
 const char* PTAStat:: ProcessCopyGepTime = "CopyGepTime";	///< process copy and gep time
-const char* PTAStat:: UpdateCallGraphTime = "UpdateCGTime";	///< process copy and gep time
+const char* PTAStat:: UpdateCallGraphTime = "UpdateCGTime";	///< process copy and gep time ？？
 
 const char* PTAStat:: TotalNumOfPointers = "TotalPointers";	///< SVFIR value nodes
 const char* PTAStat:: TotalNumOfObjects = "TotalObjects";	///< Total SVFIR object node
@@ -113,6 +113,7 @@ PTAStat::PTAStat(PointerAnalysis* p) : startTime(0), endTime(0), pta(p)
 
 double PTAStat::getClk(bool mark)
 {
+    std::cout << Options::MarkedClocksOnly;
     if (Options::MarkedClocksOnly && !mark) return 0.0;
 
     if (Options::ClockType == ClockType::Wall)

package/lib/WPA/TypeAnalysis.cpp

@@ -32,7 +32,7 @@
 #include "SVF-FE/ICFGBuilder.h"
 #include "Graphs/CHG.h"
 #include "WPA/TypeAnalysis.h"
-#include "MemoryModel/PTAStat.h"
+#include "Util/PTAStat.h"
 #include "Graphs/ICFGStat.h"
 #include "Graphs/VFG.h"
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "svf-tools",
-  "version": "1.0.539",
+  "version": "1.0.540",
   "description": "* <b>[TypeClone](https://github.com/SVF-tools/SVF/wiki/TypeClone) published in our [ECOOP paper](https://yuleisui.github.io/publications/ecoop20.pdf) is now available in SVF </b> * <b>SVF now uses a single script for its build. Just type [`source ./build.sh`](https://github.com/SVF-tools/SVF/blob/master/build.sh) in your terminal, that's it!</b> * <b>SVF now supports LLVM-10.0.0! </b> * <b>We thank [bsauce](https://github.com/bsauce) for writing a user manual of SVF ([link1](https://www.jianshu.com/p/068a08ec749c) and [link2](https://www.jianshu.com/p/777c30d4240e)) in Chinese </b> * <b>SVF now supports LLVM-9.0.0 (Thank [Byoungyoung Lee](https://github.com/SVF-tools/SVF/issues/142) for his help!). </b> * <b>SVF now supports a set of [field-sensitive pointer analyses](https://yuleisui.github.io/publications/sas2019a.pdf). </b> * <b>[Use SVF as an external lib](https://github.com/SVF-tools/SVF/wiki/Using-SVF-as-a-lib-in-your-own-tool) for your own project (Contributed by [Hongxu Chen](https://github.com/HongxuChen)). </b> * <b>SVF now supports LLVM-7.0.0. </b> * <b>SVF now supports Docker. [Try SVF in Docker](https://github.com/SVF-tools/SVF/wiki/Try-SVF-in-Docker)! </b> * <b>SVF now supports [LLVM-6.0.0](https://github.com/svf-tools/SVF/pull/38) (Contributed by [Jack Anthony](https://github.com/jackanth)). </b> * <b>SVF now supports [LLVM-4.0.0](https://github.com/svf-tools/SVF/pull/23) (Contributed by Jared Carlson. Thank [Jared](https://github.com/jcarlson23) and [Will](https://github.com/dtzWill) for their in-depth [discussions](https://github.com/svf-tools/SVF/pull/18) about updating SVF!) </b> * <b>SVF now supports analysis for C++ programs.</b> <br />",
   "main": "index.js",
   "scripts": {