svf-lib 1.0.1262 → 1.0.1264

package/SVF-linux/include/CFL/CFLBase.h

@@ -94,6 +94,8 @@ public:
     static double numOfNonterminalEdges;            // Number of nonterminal labeled edges
     static double numOfStartEdges;                  // Number of start nonterminal labeled edges
     // Solver
+    static double numOfIteration;                   // Number solving Iteration
+    static double numOfChecks;                      // Number of checks
     static double timeOfSolving;                    // time of solving CFL Reachability
     //@}
 

package/SVF-linux/include/CFL/CFLGrammar.h

@@ -177,6 +177,16 @@ public:
         this->terminals = terminals;
     }
 
+    inline Map<std::string, Kind>& getEBNFSigns()
+    {
+        return this->EBNFSigns;
+    }
+
+    inline void setEBNFSigns(Map<std::string, Kind>& EBNFSigns)
+    {
+        this->EBNFSigns = EBNFSigns;
+    }
+
     inline SymbolMap<Symbol, Productions>& getRawProductions()
     {
         return this->rawProductions;
@@ -248,6 +258,8 @@ public:
 
     Symbol insertTerminalSymbol(std::string strLit);
 
+    Symbol insertEBNFSigns(std::string strLit);
+
     void insertAttribute(Kind kind, Attribute a);
 
     inline static Kind getAttributedKind(Attribute attribute, Kind kind)
@@ -268,6 +280,7 @@ protected:
 private:
     Map<std::string, Kind> nonterminals;
     Map<std::string, Kind> terminals;
+    Map<std::string, Kind> EBNFSigns; /// Map contains Signs' String and associated Symbols
     Set<Kind> attributeKinds;
     Map<Kind,  Set<Attribute>> kind2AttrsMap;
     SymbolMap<Symbol, Productions> rawProductions;

package/SVF-linux/include/CFL/CFLGrammar.txt

@@ -3,37 +3,13 @@ Start:
 Terminal:
    addr copy store load gep vgep 
 Productions:
-   F -> epsilon;
-   F -> F copy;
-   F -> addr Memflow;
-   F -> F store V load;
-   F -> store Memflow load;
-   Fbar -> epsilon;
-   Fbar -> copybar Fbar;
-   Fbar -> Memflowbar addrbar;
-   Fbar -> loadbar V storebar Fbar;
-   Fbar -> loadbar Memflowbar storebar;
-   V -> Fbar V F;
-   V -> addrbar addr;
-   V -> gepbar_i V gep_i;
-   V -> gepbarpath V gep_0;
-   V -> gepbar_i F gep_i;
-   V -> gepbar_i Fbar gep_i;
-   copy -> vgep;
+   F -> epsilon | F copy | addr Memflow | F store V load | store Memflow load;
+   Fbar -> epsilon | copybar Fbar | Memflowbar addrbar | loadbar V storebar Fbar | loadbar Memflowbar storebar;
+   V -> Fbar V F | addrbar addr | gepbar_i V gep_i | gepbarpath V gep_0 | gepbar_i F gep_i | gepbar_i Fbar gep_i;
+   copy -> vgep； 
    copybar -> vgepbar;
-   gep_1 -> gep_0 F gep_1;
-   gepbar_1 -> gepbar_1 Fbar gepbar_0;
-   gep_1 -> gep_0 F vgep;
-   gepbar_1 -> vgepbar Fbar gepbar_0;
-   gepbarpath -> gepbar_0 gepbar_0;
-   gepbarpath -> gepbarpath gepbar_0;
-   Memflow -> load store;
-   Memflow -> Fbar Memflow;
-   Memflow -> F Memflow Fbar;
-   Memflow -> gep_i Memflow gepbar_i;
-   Memflow -> gepbar_i Memflow gep_i;
-   Memflowbar -> storebar loadbar;
-   Memflowbar -> Memflowbar F;
-   Memflowbar -> F Memflowbar Fbar;
-   Memflowbar -> gep_i Memflowbar gepbar_i;
-   Memflowbar -> gepbar_i Memflowbar gep_i;
+   gep_1 -> gep_0 F vgep | gep_0 F gep_1;
+   gepbar_1 -> gepbar_1 Fbar gepbar_0 | vgepbar Fbar gepbar_0;
+   gepbarpath -> gepbar_0 gepbar_0 | gepbarpath gepbar_0;
+   Memflow -> load store | Fbar Memflow | F Memflow Fbar | gep_i Memflow gepbar_i | gepbar_i Memflow gep_i;;
+   Memflowbar -> storebar loadbar | Memflowbar F | F Memflowbar Fbar | gep_i Memflowbar gepbar_i | gepbar_i Memflowbar gep_i;

package/SVF-linux/include/CFL/CFLSolver.h

@@ -47,6 +47,8 @@ public:
     typedef CFLGrammar::Production Production;
     typedef CFLGrammar::Symbol Symbol;
 
+    static double numOfChecks;
+
     CFLSolver(CFLGraph* _graph, CFLGrammar* _grammar): graph(_graph), grammar(_grammar)
     {
     }
@@ -57,6 +59,12 @@ public:
         delete grammar;
     }
 
+    /// Initialize worklist
+    void initialize();
+
+    /// Process CFLEdge
+    void processCFLEdge(const CFLEdge* Y_edge);
+
     /// Start solving
     void solve();
 

package/SVF-linux/include/CFL/CFLStat.h

@@ -38,38 +38,28 @@
 namespace SVF
 {
 
-class CFLAlias;
-class CFLVF;
-class SVFIR;
-class ConstraintGraph;
-
 /*!
  * Statistics of CFL's analysis
  */
 class CFLStat : public PTAStat
 {
-
 private:
     CFLBase* pta;
 
 public:
-    /// CFL Stat
-    u32_t _NumofCFLGraphNode;
-
     CFLStat(CFLBase* p);
 
     virtual ~CFLStat()
     {
-
     }
 
     virtual void performStat();
 
-    void collectCFLInfo(CFLGraph* CFLGraph);
-
-    void constraintGraphStat();
+    void CFLGraphStat();
 
     void CFLGrammarStat();
+
+    void CFLSolverStat();
 };
 
 } // End namespace SVF

package/SVF-linux/include/Graphs/CFLGraph.h

@@ -47,6 +47,8 @@ typedef GenericEdge<CFLNode> GenericCFLEdgeTy;
 class CFLEdge: public GenericCFLEdgeTy
 {
 public:
+    typedef GenericNode<CFLNode, CFLEdge>::GEdgeSetTy CFLEdgeSetTy;
+
     CFLEdge(CFLNode *s, CFLNode *d, GEdgeFlag k = 0):
         GenericCFLEdgeTy(s,d,k)
     {
@@ -78,7 +80,74 @@ public:
         GenericCFLNodeTy(i, k)
     {
     }
+
     ~CFLNode() override = default;
+
+    /// Different Kind(label) associated edges set
+    typedef std::map <GrammarBase::Symbol, CFLEdge::CFLEdgeSetTy> CFLEdgeDataTy;
+
+private:
+    CFLEdgeDataTy inCFLEdges;
+    CFLEdgeDataTy outCFLEdges;
+
+public:
+    inline const CFLEdge::CFLEdgeSetTy& getInEdgeWithTy(GrammarBase::Symbol s)
+    {
+        return inCFLEdges[s];
+    }
+
+    inline const CFLEdge::CFLEdgeSetTy& getOutEdgeWithTy(GrammarBase::Symbol s)
+    {
+        return outCFLEdges[s];
+    }
+
+    inline bool addInEdgeWithKind(CFLEdge* inEdge, GrammarBase::Symbol s)
+    {
+        assert(inEdge->getDstID() == this->getId());
+        bool added1 = GenericNode::addIncomingEdge(inEdge);
+        bool added2 = inCFLEdges[s].insert(inEdge).second;
+
+        return added1 && added2;
+    }
+
+    inline bool addIngoingEdge(CFLEdge* inEdge)
+    {
+        return addInEdgeWithKind(inEdge, inEdge->getEdgeKind());
+    }
+
+    inline bool addOutEdgeWithKind(CFLEdge* outEdge, GrammarBase::Symbol s)
+    {
+        assert(outEdge->getSrcID() == this->getId());
+        bool added1 = GenericNode::addOutgoingEdge(outEdge);
+        bool added2 = outCFLEdges[s].insert(outEdge).second;
+
+        return added1 && added2;
+    }
+
+    inline bool addOutgoingEdge(CFLEdge* OutEdge)
+    {
+        return addOutEdgeWithKind(OutEdge, OutEdge->getEdgeKind());
+    }
+
+    inline bool removeCFLInEdge(CFLEdge* inEdge)
+    {
+        u32_t num1 = removeIncomingEdge(inEdge);
+
+        GrammarBase::Symbol s = inEdge->getEdgeKind();
+        u32_t num2 = inCFLEdges[s].erase(inEdge);
+
+        return num1 && num2;
+    }
+
+    inline bool removeCFLOutEdge(CFLEdge* outEdge)
+    {
+        u32_t num1 = removeOutgoingEdge(outEdge);
+
+        GrammarBase::Symbol s = outEdge->getEdgeKind();
+        u32_t num2 = outCFLEdges[s].erase(outEdge);
+
+        return num1 && num2;
+    }
 };
 
 /// Edge-labeled graph for CFL Reachability analysis

package/package.json

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