svf-tools 1.0.730 → 1.0.732

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "svf-tools",
-  "version": "1.0.730",
+  "version": "1.0.732",
   "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": {

package/svf/include/CFL/CFGNormalizer.h

@@ -56,7 +56,7 @@ public:
     CFLGrammar* normalize(GrammarBase *generalGrammar);
 
     /// Expand every variable attribute in rawProductions of grammarbase
-    CFLGrammar* fillAttribute(CFLGrammar *grammar, const Map<CFLGrammar::Kind, Set<CFLGrammar::Attribute>>& kind2AttrsMap);
+    CFLGrammar* fillAttribute(CFLGrammar *grammar, const Map<CFLGrammar::Kind, Set<CFLGrammar::Attribute>>& kindToAttrsMap);
 
 private:
     /// Add nonterminal to tranfer long rules to binary rules

package/svf/include/CFL/CFLAlias.h

@@ -112,8 +112,8 @@ public:
         {
             return false;
         }
-        CFLGrammar::Kind copyKind = grammar->str2Kind("copy");
-        CFLGrammar::Kind copybarKind = grammar->str2Kind("copybar");
+        CFLGrammar::Kind copyKind = grammar->strToKind("copy");
+        CFLGrammar::Kind copybarKind = grammar->strToKind("copybar");
         solver->pushIntoWorklist(graph->addCFLEdge(graph->getGNode(src),graph->getGNode(dst), copyKind));
         solver->pushIntoWorklist(graph->addCFLEdge(graph->getGNode(dst),graph->getGNode(src), copybarKind));
         return true;

package/svf/include/CFL/CFLBase.h

@@ -61,6 +61,9 @@ public:
         delete grammarBase;
     }
 
+    /// Parameter Checking
+    virtual void checkParameter();
+
     /// Build Grammar from text file
     virtual void buildCFLGrammar();
 

package/svf/include/CFL/CFLGramGraphChecker.h

@@ -42,29 +42,29 @@ public:
         /// Check all kinds in grammar in graphBuilder with the same label
         for(auto pairV : grammar->getTerminals())
         {
-            if (graphBuilder->getLabel2KindMap().find(pairV.first) != graphBuilder->getLabel2KindMap().end())
+            if (graphBuilder->getLabelToKindMap().find(pairV.first) != graphBuilder->getLabelToKindMap().end())
             {
-                assert(graphBuilder->getLabel2KindMap()[pairV.first] == pairV.second);
-                assert(graphBuilder->getKind2LabelMap()[pairV.second] == pairV.first);
+                assert(graphBuilder->getLabelToKindMap()[pairV.first] == pairV.second);
+                assert(graphBuilder->getKindToLabelMap()[pairV.second] == pairV.first);
             }
         }
 
         for(auto pairV : grammar->getNonterminals())
         {
-            if (graphBuilder->getLabel2KindMap().find(pairV.first) != graphBuilder->getLabel2KindMap().end())
+            if (graphBuilder->getLabelToKindMap().find(pairV.first) != graphBuilder->getLabelToKindMap().end())
             {
-                assert(graphBuilder->getLabel2KindMap()[pairV.first] == pairV.second);
-                assert(graphBuilder->getKind2LabelMap()[pairV.second] == pairV.first);
+                assert(graphBuilder->getLabelToKindMap()[pairV.first] == pairV.second);
+                assert(graphBuilder->getKindToLabelMap()[pairV.second] == pairV.first);
             }
             else
             {
-                graphBuilder->getLabel2KindMap().insert(std::make_pair (pairV.first,pairV.second));
-                graphBuilder->getKind2LabelMap().insert(std::make_pair (pairV.second, pairV.first));
+                graphBuilder->getLabelToKindMap().insert(std::make_pair (pairV.first,pairV.second));
+                graphBuilder->getKindToLabelMap().insert(std::make_pair (pairV.second, pairV.first));
             }
         }
 
-        /// Get Kind2Attrs Map from Graph to Grammar
-        grammar->setKind2AttrsMap(graphBuilder->getKind2AttrsMap());
+        /// Get KindToAttrs Map from Graph to Grammar
+        grammar->setKindToAttrsMap(graphBuilder->getKindToAttrsMap());
         graph->startKind = grammar->getStartKind();
     }
 };

package/svf/include/CFL/CFLGrammar.h

@@ -192,9 +192,9 @@ public:
         return this->rawProductions;
     }
 
-    inline const Map<Kind,  Set<Attribute>>& getKind2AttrsMap() const
+    inline const Map<Kind,  Set<Attribute>>& getKindToAttrsMap() const
     {
-        return this->kind2AttrsMap;
+        return this->kindToAttrsMap;
     }
 
     inline Kind getTotalKind()
@@ -223,17 +223,17 @@ public:
 
     void setRawProductions(SymbolMap<Symbol, Productions>& rawProductions);
 
-    void setKind2AttrsMap(const Map<Kind,  Set<Attribute>>& kind2AttrsMap);
+    void setKindToAttrsMap(const Map<Kind,  Set<Attribute>>& kindToAttrsMap);
 
     void setAttributeKinds(const Set<Kind>& attributeKind);
 
-    Kind str2Kind(std::string str) const;
+    Kind strToKind(std::string str) const;
 
-    Symbol str2Symbol(const std::string str) const;
+    Symbol strToSymbol(const std::string str) const;
 
-    std::string kind2Str(Kind kind) const;
+    std::string kindToStr(Kind kind) const;
 
-    std::string sym2StrDump(Symbol sym) const;
+    std::string symToStrDump(Symbol sym) const;
 
     Symbol getSymbol(const Production& prod, u32_t pos)
     {
@@ -282,7 +282,7 @@ private:
     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;
+    Map<Kind,  Set<Attribute>> kindToAttrsMap;
     SymbolMap<Symbol, Productions> rawProductions;
     u32_t totalKind;
 };
@@ -310,57 +310,57 @@ public:
         return epsilonProds;
     }
 
-    SymbolMap<Symbol, Productions>& getSingleRHS2Prods()
+    SymbolMap<Symbol, Productions>& getSingleRHSToProds()
     {
-        return singleRHS2Prods;
+        return singleRHSToProds;
     }
 
-    SymbolMap<Symbol, Productions>& getFirstRHS2Prods()
+    SymbolMap<Symbol, Productions>& getFirstRHSToProds()
     {
-        return firstRHS2Prods;
+        return firstRHSToProds;
     }
 
-    SymbolMap<Symbol, Productions>& getSecondRHS2Prods()
+    SymbolMap<Symbol, Productions>& getSecondRHSToProds()
     {
-        return secondRHS2Prods;
+        return secondRHSToProds;
     }
 
     const bool hasProdsFromFirstRHS(const Symbol sym) const
     {
-        auto it = firstRHS2Prods.find(sym);
-        return it!=firstRHS2Prods.end();
+        auto it = firstRHSToProds.find(sym);
+        return it!=firstRHSToProds.end();
     }
 
     const bool hasProdsFromSingleRHS(const Symbol sym) const
     {
-        auto it = singleRHS2Prods.find(sym);
-        return it!=singleRHS2Prods.end();
+        auto it = singleRHSToProds.find(sym);
+        return it!=singleRHSToProds.end();
     }
 
     const bool hasProdsFromSecondRHS(const Symbol sym) const
     {
-        auto it = secondRHS2Prods.find(sym);
-        return it!=secondRHS2Prods.end();
+        auto it = secondRHSToProds.find(sym);
+        return it!=secondRHSToProds.end();
     }
 
     const Productions& getProdsFromSingleRHS(const Symbol sym) const
     {
-        auto it = singleRHS2Prods.find(sym);
-        assert(it!=singleRHS2Prods.end() && "production (X -> sym) not found for sym!!");
+        auto it = singleRHSToProds.find(sym);
+        assert(it!=singleRHSToProds.end() && "production (X -> sym) not found for sym!!");
         return it->second;
     }
 
     const Productions& getProdsFromFirstRHS(const Symbol sym) const
     {
-        auto it = firstRHS2Prods.find(sym);
-        assert(it!=firstRHS2Prods.end() && "production (X -> sym Y ) not found for sym!!");
+        auto it = firstRHSToProds.find(sym);
+        assert(it!=firstRHSToProds.end() && "production (X -> sym Y ) not found for sym!!");
         return it->second;
     }
 
     const Productions& getProdsFromSecondRHS(const Symbol sym) const
     {
-        auto it = secondRHS2Prods.find(sym);
-        assert(it!=secondRHS2Prods.end() && "production (X -> Y sym) not found for sym!!");
+        auto it = secondRHSToProds.find(sym);
+        assert(it!=secondRHSToProds.end() && "production (X -> Y sym) not found for sym!!");
         return it->second;
     }
 
@@ -392,9 +392,9 @@ public:
 
 private:
     SymbolSet<Production> epsilonProds;
-    SymbolMap<Symbol, Productions> singleRHS2Prods;
-    SymbolMap<Symbol, Productions> firstRHS2Prods;
-    SymbolMap<Symbol, Productions> secondRHS2Prods;
+    SymbolMap<Symbol, Productions> singleRHSToProds;
+    SymbolMap<Symbol, Productions> firstRHSToProds;
+    SymbolMap<Symbol, Productions> secondRHSToProds;
     u32_t newTerminalSubscript;
 };
 

package/svf/include/CFL/CFLGraphBuilder.h

@@ -37,27 +37,40 @@
 namespace SVF
 {
 
-/*!
- * Build CFLGraph from memory graph or dot form
-
+/**
+ * CFLGraphBuilder class is responsible for building CFL (Context-Free Language) graphs
+ * from text files or dot files or from memory graph.
  */
-
 class CFLGraphBuilder
 {
 protected:
+    /// Define Kind(Not contain attribute) and Symbol(May contain attribute) as types derived from CFLGrammar
+    /// to numerically represent label
     typedef CFLGrammar::Kind Kind;
     typedef CFLGrammar::Symbol Symbol;
-    Map<std::string, Kind> label2KindMap;
-    Map<Kind, std::string> kind2LabelMap;
-    Map<CFLGrammar::Kind,  Set<CFLGrammar::Attribute>> kind2AttrsMap;
-    bool externMap;
+
+    /// Maps to maintain mapping between labels and kinds
+    Map<std::string, Kind> labelToKindMap;
+    Map<Kind, std::string> kindToLabelMap;
+
+    /// Map to maintain attributes associated with each kind
+    Map<CFLGrammar::Kind,  Set<CFLGrammar::Attribute>> kindToAttrsMap;
+
     Kind current;
+    CFLGraph *cflGraph;
 
-public:
-    /// add attribute to kind2Attribute Map
+    /// Method to add an attribute to a specific kind
     void addAttribute(CFLGrammar::Kind kind, CFLGrammar::Attribute attribute);
 
-    /// Build graph by copying nodes and edges from any graph inherited from GenericGraph
+    /// build label and kind connect from the grammar
+    void buildlabelToKindMap(GrammarBase *grammar);
+
+    /// add src and dst node from file
+    CFLNode* addGNode(u32_t NodeID);
+
+public:
+    /// Method to build a CFL graph by copying nodes and edges from any graph
+    /// inherited from GenericGraph
     template<class N, class E>
     void build(GenericGraph<N,E>* graph, CFLGraph* cflGraph)
     {
@@ -76,32 +89,32 @@ public:
         }
     }
 
-    /// Build Bidirectional graph by copying nodes and edges from any graph inherited from GenericGraph
+    /// Method to build a bidirectional CFL graph by copying nodes and edges
+    /// from any graph inherited from GenericGraph
     template<class N, class E>
     CFLGraph* buildBigraph(GenericGraph<N,E>* graph, Kind startKind, GrammarBase *grammar)
     {
         CFLGraph *cflGraph = new CFLGraph(startKind);
-        externMap = true;
         for(auto pairV : grammar->getTerminals())
         {
-            if(label2KindMap.find(pairV.first) == label2KindMap.end())
+            if(labelToKindMap.find(pairV.first) == labelToKindMap.end())
             {
-                label2KindMap.insert(pairV);
+                labelToKindMap.insert(pairV);
             }
-            if(kind2LabelMap.find(pairV.second) == kind2LabelMap.end())
+            if(kindToLabelMap.find(pairV.second) == kindToLabelMap.end())
             {
-                kind2LabelMap.insert(make_pair(pairV.second, pairV.first));
+                kindToLabelMap.insert(make_pair(pairV.second, pairV.first));
             }
         }
         for(auto pairV : grammar->getNonterminals())
         {
-            if(label2KindMap.find(pairV.first) == label2KindMap.end())
+            if(labelToKindMap.find(pairV.first) == labelToKindMap.end())
             {
-                label2KindMap.insert(pairV);
+                labelToKindMap.insert(pairV);
             }
-            if(kind2LabelMap.find(pairV.second) == kind2LabelMap.end())
+            if(kindToLabelMap.find(pairV.second) == kindToLabelMap.end())
             {
-                kind2LabelMap.insert(make_pair(pairV.second, pairV.first));
+                kindToLabelMap.insert(make_pair(pairV.second, pairV.first));
             }
         }
         for(auto it = graph->begin(); it!= graph->end(); it++)
@@ -116,78 +129,89 @@ public:
             {
                 CFLGrammar::Kind edgeLabel = edge->getEdgeKind();
                 cflGraph->addCFLEdge(cflGraph->getGNode(edge->getSrcID()), cflGraph->getGNode(edge->getDstID()), edgeLabel);
-                std::string key = kind2LabelMap[edge->getEdgeKind()];
+                std::string key = kindToLabelMap[edge->getEdgeKind()];
                 key.append("bar");
-                cflGraph->addCFLEdge(cflGraph->getGNode(edge->getDstID()), cflGraph->getGNode(edge->getSrcID()), label2KindMap[key]);
+                cflGraph->addCFLEdge(cflGraph->getGNode(edge->getDstID()), cflGraph->getGNode(edge->getSrcID()), labelToKindMap[key]);
             }
         }
         return cflGraph;
     }
 
-    /// Build graph from file
-    void build(std::string filename, CFLGraph* cflGraph);
-
-    /// Build graph from Dot
+    /// Method to build a CFL graph from a Dot file
     CFLGraph *buildFromDot(std::string filename, GrammarBase *grammar);
 
-    Map<std::string, Kind>& getLabel2KindMap()
+    /// Method to build a CFL graph from a Text file
+    CFLGraph* buildFromTextFile(std::string fileName, GrammarBase *grammar);
+
+    /// @{
+    /// Getter methods for accessing class variables
+
+    /// Returns a reference to the map that associates string labels with their corresponding Kind
+    Map<std::string, Kind>& getLabelToKindMap()
     {
-        return this->label2KindMap;
+        return this->labelToKindMap;
     }
 
-    Map<Kind, std::string>& getKind2LabelMap()
+    /// Returns a reference to the map that associates Kinds with their corresponding string labels
+    Map<Kind, std::string>& getKindToLabelMap()
     {
-        return this->kind2LabelMap;
+        return this->kindToLabelMap;
     }
 
-    Map<CFLGrammar::Kind,  Set<CFLGrammar::Attribute>>& getKind2AttrsMap()
+    /// Returns a reference to the map that associates Kinds with their corresponding attributes
+    Map<CFLGrammar::Kind,  Set<CFLGrammar::Attribute>>& getKindToAttrsMap()
     {
-        return this->kind2AttrsMap;
+        return this->kindToAttrsMap;
     }
 
-
+    /// @}
 };
 
+/// AliasCFLGraphBuilder: a CFLGraphBuilder specialized for handling aliasing
 class AliasCFLGraphBuilder : public CFLGraphBuilder
 {
 public:
-    /// Build Bidirectional graph by copying nodes and edges from const graph inherited from GenericGraph
+    /// Builds a bidirectional CFL graph by copying nodes and edges from a const graph that inherits from GenericGraph
     CFLGraph* buildBigraph(ConstraintGraph *graph, Kind startKind, GrammarBase *grammar);
 
-    /// Build Bidirectional graph by copying nodes and edges from any graph inherited from GenericGraph
-    /// And transfer Load Store to copy edge and address edge to construct PEG style CFG
+    /// Builds a bidirectional CFL graph by copying nodes and edges from any graph that inherits from GenericGraph
+    /// Transfers Load and Store to copy edge and address edge to construct PEG style CFLGraph
     CFLGraph* buildBiPEGgraph(ConstraintGraph *graph, Kind startKind, GrammarBase *grammar, SVFIR* pag);
 
 private:
+    /// Connects VGep (Variable GEP)
     void connectVGep(CFLGraph *cflGraph,  ConstraintGraph *graph, ConstraintNode *src, ConstraintNode *dst, u32_t level, SVFIR* pag);
 
-    /// Handle edge except for the GEP
+    /// Handles edges, with the exception of the GEP
     void addBiCFLEdge(CFLGraph *cflGraph,  ConstraintNode* src, ConstraintNode* dst, CFLGrammar::Kind label);
 
-    /// Add Bidirectional GEP edge with attribute
+    /// Adds bidirectional GEP edges with attributes
     void addBiGepCFLEdge(CFLGraph *cflGraph,  ConstraintNode* src, ConstraintNode* dst, CFLGrammar::Attribute attri);
 };
 
+/// VFCFLGraphBuilder: a CFLGraphBuilder specialized for handling value-flow
 class VFCFLGraphBuilder : public CFLGraphBuilder
 {
 public:
-    /// Build Bidirectional graph by copying nodes and edges from const graph inherited from GenericGraph
+    /// Builds a bidirectional CFL graph by copying nodes and edges from a const graph that inherits from SVFG
     CFLGraph* buildBigraph(SVFG *graph, Kind startKind, GrammarBase *grammar);
 
-    /// Build Bidirectional graph by copying nodes and edges from any graph inherited from GenericGraph
-    /// And transfer Load Store to copy edge and address edge to construct PEG style CFG
+    /// Builds a bidirectional CFL graph by copying nodes and edges from any graph that inherits from GenericGraph
+    /// Transfers Load and Store to copy edge and address edge to construct PEG style CFLGraph
     CFLGraph* buildBiPEGgraph(ConstraintGraph *graph, Kind startKind, GrammarBase *grammar, SVFIR* pag);
 
 private:
+    /// Connects VGep (Variable GEP)
     void connectVGep(CFLGraph *cflGraph,  ConstraintGraph *graph, ConstraintNode *src, ConstraintNode *dst, u32_t level, SVFIR* pag);
 
-    /// Handle edge except for the GEP
+    /// Handles edges, with the exception of the GEP
     void addBiCFLEdge(CFLGraph *cflGraph,  ConstraintNode* src, ConstraintNode* dst, CFLGrammar::Kind label);
 
-    /// Add Bidirectional GEP edge with attribute
+    /// Adds bidirectional GEP edges with attributes
     void addBiGepCFLEdge(CFLGraph *cflGraph,  ConstraintNode* src, ConstraintNode* dst, CFLGrammar::Attribute attri);
 };
 
+
 }// SVF
 
 #endif /* INCLUDE_CFL_CFLGRAPHBUILDER_H_*/

package/svf/include/CFL/CFLVF.h

@@ -46,6 +46,9 @@ public:
     {
     }
 
+    /// Parameter Checking
+    virtual void checkParameter();
+
     /// Initialize the grammar, graph, solver
     virtual void initialize();
 

package/svf/include/SVFIR/SVFValue.h

@@ -218,6 +218,10 @@ public:
     {
         return name;
     }
+    inline virtual void setName(const std::string& valueName)
+    {
+        name = valueName;
+    }
 
     inline virtual const SVFType* getType() const
     {
@@ -266,6 +270,7 @@ class SVFFunction : public SVFValue
     friend class LLVMModuleSet;
     friend class SVFIRWriter;
     friend class SVFIRReader;
+    friend class SVFIRBuilder;
 
 public:
     typedef std::vector<const SVFBasicBlock*>::const_iterator const_iterator;
@@ -482,6 +487,7 @@ class SVFBasicBlock : public SVFValue
     friend class LLVMModuleSet;
     friend class SVFIRWriter;
     friend class SVFIRReader;
+    friend class SVFIRBuilder;
 
 public:
     typedef std::vector<const SVFInstruction*>::const_iterator const_iterator;
@@ -650,6 +656,7 @@ class SVFCallInst : public SVFInstruction
     friend class SVFIRWriter;
     friend class SVFIRReader;
     friend class LLVMModuleSet;
+    friend class SVFIRBuilder;
 
 private:
     std::vector<const SVFValue*> args;