svf-tools 1.0.463 → 1.0.466

package/lib/Graphs/SVFG.cpp

@@ -36,7 +36,7 @@
 #include "Util/Options.h"
 #include "MemoryModel/PointerAnalysisImpl.h"
 #include <fstream>
-
+#include "Util/Options.h"
 
 using namespace SVF;
 using namespace SVFUtil;
@@ -226,19 +226,23 @@ void SVFG::buildSVFG()
     DBOUT(DGENERAL, outs() << pasMsg("Build Sparse Value-Flow Graph \n"));
 
     stat->startClk();
-
-    DBOUT(DGENERAL, outs() << pasMsg("\tCreate SVFG Addr-taken Node\n"));
-
-    stat->ATVFNodeStart();
-    addSVFGNodesForAddrTakenVars();
-    stat->ATVFNodeEnd();
-
-    DBOUT(DGENERAL, outs() << pasMsg("\tCreate SVFG Indirect Edge\n"));
-
-    stat->indVFEdgeStart();
-    connectIndirectSVFGEdges();
-    stat->indVFEdgeEnd();
-
+    if (!Options::ReadSVFG.empty())
+    {
+        readFile(Options::ReadSVFG);
+    }
+    else
+    {
+        DBOUT(DGENERAL, outs() << pasMsg("\tCreate SVFG Addr-taken Node\n"));
+        stat->ATVFNodeStart();
+        addSVFGNodesForAddrTakenVars();
+        stat->ATVFNodeEnd();
+        DBOUT(DGENERAL, outs() << pasMsg("\tCreate SVFG Indirect Edge\n"));
+        stat->indVFEdgeStart();
+        connectIndirectSVFGEdges();
+        stat->indVFEdgeEnd();
+        if (!Options::WriteSVFG.empty())
+            writeToFile(Options::WriteSVFG);
+    }
 }
 
 /*
@@ -574,15 +578,15 @@ void SVFG::dump(const std::string& file, bool simple)
 /**
  * Get all inter value flow edges at this indirect call site, including call and return edges.
  */
-void SVFG::getInterVFEdgesForIndirectCallSite(const CallICFGNode* callBlockNode, const SVFFunction* callee, SVFGEdgeSetTy& edges)
+void SVFG::getInterVFEdgesForIndirectCallSite(const CallICFGNode* callICFGNode, const SVFFunction* callee, SVFGEdgeSetTy& edges)
 {
-    CallSiteID csId = getCallSiteID(callBlockNode, callee);
-    RetICFGNode* retBlockNode = pag->getICFG()->getRetICFGNode(callBlockNode->getCallSite());
+    CallSiteID csId = getCallSiteID(callICFGNode, callee);
+    RetICFGNode* retICFGNode = pag->getICFG()->getRetICFGNode(callICFGNode->getCallSite());
 
     // Find inter direct call edges between actual param and formal param.
-    if (pag->hasCallSiteArgsMap(callBlockNode) && pag->hasFunArgsList(callee))
+    if (pag->hasCallSiteArgsMap(callICFGNode) && pag->hasFunArgsList(callee))
     {
-        const SVFIR::SVFVarList& csArgList = pag->getCallSiteArgsList(callBlockNode);
+        const SVFIR::SVFVarList& csArgList = pag->getCallSiteArgsList(callICFGNode);
         const SVFIR::SVFVarList& funArgList = pag->getFunArgsList(callee);
         SVFIR::SVFVarList::const_iterator csArgIt = csArgList.begin(), csArgEit = csArgList.end();
         SVFIR::SVFVarList::const_iterator funArgIt = funArgList.begin(), funArgEit = funArgList.end();
@@ -591,7 +595,7 @@ void SVFG::getInterVFEdgesForIndirectCallSite(const CallICFGNode* callBlockNode,
             const PAGNode *cs_arg = *csArgIt;
             const PAGNode *fun_arg = *funArgIt;
             if (fun_arg->isPointer() && cs_arg->isPointer())
-                getInterVFEdgeAtIndCSFromAPToFP(cs_arg, fun_arg, callBlockNode, csId, edges);
+                getInterVFEdgeAtIndCSFromAPToFP(cs_arg, fun_arg, callICFGNode, csId, edges);
         }
         assert(funArgIt == funArgEit && "function has more arguments than call site");
         if (callee->getLLVMFun()->isVarArg())
@@ -604,25 +608,25 @@ void SVFG::getInterVFEdgesForIndirectCallSite(const CallICFGNode* callBlockNode,
                 {
                     const PAGNode *cs_arg = *csArgIt;
                     if (cs_arg->isPointer())
-                        getInterVFEdgeAtIndCSFromAPToFP(cs_arg, varFunArgNode, callBlockNode, csId, edges);
+                        getInterVFEdgeAtIndCSFromAPToFP(cs_arg, varFunArgNode, callICFGNode, csId, edges);
                 }
             }
         }
     }
 
     // Find inter direct return edges between actual return and formal return.
-    if (pag->funHasRet(callee) && pag->callsiteHasRet(retBlockNode))
+    if (pag->funHasRet(callee) && pag->callsiteHasRet(retICFGNode))
     {
-        const PAGNode* cs_return = pag->getCallSiteRet(retBlockNode);
+        const PAGNode* cs_return = pag->getCallSiteRet(retICFGNode);
         const PAGNode* fun_return = pag->getFunRet(callee);
         if (cs_return->isPointer() && fun_return->isPointer())
             getInterVFEdgeAtIndCSFromFRToAR(fun_return, cs_return, csId, edges);
     }
 
     // Find inter indirect call edges between actual-in and formal-in svfg nodes.
-    if (hasFuncEntryChi(callee) && hasCallSiteMu(callBlockNode))
+    if (hasFuncEntryChi(callee) && hasCallSiteMu(callICFGNode))
     {
-        SVFG::ActualINSVFGNodeSet& actualInNodes = getActualINSVFGNodes(callBlockNode);
+        SVFG::ActualINSVFGNodeSet& actualInNodes = getActualINSVFGNodes(callICFGNode);
         for(SVFG::ActualINSVFGNodeSet::iterator ai_it = actualInNodes.begin(),
                 ai_eit = actualInNodes.end(); ai_it!=ai_eit; ++ai_it)
         {
@@ -632,9 +636,9 @@ void SVFG::getInterVFEdgesForIndirectCallSite(const CallICFGNode* callBlockNode,
     }
 
     // Find inter indirect return edges between actual-out and formal-out svfg nodes.
-    if (hasFuncRetMu(callee) && hasCallSiteChi(callBlockNode))
+    if (hasFuncRetMu(callee) && hasCallSiteChi(callICFGNode))
     {
-        SVFG::ActualOUTSVFGNodeSet& actualOutNodes = getActualOUTSVFGNodes(callBlockNode);
+        SVFG::ActualOUTSVFGNodeSet& actualOutNodes = getActualOUTSVFGNodes(callICFGNode);
         for(SVFG::ActualOUTSVFGNodeSet::iterator ao_it = actualOutNodes.begin(),
                 ao_eit = actualOutNodes.end(); ao_it!=ao_eit; ++ao_it)
         {

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/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(
@@ -739,14 +750,6 @@ const llvm::cl::opt<bool> Options::TBHCAllReuse(
 );
 
 
-// TypeAnalysis.cpp
-const llvm::cl::opt<bool> Options::GenICFG(
-    "gen-icfg",
-    llvm::cl::init(true),
-    llvm::cl::desc("Generate ICFG graph")
-);
-
-
 //WPAPass.cpp
 const llvm::cl::opt<bool> Options::AnderSVFG(
     "svfg",

package/lib/WPA/TypeAnalysis.cpp

@@ -46,7 +46,7 @@ using namespace std;
 void TypeAnalysis::initialize()
 {
     AndersenBase::initialize();
-    if (Options::GenICFG)
+    if (Options::DumpICFG)
     {
         icfg = SVFIR::getPAG()->getICFG();
         icfg->dump("icfg_initial");

package/package.json

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