svf-tools 1.0.477 → 1.0.480

package/lib/CFL/CFLGrammar.cpp

@@ -28,6 +28,7 @@
  */
 
 #include "CFL/CFLGrammar.h"
+#include "Util/SVFUtil.h"
 #include <string>
 #include <iostream>
 #include <fstream>
@@ -35,7 +36,8 @@
 
 using namespace SVF;
 
-void GrammarBase::setRawProductions(Map<Symbol, Productions>& rawProductions)
+
+void GrammarBase::setRawProductions(SymbolMap<Symbol, Productions>& rawProductions)
 {
     this->rawProductions = rawProductions;
 }
@@ -65,6 +67,35 @@ GrammarBase::Kind GrammarBase::str2Kind(std::string str) const
     abort();
 }
 
+GrammarBase::Symbol GrammarBase::str2Symbol(const std::string str) const
+{
+    Symbol symbol;
+    std::string attributeStr = extractAttributeStrFromSymbolStr(str);
+    std::string kindStr = extractKindStrFromSymbolStr(str);
+    symbol.kind = str2Kind(kindStr);
+
+    if ( attributeStr == "") return symbol;
+
+    if ( (attributeStr.size() == 1) && (std::isalpha(attributeStr[attributeStr.size()-1])) )
+    {
+        symbol.variableAttribute = (u32_t)attributeStr[attributeStr.size()-1];
+    }
+    else
+    {
+        for( char &c : attributeStr)
+        {
+            if ( std::isdigit(c) == false )
+            {
+                SVFUtil::errs() << SVFUtil::errMsg("\t Symbol Attribute Parse Failure :") << str
+                                << " Attribute:" << attributeStr << " (only number or single alphabet.)";
+                assert(false && "grammar loading failed!");
+            }
+        }
+        symbol.attribute = std::stoi(attributeStr);
+    }
+    return symbol;
+}
+
 std::string GrammarBase::kind2Str(Kind kind) const
 {
 
@@ -93,8 +124,8 @@ std::string GrammarBase::kind2Str(Kind kind) const
 
 std::string GrammarBase::sym2StrDump(Symbol sym) const
 {
-    Kind kind = getSymKind(sym);
-    Attribute attribute = getSymAttribute(sym);
+    Kind kind = sym.kind;
+    Attribute attribute = sym.attribute;
 
     std::string key = "";
     for (auto &i : terminals)
@@ -102,9 +133,9 @@ std::string GrammarBase::sym2StrDump(Symbol sym) const
         if (i.second == kind)
         {
             key = i.first;
-            if(this->attributeKinds.find(kind) != this->attributeKinds.end())
+            if(attribute != 0)
             {
-                key.pop_back();
+                key.append("_");
                 key.append(std::to_string(attribute));
             }
             return key;
@@ -117,9 +148,9 @@ std::string GrammarBase::sym2StrDump(Symbol sym) const
         if (ni.second == kind)
         {
             nkey = ni.first;
-            if(this->attributeKinds.find(kind) != this->attributeKinds.end())
+            if(attribute != 0)
             {
-                nkey.pop_back();
+                nkey.append("_");
                 nkey.append(std::to_string(attribute));
             }
             return nkey;
@@ -143,7 +174,8 @@ GrammarBase::Kind GrammarBase::insertTerminalKind(std::string kindStr)
     }
     return kind;
 }
-GrammarBase::Kind GrammarBase::insertNonTerminalKind(std::string kindStr)
+
+inline GrammarBase::Kind GrammarBase::insertNonterminalKind(std::string const kindStr)
 {
     Kind kind;
     if (nonterminals.find(kindStr) == nonterminals.end())
@@ -155,14 +187,76 @@ GrammarBase::Kind GrammarBase::insertNonTerminalKind(std::string kindStr)
     {
         kind = str2Kind(kindStr);
     }
-    if(kindStr.size() >= 3)
+    return kind;
+}
+
+std::string GrammarBase::extractKindStrFromSymbolStr(const std::string symbolStr) const
+{
+    std::string kindStr;
+    // symbolStr end with '_', the whole symbolStr treat as kind, not with attribute.
+    auto underscorePosition = symbolStr.find_last_of("_", symbolStr.size()-1);
+    if (underscorePosition == std::string::npos)
+    {
+        return symbolStr;
+    }
+    return symbolStr.substr(0, underscorePosition);
+}
+
+std::string GrammarBase::extractAttributeStrFromSymbolStr(const std::string symbolStr) const
+{
+    std::string attributeStr;
+    // symbolStr end with '_', the whole symbolStr treat as kind, not with attribute.
+    auto underscorePosition = symbolStr.find_last_of("_", symbolStr.size()-1);
+    if (underscorePosition == std::string::npos)
     {
-        if (kindStr.compare(kindStr.size()-2, 2, "_i")==0)
+        return "";
+    }
+    return symbolStr.substr(underscorePosition+1);
+}
+
+GrammarBase::Symbol GrammarBase::insertSymbol(std::string symbolStr)
+{
+    Symbol symbol;
+    if (isupper(symbolStr[0]))
+    {
+        symbol = insertNonTerminalSymbol(symbolStr);
+    }
+    else
+    {
+        symbol.kind = insertTerminalKind(symbolStr);
+    }
+    return symbol;
+}
+
+GrammarBase::Symbol GrammarBase::insertNonTerminalSymbol(std::string symbolStr)
+{
+    Symbol symbol;
+    std::string kindStr = extractKindStrFromSymbolStr(symbolStr);
+    std::string attributeStr = extractAttributeStrFromSymbolStr(symbolStr);
+    symbol.kind = insertNonterminalKind(kindStr);
+
+    if ( attributeStr == "") return symbol;
+
+    if ( (attributeStr.size() == 1) && (std::isalpha(attributeStr[attributeStr.size()-1])) )
+    {
+        attributeKinds.insert(symbol.kind);
+        symbol.variableAttribute = (u32_t)attributeStr[attributeStr.size()-1];
+    }
+    else
+    {
+        for( char &c : attributeStr)
         {
-            insertAttribute(kind, 0);
+            if ( std::isdigit(c) == false )
+            {
+                SVFUtil::errs() << SVFUtil::errMsg("\t Symbol Attribute Parse Failure :") << symbolStr
+                                << " Attribute:" << attributeStr << " (only number or single alphabet.)";
+                assert(false && "grammar loading failed!");
+            }
         }
+        attributeKinds.insert(symbol.kind);
+        symbol.attribute = std::stoi(attributeStr);
     }
-    return kind;
+    return symbol;
 }
 
 void GrammarBase::insertAttribute(Kind kind, Attribute attribute)
@@ -186,7 +280,12 @@ CFLGrammar::CFLGrammar()
 
 void CFLGrammar::dump() const
 {
-    std::ofstream gramFile("Normailized_Grammar.txt");
+    dump("Normailized_Grammar.txt");
+}
+
+void CFLGrammar::dump(std::string fileName) const
+{
+    std::ofstream gramFile(fileName);
     gramFile << "Start Kind:\n";
     gramFile << '\t' << kind2Str(startKind) << '(' << startKind << ')' << ' ' << "\n\n";
 
@@ -201,7 +300,7 @@ void CFLGrammar::dump() const
             {
                 ss << "-> ";
             }
-            ss << sym2StrDump(sym) << '(' << sym << ')' << ' ';
+            ss << sym2StrDump(sym) << '(' << sym.kind << ')' << ' ';
         }
         strV.insert(strV.begin(), ss.str());
     }
@@ -229,7 +328,7 @@ void CFLGrammar::dump() const
                 {
                     ss << "-> ";
                 }
-                ss << sym2StrDump(sym) << '(' << sym << ')' << ' ';
+                ss << sym2StrDump(sym) << '(' << sym.kind << ')' << ' ';
             }
             strV.insert(strV.begin(), ss.str());
         }
@@ -259,7 +358,7 @@ void CFLGrammar::dump() const
                 {
                     ss << "-> ";
                 }
-                ss << sym2StrDump(sym) << '(' << sym << ')' << ' ';
+                ss << sym2StrDump(sym) << '(' << sym.kind << ')' << ' ';
             }
             strV.insert(strV.begin(), ss.str());
         }

package/lib/CFL/CFLGraphBuilder.cpp

@@ -159,4 +159,67 @@ CFLGraph * CFLGraphBuilder::buildFromDot(std::string fileName, GrammarBase *gram
     return cflGraph;
 }
 
-}
+CFLGraph* AliasCFLGraphBuilder::buildBigraph(ConstraintGraph *graph, Kind startKind, GrammarBase *grammar)
+{
+    CFLGraph *cflGraph = new CFLGraph(startKind);
+    externMap = true;
+    for(auto pairV : grammar->getTerminals())
+    {
+        if(label2KindMap.find(pairV.first) == label2KindMap.end())
+        {
+            label2KindMap.insert(pairV);
+        }
+        if(kind2LabelMap.find(pairV.second) == kind2LabelMap.end())
+        {
+            kind2LabelMap.insert(make_pair(pairV.second, pairV.first));
+        }
+    }
+    for(auto pairV : grammar->getNonterminals())
+    {
+        if(label2KindMap.find(pairV.first) == label2KindMap.end())
+        {
+            label2KindMap.insert(pairV);
+        }
+        if(kind2LabelMap.find(pairV.second) == kind2LabelMap.end())
+        {
+            kind2LabelMap.insert(make_pair(pairV.second, pairV.first));
+        }
+    }
+    for(auto it = graph->begin(); it!= graph->end(); it++)
+    {
+        CFLNode* node = new CFLNode((*it).first);
+        cflGraph->addCFLNode((*it).first, node);
+    }
+    for(auto it = graph->begin(); it!= graph->end(); it++)
+    {
+        ConstraintNode* node = (*it).second;
+        for(ConstraintEdge* edge : node->getOutEdges())
+        {
+            CFLGrammar::Kind edgeLabel = edge->getEdgeKind();
+            // Need to get the offset from the Const Edge
+            // The offset present edge is only from Normal Gep CG at moment
+            if(NormalGepCGEdge::classof(edge))
+            {
+                NormalGepCGEdge *nGepEdge = SVFUtil::dyn_cast<NormalGepCGEdge>(edge);
+                CFLGrammar::Attribute attr =  nGepEdge->getConstantFieldIdx();
+                addAttribute(edgeLabel, attr);
+                edgeLabel = CFLGrammar::getAttributedKind(attr, edgeLabel);
+                cflGraph->addCFLEdge(cflGraph->getGNode(edge->getSrcID()), cflGraph->getGNode(edge->getDstID()), edgeLabel);
+                std::string key = kind2LabelMap[edge->getEdgeKind()];
+                key.append("bar");   // for example Gep_i should be Gepbar_i, not Gep_ibar
+                cflGraph->addCFLEdge(cflGraph->getGNode(edge->getDstID()), cflGraph->getGNode(edge->getSrcID()), CFLGrammar::getAttributedKind(attr, label2KindMap[key]));
+                addAttribute(label2KindMap[key], attr);
+            }
+            else
+            {
+                cflGraph->addCFLEdge(cflGraph->getGNode(edge->getSrcID()), cflGraph->getGNode(edge->getDstID()), edgeLabel);
+                std::string key = kind2LabelMap[edge->getEdgeKind()];
+                key.append("bar");
+                cflGraph->addCFLEdge(cflGraph->getGNode(edge->getDstID()), cflGraph->getGNode(edge->getSrcID()), label2KindMap[key]);
+            }
+        }
+    }
+    return cflGraph;
+}
+
+} // end of SVF namespace

package/lib/CFL/GrammarBuilder.cpp

@@ -36,52 +36,59 @@
 
 namespace SVF
 {
-const inline std::string GrammarBuilder::loadFileString() const
+const inline std::string GrammarBuilder::parseProductionsString() const
 {
     std::ifstream textFile(fileName);
     std::string lineString;
     std::string lines = "";
+    std::string startString;
+    int lineNum = 0;
     while (getline(textFile, lineString))
     {
+        if(lineNum == 1)
+        {
+            startString = stripSpace(lineString);
+        }
         lines.append(lineString);
+        lineNum++;
     }
-    textFile.close();
-    return lines;
-}
 
-const inline std::string GrammarBuilder::parseProduction() const
-{
-    std::regex reg("Start:([\\s\\S]*)Productions:([\\s\\S]*)");
+    std::regex reg("Start:([\\s\\S]*)Terminal:[\\s]*([\\s\\S]*)Productions:([\\s\\S]*)");
     std::smatch matches;
-    std::string startS = "";
-    std::string lines = loadFileString();
-
     if (std::regex_search(lines, matches, reg))
     {
-        lines = matches.str(2);
-        startS = matches.str(1);
-        startS = stripSpace(startS);
+        lines = matches.str(3);
     }
+    std::string terminalString = matches.str(2);
+    std::string symbolString;
+    size_t pos;
+    while ((pos = terminalString.find(" ")) != std::string::npos)
+    {
+        symbolString = stripSpace(terminalString.substr(0, pos));
+        terminalString.erase(0, pos + 1); //Capital is Nonterminal, Otherwise is terminal
+        grammar->insertSymbol(symbolString);
+    }
+    grammar->insertSymbol(symbolString);
+    grammar->setStartKind(grammar->insertSymbol(startString));
     grammar->insertTerminalKind("epsilon");
-    grammar->insertNonTerminalKind(startS);
-    grammar->setStartKind(grammar->str2Kind(startS));
+
     return lines;
 }
 
 const inline std::vector<std::string> GrammarBuilder::loadWordProductions() const
 {
     size_t pos = 0;
-    std::string lines = parseProduction();
+    std::string lines = parseProductionsString();
     std::string word = "";
-    std::vector<std::string> wordProd;
+    std::vector<std::string> wordProds;
     std::string delimiter = ";";
     while ((pos = lines.find(";")) != std::string::npos)
     {
         word = lines.substr(0, pos);
-        wordProd.push_back(word);
+        wordProds.push_back(word);
         lines.erase(0, pos + delimiter.length());
     }
-    return wordProd;
+    return wordProds;
 }
 
 const inline std::string GrammarBuilder::stripSpace(std::string s) const
@@ -97,52 +104,33 @@ const inline std::string GrammarBuilder::stripSpace(std::string s) const
 GrammarBase* GrammarBuilder::build() const
 {
     std::smatch matches;
-    std::string delimiter = ";";
-    size_t pos = 0;
+    std::string delimiter = " ";
+    std::string delimiter1 = "->";
     std::string word = "";
+    size_t pos;
     GrammarBase::Production prod;
-    std::vector<std::string> wordProd = loadWordProductions();
-    std::string delimiter1 = "->";
+    std::vector<std::string> wordProdVec = loadWordProductions();
 
-    for (auto it : wordProd)
+    for (auto wordProd : wordProdVec)
     {
-        if ((pos = it.find(delimiter1)) != std::string::npos)
+        if ((pos = wordProd.find(delimiter1)) != std::string::npos)
         {
-            std::string head = it.substr(0, pos);
-            std::string LHS = it.substr(pos + delimiter1.size(), it.size() - 1);
-            head = stripSpace(head);
-            prod.push_back(grammar->insertNonTerminalKind(head));
-            if (grammar->getRawProductions().find(grammar->str2Kind(head)) == grammar->getRawProductions().end())
-            {
-                grammar->getRawProductions().insert({grammar->str2Kind(head), {}});
-            }
-
-            std::regex LHSReg("\\s*(.*)");
-            std::regex_search(LHS, matches, LHSReg);
+            std::string RHS = stripSpace(wordProd.substr(0, pos));
+            std::string LHS = wordProd.substr(pos + delimiter1.size(), wordProd.size() - 1);
+            GrammarBase::Symbol RHSSymbol = grammar->insertNonTerminalSymbol(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);
-            delimiter = " ";
             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
-                if (isupper(word[0]))
-                {
-                    prod.push_back(grammar->insertNonTerminalKind(word));
-                }
-                else
-                {
-                    prod.push_back(grammar->insertTerminalKind(word));
-                }
+                prod.push_back(grammar->insertSymbol(word));
             }
-            if (isupper(LHS[0]))
-            {
-                prod.push_back(grammar->insertNonTerminalKind(LHS));
-            }
-            else
-            {
-                prod.push_back(grammar->insertTerminalKind(LHS));
-            }
-            grammar->getRawProductions().at(grammar->str2Kind(head)).insert(prod);
+            prod.push_back(grammar->insertSymbol(LHS));
+            grammar->getRawProductions().at(RHSSymbol).insert(prod);
             prod = {};
         }
     }
@@ -150,10 +138,4 @@ GrammarBase* GrammarBuilder::build() const
     return grammar;
 };
 
-GrammarBase* GrammarBuilder::build(Map<std::string, SVF::CFLGraph::Symbol> &preMap) const
-{
-    grammar->setNonterminals(preMap);
-    grammar->setTotalKind(preMap.size());
-    return build();
-};
 }

package/lib/Graphs/CFLGraph.cpp

@@ -34,6 +34,10 @@
 
 using namespace SVF;
 
+CFLGraph::Kind CFLGraph::getStartKind() const
+{
+    return this->startKind;
+}
 
 void CFLGraph::addCFLNode(NodeID id, CFLNode* node)
 {
@@ -76,7 +80,7 @@ void CFLGraph::view()
 namespace llvm
 {
 /*!
- * Write value flow graph into dot file for debugging
+ * Write CFL graph into dot file for debugging
  */
 template<>
 struct DOTGraphTraits<CFLGraph*> : public DefaultDOTGraphTraits
@@ -114,6 +118,42 @@ struct DOTGraphTraits<CFLGraph*> : public DefaultDOTGraphTraits
         assert(edge && "No edge found!!");
         std::string str;
         raw_string_ostream rawstr(str);
+        if (edge->getEdgeKind() == ConstraintEdge::Addr)
+        {
+            rawstr << "color=green";
+        }
+        else if (edge->getEdgeKind() == ConstraintEdge::Copy)
+        {
+            rawstr << "color=black";
+        }
+        else if (edge->getEdgeKindWithMask() == ConstraintEdge::NormalGep)
+        {
+            rawstr << "color=purple,label=" << '"' << "Gep_" << edge->getEdgeAttri() << '"';
+        }
+        else if (edge->getEdgeKindWithMask() == ConstraintEdge::VariantGep)
+        {
+            rawstr << "color=purple,label=" << '"' << "VGep" << '"';
+        }
+        else if (edge->getEdgeKind() == ConstraintEdge::Store)
+        {
+            rawstr << "color=blue";
+        }
+        else if (edge->getEdgeKind() == ConstraintEdge::Load)
+        {
+            rawstr << "color=red";
+        }
+        else if (edge->getEdgeKind() == graph->getStartKind())
+        {
+            rawstr << "color=Turquoise";
+        }
+        else if (edge->getEdgeKind() == 14)
+        {
+            rawstr << "color=Sienna";
+        }
+        else
+        {
+            rawstr  << "style=invis";
+        }
         return rawstr.str();
     }
 

package/lib/MemoryModel/LocationSet.cpp

@@ -90,7 +90,7 @@ u32_t LocationSet::getElementNum(const Type* type) const
 /// "value" is the offset variable (must be a constant)
 /// "type" is the location where we want to compute offset
 /// Given a vector: [(value1,type1), (value2,type2), (value3,type3)]
-/// totalConstOffset = flattenOffset(value1,type1) * flattenOffset(type2,type2) + flattenOffset(type3,type3)
+/// totalConstOffset = flattenOffset(value1,type1) * flattenOffset(value2,type2) + flattenOffset(value3,type3)
 /// For a pointer type (e.g., t1 is PointerType), we will retrieve the pointee type and times the offset, i.e., getElementNum(t1) X off1
 
 /// For example,

package/lib/SVF-FE/SVFIRBuilder.cpp

@@ -1207,9 +1207,9 @@ void SVFIRBuilder::handleExtCall(CallSite cs, const SVFFunction *callee)
             // The external function exists in ExtAPI.json
             if (item != nullptr)
             {
-                //  Get the first operation of the function
                 cJSON *obj = item->child;
-                obj = obj -> next;
+                //  Get the first operation of the function
+                obj = obj -> next -> next;
                 while (obj)
                 {
                     std::string op = obj->string;

package/lib/Util/ExtAPI.cpp

@@ -138,7 +138,7 @@ ExtAPI::extType ExtAPI::get_type(const SVF::SVFFunction *F)
     {
         //  Get the first operation of the function
         cJSON *obj = item->child;
-        if (strcmp(obj->string, "type") == 0)
+        if (strcmp(obj->string, JSON_OPT_FUNCTIONTYPE) == 0)
             type = obj->valuestring;
         else
             assert(false && "The function operation format is illegal!");
@@ -150,6 +150,25 @@ ExtAPI::extType ExtAPI::get_type(const SVF::SVFFunction *F)
         return it->second;
 }
 
+// Get priority of he function, return value
+// 0: Apply user-defined functions
+// 1: Apply function specification in ExtAPI.json
+u32_t ExtAPI::isOverwrittenAppFunction(const SVF::SVFFunction *callee)
+{
+    std::string funName = get_name(callee);
+    cJSON *item = get_FunJson(funName);
+    if (item != nullptr)
+    {
+        cJSON *obj = item->child;
+        obj = obj->next;
+        if (strcmp(obj->string, JSON_OPT_OVERWRITE) == 0)
+            return obj->valueint;
+        else
+            assert(false && "The function operation format is illegal!");
+    }
+    return 0;
+}
+
 // Does (F) have a static var X (unavailable to us) that its return points to?
 bool ExtAPI::has_static(const SVFFunction *F)
 {
@@ -240,7 +259,20 @@ bool ExtAPI::is_ext(const SVFFunction *F)
     else
     {
         ExtAPI::extType t = get_type(F);
-        res = t == EFT_ALLOC || t == EFT_REALLOC || t == EFT_NOSTRUCT_ALLOC || t == EFT_NOOP || t == EFT_FREE;
+        if (t != EFT_NULL)
+        {
+            u32_t overwrittenAppFunction = isOverwrittenAppFunction(F);
+            // overwrittenAppFunction = 1: Execute function specification in ExtAPI.json
+            // F is considered as external function
+            if (overwrittenAppFunction == 1)
+                res = 1;
+            // overwrittenAppFunction = 0: Execute user-defined functions
+            // F is not considered as external function
+            else
+                res = 0;
+        }
+        else
+            res = 0;
     }
     return res;
 }