svf-tools 1.0.1021 → 1.0.1023

package/build.sh

@@ -250,10 +250,10 @@ BUILD_DIR="./${BUILD_TYPE}-build"
 rm -rf "${BUILD_DIR}"
 mkdir "${BUILD_DIR}"
 # If you need shared libs, turn BUILD_SHARED_LIBS on
-cmake -D CMAKE_BUILD_TYPE:STRING="${BUILD_TYPE}" \
-    -DSVF_ENABLE_ASSERTIONS:BOOL=true            \
-    -DSVF_SANITIZE="${SVF_SANITIZER}"            \
-    -DBUILD_SHARED_LIBS=off                      \
+cmake -D CMAKE_BUILD_TYPE:STRING="${BUILD_TYPE}"   \
+    -DSVF_ENABLE_ASSERTIONS:BOOL=true              \
+    -DSVF_SANITIZE="${SVF_SANITIZER}"              \
+    -DBUILD_SHARED_LIBS=off                        \
     -S "${SVFHOME}" -B "${BUILD_DIR}"
 cmake --build "${BUILD_DIR}" -j ${jobs}
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "svf-tools",
-  "version": "1.0.1021",
+  "version": "1.0.1023",
   "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/Graphs/CFLGraph.h

@@ -33,7 +33,6 @@
 #include <fstream>
 #include <iostream>
 #include <string>
-#include <regex>
 #include "CFL/CFGrammar.h"
 #include "Graphs/GenericGraph.h"
 #include "Graphs/ConsG.h"

package/svf/lib/CFL/CFGNormalizer.cpp

@@ -32,7 +32,6 @@
 #include "Util/WorkList.h"
 #include "SVFIR/SVFValue.h"
 #include <string>
-#include <regex>
 #include <fstream>
 #include <sstream>
 #include <iostream>
@@ -437,13 +436,23 @@ void CFGNormalizer::ebnfSignReplace(char sign, CFGrammar *grammar)
 
 void CFGNormalizer::strTrans(std::string LHS, CFGrammar *grammar, GrammarBase::Production& normalProd)
 {
-    std::smatch matches;
-    std::regex LHSReg("\\s*(.*)");
+    // Find the position of the first non-whitespace character
+    size_t start = LHS.find_first_not_of(" \t\n\r");
+    // If the string contains non-whitespace characters, remove leading spaces
+    if (start != std::string::npos)
+    {
+        LHS = LHS.substr(start);
+    }
+    else
+    {
+        // If the string contains only spaces, clear it
+        LHS.clear();
+    }
+
     std::string delimiter;
     size_t pos;
     std::string word;
-    std::regex_search(LHS, matches, LHSReg);
-    LHS = matches.str(1);
+
     delimiter = " ";
     while ((pos = LHS.find(delimiter)) != std::string::npos)
     {
@@ -454,6 +463,7 @@ void CFGNormalizer::strTrans(std::string LHS, CFGrammar *grammar, GrammarBase::P
     normalProd.push_back(grammar->strToSymbol(LHS));
 }
 
+
 GrammarBase::Symbol CFGNormalizer::check_head(GrammarBase::SymbolMap<GrammarBase::Symbol, GrammarBase::Productions> &grammar, GrammarBase::Production &rule)
 {
     for(auto symProdPair: grammar)

package/svf/lib/CFL/CFLGraphBuilder.cpp

@@ -193,49 +193,79 @@ CFLGraph* CFLGraphBuilder::buildFromText(std::string fileName, GrammarBase *gram
     return cflGraph;
 }
 
-CFLGraph * CFLGraphBuilder::buildFromDot(std::string fileName, GrammarBase *grammar, BuildDirection direction)
+CFLGraph *CFLGraphBuilder::buildFromDot(std::string fileName, GrammarBase *grammar, BuildDirection direction)
 {
     buildlabelToKindMap(grammar);
     cflGraph = new CFLGraph(grammar->getStartKind());
     std::string lineString;
     std::ifstream inputFile(fileName);
     std::cout << "Building CFL Graph from dot file: " << fileName << "..\n";
-    std::regex reg("Node(\\w+)\\s*->\\s*Node(\\w+)\\s*\\[.*label=(.*)\\]");
     std::cout << std::boolalpha;
-    u32_t lineNum = 0 ;
+
+    u32_t lineNum = 0;
     current = labelToKindMap.size();
 
     while (getline(inputFile, lineString))
     {
         lineNum += 1;
-        std::smatch matches;
-        if (std::regex_search(lineString, matches, reg))
+
+        // Find "Node" prefixes and "->"
+        size_t srcStart = lineString.find("Node");
+        if (srcStart == std::string::npos) continue;
+
+        size_t srcEnd = lineString.find(" ", srcStart);
+        if (srcEnd == std::string::npos) continue;
+
+        size_t arrowPos = lineString.find("->", srcEnd);
+        if (arrowPos == std::string::npos) continue;
+
+        size_t dstStart = lineString.find("Node", arrowPos);
+        if (dstStart == std::string::npos) continue;
+
+        size_t dstEnd = lineString.find(" ", dstStart);
+        if (dstEnd == std::string::npos) continue;
+
+        size_t labelStart = lineString.find("label=", dstEnd);
+        if (labelStart == std::string::npos) continue;
+
+        labelStart += 6; // Move past "label=" to the start of the label
+        size_t labelEnd = lineString.find_first_of("]", labelStart);
+        if (labelEnd == std::string::npos) continue;
+
+        // Extract the source ID, destination ID, and label
+        std::string srcIDStr = lineString.substr(srcStart + 4, srcEnd - (srcStart + 4));
+        std::string dstIDStr = lineString.substr(dstStart + 4, dstEnd - (dstStart + 4));
+        std::string label = lineString.substr(labelStart, labelEnd - labelStart);
+
+        // Convert source and destination IDs from hexadecimal
+        u32_t srcID = std::stoul(srcIDStr, nullptr, 16);
+        u32_t dstID = std::stoul(dstIDStr, nullptr, 16);
+
+        CFLNode *src = addGNode(srcID);
+        CFLNode *dst = addGNode(dstID);
+
+        if (labelToKindMap.find(label) != labelToKindMap.end())
+        {
+            cflGraph->addCFLEdge(src, dst, labelToKindMap[label]);
+        }
+        else
         {
-            u32_t srcID = std::stoul(matches.str(1), nullptr, 16);
-            u32_t dstID = std::stoul(matches.str(2), nullptr, 16);
-            std::string label = matches.str(3);
-            CFLNode *src = addGNode(srcID);
-            CFLNode *dst = addGNode(dstID);
-            if (labelToKindMap.find(label) != labelToKindMap.end())
+            if (Options::FlexSymMap() == true)
+            {
+                labelToKindMap.insert({label, current++});
                 cflGraph->addCFLEdge(src, dst, labelToKindMap[label]);
+            }
             else
             {
-                if(Options::FlexSymMap() == true)
-                {
-                    labelToKindMap.insert({label, current++});
-                    cflGraph->addCFLEdge(src, dst, labelToKindMap[label]);
-                }
-                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();
-                }
+                std::string msg = "In line " + std::to_string(lineNum) +
+                                  " sym cannot be found in grammar. Please correct the input dot or set --flexsymmap.";
+                SVFUtil::errMsg(msg);
+                std::cout << msg;
+                abort();
             }
         }
     }
+
     inputFile.close();
     return cflGraph;
 }
@@ -247,7 +277,6 @@ CFLGraph* CFLGraphBuilder::buildFromJson(std::string fileName, GrammarBase *gram
     return cflGraph;
 }
 
-
 CFLGraph* AliasCFLGraphBuilder::buildBigraph(ConstraintGraph *graph, Kind startKind, GrammarBase *grammar)
 {
     cflGraph = new CFLGraph(startKind);
@@ -543,4 +572,4 @@ CFLGraph* VFCFLGraphBuilder::buildBiPEGgraph(ConstraintGraph *graph, Kind startK
 }
 
 
-} // end of SVF namespace
+} // end of SVF namespace

package/svf/lib/CFL/GrammarBuilder.cpp

@@ -29,7 +29,6 @@
 
 #include <string>
 #include <fstream>
-#include <regex>
 #include <sstream>
 #include <iostream>
 #include "CFL/GrammarBuilder.h"
@@ -44,48 +43,69 @@ const inline std::string GrammarBuilder::parseProductionsString() const
         std::cerr << "Can't open CFL grammar file `" << fileName << "`" << std::endl;
         abort();
     }
+
     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))
     {
-        if(lineNum == 1)
+        if (lineNum == 1)
         {
             startString = stripSpace(lineString);
         }
-        if(lineNum == 3)
+        else if (lineNum == 3)
+        {
+            // Trim leading and trailing whitespace
+            size_t start = lineString.find_first_not_of(WHITESPACE);
+            size_t end = lineString.find_last_not_of(WHITESPACE);
+            if (start != std::string::npos && end != std::string::npos)
+            {
+                symbolString = lineString.substr(start, end - start + 1);
+            }
+        }
+
+        // Append line to `lines` with whitespace trimmed
+        size_t start = lineString.find_first_not_of(WHITESPACE);
+        size_t end = lineString.find_last_not_of(WHITESPACE);
+        if (start != std::string::npos && end != std::string::npos)
         {
-            symbolString = lineString.substr(lineString.find_first_not_of(WHITESPACE), lineString.find_last_not_of(WHITESPACE)+1);
+            lines.append(lineString.substr(start, end - start + 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:(.*)Productions:([\\s\\S]*)");
-    std::smatch matches;
-    if (std::regex_search(lines, matches, reg))
+    // Extract "Productions:" part from `lines` manually
+    size_t productionsPos = lines.find("Productions:");
+    if (productionsPos != std::string::npos)
     {
-        lines = matches.str(3);
+        lines = lines.substr(productionsPos + std::string("Productions:").length());
     }
+
+    // Parse `symbolString` to insert symbols
     std::string sString;
     size_t pos = 0;
     while ((pos = symbolString.find(" ")) != std::string::npos)
     {
         sString = stripSpace(symbolString.substr(0, pos));
-        symbolString.erase(0, pos + 1); //Capital is Nonterminal, Otherwise is terminal
+        symbolString.erase(0, pos + 1); // Remove the processed part
         grammar->insertSymbol(sString);
     }
+    // Insert the remaining symbol
     grammar->insertSymbol(symbolString);
+
+    // Set the start kind and add the epsilon terminal
     grammar->setStartKind(grammar->insertSymbol(startString));
     grammar->insertTerminalKind("epsilon");
 
     return lines;
 }
 
+
 const inline std::vector<std::string> GrammarBuilder::loadWordProductions() const
 {
     size_t pos = 0;
@@ -104,17 +124,21 @@ const inline std::vector<std::string> GrammarBuilder::loadWordProductions() cons
 
 const inline std::string GrammarBuilder::stripSpace(std::string s) const
 {
-    std::smatch matches;
-    std::regex stripReg("\\s*(\\S*)\\s*");
-    std::regex_search(s, matches, stripReg);
-    return matches.str(1);
-}
+    // Remove leading spaces
+    size_t start = s.find_first_not_of(" ");
+    if (start == std::string::npos)
+    {
+        return ""; // Return an empty string if no non-space character is found
+    }
 
+    // Remove trailing spaces
+    size_t end = s.find_last_not_of(" ");
+    return s.substr(start, end - start + 1);
+}
 
-/// build grammarbase from textfile
+/// Build grammarbase from textfile
 GrammarBase* GrammarBuilder::build() const
 {
-    std::smatch matches;
     std::string delimiter = " ";
     std::string delimiter1 = "->";
     std::string word = "";
@@ -124,29 +148,50 @@ GrammarBase* GrammarBuilder::build() const
 
     for (auto wordProd : wordProdVec)
     {
+        // Find the position of the '->' delimiter
         if ((pos = wordProd.find(delimiter1)) != std::string::npos)
         {
+            // Extract and strip RHS (right-hand side) and LHS (left-hand side)
             std::string RHS = stripSpace(wordProd.substr(0, pos));
-            std::string LHS = wordProd.substr(pos + delimiter1.size(), wordProd.size() - 1);
+            std::string LHS = stripSpace(wordProd.substr(pos + delimiter1.size()));
+
+            // Insert RHS symbol into grammar
             GrammarBase::Symbol RHSSymbol = grammar->insertSymbol(RHS);
             prod.push_back(RHSSymbol);
-            if (grammar->getRawProductions().find(RHSSymbol) == grammar->getRawProductions().end())  grammar->getRawProductions().insert({RHSSymbol, {}});
-            std::regex LHSRegEx("\\s*(.*)");
-            std::regex_search(LHS, matches, LHSRegEx);
-            LHS = matches.str(1);
+
+            // Ensure RHS symbol exists in raw productions
+            if (grammar->getRawProductions().find(RHSSymbol) == grammar->getRawProductions().end())
+            {
+                grammar->getRawProductions().insert({RHSSymbol, {}});
+            }
+
+            // Parse LHS string into symbols
             while ((pos = LHS.find(delimiter)) != std::string::npos)
             {
-                word = LHS.substr(0, pos);
-                LHS.erase(0, pos + delimiter.length()); //Capital is Nonterminal, Otherwise is terminal
+                // Extract each word before the space
+                word = stripSpace(LHS.substr(0, pos));
+                LHS.erase(0, pos + delimiter.length());
+
+                // Insert symbol into production
                 prod.push_back(grammar->insertSymbol(word));
             }
-            prod.push_back(grammar->insertSymbol(LHS));
+
+            // Insert the remaining word (if any) into the production
+            if (!LHS.empty())
+            {
+                prod.push_back(grammar->insertSymbol(stripSpace(LHS)));
+            }
+
+            // Add the production to raw productions
             grammar->getRawProductions().at(RHSSymbol).insert(prod);
+
+            // Clear the production for the next iteration
             prod = {};
         }
     }
 
     return grammar;
-};
-
 }
+
+
+}

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

@@ -75,7 +75,7 @@ private:
     ///@{
     void processFunEntry(const Function*  fun, WorkList& worklist);
 
-    void processNoPrecessorBasicBlocks(const Function*  fun, WorkList& worklist);
+    void processUnreachableFromEntry(const Function*  fun, WorkList& worklist);
 
     void processFunBody(WorkList& worklist);
 

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

@@ -109,6 +109,8 @@ private:
     FunToFunExitNodeMapTy FunToFunExitNodeMap; ///< map a function to its FunEntryICFGNode
     CallGraph* callgraph;
 
+    Map<const Function*, DominatorTree> FunToDominatorTree;
+
     /// Constructor
     LLVMModuleSet();
 
@@ -397,6 +399,8 @@ public:
         return icfg;
     }
 
+    DominatorTree& getDomTree(const Function* fun);
+
 private:
     /// Create SVFTypes
     SVFType* addSVFTypeInfo(const Type* t);

package/svf-llvm/lib/ICFGBuilder.cpp

@@ -70,7 +70,7 @@ ICFG* ICFGBuilder::build()
                 continue;
             WorkList worklist;
             processFunEntry(fun,worklist);
-            processNoPrecessorBasicBlocks(fun, worklist);
+            processUnreachableFromEntry(fun, worklist);
             processFunBody(worklist);
             processFunExit(fun);
 
@@ -122,21 +122,20 @@ void ICFGBuilder::processFunEntry(const Function*  fun, WorkList& worklist)
 }
 
 /*!
- * bbs with no predecessors
+ * bbs unreachable from function entry
  */
-void ICFGBuilder::processNoPrecessorBasicBlocks(const Function* fun, WorkList& worklist)
+void ICFGBuilder::processUnreachableFromEntry(const Function* fun, WorkList& worklist)
 {
-    for (const auto& bb: *fun)
+    SVFLoopAndDomInfo* pInfo =
+        llvmModuleSet()->getSVFFunction(fun)->getLoopAndDomInfo();
+    for (const auto& bb : *fun)
     {
-        for (const auto& inst: bb)
+        if (pInfo->isUnreachable(llvmModuleSet()->getSVFBasicBlock(&bb)) &&
+                !visited.count(&bb.front()))
         {
-            if (LLVMUtil::isNoPrecessorBasicBlock(inst.getParent()) &&
-                    !visited.count(&inst))
-            {
-                visited.insert(&inst);
-                (void)addBlockICFGNode(&inst);
-                worklist.push(&inst);
-            }
+            visited.insert(&bb.front());
+            (void)addBlockICFGNode(&bb.front());
+            worklist.push(&bb.front());
         }
     }
 }

package/svf-llvm/lib/LLVMLoopAnalysis.cpp

@@ -48,7 +48,6 @@ using namespace SVFUtil;
  */
 void LLVMLoopAnalysis::buildLLVMLoops(SVFModule *mod, ICFG* icfg)
 {
-    llvm::DominatorTree DT = llvm::DominatorTree();
     std::vector<const Loop *> loop_stack;
     for (Module& M : LLVMModuleSet::getLLVMModuleSet()->getLLVMModules())
     {
@@ -59,7 +58,7 @@ void LLVMLoopAnalysis::buildLLVMLoops(SVFModule *mod, ICFG* icfg)
             if (func->isDeclaration()) continue;
             // do not analyze external call
             if (SVFUtil::isExtCall(svffun)) continue;
-            DT.recalculate(const_cast<Function&>(*func));
+            llvm::DominatorTree& DT = LLVMModuleSet::getLLVMModuleSet()->getDomTree(func);
             llvm::LoopInfoBase<llvm::BasicBlock, llvm::Loop> loopInfo;
             std::vector<const Loop*> llvmLoops;
             loopInfo.analyze(DT);

package/svf-llvm/lib/LLVMModule.cpp

@@ -99,6 +99,15 @@ ObjTypeInference* LLVMModuleSet::getTypeInference()
     return typeInference;
 }
 
+DominatorTree& LLVMModuleSet::getDomTree(const SVF::Function* fun)
+{
+    auto it = FunToDominatorTree.find(fun);
+    if(it != FunToDominatorTree.end()) return it->second;
+    DominatorTree& dt = FunToDominatorTree[fun];
+    dt.recalculate(const_cast<Function&>(*fun));
+    return dt;
+}
+
 SVFModule* LLVMModuleSet::buildSVFModule(Module &mod)
 {
     LLVMModuleSet* mset = getLLVMModuleSet();
@@ -407,9 +416,8 @@ void LLVMModuleSet::initDomTree(SVFFunction* svffun, const Function* fun)
     if (fun->isDeclaration())
         return;
     //process and stored dt & df
-    DominatorTree dt;
     DominanceFrontier df;
-    dt.recalculate(const_cast<Function&>(*fun));
+    DominatorTree& dt = getDomTree(fun);
     df.analyze(dt);
     LoopInfo loopInfo = LoopInfo(dt);
     PostDominatorTree pdt = PostDominatorTree(const_cast<Function&>(*fun));

package/svf-llvm/lib/LLVMUtil.cpp

@@ -75,8 +75,7 @@ void LLVMUtil::getFunReachableBBs (const Function* fun, std::vector<const SVFBas
 {
     assert(!SVFUtil::isExtCall(LLVMModuleSet::getLLVMModuleSet()->getSVFFunction(fun)) && "The calling function cannot be an external function.");
     //initial DominatorTree
-    DominatorTree dt;
-    dt.recalculate(const_cast<Function&>(*fun));
+    DominatorTree& dt = LLVMModuleSet::getLLVMModuleSet()->getDomTree(fun);
 
     Set<const BasicBlock*> visited;
     std::vector<const BasicBlock*> bbVec;