svf-tools 1.0.440 → 1.0.443

package/lib/Graphs/CFLGraph.cpp

@@ -0,0 +1,225 @@
+//===----- CFLGraph.cpp -- Graph for context-free language reachability analysis --//
+//
+//                     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 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 General Public License for more details.
+
+// You should have received a copy of the GNU General Public License
+// along with this program.  If not, see <http://www.gnu.org/licenses/>.
+//
+//===----------------------------------------------------------------------===//
+
+
+/*
+ * CFLGraph.cpp
+ *
+ *  Created on: March 5, 2022
+ *      Author: Yulei Sui
+ */
+
+#include "Util/Options.h"
+#include "Graphs/CFLGraph.h"
+#include "Util/SVFUtil.h"
+
+using namespace SVF;
+
+//// Build graph from file
+void CFLGraph::build(std::string filename){
+
+}
+
+void CFLGraph::addCFLNode(NodeID id, CFLNode* node){
+    addGNode(id, node);
+}
+
+const CFLEdge* CFLGraph::addCFLEdge(CFLNode* src, CFLNode* dst, CFLEdge::GEdgeFlag label){
+    CFLEdge* edge = new CFLEdge(src,dst,label);
+    if(cflEdgeSet.insert(edge).second){
+        src->addOutgoingEdge(edge);
+        dst->addIncomingEdge(edge);
+        return edge;
+    }
+    else
+        return nullptr;
+}
+
+const CFLEdge* CFLGraph::hasEdge(CFLNode* src, CFLNode* dst, CFLEdge::GEdgeFlag label){
+    CFLEdge edge(src,dst,label);
+    auto it = cflEdgeSet.find(&edge);
+    if(it !=cflEdgeSet.end())
+        return *it;
+    else
+        return nullptr;
+}
+
+void CFLGraph::dump(const std::string& filename)
+{
+    GraphPrinter::WriteGraphToFile(SVFUtil::outs(), filename, this);
+}
+
+void CFLGraph::view()
+{
+    llvm::ViewGraph(this, "CFL Graph");
+}
+
+void CFLGraph::buildFromDot(std::string fileName)
+{
+    std::cout << "Building CFL Graph from dot file: " << fileName << "..\n";
+    std::string lineString;
+    std::ifstream inputFile(fileName);
+
+    std::regex reg("Node(\\w+)\\s*->\\s*Node(\\w+)\\s*\\[.*label=(.*)\\]");
+
+    std::cout << std::boolalpha;
+    u32_t lineNum = 0 ;
+
+    while (getline(inputFile, lineString))
+    {
+        lineNum += 1;
+        std::smatch matches;
+        if (std::regex_search(lineString, matches, reg))
+        {
+            CFLNode *src, *dst;
+            if (hasGNode(std::stoul(matches.str(1), nullptr, 16))==false) {
+            src = new CFLNode(std::stoul(matches.str(1), nullptr, 16));
+            addCFLNode(src->getId(), src);
+            } else {
+                src = getGNode(std::stoul(matches.str(1), nullptr, 16));
+            }
+            if (hasGNode(std::stoul(matches.str(2), nullptr, 16))==false){
+            dst = new CFLNode(std::stoul(matches.str(2), nullptr, 16));
+            addCFLNode(dst->getId(), dst);
+            }else{
+                dst = getGNode(std::stoul(matches.str(2), nullptr, 16));
+            }
+            if (externMap == false){
+                if (label2SymMap.find(matches.str(3)) != label2SymMap.end()) {
+                    addCFLEdge(src, dst, label2SymMap[matches.str(3)]);
+                }
+                else {
+                    label2SymMap.insert({matches.str(3), current++});
+                    addCFLEdge(src, dst, label2SymMap[matches.str(3)]);
+                }
+            }
+            else {
+                if (label2SymMap.find(matches.str(3)) != label2SymMap.end()) {
+                    addCFLEdge(src, dst, label2SymMap[matches.str(3)]);
+                }
+                else {
+                    if(Options::FlexSymMap == true){
+                        label2SymMap.insert({matches.str(3), current++});
+                        addCFLEdge(src, dst, label2SymMap[matches.str(3)]);
+                    }
+                    else {
+                        std::string msg = "In line " + std::to_string(lineNum) + " sym can not find in grammar, please correct the input dot or set --flexsymmap.";
+                        SVFUtil::errMsg(msg);
+                        std::cout << msg;
+                        abort();
+                        }
+                }
+            }
+        }
+    }
+    inputFile.close();
+}
+
+void CFLGraph::setMap(Map<std::string, Symbol>* terminals, Map<std::string, Symbol>* nonterminals)
+{
+    externMap = true;
+    for(auto pairV : *terminals){
+        if(label2SymMap.find(pairV.first) == label2SymMap.end()){
+            label2SymMap.insert(pairV);
+        }  
+    }
+
+    for(auto pairV : *nonterminals){
+        if(label2SymMap.find(pairV.first) == label2SymMap.end()){
+            label2SymMap.insert(pairV);
+        }  
+    }
+    current = label2SymMap.size();
+}
+
+
+
+namespace llvm
+{
+/*!
+ * Write value flow graph into dot file for debugging
+ */
+template<>
+struct DOTGraphTraits<CFLGraph*> : public DefaultDOTGraphTraits
+{
+
+    typedef CFLNode NodeType;
+
+    DOTGraphTraits(bool isSimple = false) : DefaultDOTGraphTraits(isSimple)
+    {
+    }
+
+    /// Return name of the graph
+    static std::string getGraphName(CFLGraph*)
+    {
+        return "CFL Reachability Graph";
+    }
+    /// Return function name;
+    static std::string getNodeLabel(CFLNode *node, CFLGraph*)
+    {
+        std::string str;
+        raw_string_ostream rawstr(str);
+        rawstr << "Node ID: " << node->getId() << " ";
+        return rawstr.str();
+    }
+
+    static std::string getNodeAttributes(CFLNode *node, CFLGraph*)
+    {
+        return "shape=box";
+    }
+
+    template<class EdgeIter>
+    static std::string getEdgeAttributes(CFLNode*, EdgeIter EI, CFLGraph* graph)
+    {
+        CFLEdge* edge = *(EI.getCurrent());
+        assert(edge && "No edge found!!");
+        std::string str;
+        raw_string_ostream rawstr(str);
+        std::string key = "";
+        for (auto &i : graph->label2SymMap)
+        {
+            if (i.second == edge->getEdgeKind())
+            {
+                key = i.first;
+            }
+        }
+        rawstr << "label=" << '"' <<key << '"';
+        if( graph->label2SymMap[key] == graph->startSymbol){
+            rawstr << ',' << "color=red";
+        }
+        
+        return rawstr.str();
+    }
+
+    template<class EdgeIter>
+    static std::string getEdgeSourceLabel(NodeType*, EdgeIter EI)
+    {
+        CFLEdge* edge = *(EI.getCurrent());
+        assert(edge && "No edge found!!");
+        std::string str;
+        raw_string_ostream rawstr(str);
+        rawstr << "Edge label: " << edge->getEdgeKind() << " ";
+        return rawstr.str();
+    }
+};
+
+}

package/lib/Util/ExeState.cpp

@@ -147,30 +147,8 @@ ExeState &ExeState::operator=(const ExeState &rhs) {
  * @return
  */
 bool ExeState::operator==(const ExeState &rhs) const {
-    // return false if path constraint is not equivalent
-    if (!eq(pathConstraint, rhs.getPathConstraint()))
-        return false;
-    if(varToVal.size() != rhs.getVarToVal().size() || locToVal.size() != rhs.getLocToVal().size())
-         return false;
-    for (const auto &item: varToVal) {
-        auto it = rhs.getVarToVal().find(item.first);
-        // return false if SVFVar not exists in rhs
-        if (it == rhs.getVarToVal().end())
-            return false;
-        // return false if Z3Expr is not equivalent
-        if (!eq(item.second, it->second))
-            return false;
-    }
-    for (const auto &item: locToVal) {
-        auto it = rhs.getLocToVal().find(item.first);
-        // return false if location not exists in rhs
-        if (it == rhs.getLocToVal().end())
-            return false;
-        // return false if Z3Expr is not equivalent
-        if (!eq(item.second, it->second))
-            return false;
-    }
-    return true;
+    return eq(pathConstraint, rhs.getPathConstraint()) && eqVarToValMap(varToVal, rhs.getVarToVal()) &&
+           eqVarToValMap(locToVal, rhs.getLocToVal());
 }
 
 /*!
@@ -182,21 +160,28 @@ bool ExeState::operator<(const ExeState &rhs) const {
     // judge from path constraint
     if (!eq(pathConstraint, rhs.getPathConstraint()))
         return pathConstraint.id() < rhs.getPathConstraint().id();
-    if(varToVal.size() < rhs.getVarToVal().size() || locToVal.size() < rhs.getLocToVal().size())
+    if (lessThanVarToValMap(varToVal, rhs.getVarToVal()) || lessThanVarToValMap(locToVal, rhs.getLocToVal()))
         return true;
-    for (const auto &item: varToVal) {
-        auto it = rhs.getVarToVal().find(item.first);
-        // lhs > rhs if SVFVar not exists in rhs
-        if (it == rhs.getVarToVal().end())
+    return false;
+}
+
+bool ExeState::eqVarToValMap(const VarToValMap &lhs, const VarToValMap &rhs) const {
+    if(lhs.size() != rhs.size()) return false;
+    for (const auto &item: lhs) {
+        auto it = rhs.find(item.first);
+        // return false if SVFVar not exists in rhs or z3Expr not equal
+        if (it == rhs.end() || !eq(item.second, it->second))
             return false;
-        // judge from expr id
-        if (!eq(item.second, it->second))
-            return item.second.id() < it->second.id();
     }
-    for (const auto &item: locToVal) {
-        auto it = rhs.getLocToVal().find(item.first);
+    return true;
+}
+
+bool ExeState::lessThanVarToValMap(const VarToValMap &lhs, const VarToValMap &rhs) const {
+    if(lhs.size() != rhs.size()) return lhs.size() < rhs.size();
+    for (const auto &item: lhs) {
+        auto it = rhs.find(item.first);
         // lhs > rhs if SVFVar not exists in rhs
-        if (it == rhs.getLocToVal().end())
+        if (it == rhs.end())
             return false;
         // judge from expr id
         if (!eq(item.second, it->second))
@@ -204,7 +189,6 @@ bool ExeState::operator<(const ExeState &rhs) const {
     }
     return false;
 }
-
 /*!
  * Store value to location
  * @param loc location, e.g., int_val(0x7f..01)

package/lib/Util/Options.cpp

@@ -797,4 +797,35 @@ namespace SVF
         llvm::cl::init(false),
         llvm::cl::desc("Show hidden nodes on DOT Graphs (e.g., isolated node on a graph)")
     );
+
+    const llvm::cl::opt<std::string> Options::InputFilename(
+        llvm::cl::Positional,
+        llvm::cl::desc("<input bitcode>"), 
+        llvm::cl::init("-")
+    );
+
+    const llvm::cl::opt<std::string> Options::GrammarFilename(
+        llvm::cl::Positional, 
+        llvm::cl::desc("<Grammar textfile>"), 
+        llvm::cl::init("-")
+    );
+
+    const llvm::cl::opt<bool> Options::GraphIsFromDot(
+        "dot-graph", 
+        llvm::cl::init(false), 
+        llvm::cl::desc("Dot text as graph input")
+    );
+
+    const llvm::cl::opt<bool> Options::GrammarIsEBNF(
+        "ebnf-grammar", 
+        llvm::cl::init(false), 
+        llvm::cl::desc("EBNF grammar as grammar input")
+    );
+
+    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.")
+    );
+
 } // namespace SVF.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "svf-tools",
-  "version": "1.0.440",
+  "version": "1.0.443",
   "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/tools/CFL/CMakeLists.txt

@@ -0,0 +1,12 @@
+
+if(DEFINED IN_SOURCE_BUILD)
+    set(LLVM_LINK_COMPONENTS BitWriter Core IPO IrReader InstCombine Instrumentation Target Linker Analysis ScalarOpts Support Svf Cudd)
+    add_llvm_tool( cfl cfl.cpp )
+else()
+    add_executable( cfl cfl.cpp )
+
+    target_link_libraries( cfl Svf Cudd ${llvm_libs} )
+
+    set_target_properties( cfl PROPERTIES
+                           RUNTIME_OUTPUT_DIRECTORY ${CMAKE_BINARY_DIR}/bin )
+endif()

package/tools/CFL/cfl.cpp

@@ -0,0 +1,80 @@
+//===- cfl.cpp -- A driver of CFL Reachability Analysis-------------------------------------//
+//
+//                     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 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 General Public License for more details.
+
+// You should have received a copy of the GNU General Public License
+// along with this program.  If not, see <http://www.gnu.org/licenses/>.
+//
+//===-----------------------------------------------------------------------===//
+
+/*
+ //  A driver of CFL Reachability Analysis
+ //
+ // Author: Yulei Sui,
+ */
+
+
+#include "SVF-FE/LLVMUtil.h"
+#include "CFL/CFLAlias.h"
+#include "Util/Options.h"
+#include "SVF-FE/SVFIRBuilder.h"
+#include "CFL/CFGNormalizer.h"
+
+using namespace llvm;
+using namespace SVF;
+
+static cl::opt<bool>
+StandardCompileOpts("std-compile-opts",
+                    cl::desc("Include the standard compile time optimizations"));
+
+int main(int argc, char ** argv)
+{
+    int arg_num = 0;
+    char **arg_value = new char*[argc];
+    std::vector<std::string> moduleNameVec;
+    SVFUtil::processArguments(argc, argv, arg_num, arg_value, moduleNameVec);
+    cl::ParseCommandLineOptions(arg_num, arg_value,
+                                "CFL Reachability Analysis\n");
+
+    if (Options::WriteAnder == "ir_annotator")
+    {
+        LLVMModuleSet::getLLVMModuleSet()->preProcessBCs(moduleNameVec);
+    }
+    if (Options::GraphIsFromDot == false){
+        SVFModule* svfModule = LLVMModuleSet::getLLVMModuleSet()->buildSVFModule(moduleNameVec);
+        svfModule->buildSymbolTableInfo();
+
+        /// Build Program Assignment Graph (SVFIR)
+        SVFIRBuilder builder;
+        SVFIR* svfir = builder.build(svfModule);
+        CFLAlias* cflaa = new CFLAlias(svfir);
+        cflaa->analyze();
+        delete cflaa;
+    }
+    else {
+        SVFIR* svfir = nullptr;
+        CFLAlias* cflaa = new CFLAlias(svfir);
+        cflaa->analyze();
+        delete cflaa;
+    }
+
+    SVFIR::releaseSVFIR();
+    SVF::LLVMModuleSet::releaseLLVMModuleSet();
+
+    return 0;
+
+}
+

package/tools/CMakeLists.txt

@@ -3,3 +3,4 @@ add_subdirectory(WPA)
 add_subdirectory(Example)
 add_subdirectory(DDA)
 add_subdirectory(MTA)
+add_subdirectory(CFL)

package/tools/DDA/dda.cpp

@@ -13,9 +13,6 @@
 using namespace llvm;
 using namespace SVF;
 
-static cl::opt<std::string> InputFilename(cl::Positional,
-        cl::desc("<input bitcode>"), cl::init("-"));
-
 static cl::opt<bool>
 StandardCompileOpts("std-compile-opts",
                     cl::desc("Include the standard compile time optimizations"));

package/tools/Example/svf-ex.cpp

@@ -36,9 +36,6 @@ using namespace llvm;
 using namespace std;
 using namespace SVF;
 
-static llvm::cl::opt<std::string> InputFilename(cl::Positional,
-        llvm::cl::desc("<input bitcode>"), llvm::cl::init("-"));
-
 /*!
  * An example to query alias results of two LLVM values
  */

package/tools/MTA/mta.cpp

@@ -6,10 +6,6 @@ using namespace llvm;
 using namespace std;
 using namespace SVF;
 
-static llvm::cl::opt<std::string> InputFilename(cl::Positional,
-        llvm::cl::desc("<input bitcode>"), llvm::cl::init("-"));
-
-
 int main(int argc, char ** argv)
 {
 

package/tools/SABER/saber.cpp

@@ -35,9 +35,6 @@
 using namespace llvm;
 using namespace SVF;
 
-static llvm::cl::opt<std::string> InputFilename(cl::Positional,
-        llvm::cl::desc("<input bitcode>"), llvm::cl::init("-"));
-
 static llvm::cl::opt<bool> LEAKCHECKER("leak", llvm::cl::init(false),
                                        llvm::cl::desc("Memory Leak Detection"));
 

package/tools/WPA/wpa.cpp

@@ -34,10 +34,6 @@ using namespace llvm;
 using namespace std;
 using namespace SVF;
 
-static llvm::cl::opt<std::string> InputFilename(cl::Positional,
-        llvm::cl::desc("<input bitcode>"), llvm::cl::init("-"));
-
-
 int main(int argc, char ** argv)
 {