svf-tools 1.0.1020 → 1.0.1022

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.1020",
+  "version": "1.0.1022",
   "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/include/Util/ExtAPI.h

@@ -91,6 +91,9 @@ public:
     // Does (F) allocate a new object and assign it to one of its arguments?
     bool is_arg_alloc(const SVFFunction *F);
 
+    // Does (F) allocate a new stack object and return it?
+    bool is_alloc_stack_ret(const SVFFunction *F);
+
     // Get the position of argument which holds the new object
     s32_t get_alloc_arg_pos(const SVFFunction *F);
 

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/lib/Util/ExtAPI.cpp

@@ -216,19 +216,24 @@ bool ExtAPI::is_memset(const SVFFunction *F)
 
 bool ExtAPI::is_alloc(const SVFFunction* F)
 {
-    return F && hasExtFuncAnnotation(F, "ALLOC_RET");
+    return F && hasExtFuncAnnotation(F, "ALLOC_HEAP_RET");
 }
 
 // Does (F) allocate a new object and assign it to one of its arguments?
 bool ExtAPI::is_arg_alloc(const SVFFunction* F)
 {
-    return F && hasExtFuncAnnotation(F, "ALLOC_ARG");
+    return F && hasExtFuncAnnotation(F, "ALLOC_HEAP_ARG");
+}
+
+bool ExtAPI::is_alloc_stack_ret(const SVFFunction* F)
+{
+    return F && hasExtFuncAnnotation(F, "ALLOC_STACK_RET");
 }
 
 // Get the position of argument which holds the new object
 s32_t ExtAPI::get_alloc_arg_pos(const SVFFunction* F)
 {
-    std::string allocArg = getExtFuncAnnotation(F, "ALLOC_ARG");
+    std::string allocArg = getExtFuncAnnotation(F, "ALLOC_HEAP_ARG");
     assert(!allocArg.empty() && "Not an alloc call via argument or incorrect extern function annotation!");
 
     std::string number;
@@ -237,14 +242,14 @@ s32_t ExtAPI::get_alloc_arg_pos(const SVFFunction* F)
         if (isdigit(c))
             number.push_back(c);
     }
-    assert(!number.empty() && "Incorrect naming convention for svf external functions(ALLOC_ARG + number)?");
+    assert(!number.empty() && "Incorrect naming convention for svf external functions(ALLOC_HEAP_ARG + number)?");
     return std::stoi(number);
 }
 
 // Does (F) reallocate a new object?
 bool ExtAPI::is_realloc(const SVFFunction* F)
 {
-    return F && hasExtFuncAnnotation(F, "REALLOC_RET");
+    return F && hasExtFuncAnnotation(F, "REALLOC_HEAP_RET");
 }
 
 

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

@@ -360,9 +360,19 @@ inline bool isHeapAllocExtCall(const Instruction *inst)
     return isHeapAllocExtCallViaRet(inst) || isHeapAllocExtCallViaArg(inst);
 }
 
+bool isStackAllocExtCallViaRet(const Instruction *inst);
+
+inline bool isStackAllocExtCall(const Instruction *inst)
+{
+    return isStackAllocExtCallViaRet(inst);
+}
+
 // Check if a given value represents a heap object.
 bool isHeapObj(const Value* val);
 
+// Check if a given value represents a stack object.
+bool isStackObj(const Value* val);
+
 /// Whether an instruction is a callsite in the application code, excluding llvm intrinsic calls
 bool isNonInstricCallSite(const Instruction* inst);
 

package/svf-llvm/lib/LLVMUtil.cpp

@@ -646,6 +646,21 @@ bool LLVMUtil::isHeapAllocExtCallViaArg(const Instruction* inst)
     }
 }
 
+bool LLVMUtil::isStackAllocExtCallViaRet(const Instruction *inst)
+{
+    LLVMModuleSet* pSet = LLVMModuleSet::getLLVMModuleSet();
+    ExtAPI* extApi = ExtAPI::getExtAPI();
+    bool isPtrTy = inst->getType()->isPointerTy();
+    if (const CallBase* call = SVFUtil::dyn_cast<CallBase>(inst))
+    {
+        const Function* fun = call->getCalledFunction();
+        return fun && isPtrTy &&
+               extApi->is_alloc_stack_ret(pSet->getSVFFunction(fun));
+    }
+    else
+        return false;
+}
+
 /**
  * Check if a given value represents a heap object.
  *
@@ -670,6 +685,26 @@ bool LLVMUtil::isHeapObj(const Value* val)
     return false;
 }
 
+/**
+ * @param val The value to check.
+ * @return True if the value represents a stack object, false otherwise.
+ */
+bool LLVMUtil::isStackObj(const Value* val)
+{
+    if (SVFUtil::isa<AllocaInst>(val))
+    {
+        return true;
+    }
+    // Check if the value is an instruction and if it is a stack allocation external call
+    else if (SVFUtil::isa<Instruction>(val) &&
+             LLVMUtil::isStackAllocExtCall(SVFUtil::cast<Instruction>(val)))
+    {
+        return true;
+    }
+    // Return false if none of the above conditions are met
+    return false;
+}
+
 bool LLVMUtil::isNonInstricCallSite(const Instruction* inst)
 {
     bool res = false;

package/svf-llvm/lib/SVFIRBuilder.cpp

@@ -282,7 +282,7 @@ void SVFIRBuilder::initialiseNodes()
             llvmModuleSet()->setValueAttr(llvmValue,pag->getGNode(iter->second));
         }
         // Check if the value is an alloca instruction and add a stack object node
-        else if (SVFUtil::isa<AllocaInst>(llvmValue))
+        else if (LLVMUtil::isStackObj(llvmValue))
         {
             const SVFFunction* f =
                 SVFUtil::cast<SVFInstruction>(iter->first)->getFunction();

package/svf-llvm/lib/SymbolTableBuilder.cpp

@@ -724,13 +724,13 @@ void SymbolTableBuilder::analyzeObjType(ObjTypeInfo* typeinfo, const Value* val)
 
 /*!
  * Analyze byte size of heap alloc function (e.g. malloc/calloc/...)
- * 1) __attribute__((annotate("ALLOC_RET"), annotate("AllocSize:Arg0")))
+ * 1) __attribute__((annotate("ALLOC_HEAP_RET"), annotate("AllocSize:Arg0")))
      void* safe_malloc(unsigned long size).
      Byte Size is the size(Arg0)
-   2)__attribute__((annotate("ALLOC_RET"), annotate("AllocSize:Arg0*Arg1")))
+   2)__attribute__((annotate("ALLOC_HEAP_RET"), annotate("AllocSize:Arg0*Arg1")))
     char* safecalloc(int a, int b)
     Byte Size is a(Arg0) * b(Arg1)
-   3)__attribute__((annotate("ALLOC_RET"), annotate("UNKNOWN")))
+   3)__attribute__((annotate("ALLOC_HEAP_RET"), annotate("UNKNOWN")))
     void* __sysv_signal(int a, void *b)
     Byte Size is Unknown
     If all required arg values are constant, byte Size is also constant,