svf-tools 1.0.995 → 1.0.997

package/svf/lib/AE/Svfexe/AbsExtAPI.cpp

@@ -41,11 +41,11 @@ void AbsExtAPI::initExtFunMap()
         auto sse_##FUNC_NAME = [this](const CallICFGNode *callNode) { \
         /* run real ext function */            \
         AbstractState& as = getAbsStateFromTrace(callNode); \
-        u32_t rhs_id = svfir->getValueNode(callNode->getArgument(0)); \
+        u32_t rhs_id = callNode->getArgument(0)->getId(); \
         if (!as.inVarToValTable(rhs_id)) return; \
         u32_t rhs = as[rhs_id].getInterval().lb().getIntNumeral(); \
         s32_t res = FUNC_NAME(rhs);            \
-        u32_t lhsId = svfir->getValueNode(callNode->getCallSite());               \
+        u32_t lhsId = callNode->getRetICFGNode()->getActualRet()->getId();               \
         as[lhsId] = IntervalValue(res);           \
         return; \
     };                                                                         \
@@ -73,7 +73,7 @@ void AbsExtAPI::initExtFunMap()
     auto sse_svf_assert = [this](const CallICFGNode* callNode)
     {
         AbstractInterpretation::getAEInstance().checkpoints.erase(callNode);
-        u32_t arg0 = svfir->getValueNode(callNode->getArgument(0));
+        u32_t arg0 = callNode->getArgument(0)->getId();
         AbstractState&as = getAbsStateFromTrace(callNode);
         if (as[arg0].getInterval().equals(IntervalValue(1, 1)))
         {
@@ -90,8 +90,8 @@ void AbsExtAPI::initExtFunMap()
 
     auto svf_assert_eq = [this](const CallICFGNode* callNode)
     {
-        u32_t arg0 = svfir->getValueNode(callNode->getArgument(0));
-        u32_t arg1 = svfir->getValueNode(callNode->getArgument(1));
+        u32_t arg0 = callNode->getArgument(0)->getId();
+        u32_t arg1 = callNode->getArgument(1)->getId();
         AbstractState&as = getAbsStateFromTrace(callNode);
         if (as[arg0].getInterval().equals(as[arg1].getInterval()))
         {
@@ -110,8 +110,8 @@ void AbsExtAPI::initExtFunMap()
     {
         if (callNode->arg_size() < 2) return;
         AbstractState&as = getAbsStateFromTrace(callNode);
-        u32_t num_id = svfir->getValueNode(callNode->getArgument(0));
-        std::string text = strRead(as, getSVFVar(callNode->getArgument(1)));
+        u32_t num_id = callNode->getArgument(0)->getId();
+        std::string text = strRead(as, callNode->getArgument(1));
         assert(as.inVarToValTable(num_id) && "print() should pass integer");
         IntervalValue itv = as[num_id].getInterval();
         std::cout << "Text: " << text <<", Value: " << callNode->getArgument(0)->toString()
@@ -124,14 +124,14 @@ void AbsExtAPI::initExtFunMap()
     {
         if (callNode->arg_size() < 2) return;
         AbstractState&as = getAbsStateFromTrace(callNode);
-        AbstractValue& num = as[svfir->getValueNode(callNode->getArgument(0))];
-        AbstractValue& lb = as[svfir->getValueNode(callNode->getArgument(1))];
-        AbstractValue& ub = as[svfir->getValueNode(callNode->getArgument(2))];
+        AbstractValue& num = as[callNode->getArgument(0)->getId()];
+        AbstractValue& lb = as[callNode->getArgument(1)->getId()];
+        AbstractValue& ub = as[callNode->getArgument(2)->getId()];
         assert(lb.getInterval().is_numeral() && ub.getInterval().is_numeral());
         num.getInterval().set_to_top();
         num.getInterval().meet_with(IntervalValue(lb.getInterval().lb(), ub.getInterval().ub()));
         const ICFGNode* node = SVFUtil::cast<ICFGNode>(
-                                   SVFUtil::cast<ValVar>(callNode->getArgumentVar(0))->getGNode());
+                                   SVFUtil::cast<ValVar>(callNode->getArgument(0))->getGNode());
         for (const SVFStmt* stmt: node->getSVFStmts())
         {
             if (SVFUtil::isa<LoadStmt>(stmt))
@@ -151,7 +151,7 @@ void AbsExtAPI::initExtFunMap()
         //scanf("%d", &data);
         if (callNode->arg_size() < 2) return;
 
-        u32_t dst_id = svfir->getValueNode(callNode->getArgument(1));
+        u32_t dst_id = callNode->getArgument(1)->getId();
         if (!as.inVarToAddrsTable(dst_id))
         {
             return;
@@ -172,7 +172,7 @@ void AbsExtAPI::initExtFunMap()
         //fscanf(stdin, "%d", &data);
         if (callNode->arg_size() < 3) return;
         AbstractState& as = getAbsStateFromTrace(callNode);
-        u32_t dst_id = svfir->getValueNode(callNode->getArgument(2));
+        u32_t dst_id = callNode->getArgument(2)->getId();
         if (!as.inVarToAddrsTable(dst_id))
         {
         }
@@ -201,8 +201,8 @@ void AbsExtAPI::initExtFunMap()
     {
         if (callNode->arg_size() < 3) return;
         AbstractState&as = getAbsStateFromTrace(callNode);
-        u32_t block_count_id = svfir->getValueNode(callNode->getArgument(2));
-        u32_t block_size_id = svfir->getValueNode(callNode->getArgument(1));
+        u32_t block_count_id = callNode->getArgument(2)->getId();
+        u32_t block_size_id = callNode->getArgument(1)->getId();
         IntervalValue block_count = as[block_count_id].getInterval();
         IntervalValue block_size = as[block_size_id].getInterval();
         IntervalValue block_byte = block_count * block_size;
@@ -218,17 +218,18 @@ void AbsExtAPI::initExtFunMap()
     {
         if (callNode->arg_size() < 2) return;
         AbstractState&as = getAbsStateFromTrace(callNode);
-        u32_t size_id = svfir->getValueNode(callNode->getArgument(1));
-        u32_t dst_id = svfir->getValueNode(callNode->getArgument(0));
+        u32_t size_id = callNode->getArgument(1)->getId();
+        u32_t dst_id = callNode->getArgument(0)->getId();
         // get elem size of arg2
         u32_t elemSize = 1;
         if (callNode->getArgument(2)->getType()->isArrayTy())
         {
-            elemSize = SVFUtil::dyn_cast<SVFArrayType>(callNode->getArgument(2)->getType())->getTypeOfElement()->getByteSize();
+            elemSize = SVFUtil::dyn_cast<SVFArrayType>(
+                           callNode->getArgument(2)->getType())->getTypeOfElement()->getByteSize();
         }
         else if (callNode->getArgument(2)->getType()->isPointerTy())
         {
-            elemSize = as.getPointeeElement(svfir->getValueNode(callNode->getArgument(2)))->getByteSize();
+            elemSize = as.getPointeeElement(callNode->getArgument(2)->getId())->getByteSize();
         }
         else
         {
@@ -258,7 +259,7 @@ void AbsExtAPI::initExtFunMap()
         // num: int, ch: char*, 10 is decimal
         if (callNode->arg_size() < 3) return;
         AbstractState&as = getAbsStateFromTrace(callNode);
-        u32_t num_id = svfir->getValueNode(callNode->getArgument(0));
+        u32_t num_id = callNode->getArgument(0)->getId();
 
         u32_t num = (u32_t) as[num_id].getInterval().getNumeral();
         std::string snum = std::to_string(num);
@@ -270,10 +271,10 @@ void AbsExtAPI::initExtFunMap()
     {
         // check the arg size
         if (callNode->arg_size() < 1) return;
-        const SVFValue* strValue = callNode->getArgument(0);
+        const SVFVar* strValue = callNode->getArgument(0);
         AbstractState& as = getAbsStateFromTrace(callNode);
-        NodeID value_id = svfir->getValueNode(strValue);
-        u32_t lhsId = svfir->getValueNode(callNode->getCallSite());
+        NodeID value_id = strValue->getId();
+        u32_t lhsId = callNode->getRetICFGNode()->getActualRet()->getId();
         u32_t dst_size = 0;
         for (const auto& addr : as[value_id].getAddrs())
         {
@@ -295,7 +296,7 @@ void AbsExtAPI::initExtFunMap()
             }
         }
         u32_t len = 0;
-        NodeID dstid = svfir->getValueNode(strValue);
+        NodeID dstid = strValue->getId();
         if (as.inVarToAddrsTable(dstid))
         {
             for (u32_t index = 0; index < dst_size; index++)
@@ -331,9 +332,9 @@ void AbsExtAPI::initExtFunMap()
         // recv(sockfd, buf, len, flags);
         if (callNode->arg_size() < 4) return;
         AbstractState&as = getAbsStateFromTrace(callNode);
-        u32_t len_id = svfir->getValueNode(callNode->getArgument(2));
+        u32_t len_id = callNode->getArgument(2)->getId();
         IntervalValue len = as[len_id].getInterval() - IntervalValue(1);
-        u32_t lhsId = svfir->getValueNode(callNode->getCallSite());
+        u32_t lhsId = callNode->getRetICFGNode()->getActualRet()->getId();
         as[lhsId] = len;
     };
     func_map["recv"] = sse_recv;
@@ -409,14 +410,17 @@ void AbsExtAPI::handleExtAPI(const CallICFGNode *call)
         }
         else
         {
-            u32_t lhsId = svfir->getValueNode(call->getCallSite());
-            if (as.inVarToAddrsTable(lhsId))
+            if (const SVFVar* ret = call->getRetICFGNode()->getActualRet())
             {
+                u32_t lhsId = ret->getId();
+                if (as.inVarToAddrsTable(lhsId))
+                {
 
-            }
-            else
-            {
-                as[lhsId] = IntervalValue();
+                }
+                else
+                {
+                    as[lhsId] = IntervalValue();
+                }
             }
             return;
         }
@@ -424,16 +428,16 @@ void AbsExtAPI::handleExtAPI(const CallICFGNode *call)
     // 1. memcpy functions like memcpy_chk, strncpy, annotate("MEMCPY"), annotate("BUF_CHECK:Arg0, Arg2"), annotate("BUF_CHECK:Arg1, Arg2")
     else if (extType == MEMCPY)
     {
-        IntervalValue len = as[svfir->getValueNode(call->getArgument(2))].getInterval();
-        svfir->getGNode(svfir->getValueNode(call->getArgument(0)));
-        handleMemcpy(as, getSVFVar(call->getArgument(0)), getSVFVar(call->getArgument(1)), len, 0);
+        IntervalValue len = as[call->getArgument(2)->getId()].getInterval();
+        svfir->getGNode(call->getArgument(0)->getId());
+        handleMemcpy(as, call->getArgument(0), call->getArgument(1), len, 0);
     }
     else if (extType == MEMSET)
     {
         // memset dst is arg0, elem is arg1, size is arg2
-        IntervalValue len = as[svfir->getValueNode(call->getArgument(2))].getInterval();
-        IntervalValue elem = as[svfir->getValueNode(call->getArgument(1))].getInterval();
-        handleMemset(as, getSVFVar(call->getArgument(0)), elem, len);
+        IntervalValue len = as[call->getArgument(2)->getId()].getInterval();
+        IntervalValue elem = as[call->getArgument(1)->getId()].getInterval();
+        handleMemset(as, call->getArgument(0), elem, len);
     }
     else if (extType == STRCPY)
     {
@@ -455,8 +459,8 @@ void AbsExtAPI::handleStrcpy(const CallICFGNode *call)
     // strcpy, __strcpy_chk, stpcpy , wcscpy, __wcscpy_chk
     // get the dst and src
     AbstractState& as = getAbsStateFromTrace(call);
-    const SVFVar* arg0Val = getSVFVar(call->getArgument(0));
-    const SVFVar* arg1Val = getSVFVar(call->getArgument(1));
+    const SVFVar* arg0Val = call->getArgument(0);
+    const SVFVar* arg1Val = call->getArgument(1);
     IntervalValue strLen = getStrlen(as, arg1Val);
     // no need to -1, since it has \0 as the last byte
     handleMemcpy(as, arg0Val, arg1Val, strLen, strLen.lb().getIntNumeral());
@@ -548,8 +552,8 @@ void AbsExtAPI::handleStrcat(const SVF::CallICFGNode *call)
     const std::vector<std::string> strncatGroup = {"__strncat_chk", "strncat", "__wcsncat_chk", "wcsncat"};
     if (std::find(strcatGroup.begin(), strcatGroup.end(), fun->getName()) != strcatGroup.end())
     {
-        const SVFVar* arg0Val = getSVFVar(call->getArgument(0));
-        const SVFVar* arg1Val = getSVFVar(call->getArgument(1));
+        const SVFVar* arg0Val = call->getArgument(0);
+        const SVFVar* arg1Val = call->getArgument(1);
         IntervalValue strLen0 = getStrlen(as, arg0Val);
         IntervalValue strLen1 = getStrlen(as, arg1Val);
         IntervalValue totalLen = strLen0 + strLen1;
@@ -558,9 +562,9 @@ void AbsExtAPI::handleStrcat(const SVF::CallICFGNode *call)
     }
     else if (std::find(strncatGroup.begin(), strncatGroup.end(), fun->getName()) != strncatGroup.end())
     {
-        const SVFVar* arg0Val = getSVFVar(call->getArgument(0));
-        const SVFVar* arg1Val = getSVFVar(call->getArgument(1));
-        const SVFVar* arg2Val = getSVFVar(call->getArgument(2));
+        const SVFVar* arg0Val = call->getArgument(0);
+        const SVFVar* arg1Val = call->getArgument(1);
+        const SVFVar* arg2Val = call->getArgument(2);
         IntervalValue arg2Num = as[arg2Val->getId()].getInterval();
         IntervalValue strLen0 = getStrlen(as, arg0Val);
         IntervalValue totalLen = strLen0 + arg2Num;

package/svf/lib/CFL/CFLAlias.cpp

@@ -155,7 +155,7 @@ void CFLAlias::heapAllocatorViaIndCall(const CallICFGNode* cs)
     else
     {
         NodeID valNode = svfir->addDummyValNode();
-        NodeID objNode = svfir->addDummyObjNode(cs->getCallSite()->getType());
+        NodeID objNode = svfir->addDummyObjNode(cs->getType());
         callsite2DummyValPN.insert(std::make_pair(cs,valNode));
         graph->addCFLNode(valNode, new CFLNode(valNode));
         graph->addCFLNode(objNode, new CFLNode(objNode));

package/svf/lib/DDA/DDAClient.cpp

@@ -145,8 +145,8 @@ void FunptrDDAClient::performStat(PointerAnalysis* pta)
 
         ++morePreciseCallsites;
         outs() << "============more precise callsite =================\n";
-        outs() << (nIter->second)->getCallSite()->toString() << "\n";
-        outs() << (nIter->second)->getCallSite()->getSourceLoc() << "\n";
+        outs() << (nIter->second)->toString() << "\n";
+        outs() << (nIter->second)->getSourceLoc() << "\n";
         outs() << "\n";
         outs() << "------ander pts or vtable num---(" << anderPts.count()  << ")--\n";
         outs() << "------DDA vfn num---(" << ander_vfns.size() << ")--\n";

package/svf/lib/Graphs/CHG.cpp

@@ -30,6 +30,7 @@
 #include "Graphs/CHG.h"
 #include "Util/SVFUtil.h"
 #include "Graphs/ICFG.h"
+#include "SVFIR/SVFIR.h"
 
 using namespace SVF;
 using namespace SVFUtil;
@@ -49,7 +50,7 @@ static bool hasEdge(const CHNode *src, const CHNode *dst,
     return false;
 }
 
-static bool checkArgTypes(const SVFCallInst* cs, const SVFFunction* fn)
+static bool checkArgTypes(const CallICFGNode* cs, const SVFFunction* fn)
 {
 
     // here we skip the first argument (i.e., this pointer)
@@ -58,7 +59,7 @@ static bool checkArgTypes(const SVFCallInst* cs, const SVFFunction* fn)
     {
         for (unsigned i = 1; i < arg_size; i++)
         {
-            auto cs_arg = cs->getArgOperand(i);
+            auto cs_arg = cs->getArgument(i);
             auto fn_arg = fn->getArg(i);
             if (cs_arg->getType() != fn_arg->getType())
             {
@@ -72,24 +73,24 @@ static bool checkArgTypes(const SVFCallInst* cs, const SVFFunction* fn)
 
 bool CHGraph::csHasVtblsBasedonCHA(const CallICFGNode* cs)
 {
-    CallSiteToVTableSetMap::const_iterator it = csToCHAVtblsMap.find(cs->getCallSite());
-    return it != csToCHAVtblsMap.end();
+    CallNodeToVTableSetMap::const_iterator it = callNodeToCHAVtblsMap.find(cs);
+    return it != callNodeToCHAVtblsMap.end();
 }
 bool CHGraph::csHasVFnsBasedonCHA(const CallICFGNode* cs)
 {
-    CallSiteToVFunSetMap::const_iterator it = csToCHAVFnsMap.find(cs->getCallSite());
-    return it != csToCHAVFnsMap.end();
+    CallNodeToVFunSetMap::const_iterator it = callNodeToCHAVFnsMap.find(cs);
+    return it != callNodeToCHAVFnsMap.end();
 }
 const VTableSet& CHGraph::getCSVtblsBasedonCHA(const CallICFGNode* cs)
 {
-    CallSiteToVTableSetMap::const_iterator it = csToCHAVtblsMap.find(cs->getCallSite());
-    assert(it != csToCHAVtblsMap.end() && "cs does not have vtabls based on CHA.");
+    CallNodeToVTableSetMap::const_iterator it = callNodeToCHAVtblsMap.find(cs);
+    assert(it != callNodeToCHAVtblsMap.end() && "cs does not have vtabls based on CHA.");
     return it->second;
 }
 const VFunSet& CHGraph::getCSVFsBasedonCHA(const CallICFGNode* cs)
 {
-    CallSiteToVFunSetMap::const_iterator it = csToCHAVFnsMap.find(cs->getCallSite());
-    assert(it != csToCHAVFnsMap.end() && "cs does not have vfns based on CHA.");
+    CallNodeToVFunSetMap::const_iterator it = callNodeToCHAVFnsMap.find(cs);
+    assert(it != callNodeToCHAVFnsMap.end() && "cs does not have vfns based on CHA.");
     return it->second;
 }
 
@@ -120,13 +121,12 @@ CHNode *CHGraph::getNode(const string name) const
  * Get virtual functions for callsite "cs" based on vtbls (calculated
  * based on pointsto set)
  */
-void CHGraph::getVFnsFromVtbls(const SVFCallInst* callsite, const VTableSet &vtbls, VFunSet &virtualFunctions)
+void CHGraph::getVFnsFromVtbls(const CallICFGNode* callsite, const VTableSet &vtbls, VFunSet &virtualFunctions)
 {
-    const SVFVirtualCallInst* cs = SVFUtil::cast<SVFVirtualCallInst>(callsite);
     /// get target virtual functions
-    size_t idx = cs->getFunIdxInVtable();
+    size_t idx = callsite->getFunIdxInVtable();
     /// get the function name of the virtual callsite
-    string funName = cs->getFunNameOfVirtualCall();
+    string funName = callsite->getFunNameOfVirtualCall();
     for (const SVFGlobalValue *vt : vtbls)
     {
         const CHNode *child = getNode(vt->getName());
@@ -138,13 +138,13 @@ void CHGraph::getVFnsFromVtbls(const SVFCallInst* callsite, const VTableSet &vtb
                 feit = vfns.end(); fit != feit; ++fit)
         {
             const SVFFunction* callee = *fit;
-            if (cs->arg_size() == callee->arg_size() ||
-                    (cs->isVarArg() && callee->isVarArg()))
+            if (callsite->arg_size() == callee->arg_size() ||
+                    (callsite->isVarArg() && callee->isVarArg()))
             {
 
                 // if argument types do not match
                 // skip this one
-                if (!checkArgTypes(cs, callee))
+                if (!checkArgTypes(callsite, callee))
                     continue;
 
                 string calleeName = callee->getName();

package/svf/lib/Graphs/CallGraph.cpp

@@ -32,6 +32,7 @@
 #include "SVFIR/SVFModule.h"
 #include "Util/SVFUtil.h"
 #include "Graphs/CallGraph.h"
+#include "SVFIR/SVFIR.h"
 
 using namespace SVF;
 using namespace SVFUtil;
@@ -51,7 +52,7 @@ void CallGraphEdge::addDirectCallSite(const CallICFGNode* call)
 
 void CallGraphEdge::addInDirectCallSite(const CallICFGNode* call)
 {
-    assert((nullptr == call->getCalledFunction() || nullptr == SVFUtil::dyn_cast<SVFFunction> (SVFUtil::getForkedFun(call))) && "not an indirect callsite??");
+    assert((nullptr == call->getCalledFunction() || nullptr == SVFUtil::dyn_cast<SVFFunction> (SVFUtil::getForkedFun(call)->getValue())) && "not an indirect callsite??");
     indirectCalls.insert(call);
 }
 //@}

package/svf/lib/Graphs/ICFG.cpp

@@ -87,11 +87,11 @@ const std::string IntraICFGNode::toString() const
     std::string str;
     std::stringstream rawstr(str);
     rawstr << "IntraICFGNode" << getId();
-    rawstr << " {fun: " << getFun()->getName() << getInst()->getSourceLoc() << "}";
+    rawstr << " {fun: " << getFun()->getName() << getSourceLoc() << "}";
     for (const SVFStmt *stmt : getSVFStmts())
         rawstr << "\n" << stmt->toString();
     if(getSVFStmts().empty())
-        rawstr << "\n" << getInst()->toString();
+        rawstr << "\n" << SVFBaseNode::toString();
     return rawstr.str();
 }
 
@@ -120,7 +120,7 @@ const std::string FunExitICFGNode::toString() const
     // ensure the enclosing function has exit basic block
     if (!isExtCall(fun) && fun->hasReturn())
         if(const IntraICFGNode* intraICFGNode = dyn_cast<IntraICFGNode>(fun->getExitBB()->front()))
-            rawstr << intraICFGNode->getInst()->getSourceLoc();
+            rawstr << intraICFGNode->getSourceLoc();
     rawstr << "}";
     for (const SVFStmt *stmt : getSVFStmts())
         rawstr << "\n" << stmt->toString();
@@ -133,11 +133,11 @@ const std::string CallICFGNode::toString() const
     std::string str;
     std::stringstream rawstr(str);
     rawstr << "CallICFGNode" << getId();
-    rawstr << " {fun: " << getFun()->getName() << getCallSite()->getSourceLoc() << "}";
+    rawstr << " {fun: " << getFun()->getName() << ICFGNode::getSourceLoc() << "}";
     for (const SVFStmt *stmt : getSVFStmts())
         rawstr << "\n" << stmt->toString();
-    if(getSVFStmts().empty() && cs)
-        rawstr << "\n" << cs->toString();
+    if(getSVFStmts().empty())
+        rawstr << "\n" << SVFBaseNode::toString();
     return rawstr.str();
 }
 
@@ -146,11 +146,11 @@ const std::string RetICFGNode::toString() const
     std::string str;
     std::stringstream rawstr(str);
     rawstr << "RetICFGNode" << getId();
-    rawstr << " {fun: " << getFun()->getName() << getCallSite()->getSourceLoc() << "}";
+    rawstr << " {fun: " << getFun()->getName() << ICFGNode::getSourceLoc() << "}";
     for (const SVFStmt *stmt : getSVFStmts())
         rawstr << "\n" << stmt->toString();
-    if(getSVFStmts().empty() && cs)
-        rawstr << "\n" << cs->toString();
+    if(getSVFStmts().empty())
+        rawstr << "\n" << SVFBaseNode::toString();
     return rawstr.str();
 }
 

package/svf/lib/Graphs/SVFG.cpp

@@ -79,10 +79,10 @@ const std::string ActualINSVFGNode::toString() const
 {
     std::string str;
     std::stringstream rawstr(str);
-    rawstr << "ActualINSVFGNode ID: " << getId() << " at callsite: " <<  getCallSite()->getCallSite()->toString() << " {fun: " << getFun()->getName() << "}";
+    rawstr << "ActualINSVFGNode ID: " << getId() << " at callsite: " <<  (getCallSite())->toString() << " {fun: " << getFun()->getName() << "}";
     rawstr << "CSMU(" << getMRVer()->getMR()->getMRID() << "V_" << getMRVer()->getSSAVersion() << ")\n";
     rawstr << getMRVer()->getMR()->dumpStr() << "\n";
-    rawstr << "CS[" << getCallSite()->getCallSite()->getSourceLoc() << "]";
+    rawstr << "CS[" << getCallSite()->getSourceLoc() << "]";
     return rawstr.str();
 }
 
@@ -90,11 +90,11 @@ const std::string ActualOUTSVFGNode::toString() const
 {
     std::string str;
     std::stringstream rawstr(str);
-    rawstr << "ActualOUTSVFGNode ID: " << getId() << " at callsite: " <<  getCallSite()->getCallSite()->toString() << " {fun: " << getFun()->getName() << "}";
+    rawstr << "ActualOUTSVFGNode ID: " << getId() << " at callsite: " <<  (getCallSite())->toString() << " {fun: " << getFun()->getName() << "}";
     rawstr <<  getMRVer()->getMR()->getMRID() << "V_" << getMRVer()->getSSAVersion() <<
            " = CSCHI(MR_" << getMRVer()->getMR()->getMRID() << "V_" << getMRVer()->getSSAVersion() << ")\n";
     rawstr << getMRVer()->getMR()->dumpStr() << "\n";
-    rawstr << "CS[" << getCallSite()->getCallSite()->getSourceLoc() << "]" ;
+    rawstr << "CS[" << getCallSite()->getSourceLoc() << "]" ;
     return rawstr.str();
 }
 
@@ -114,7 +114,7 @@ const std::string MSSAPHISVFGNode::toString() const
     if (const IntraICFGNode* intraNode =
                 dyn_cast<IntraICFGNode>(getICFGNode()->getBB()->back()))
     {
-        rawstr << intraNode->getInst()->getSourceLoc();
+        rawstr << intraNode->getSourceLoc();
     }
     return rawstr.str();
 }
@@ -142,7 +142,7 @@ const std::string InterMSSAPHISVFGNode::toString() const
     if(isFormalINPHI())
         rawstr << "FormalINPHISVFGNode ID: " << getId() << " {fun: " << getFun()->getName() << "}";
     else
-        rawstr << "ActualOUTPHISVFGNode ID: " << getId() << " at callsite: " <<  getCallSite()->getCallSite()->toString() << " {fun: " << getFun()->getName() << "}";
+        rawstr << "ActualOUTPHISVFGNode ID: " << getId() << " at callsite: " <<  (getCallSite())->toString() << " {fun: " << getFun()->getName() << "}";
     rawstr << MSSAPHISVFGNode::toString();
     return rawstr.str();
 }

package/svf/lib/Graphs/ThreadCallGraph.cpp

@@ -72,11 +72,11 @@ void ThreadCallGraph::updateCallGraph(PointerAnalysis* pta)
     // Fork sites
     for (CallSiteSet::const_iterator it = forksitesBegin(), eit = forksitesEnd(); it != eit; ++it)
     {
-        const SVFValue* forkedval = tdAPI->getForkedFun(*it);
-        if(SVFUtil::dyn_cast<SVFFunction>(forkedval)==nullptr)
+        const SVFVar* forkedval = tdAPI->getForkedFun(*it);
+        if(SVFUtil::dyn_cast<SVFFunction>(forkedval->getValue())==nullptr)
         {
             SVFIR* pag = pta->getPAG();
-            const NodeBS targets = pta->getPts(pag->getValueNode(forkedval)).toNodeBS();
+            const NodeBS targets = pta->getPts(forkedval->getId()).toNodeBS();
             for (NodeBS::iterator ii = targets.begin(), ie = targets.end(); ii != ie; ii++)
             {
                 if(ObjVar* objPN = SVFUtil::dyn_cast<ObjVar>(pag->getGNode(*ii)))
@@ -102,13 +102,13 @@ void ThreadCallGraph::updateJoinEdge(PointerAnalysis* pta)
 
     for (CallSiteSet::const_iterator it = joinsitesBegin(), eit = joinsitesEnd(); it != eit; ++it)
     {
-        const SVFValue* jointhread = tdAPI->getJoinedThread(*it);
+        const SVFVar* jointhread = tdAPI->getJoinedThread(*it);
         // find its corresponding fork sites first
         CallSiteSet forkset;
         for (CallSiteSet::const_iterator it = forksitesBegin(), eit = forksitesEnd(); it != eit; ++it)
         {
-            const SVFValue* forkthread = tdAPI->getForkedThread(*it);
-            if (pta->alias(jointhread, forkthread))
+            const SVFVar* forkthread = tdAPI->getForkedThread(*it);
+            if (pta->alias(jointhread->getId(), forkthread->getId()))
             {
                 forkset.insert(*it);
             }
@@ -125,7 +125,7 @@ bool ThreadCallGraph::addDirectForkEdge(const CallICFGNode* cs)
 {
 
     CallGraphNode* caller = getCallGraphNode(cs->getCaller());
-    const SVFFunction* forkee = SVFUtil::dyn_cast<SVFFunction>(tdAPI->getForkedFun(cs));
+    const SVFFunction* forkee = SVFUtil::dyn_cast<SVFFunction>(tdAPI->getForkedFun(cs)->getValue());
     assert(forkee && "callee does not exist");
     CallGraphNode* callee = getCallGraphNode(forkee->getDefFunForMultipleModule());
     CallSiteID csId = addCallSite(cs, callee->getFunction());
@@ -184,7 +184,7 @@ void ThreadCallGraph::addDirectJoinEdge(const CallICFGNode* cs,const CallSiteSet
     for (CallSiteSet::const_iterator it = forkset.begin(), eit = forkset.end(); it != eit; ++it)
     {
 
-        const SVFFunction* threadRoutineFun = SVFUtil::dyn_cast<SVFFunction>(tdAPI->getForkedFun(*it));
+        const SVFFunction* threadRoutineFun = SVFUtil::dyn_cast<SVFFunction>(tdAPI->getForkedFun(*it)->getValue());
         assert(threadRoutineFun && "thread routine function does not exist");
         CallGraphNode* threadRoutineFunNode = getCallGraphNode(threadRoutineFun);
         CallSiteID csId = addCallSite(cs, threadRoutineFun);

package/svf/lib/Graphs/VFG.cpp

@@ -290,7 +290,7 @@ const std::string ActualParmVFGNode::toString() const
     std::string str;
     std::stringstream rawstr(str);
     rawstr << "ActualParmVFGNode ID: " << getId() << " ";
-    rawstr << "CS[" << getCallSite()->getCallSite()->getSourceLoc() << "]";
+    rawstr << "CS[" << getCallSite()->getSourceLoc() << "]";
     rawstr << param->toString();
     return rawstr.str();
 }
@@ -324,7 +324,7 @@ const std::string ActualRetVFGNode::toString() const
     std::string str;
     std::stringstream rawstr(str);
     rawstr << "ActualRetVFGNode ID: " << getId() << " ";
-    rawstr << "CS[" << getCallSite()->getCallSite()->getSourceLoc() << "]";
+    rawstr << "CS[" << getCallSite()->getSourceLoc() << "]";
     rawstr << param->toString();
     return rawstr.str();
 }

package/svf/lib/MTA/MTAStat.cpp

@@ -49,7 +49,7 @@ void MTAStat::performThreadCallGraphStat(ThreadCallGraph* tcg)
     for (ThreadCallGraph::CallSiteSet::const_iterator it = tcg->forksitesBegin(), eit = tcg->forksitesEnd(); it != eit; ++it)
     {
         bool indirectfork = false;
-        const SVFFunction* spawnee = SVFUtil::dyn_cast<SVFFunction>(tcg->getThreadAPI()->getForkedFun(*it));
+        const SVFFunction* spawnee = SVFUtil::dyn_cast<SVFFunction>(tcg->getThreadAPI()->getForkedFun(*it)->getValue());
         if(spawnee==nullptr)
         {
             numOfIndForksite++;

package/svf/lib/MTA/TCT.cpp

@@ -108,14 +108,14 @@ bool TCT::isInRecursion(const ICFGNode* inst) const
             for(CallGraphEdge::CallInstSet::const_iterator cit = (*nit)->directCallsBegin(),
                     ecit = (*nit)->directCallsEnd(); cit!=ecit; ++cit)
             {
-                const SVFFunction* caller = (*cit)->getCallSite()->getFunction();
+                const SVFFunction* caller = (*cit)->getFun();
                 if(visits.find(caller)==visits.end())
                     worklist.push(caller);
             }
             for(CallGraphEdge::CallInstSet::const_iterator cit = (*nit)->indirectCallsBegin(),
                     ecit = (*nit)->indirectCallsEnd(); cit!=ecit; ++cit)
             {
-                const SVFFunction* caller = (*cit)->getCallSite()->getFunction();
+                const SVFFunction* caller = (*cit)->getFun();
                 if(visits.find(caller)==visits.end())
                     worklist.push(caller);
             }
@@ -499,7 +499,7 @@ void TCT::dumpCxt(CallStrCxt& cxt)
     for(CallStrCxt::const_iterator it = cxt.begin(), eit = cxt.end(); it!=eit; ++it)
     {
         rawstr << " ' "<< *it << " ' ";
-        rawstr << tcg->getCallSite(*it)->getCallSite()->toString();
+        rawstr << (tcg->getCallSite(*it))->toString();
         rawstr << "  call  " << tcg->getCallSite(*it)->getCaller()->getName() << "-->" << tcg->getCalleeOfCallSite(*it)->getName() << ", \n";
     }
     rawstr << " ]";

package/svf/lib/MemoryModel/PointerAnalysis.cpp

@@ -454,7 +454,7 @@ void PointerAnalysis::getVFnsFromPts(const CallICFGNode* cs, const PointsTo &tar
                 }
             }
         }
-        chgraph->getVFnsFromVtbls(SVFUtil::cast<SVFCallInst>(cs->getCallSite()), vtbls, vfns);
+        chgraph->getVFnsFromVtbls(cs, vtbls, vfns);
     }
 }
 
@@ -513,9 +513,9 @@ void PointerAnalysis::validateSuccessTests(std::string fun)
             {
                 assert(callNode->getNumArgOperands() == 2
                        && "arguments should be two pointers!!");
-                const SVFValue* V1 = callNode->getArgOperand(0);
-                const SVFValue* V2 = callNode->getArgOperand(1);
-                AliasResult aliasRes = alias(V1, V2);
+                const SVFVar* V1 = callNode->getArgument(0);
+                const SVFVar* V2 = callNode->getArgument(1);
+                AliasResult aliasRes = alias(V1->getId(), V2->getId());
 
                 bool checkSuccessful = false;
                 if (fun == aliasTestMayAlias || fun == aliasTestMayAliasMangled)
@@ -543,8 +543,8 @@ void PointerAnalysis::validateSuccessTests(std::string fun)
                 else
                     assert(false && "not supported alias check!!");
 
-                NodeID id1 = pag->getValueNode(V1);
-                NodeID id2 = pag->getValueNode(V2);
+                NodeID id1 = V1->getId();
+                NodeID id2 = V2->getId();
 
                 if (checkSuccessful)
                     outs() << sucMsg("\t SUCCESS :") << fun << " check <id:" << id1 << ", id:" << id2 << "> at ("
@@ -578,9 +578,9 @@ void PointerAnalysis::validateExpectedFailureTests(std::string fun)
             {
                 assert(callNode->arg_size() == 2
                        && "arguments should be two pointers!!");
-                const SVFValue* V1 = callNode->getArgOperand(0);
-                const SVFValue* V2 = callNode->getArgOperand(1);
-                AliasResult aliasRes = alias(V1, V2);
+                const SVFVar* V1 = callNode->getArgument(0);
+                const SVFVar* V2 = callNode->getArgument(1);
+                AliasResult aliasRes = alias(V1->getId(), V2->getId());
 
                 bool expectedFailure = false;
                 if (fun == aliasTestFailMayAlias || fun == aliasTestFailMayAliasMangled)
@@ -598,8 +598,8 @@ void PointerAnalysis::validateExpectedFailureTests(std::string fun)
                 else
                     assert(false && "not supported alias check!!");
 
-                NodeID id1 = pag->getValueNode(V1);
-                NodeID id2 = pag->getValueNode(V2);
+                NodeID id1 = V1->getId();
+                NodeID id2 = V2->getId();
 
                 if (expectedFailure)
                     outs() << sucMsg("\t EXPECTED-FAILURE :") << fun << " check <id:" << id1 << ", id:" << id2 << "> at ("

package/svf/lib/MemoryModel/PointerAnalysisImpl.cpp

@@ -521,7 +521,7 @@ void BVDataPTAImpl::onTheFlyThreadCallGraphSolve(const CallSiteToFunPtrMap& call
         for(CallSiteSet::const_iterator it = tdCallGraph->forksitesBegin(),
                 eit = tdCallGraph->forksitesEnd(); it != eit; ++it)
         {
-            const SVFValue* forkedVal =tdCallGraph->getThreadAPI()->getForkedFun(*it);
+            const SVFValue* forkedVal =tdCallGraph->getThreadAPI()->getForkedFun(*it)->getValue();
             if(SVFUtil::dyn_cast<SVFFunction>(forkedVal) == nullptr)
             {
                 SVFIR *pag = this->getPAG();