svf-tools 1.0.464 → 1.0.467

package/lib/Graphs/SVFGReadWrite.cpp

@@ -0,0 +1,478 @@
+//===- SVFGReadWrite.cpp -- SVFG read & write-----------------------------------//
+//
+//                     SVF: Static Value-Flow Analysis
+//
+// Copyright (C) <2013-2017>  <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/>.
+//
+//===----------------------------------------------------------------------===//
+
+/*
+ * SVFGReadWrite.cpp
+ *
+ *  Created on: May 21, 2022
+ *      Author: Jeffrey Ma
+ */
+
+#include "Util/SVFModule.h"
+#include "SVF-FE/LLVMUtil.h"
+#include "Graphs/SVFG.h"
+#include "Graphs/SVFGStat.h"
+#include "MemoryModel/PointerAnalysisImpl.h"
+#include <fstream>
+#include "Util/Options.h"
+
+using namespace SVF;
+using namespace SVFUtil;
+
+// Format of file
+// __Nodes__
+// SVFGNodeID: <id> >= <node type> >= MVER: {MRVERID: <id> MemRegion: pts{<pts> } MRVERSION: <version> MSSADef: <version>, pts{<pts> }} >= ICFGNodeID: <id>
+// __Edges__
+// srcSVFGNodeID: <id> => dstSVFGNodeID: <id> >= <edge type> | MVER: {MRVERID: <id> MemRegion: pts{<pts> } MRVERSION: <version> MSSADef: <version>, pts{<pts> }}
+void SVFG::writeToFile(const string& filename)
+{
+    outs() << "Writing SVFG analysis to '" << filename << "'...";
+    error_code err;
+    std::fstream f(filename.c_str(), std::ios_base::out);
+    if (!f.good())
+    {
+        outs() << "  error opening file for writing!\n";
+        return;
+    }
+    f << "__Nodes__\n";
+    // Iterate over nodes and write to file
+    for(iterator it = begin(), eit = end(); it!=eit; ++it)
+    {
+        NodeID nodeId = it->first;
+        const SVFGNode* node = it->second;
+        if(const FormalINSVFGNode* formalIn = SVFUtil::dyn_cast<FormalINSVFGNode>(node))
+        {
+            //node
+            f << "SVFGNodeID: " << nodeId << " >= " << "FormalINSVFGNode";
+            f << " >= MVER: {";
+            f << *formalIn->getMRVer() << "} >= ICFGNodeID: " << formalIn->getFunEntryNode()->getId() << "\n";
+        }
+        else if(const FormalOUTSVFGNode* formalOut = SVFUtil::dyn_cast<FormalOUTSVFGNode>(node))
+        {
+            //node
+            f << "SVFGNodeID: " << nodeId << " >= " << "FormalOUTSVFGNode";
+            f << " >= MVER: {";
+            f << *formalOut->getMRVer() << "} >= ICFGNodeID: " <<  formalOut->getFunExitNode()->getId() << "\n";
+        }
+        else if(const ActualINSVFGNode* actualIn = SVFUtil::dyn_cast<ActualINSVFGNode>(node))
+        {
+            //node
+            f << "SVFGNodeID: " << nodeId << " >= " << "ActualINSVFGNode";
+            f << " >= MVER: {";
+            f << *actualIn->getMRVer() << "} >= ICFGNodeID: " << actualIn->getCallSite()->getId() << "\n";
+        }
+        else if(const ActualOUTSVFGNode* actualOut = SVFUtil::dyn_cast<ActualOUTSVFGNode>(node))
+        {
+            //node
+            f << "SVFGNodeID: " << nodeId << " >= " << "ActualOUTSVFGNode" << " >= MVER: {";
+            f << *actualOut->getMRVer() << "} >= ICFGNodeID: "  <<  actualOut->getCallSite()->getId() << "\n";
+        }
+        else if(const MSSAPHISVFGNode* phiNode = SVFUtil::dyn_cast<MSSAPHISVFGNode>(node))
+        {
+            //node
+            f << "SVFGNodeID: " << nodeId << " >= " << "PHISVFGNode";
+            unordered_map<u32_t,const MRVer*> opvers;
+            for (MemSSA::PHI::OPVers::const_iterator it = phiNode->opVerBegin(), eit = phiNode->opVerEnd();
+                    it != eit; it++)
+            {
+                opvers.insert(make_pair(it->first, it->second));
+            }
+            // opvers
+            f << " >= MVER: {";
+            f << *phiNode->getResVer();
+            f << "} >= ICFGNodeID: " << pag->getICFG()->getICFGNode(&(phiNode->getICFGNode()->getBB()->front()))->getId();
+            f << " >= OPVers: {";
+            for (auto x: opvers)
+            {
+                const MRVer* op = x.second;
+                f << "{" << *op << "}" << ",";
+            }
+            f << "}\n";
+        }
+    }
+
+    f << "\n\n__Edges__\n";
+    // Iterate over edges and write to file
+    for(iterator it = begin(), eit = end(); it!=eit; ++it)
+    {
+        NodeID nodeId = it->first;
+        const SVFGNode* node = it->second;
+        if(const LoadSVFGNode* loadNode = SVFUtil::dyn_cast<LoadSVFGNode>(node))
+        {
+            MUSet& muSet = mssa->getMUSet(SVFUtil::cast<LoadStmt>(loadNode->getPAGEdge()));
+            for(MUSet::iterator it = muSet.begin(), eit = muSet.end(); it!=eit; ++it)
+            {
+                if(LOADMU* mu = SVFUtil::dyn_cast<LOADMU>(*it))
+                {
+                    NodeID def = getDef(mu->getMRVer());
+                    f << "srcSVFGNodeID: " << nodeId << " => " << "dstSVFGNodeID: " << def << " >= LoadNode | MVER: {"<< *mu->getMRVer() << "}" << "\n";
+                }
+            }
+        }
+        else if(const StoreSVFGNode* storeNode = SVFUtil::dyn_cast<StoreSVFGNode>(node))
+        {
+            CHISet& chiSet = mssa->getCHISet(SVFUtil::cast<StoreStmt>(storeNode->getPAGEdge()));
+            for(CHISet::iterator it = chiSet.begin(), eit = chiSet.end(); it!=eit; ++it)
+            {
+                if(STORECHI* chi = SVFUtil::dyn_cast<STORECHI>(*it))
+                {
+                    NodeID def = getDef(chi->getOpVer());
+                    f << "srcSVFGNodeID: " << nodeId << " => " << "dstSVFGNodeID: " << def << " >= StoreNode | MVER: {"<< *chi->getOpVer() << "}" << "\n";
+                }
+            }
+        }
+        else if(const FormalINSVFGNode* formalIn = SVFUtil::dyn_cast<FormalINSVFGNode>(node))
+        {
+            PTACallGraphEdge::CallInstSet callInstSet;
+            mssa->getPTA()->getPTACallGraph()->getDirCallSitesInvokingCallee(formalIn->getFun(),callInstSet);
+            for(PTACallGraphEdge::CallInstSet::iterator it = callInstSet.begin(), eit = callInstSet.end(); it!=eit; ++it)
+            {
+                const CallICFGNode* cs = *it;
+                if(!mssa->hasMU(cs))
+                    continue;
+                ActualINSVFGNodeSet& actualIns = getActualINSVFGNodes(cs);
+                for(ActualINSVFGNodeSet::iterator ait = actualIns.begin(), aeit = actualIns.end(); ait!=aeit; ++ait)
+                {
+                    const ActualINSVFGNode* actualIn = SVFUtil::cast<ActualINSVFGNode>(getSVFGNode(*ait));
+                    f << "srcSVFGNodeID: " << nodeId << " => " << "dstSVFGNodeID: " << actualIn->getId() << " >= FormalINSVFGNode" << "\n";
+                }
+            }
+        }
+        else if(const FormalOUTSVFGNode* formalOut = SVFUtil::dyn_cast<FormalOUTSVFGNode>(node))
+        {
+            PTACallGraphEdge::CallInstSet callInstSet;
+            mssa->getPTA()->getPTACallGraph()->getDirCallSitesInvokingCallee(formalOut->getFun(),callInstSet);
+            for(PTACallGraphEdge::CallInstSet::iterator it = callInstSet.begin(), eit = callInstSet.end(); it!=eit; ++it)
+            {
+                const CallICFGNode* cs = *it;
+                if(!mssa->hasCHI(cs))
+                    continue;
+                ActualOUTSVFGNodeSet& actualOuts = getActualOUTSVFGNodes(cs);
+                for(ActualOUTSVFGNodeSet::iterator ait = actualOuts.begin(), aeit = actualOuts.end(); ait!=aeit; ++ait)
+                {
+                    const ActualOUTSVFGNode* actualOut = SVFUtil::cast<ActualOUTSVFGNode>(getSVFGNode(*ait));
+                    f << "srcSVFGNodeID: " << nodeId << " => " << "dstSVFGNodeID: " << actualOut->getId() << " >= FormalOUTSVFGNode" << "\n";
+                }
+            }
+            NodeID def = getDef(formalOut->getMRVer());
+            f << "srcSVFGNodeID: " << nodeId << " => " << "dstSVFGNodeID: " << def << " >= FormalOUTSVFGNode | intra" << "\n";
+        }
+        else if(const ActualINSVFGNode* actualIn = SVFUtil::dyn_cast<ActualINSVFGNode>(node))
+        {
+            NodeID def = getDef(actualIn->getMRVer());
+            f << "srcSVFGNodeID: " << nodeId << " => " << "dstSVFGNodeID: " << def << " >= ActualINSVFGNode" << "\n";
+
+        }
+        else if(const MSSAPHISVFGNode* phiNode = SVFUtil::dyn_cast<MSSAPHISVFGNode>(node))
+        {
+            for (MemSSA::PHI::OPVers::const_iterator it = phiNode->opVerBegin(), eit = phiNode->opVerEnd();
+                    it != eit; it++)
+            {
+                const MRVer* op = it->second;
+                NodeID def = getDef(op);
+                f << "srcSVFGNodeID: " << nodeId << " => " << "dstSVFGNodeID: " << def << " >= PHISVFGNode | MVER: {"<< *op << "}" << "\n";
+            }
+        }
+    }
+    // Job finish and close file
+    f.close();
+    if (f.good())
+    {
+        outs() << "\n";
+        return;
+    }
+}
+
+void SVFG::readFile(const string& filename)
+{
+    outs() << "Loading SVFG analysis results from '" << filename << "'...";
+    ifstream F(filename.c_str());
+    if (!F.is_open())
+    {
+        outs() << " error opening file for reading!\n";
+        return;
+    }
+
+    PAGEdge::PAGEdgeSetTy& stores = getPAGEdgeSet(PAGEdge::Store);
+    for (PAGEdge::PAGEdgeSetTy::iterator iter = stores.begin(), eiter =
+                stores.end(); iter != eiter; ++iter)
+    {
+        StoreStmt* store = SVFUtil::cast<StoreStmt>(*iter);
+        const StmtSVFGNode* sNode = getStmtVFGNode(store);
+        for(CHISet::iterator pi = mssa->getCHISet(store).begin(), epi = mssa->getCHISet(store).end(); pi!=epi; ++pi)
+            setDef((*pi)->getResVer(),sNode);
+    }
+    //outer loop through each line in the file
+    string line;
+    // add nodes
+    stat->ATVFNodeStart();
+    while (F.good())
+    {
+        getline(F, line);
+        if (line.empty())
+            continue;
+        if (line.find("__Edges__") != std::string::npos)
+            break;
+
+        std::string s = line;
+        std::string delimiter = " >= ";
+        string temp;
+        int index = 0;
+        //implement delimiter to split string using ">="
+        size_t next = 0;
+        size_t last = 0;
+        size_t outer_last = 0;
+        size_t nextTemp; //size_t lastTemp;
+        NodeID id = 0;
+        string type;
+        string MR;
+        string basicBlock;
+        string opVer;
+        //inner loop through to get each element in the line
+        while ((next = s.find(delimiter, last)) != string::npos)
+        {
+            temp = s.substr(last, next-last);
+            last = next + 4;
+            outer_last = next + 4;
+            if(index == 0)
+            {
+                nextTemp = temp.find("SVFGNodeID: ") + 12;
+                id = atoi(temp.substr(nextTemp).c_str());
+            }
+            if(index == 1)
+            {
+                type = temp;
+            }
+            if(index > 1)
+            {
+                if(index == 2)
+                {
+                    MR = temp;
+                }
+                if(index == 3)
+                {
+                    basicBlock = temp;
+                }
+            }
+            index++;
+        }
+        MRVer* tempMRVer;
+        if(!MR.empty())
+        {
+            tempMRVer = getMRVERFromString(MR);
+        }
+        else
+        {
+            tempMRVer = getMRVERFromString("");
+        }
+        //add nodes using the variables we extracted
+        if(type == "FormalINSVFGNode")
+        {
+            outer_last = s.find("ICFGNodeID: ") + 12;
+            NodeID FunID = atoi(s.substr(outer_last).c_str());
+            addFormalINSVFGNode(SVFUtil::dyn_cast<FunEntryICFGNode>(pag->getICFG()->getICFGNode(FunID)), tempMRVer, id);
+        }
+        else if(type == "FormalOUTSVFGNode")
+        {
+            outer_last = s.find("ICFGNodeID: ") + 12;
+            NodeID FunID =  atoi(s.substr(outer_last).c_str());
+            addFormalOUTSVFGNode(SVFUtil::dyn_cast<FunExitICFGNode>(pag->getICFG()->getICFGNode(FunID)), tempMRVer, id);
+        }
+        else if(type == "ActualINSVFGNode")
+        {
+            outer_last = s.find("ICFGNodeID: ") + 12;
+            NodeID CallSiteID = atoi(s.substr(outer_last).c_str());
+            addActualINSVFGNode(SVFUtil::dyn_cast<CallICFGNode>(pag->getICFG()->getICFGNode(CallSiteID)), tempMRVer, id);
+        }
+        else if(type == "ActualOUTSVFGNode")
+        {
+            outer_last = s.find("ICFGNodeID: ") + 12;
+            NodeID CallSiteID = atoi(s.substr(outer_last).c_str());
+            addActualOUTSVFGNode(SVFUtil::dyn_cast<CallICFGNode>(pag->getICFG()->getICFGNode(CallSiteID)), tempMRVer, id);
+        }
+        else if (type == "PHISVFGNode")
+        {
+            opVer =  s.substr(outer_last);
+            next = opVer.find("{") + 1;
+            last = opVer.find(",}");
+            temp = opVer.substr(next, last);
+            Map<u32_t,const MRVer*> OPVers;
+            int index = 0;
+            while ((next = temp.find("{") + 1) != string::npos)
+            {
+                if (temp == ",}")
+                    break;
+                last = temp.find("},");
+                string temp1;
+                temp1 = temp.substr(next, last-next);
+                MRVer* tempOPVer = getMRVERFromString(temp1);
+                OPVers.insert(make_pair(index, tempOPVer));
+                temp = temp.substr(last + 1);
+                index++;
+            }
+            next = basicBlock.find("ICFGNodeID: ") + 12;
+            temp = basicBlock.substr(next);
+            addIntraMSSAPHISVFGNode(pag->getICFG()->getICFGNode(atoi(temp.c_str())), OPVers.begin(), OPVers.end(), tempMRVer, id);
+        }
+        else
+        {
+        }
+
+        if (totalVFGNode < id)
+            totalVFGNode = id + 1;
+    }
+    stat->ATVFNodeEnd();
+
+    stat->indVFEdgeStart();
+    // Edges
+    while (F.good())
+    {
+        getline(F, line);
+        if (line.empty())
+            continue;
+
+        std::string s = line;
+        std::string delimiter = " >= ";
+        string temp;
+        // int index = 0;
+        size_t last = 0;
+        size_t next = 0; // size_t outer_last = 0;
+        string edge;
+        string attributes;
+
+        next = s.find(delimiter);
+
+        edge = s.substr(0, next);
+        attributes = s.substr(next + 4);
+
+        // extract nodeIDs for src and dst nodes
+        NodeID src;
+        NodeID dst;
+        next = edge.find("srcSVFGNodeID: ") + 15;
+        last = edge.find(" => ");
+        src = atoi(edge.substr(next, last-next).c_str());
+        next = edge.find("dstSVFGNodeID: ") + 15;
+        dst = atoi(edge.substr(next).c_str());
+
+        string type;
+        string attribute;
+        if (attributes.find(" | ") == string::npos)
+            type = attributes;
+        else
+        {
+            next = attributes.find(" | ");
+            type = attributes.substr(0, next);
+            attribute = attributes.substr(next + 3);
+        }
+
+        if(type == "FormalINSVFGNode")
+        {
+            const FormalINSVFGNode* formalIn = SVFUtil::cast<FormalINSVFGNode>(getSVFGNode(src));
+            const ActualINSVFGNode* actualIn = SVFUtil::cast<ActualINSVFGNode>(getSVFGNode(dst));
+            addInterIndirectVFCallEdge(actualIn,formalIn, getCallSiteID(actualIn->getCallSite(), formalIn->getFun()));
+        }
+        else if(type == "FormalOUTSVFGNode")
+        {
+            const FormalOUTSVFGNode* formalOut = SVFUtil::cast<FormalOUTSVFGNode>(getSVFGNode(src));
+            if (attribute.find("intra") != string::npos)
+            {
+                addIntraIndirectVFEdge(dst, src, formalOut->getMRVer()->getMR()->getPointsTo());
+            }
+            else
+            {
+                const ActualOUTSVFGNode* actualOut = SVFUtil::cast<ActualOUTSVFGNode>(getSVFGNode(dst));
+                addInterIndirectVFRetEdge(formalOut,actualOut,getCallSiteID(actualOut->getCallSite(), formalOut->getFun()));
+            }
+        }
+        else if(type == "ActualINSVFGNode")
+        {
+            const ActualINSVFGNode* actualIn = SVFUtil::cast<ActualINSVFGNode>(getSVFGNode(src));
+            addIntraIndirectVFEdge(dst,src, actualIn->getMRVer()->getMR()->getPointsTo());
+        }
+        else if(type == "ActualOUTSVFGNode")
+        {
+            // There's no need to connect actual out node to its definition site in the same function.
+        }
+        else if (type == "StoreNode" || type == "LoadNode" || type == "PHISVFGNode")
+        {
+            MRVer* tempMRVer;
+            tempMRVer = getMRVERFromString(attribute);
+            addIntraIndirectVFEdge(dst,src, tempMRVer->getMR()->getPointsTo());
+        }
+        else
+        {
+        }
+    }
+    stat->indVFEdgeEnd();
+    connectFromGlobalToProgEntry();
+}
+
+MRVer* SVFG::getMRVERFromString(const string& s)
+{
+    if(s == "")
+    {
+        return NULL;
+    }
+    string temp;
+    size_t last = 0;
+    size_t next = 0;
+    MRVer* tempMRVer;
+    MemRegion* tempMemRegion;
+    MSSADEF* tempDef;
+    //{create Memory Region object
+    next = s.find("MemRegion: pts{") + 15;
+    last = s.find("} MRVERSION: ");
+    temp = s.substr(next, last-next);
+    // convert string to PointsTo
+    NodeBS dstPts;
+    string point;
+    stringstream ss(temp);
+    while (getline(ss, point, ' '))
+    {
+        istringstream sss(point);
+        NodeID obj;
+        sss >> obj;
+        dstPts.set(obj);
+    }
+    tempMemRegion = new MemRegion(dstPts);
+    // create mssdef
+    next = s.find("MSSADef: ") + 9;
+    last = s.find("} >=");
+    temp = s.substr(next, last-next);
+    // convert string to deftype
+    istringstream ss1(temp.substr(0, temp.find(", ")));
+    int obj1;
+    ss1 >> obj1;
+    MSSADEF::DEFTYPE defType = static_cast<MSSADEF::DEFTYPE>(obj1);
+    tempDef = new MSSADEF(defType, tempMemRegion);
+    // mrversion
+    next = s.find("MRVERSION: ") + 11;
+    last = s.find(" MSSADef:");
+    temp = s.substr(next, last-next);
+    // convert mrversion to nodeid
+    istringstream ss2(temp);
+    NodeID obj2;
+    ss2 >> obj2;
+    // create mrver
+    tempMRVer = new MRVer(tempMemRegion, obj2, tempDef);
+    return tempMRVer;
+}

package/lib/MSSA/MemRegion.cpp

@@ -807,3 +807,10 @@ ModRefInfo MRGenerator::getModRefInfo(const CallICFGNode* cs1, const CallICFGNod
     else
         return ModRefInfo::NoModRef;
 }
+
+std::ostream& SVF::operator<<(std::ostream &o, const MRVer& mrver)
+{
+    o << "MRVERID: " << mrver.getID() <<" MemRegion: " << mrver.getMR()->dumpStr() << " MRVERSION: " << mrver.getSSAVersion() << " MSSADef: " << mrver.getDef()->getType() << ", "
+      << mrver.getDef()->getMR()->dumpStr() ;
+    return o;
+}

package/lib/MemoryModel/LocationSet.cpp

@@ -72,7 +72,7 @@ u32_t LocationSet::getElementNum(const Type* type) const
     {
         /// This is a pointer arithmic
         if(const PointerType* pty = SVFUtil::dyn_cast<PointerType>(type))
-            return getElementNum(pty->getElementType());
+            return getElementNum(getPtrElementType(pty));
         else
             return 1;
     }
@@ -134,7 +134,7 @@ s32_t LocationSet::accumulateConstantOffset() const
         }
 
         if(const PointerType* pty = SVFUtil::dyn_cast<PointerType>(type))
-            totalConstOffset += op->getSExtValue() * getElementNum(pty->getElementType());
+            totalConstOffset += op->getSExtValue() * getElementNum(getPtrElementType(pty));
         else
         {
             s32_t offset = op->getSExtValue();

package/lib/MemoryModel/PointerAnalysis.cpp

@@ -277,7 +277,7 @@ void PointerAnalysis::dumpAllTypes()
         Type* type = node->getValue()->getType();
         SymbolTableInfo::SymbolInfo()->printFlattenFields(type);
         if (PointerType* ptType = SVFUtil::dyn_cast<PointerType>(type))
-            SymbolTableInfo::SymbolInfo()->printFlattenFields(ptType->getElementType());
+            SymbolTableInfo::SymbolInfo()->printFlattenFields(getPtrElementType(ptType));
     }
 }
 

package/lib/MemoryModel/SymbolTableInfo.cpp

@@ -490,7 +490,7 @@ void SymbolTableInfo::printFlattenFields(const Type* type)
 
     else if (const PointerType* pt= SVFUtil::dyn_cast<PointerType> (type))
     {
-        u32_t eSize = getNumOfFlattenElements(pt->getElementType());
+        u32_t eSize = getNumOfFlattenElements(getPtrElementType(pt));
         outs() << "  {Type: ";
         outs() << type2String(pt);
         outs() << "}\n";

package/lib/SVF-FE/BreakConstantExpr.cpp

@@ -40,7 +40,6 @@ Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA
 //
 //===----------------------------------------------------------------------===//
 
-#define DEBUG_TYPE "break-constgeps"
 
 #include "llvm/ADT/Statistic.h"
 #include "llvm/IR/Constants.h"
@@ -62,6 +61,9 @@ using namespace SVF;
 // Identifier variable for the pass
 char BreakConstantGEPs::ID = 0;
 char MergeFunctionRets::ID = 0;
+
+#define DEBUG_TYPE "break-constgeps"
+
 // Statistics
 STATISTIC (GEPChanges,   "Number of Converted GEP Constant Expressions");
 STATISTIC (TotalChanges, "Number of Converted Constant Expressions");

package/lib/SVF-FE/CPPUtil.cpp

@@ -233,7 +233,7 @@ bool cppUtil::isLoadVtblInst(const LoadInst *loadInst)
     for (u32_t i = 0; i < 3; ++i)
     {
         if (const PointerType *ptrTy = SVFUtil::dyn_cast<PointerType>(elemTy))
-            elemTy = ptrTy->getElementType();
+            elemTy = SVFUtil::getPtrElementType(ptrTy);
         else
             return false;
     }
@@ -419,7 +419,7 @@ string cppUtil::getClassNameFromType(const Type *ty)
     string className = "";
     if (const PointerType *ptrType = SVFUtil::dyn_cast<PointerType>(ty))
     {
-        const Type *elemType = ptrType->getElementType();
+        const Type *elemType = SVFUtil::getPtrElementType(ptrType);
         if (SVFUtil::isa<StructType>(elemType) &&
                 !((SVFUtil::cast<StructType>(elemType))->isLiteral()))
         {

package/lib/SVF-FE/LLVMUtil.cpp

@@ -275,7 +275,7 @@ const Value* SVFUtil::getUniqueUseViaCastInst(const Value* val)
     const PointerType * type = SVFUtil::dyn_cast<PointerType>(val->getType());
     assert(type && "this value should be a pointer type!");
     /// If type is void* (i8*) and val is only used at a bitcast instruction
-    if (IntegerType *IT = SVFUtil::dyn_cast<IntegerType>(type->getPointerElementType()))
+    if (IntegerType *IT = SVFUtil::dyn_cast<IntegerType>(getPtrElementType(type)))
     {
         if (IT->getBitWidth() == 8 && val->getNumUses()==1)
         {
@@ -314,7 +314,7 @@ const Type* SVFUtil::getTypeOfHeapAlloc(const Instruction *inst)
     }
 
     assert(type && "not a pointer type?");
-    return type->getElementType();
+    return getPtrElementType(type);
 }
 
 /*!

package/lib/SVF-FE/SVFIRBuilder.cpp

@@ -276,7 +276,7 @@ bool SVFIRBuilder::computeGepOffset(const User *V, LocationSet& ls)
             // If it's a non-constant offset access
             // If its point-to target is struct or array, it's likely an array accessing (%result = gep %struct.A* %a, i32 %non-const-index)
             // If its point-to target is single value (pointer arithmetic), then it's a variant gep (%result = gep i8* %p, i32 %non-const-index)
-            if(!op && gepTy->isPointerTy() && gepTy->getPointerElementType()->isSingleValueType())
+            if(!op && gepTy->isPointerTy() && getPtrElementType(SVFUtil::dyn_cast<PointerType>(gepTy))->isSingleValueType())
                 return false;
 
             // The actual index
@@ -1013,7 +1013,7 @@ const Type *SVFIRBuilder::getBaseTypeAndFlattenedFields(const Value *V, std::vec
     const Value* value = getBaseValueForExtArg(V);
     const Type *T = value->getType();
     while (const PointerType *ptype = SVFUtil::dyn_cast<PointerType>(T))
-        T = ptype->getElementType();
+        T = getPtrElementType(ptype);
 
     u32_t numOfElems = SymbolTableInfo::SymbolInfo()->getNumOfFlattenElements(T);
     /// use user-specified size for this copy operation if the size is a constaint int
@@ -1327,7 +1327,7 @@ void SVFIRBuilder::handleExtCall(CallSite cs, const SVFFunction *callee)
                     Value *arg = cs.getArgument(i);
                     if(const PointerType* pty = SVFUtil::dyn_cast<PointerType>(arg->getType()))
                     {
-                        if(pty->getElementType()->isPointerTy())
+                        if(getPtrElementType(pty)->isPointerTy())
                         {
                             NodeID dummy = pag->addDummyValNode();
                             addLoadEdge(pag->getValueNode(arg),dummy);

package/lib/SVF-FE/SymbolTableBuilder.cpp

@@ -503,7 +503,7 @@ ObjTypeInfo* SymbolTableBuilder::createObjTypeInfo(const Value *val)
 
     if (refTy)
     {
-        Type *objTy = refTy->getElementType();
+        Type *objTy = getPtrElementType(refTy);
         ObjTypeInfo* typeInfo = new ObjTypeInfo(objTy, Options::MaxFieldLimit);
         initTypeInfo(typeInfo,val);
         return typeInfo;
@@ -535,7 +535,7 @@ void SymbolTableBuilder::analyzeObjType(ObjTypeInfo* typeinfo, const Value* val)
 
     const PointerType * refty = SVFUtil::dyn_cast<PointerType>(val->getType());
     assert(refty && "this value should be a pointer type!");
-    Type* elemTy = refty->getElementType();
+    Type* elemTy = getPtrElementType(refty);
     bool isPtrObj = false;
     // Find the inter nested array element
     while (const ArrayType *AT= SVFUtil::dyn_cast<ArrayType>(elemTy))

package/lib/Util/Options.cpp

@@ -471,6 +471,17 @@ llvm::cl::opt<bool> Options::OPTSVFG(
     llvm::cl::desc("Optimize SVFG to eliminate formal-in and actual-out")
 );
 
+const llvm::cl::opt<std::string> Options::WriteSVFG(
+    "write-svfg",
+    llvm::cl::init(""),
+    llvm::cl::desc("Write SVFG's analysis results to a file")
+);
+
+const llvm::cl::opt<std::string> Options::ReadSVFG(
+    "read-svfg",
+    llvm::cl::init(""),
+    llvm::cl::desc("Read SVFG's analysis results from a file")
+);
 
 // FSMPTA.cpp
 const llvm::cl::opt<bool> Options::UsePCG(

package/lib/Util/PTAStat.cpp

@@ -221,6 +221,7 @@ void PTAStat::performStat()
     generalNumMap[NumOfObjsHasConstStruct] = numOfHasConstStruct;
     generalNumMap[NumOfObjsHasConstArray] = numOfHasConstArray;
     generalNumMap[NumOfNonPtrObjs] = numOfScalar;
+    generalNumMap[NumOfConstantObjs] = numOfConstant;
 
     generalNumMap[NumOfIndirectCallSites] = pag->getIndirectCallsites().size();
     generalNumMap["TotalCallSite"] = pag->getCallSiteSet().size();

package/package.json

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