svf-tools 1.0.897 → 1.0.899

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

@@ -71,13 +71,13 @@ IntervalValue SVFIR2ItvExeState::getRangeLimitFromType(const SVFType* type)
         {
             if (intType->isSigned())
             {
-                ub = static_cast<s64_t>(std::numeric_limits<int16_t>::max());
-                lb = static_cast<s64_t>(std::numeric_limits<int16_t>::min());
+                ub = static_cast<s64_t>(std::numeric_limits<s16_t>::max());
+                lb = static_cast<s64_t>(std::numeric_limits<s16_t>::min());
             }
             else
             {
-                ub = static_cast<s64_t>(std::numeric_limits<uint16_t>::max());
-                lb = static_cast<s64_t>(std::numeric_limits<uint16_t>::min());
+                ub = static_cast<s64_t>(std::numeric_limits<u16_t>::max());
+                lb = static_cast<s64_t>(std::numeric_limits<u16_t>::min());
             }
         }
         else if (bits == 8)
@@ -109,6 +109,168 @@ IntervalValue SVFIR2ItvExeState::getRangeLimitFromType(const SVFType* type)
     }
 }
 
+IntervalValue SVFIR2ItvExeState::getZExtValue(const SVFVar* var)
+{
+    const SVFType* type = var->getType();
+    if (SVFUtil::isa<SVFIntegerType>(type))
+    {
+        u32_t bits = type->getByteSize() * 8;
+        if (_es[var->getId()].is_numeral())
+        {
+            if (bits == 8)
+            {
+                int8_t signed_i8_value = _es[var->getId()].getIntNumeral();
+                u32_t unsigned_value = static_cast<uint8_t>(signed_i8_value);
+                return IntervalValue(unsigned_value, unsigned_value);
+            }
+            else if (bits == 16)
+            {
+                s16_t signed_i16_value = _es[var->getId()].getIntNumeral();
+                u32_t unsigned_value = static_cast<u16_t>(signed_i16_value);
+                return IntervalValue(unsigned_value, unsigned_value);
+            }
+            else if (bits == 32)
+            {
+                s32_t signed_i32_value = _es[var->getId()].getIntNumeral();
+                u32_t unsigned_value = static_cast<u32_t>(signed_i32_value);
+                return IntervalValue(unsigned_value, unsigned_value);
+            }
+            else if (bits == 64)
+            {
+                s64_t signed_i64_value = _es[var->getId()].getIntNumeral();
+                return IntervalValue((s64_t)signed_i64_value, (s64_t)signed_i64_value);
+                // we only support i64 at most
+            }
+            else
+            {
+                assert(false && "cannot support int type other than u8/16/32/64");
+            }
+        }
+        else
+        {
+            return IntervalValue::top(); // TODO: may have better solution
+        }
+    }
+    assert(false && "cannot support non-integer type");
+}
+
+IntervalValue SVFIR2ItvExeState::getSExtValue(const SVFVar* var)
+{
+    return _es[var->getId()];
+}
+
+IntervalValue SVFIR2ItvExeState::getFPToSIntValue(const SVF::SVFVar* var)
+{
+    if (_es[var->getId()].is_real())
+    {
+        // get the float value of ub and lb
+        double float_lb = _es[var->getId()].lb().getRealNumeral();
+        double float_ub = _es[var->getId()].ub().getRealNumeral();
+        // get the int value of ub and lb
+        s64_t int_lb = static_cast<s64_t>(float_lb);
+        s64_t int_ub = static_cast<s64_t>(float_ub);
+        return IntervalValue(int_lb, int_ub);
+    }
+    else
+    {
+        return getSExtValue(var);
+    }
+}
+
+IntervalValue SVFIR2ItvExeState::getFPToUIntValue(const SVF::SVFVar* var)
+{
+    if (_es[var->getId()].is_real())
+    {
+        // get the float value of ub and lb
+        double float_lb = _es[var->getId()].lb().getRealNumeral();
+        double float_ub = _es[var->getId()].ub().getRealNumeral();
+        // get the int value of ub and lb
+        u64_t int_lb = static_cast<u64_t>(float_lb);
+        u64_t int_ub = static_cast<u64_t>(float_ub);
+        return IntervalValue(int_lb, int_ub);
+    }
+    else
+    {
+        return getZExtValue(var);
+    }
+}
+
+IntervalValue SVFIR2ItvExeState::getSIntToFPValue(const SVF::SVFVar* var)
+{
+    // get the sint value of ub and lb
+    s64_t sint_lb = _es[var->getId()].lb().getIntNumeral();
+    s64_t sint_ub = _es[var->getId()].ub().getIntNumeral();
+    // get the float value of ub and lb
+    double float_lb = static_cast<double>(sint_lb);
+    double float_ub = static_cast<double>(sint_ub);
+    return IntervalValue(float_lb, float_ub);
+}
+
+IntervalValue SVFIR2ItvExeState::getUIntToFPValue(const SVF::SVFVar* var)
+{
+    // get the uint value of ub and lb
+    u64_t uint_lb = _es[var->getId()].lb().getIntNumeral();
+    u64_t uint_ub = _es[var->getId()].ub().getIntNumeral();
+    // get the float value of ub and lb
+    double float_lb = static_cast<double>(uint_lb);
+    double float_ub = static_cast<double>(uint_ub);
+    return IntervalValue(float_lb, float_ub);
+}
+
+IntervalValue SVFIR2ItvExeState::getTruncValue(const SVF::SVFVar* var, const SVFType* dstType)
+{
+    // get the value of ub and lb
+    s64_t int_lb = _es[var->getId()].lb().getIntNumeral();
+    s64_t int_ub = _es[var->getId()].ub().getIntNumeral();
+    // get dst type
+    u32_t dst_bits = dstType->getByteSize() * 8;
+    if (dst_bits == 8)
+    {
+        // get the signed value of ub and lb
+        int8_t s8_lb = static_cast<int8_t>(int_lb);
+        int8_t s8_ub = static_cast<int8_t>(int_ub);
+        if (s8_lb > s8_ub)
+        {
+            // return range of s8
+            return IntervalValue::top();
+        }
+        return IntervalValue(s8_lb, s8_ub);
+    }
+    else if (dst_bits == 16)
+    {
+        // get the signed value of ub and lb
+        s16_t s16_lb = static_cast<s16_t>(int_lb);
+        s16_t s16_ub = static_cast<s16_t>(int_ub);
+        if (s16_lb > s16_ub)
+        {
+            // return range of s16
+            return IntervalValue::top();
+        }
+        return IntervalValue(s16_lb, s16_ub);
+    }
+    else if (dst_bits == 32)
+    {
+        // get the signed value of ub and lb
+        s32_t s32_lb = static_cast<s32_t>(int_lb);
+        s32_t s32_ub = static_cast<s32_t>(int_ub);
+        if (s32_lb > s32_ub)
+        {
+            // return range of s32
+            return IntervalValue::top();
+        }
+        return IntervalValue(s32_lb, s32_ub);
+    }
+    else
+    {
+        assert(false && "cannot support dst int type other than u8/16/32");
+    }
+}
+
+IntervalValue SVFIR2ItvExeState::getFPTruncValue(const SVF::SVFVar* var, const SVFType* dstType)
+{
+    // TODO: now we do not really handle fptrunc
+    return _es[var->getId()];
+}
 
 void SVFIR2ItvExeState::applySummary(IntervalExeState &es)
 {
@@ -236,7 +398,7 @@ SVFIR2ItvExeState::Addrs SVFIR2ItvExeState::getGepObjAddress(u32_t pointer, APOf
     Addrs ret;
     for (const auto &addr: addrs)
     {
-        int64_t baseObj = getInternalID(addr);
+        s64_t baseObj = getInternalID(addr);
         if (baseObj == 0)
         {
             ret.insert(getVirtualMemAddress(0));
@@ -310,12 +472,12 @@ IntervalValue SVFIR2ItvExeState::getByteOffset(const GepStmt *gep)
                 {
                     // if lb or ub is negative number, set 0.
                     // if lb or ub is positive number, guarantee lb/ub * elemByteSize <= MaxFieldLimit
-                    s64_t ub = (idxVal.ub().getNumeral() < 0) ? 0 :
+                    s64_t ub = (idxVal.ub().getIntNumeral() < 0) ? 0 :
                                (double)Options::MaxFieldLimit() /
-                               elemByteSize >= idxVal.ub().getNumeral() ? elemByteSize * idxVal.ub().getNumeral(): Options::MaxFieldLimit();
-                    s64_t lb = (idxVal.lb().getNumeral() < 0) ? 0 :
+                               elemByteSize >= idxVal.ub().getIntNumeral() ? elemByteSize * idxVal.ub().getIntNumeral(): Options::MaxFieldLimit();
+                    s64_t lb = (idxVal.lb().getIntNumeral() < 0) ? 0 :
                                ((double)Options::MaxFieldLimit() /
-                                elemByteSize >= idxVal.lb().getNumeral()) ? elemByteSize * idxVal.lb().getNumeral() : Options::MaxFieldLimit();
+                                elemByteSize >= idxVal.lb().getIntNumeral()) ? elemByteSize * idxVal.lb().getIntNumeral() : Options::MaxFieldLimit();
                     res = res + IntervalValue(lb, ub);
                 }
             }
@@ -367,8 +529,8 @@ IntervalValue SVFIR2ItvExeState::getItvOfFlattenedElemIndex(const GepStmt *gep)
                 idxLb = idxUb = 0;
             else
             {
-                idxLb = idxItv.lb().getNumeral();
-                idxUb = idxItv.ub().getNumeral();
+                idxLb = idxItv.lb().getIntNumeral();
+                idxUb = idxItv.ub().getIntNumeral();
             }
         }
         // for pointer type, flattened index = elemNum * idx
@@ -428,7 +590,7 @@ void SVFIR2ItvExeState::initObjVar(const ObjVar *objVar, u32_t varId)
         {
             if (const SVFConstantInt *consInt = SVFUtil::dyn_cast<SVFConstantInt>(obj->getValue()))
             {
-                double numeral = (double)consInt->getSExtValue();
+                s64_t numeral = consInt->getSExtValue();
                 IntervalExeState::globalES[varId] = IntervalValue(numeral, numeral);
             }
             else if (const SVFConstantFP* consFP = SVFUtil::dyn_cast<SVFConstantFP>(obj->getValue()))
@@ -822,14 +984,46 @@ void SVFIR2ItvExeState::translateCopy(const CopyStmt *copy)
     {
         if (inVarToValTable(rhs))
         {
-            _es[lhs] = _es[rhs];
-            // if copy LHS is integerType(i8 i32 etc), value should be limited.
-            // this branch can handle bitcast from higher bits integer to
-            // lower bits integer. e.g. bitcast i32 to i8
-            if (copy->getLHSVar()->getType()->getKind() == SVFType::SVFIntegerTy)
+            if (copy->getCopyKind() == CopyStmt::COPYVAL)
+            {
+                _es[lhs] = _es[rhs];
+            }
+            else if (copy->getCopyKind() == CopyStmt::ZEXT)
+            {
+                _es[lhs] = getZExtValue(copy->getRHSVar());
+            }
+            else if (copy->getCopyKind() == CopyStmt::SEXT)
+            {
+                _es[lhs] = getSExtValue(copy->getRHSVar());
+            }
+            else if (copy->getCopyKind() == CopyStmt::FPTOSI)
+            {
+                _es[lhs] = getFPToSIntValue(copy->getRHSVar());
+            }
+            else if (copy->getCopyKind() == CopyStmt::FPTOUI)
+            {
+                _es[lhs] = getFPToUIntValue(copy->getRHSVar());
+            }
+            else if (copy->getCopyKind() == CopyStmt::SITOFP)
+            {
+                _es[lhs] = getSIntToFPValue(copy->getRHSVar());
+            }
+            else if (copy->getCopyKind() == CopyStmt::UITOFP)
+            {
+                _es[lhs] = getUIntToFPValue(copy->getRHSVar());
+            }
+            else if (copy->getCopyKind() == CopyStmt::TRUNC)
+            {
+                _es[lhs] = getTruncValue(copy->getRHSVar(), copy->getLHSVar()->getType());
+            }
+            else if (copy->getCopyKind() == CopyStmt::FPTRUNC)
+            {
+                _es[lhs] = getFPTruncValue(copy->getRHSVar(), copy->getLHSVar()->getType());
+            }
+            else
             {
-                _es[lhs].meet_with(
-                    getRangeLimitFromType(copy->getLHSVar()->getType()));
+                assert(false && "undefined copy kind");
+                abort();
             }
         }
         else if (inVarToAddrsTable(rhs))
@@ -854,10 +1048,10 @@ void SVFIR2ItvExeState::translateGep(const GepStmt *gep)
     else
     {
         Addrs gepAddrs;
-        APOffset lb = offsetPair.lb().getNumeral() < Options::MaxFieldLimit()?
-                      offsetPair.lb().getNumeral(): Options::MaxFieldLimit();
-        APOffset ub = offsetPair.ub().getNumeral() < Options::MaxFieldLimit()?
-                      offsetPair.ub().getNumeral(): Options::MaxFieldLimit();
+        APOffset lb = offsetPair.lb().getIntNumeral() < Options::MaxFieldLimit()?
+                      offsetPair.lb().getIntNumeral(): Options::MaxFieldLimit();
+        APOffset ub = offsetPair.ub().getIntNumeral() < Options::MaxFieldLimit()?
+                      offsetPair.ub().getIntNumeral(): Options::MaxFieldLimit();
         for (APOffset i = lb; i <= ub; i++)
             gepAddrs.join_with(getGepObjAddress(rhs, i));
         if(gepAddrs.empty()) return;

package/svf/lib/SVFIR/PAGBuilderFromFile.cpp

@@ -52,10 +52,12 @@ static u32_t gepNodeNumIndex = 100000;
 9 v
 5 addr 6 0
 6 gep 7 4
-7 copy 8 0
+7 copy-ZEXT 8 0
 6 store 8 0
 8 load 9 0
  */
+// for copy stmt, the enum is COPYVAL, ZEXT, SEXT, BITCAST, TRUNC, FPTRUNC,
+//         FPTOUI, FPTOSI, UITOFP, SITOFP, INTTOPTR, PTRTOINT, UNKNOWN
 SVFIR* PAGBuilderFromFile::build()
 {
 
@@ -162,8 +164,65 @@ void PAGBuilderFromFile::addEdge(NodeID srcID, NodeID dstID,
     {
         pag->addAddrStmt(srcID, dstID);
     }
-    else if (edge == "copy")
-        pag->addCopyStmt(srcID, dstID);
+    if (edge.rfind("copy-", 0) == 0)
+    {
+        // the enum is COPYVAL, ZEXT, SEXT, BITCAST, TRUNC, FPTRUNC,
+        ////         FPTOUI, FPTOSI, UITOFP, SITOFP, INTTOPTR, PTRTOINT, UNKNOWN
+        std::string opType = edge.substr(5); // start substring from 5th char
+
+        if (opType == "COPYVAL")
+        {
+            pag->addCopyStmt(srcID, dstID, CopyStmt::COPYVAL);
+        }
+        else if (opType == "ZEXT")
+        {
+            pag->addCopyStmt(srcID, dstID, CopyStmt::ZEXT);
+        }
+        else if (opType == "SEXT")
+        {
+            pag->addCopyStmt(srcID, dstID, CopyStmt::SEXT);
+        }
+        else if (opType == "BITCAST")
+        {
+            pag->addCopyStmt(srcID, dstID, CopyStmt::BITCAST);
+        }
+        else if (opType == "TRUNC")
+        {
+            pag->addCopyStmt(srcID, dstID, CopyStmt::TRUNC);
+        }
+        else if (opType == "FPTRUNC")
+        {
+            pag->addCopyStmt(srcID, dstID, CopyStmt::FPTRUNC);
+        }
+        else if (opType == "FPTOUI")
+        {
+            pag->addCopyStmt(srcID, dstID, CopyStmt::FPTOUI);
+        }
+        else if (opType == "FPTOSI")
+        {
+            pag->addCopyStmt(srcID, dstID, CopyStmt::FPTOSI);
+        }
+        else if (opType == "UITOFP")
+        {
+            pag->addCopyStmt(srcID, dstID, CopyStmt::UITOFP);
+        }
+        else if (opType == "SITOFP")
+        {
+            pag->addCopyStmt(srcID, dstID, CopyStmt::SITOFP);
+        }
+        else if (opType == "INTTOPTR")
+        {
+            pag->addCopyStmt(srcID, dstID, CopyStmt::INTTOPTR);
+        }
+        else if (opType == "PTRTOINT")
+        {
+            pag->addCopyStmt(srcID, dstID, CopyStmt::PTRTOINT);
+        }
+        else
+        {
+            assert(false && "format not support, can not create such edge");
+        }
+    }
     else if (edge == "load")
         pag->addLoadStmt(srcID, dstID);
     else if (edge == "store")

package/svf/lib/SVFIR/SVFFileSystem.cpp

@@ -692,7 +692,9 @@ cJSON* SVFIRWriter::contentToJson(const AddrStmt* edge)
 
 cJSON* SVFIRWriter::contentToJson(const CopyStmt* edge)
 {
-    return contentToJson(static_cast<const AssignStmt*>(edge));
+    cJSON* root = contentToJson(static_cast<const AssignStmt*>(edge));
+    JSON_WRITE_FIELD(root, edge, copyKind);
+    return root;
 }
 
 cJSON* SVFIRWriter::contentToJson(const StoreStmt* edge)
@@ -2055,6 +2057,7 @@ void SVFIRReader::fill(const cJSON*& fieldJson, AddrStmt* stmt)
 void SVFIRReader::fill(const cJSON*& fieldJson, CopyStmt* stmt)
 {
     fill(fieldJson, static_cast<AssignStmt*>(stmt));
+    JSON_READ_FIELD_FWD(fieldJson, stmt, copyKind);
 }
 
 void SVFIRReader::fill(const cJSON*& fieldJson, StoreStmt* stmt)

package/svf/lib/SVFIR/SVFIR.cpp

@@ -61,7 +61,7 @@ AddrStmt* SVFIR::addAddrStmt(NodeID src, NodeID dst)
 /*!
  * Add Copy edge
  */
-CopyStmt* SVFIR::addCopyStmt(NodeID src, NodeID dst)
+CopyStmt* SVFIR::addCopyStmt(NodeID src, NodeID dst, CopyStmt::CopyKind type)
 {
     SVFVar* srcNode = getGNode(src);
     SVFVar* dstNode = getGNode(dst);
@@ -69,7 +69,7 @@ CopyStmt* SVFIR::addCopyStmt(NodeID src, NodeID dst)
         return nullptr;
     else
     {
-        CopyStmt* copyPE = new CopyStmt(srcNode, dstNode);
+        CopyStmt* copyPE = new CopyStmt(srcNode, dstNode, type);
         addToStmt2TypeMap(copyPE);
         addEdge(srcNode,dstNode, copyPE);
         return copyPE;
@@ -279,7 +279,7 @@ SVFStmt* SVFIR::addBlackHoleAddrStmt(NodeID node)
     if(Options::HandBlackHole())
         return pag->addAddrStmt(pag->getBlackHoleNode(), node);
     else
-        return pag->addCopyStmt(pag->getNullPtr(), node);
+        return pag->addCopyStmt(pag->getNullPtr(), node, CopyStmt::COPYVAL);
 }
 
 /*!

package/svf/lib/Util/Options.cpp

@@ -853,4 +853,12 @@ const Option<bool> Options::RunUncallFuncs(
     "run-uncall-fun","Skip Gep Unknown Index",false);
 const Option<bool> Options::ICFGMergeAdjacentNodes(
     "icfg-merge-adjnodes","ICFG Simplification - Merge Adjacent Nodes in the Same Basic Block.",false);
+
+
+const Option<u32_t> Options::AEPrecision(
+    "precision",
+    "symbolic abstraction precision for float",
+    0
+);
+
 } // namespace SVF.

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

@@ -358,16 +358,52 @@ protected:
         return edge;
     }
 
-    /// Add Copy edge
-    inline CopyStmt* addCopyEdge(NodeID src, NodeID dst)
+    inline CopyStmt* addCopyEdge(NodeID src, NodeID dst, CopyStmt::CopyKind kind)
     {
-        if(CopyStmt *edge = pag->addCopyStmt(src, dst))
+        if(CopyStmt *edge = pag->addCopyStmt(src, dst, kind))
         {
             setCurrentBBAndValueForPAGEdge(edge);
             return edge;
         }
         return nullptr;
     }
+
+    inline CopyStmt::CopyKind getCopyKind(const Value* val)
+    {
+        // COPYVAL, ZEXT, SEXT, BITCAST, FPTRUNC, FPTOUI, FPTOSI, UITOFP, SITOFP, INTTOPTR, PTRTOINT
+        if (const Instruction* inst = SVFUtil::dyn_cast<Instruction>(val))
+        {
+            switch (inst->getOpcode())
+            {
+            case Instruction::ZExt:
+                return CopyStmt::ZEXT;
+            case Instruction::SExt:
+                return CopyStmt::SEXT;
+            case Instruction::BitCast:
+                return CopyStmt::BITCAST;
+            case Instruction ::Trunc:
+                return CopyStmt::TRUNC;
+            case Instruction::FPTrunc:
+                return CopyStmt::FPTRUNC;
+            case Instruction::FPToUI:
+                return CopyStmt::FPTOUI;
+            case Instruction::FPToSI:
+                return CopyStmt::FPTOSI;
+            case Instruction::UIToFP:
+                return CopyStmt::UITOFP;
+            case Instruction::SIToFP:
+                return CopyStmt::SITOFP;
+            case Instruction::IntToPtr:
+                return CopyStmt::INTTOPTR;
+            case Instruction::PtrToInt:
+                return CopyStmt::PTRTOINT;
+            default:
+                return CopyStmt::COPYVAL;
+            }
+        }
+        assert (false && "Unknown cast inst!");
+    }
+
     /// Add Copy edge
     inline void addPhiStmt(NodeID res, NodeID opnd, const ICFGNode* pred)
     {

package/svf-llvm/lib/LLVMModule.cpp

@@ -1263,8 +1263,27 @@ SVFConstantData* LLVMModuleSet::getSVFConstantData(const ConstantData* cd)
         {
             double dval = 0;
             // TODO: Why only double is considered? What about float?
-            if(cfp->isNormalFP() &&  (&cfp->getValueAPF().getSemantics()== &llvm::APFloatBase::IEEEdouble()))
-                dval =  cfp->getValueAPF().convertToDouble();
+            if (cfp->isNormalFP())
+            {
+                if (&cfp->getValueAPF().getSemantics()== &llvm::APFloatBase::IEEEsingle())
+                {
+                    dval =  cfp->getValueAPF().convertToFloat();
+                }
+                else if (&cfp->getValueAPF().getSemantics()== &llvm::APFloatBase::IEEEdouble())
+                {
+                    dval =  cfp->getValueAPF().convertToDouble();
+                }
+                else
+                {
+                    assert (false && "Unsupported floating point type");
+                    abort();
+                }
+            }
+            else
+            {
+                // other cfp type, like isZero(), isInfinity(), isNegative(), etc.
+                // do nothing
+            }
             svfcd = new SVFConstantFP(getSVFType(cd->getType()), dval);
         }
         else if(SVFUtil::isa<ConstantPointerNull>(cd))

package/svf-llvm/lib/SVFIRBuilder.cpp

@@ -374,7 +374,7 @@ void SVFIRBuilder::processCE(const Value* val)
             const SVFValue* cval = getCurrentValue();
             const SVFBasicBlock* cbb = getCurrentBB();
             setCurrentLocation(castce, nullptr);
-            addCopyEdge(pag->getValueNode(LLVMModuleSet::getLLVMModuleSet()->getSVFValue(opnd)), pag->getValueNode(LLVMModuleSet::getLLVMModuleSet()->getSVFValue(castce)));
+            addCopyEdge(pag->getValueNode(LLVMModuleSet::getLLVMModuleSet()->getSVFValue(opnd)), pag->getValueNode(LLVMModuleSet::getLLVMModuleSet()->getSVFValue(castce)), CopyStmt::BITCAST);
             setCurrentLocation(cval, cbb);
         }
         else if (const ConstantExpr* selectce = isSelectConstantExpr(ref))
@@ -406,7 +406,7 @@ void SVFIRBuilder::processCE(const Value* val)
             const SVFBasicBlock* cbb = getCurrentBB();
             const SVFValue* cval = getCurrentValue();
             setCurrentLocation(ptr2Intce, nullptr);
-            addCopyEdge(pag->getValueNode(LLVMModuleSet::getLLVMModuleSet()->getSVFValue(opnd)), pag->getValueNode(LLVMModuleSet::getLLVMModuleSet()->getSVFValue(ptr2Intce)));
+            addCopyEdge(pag->getValueNode(LLVMModuleSet::getLLVMModuleSet()->getSVFValue(opnd)), pag->getValueNode(LLVMModuleSet::getLLVMModuleSet()->getSVFValue(ptr2Intce)), CopyStmt::PTRTOINT);
             setCurrentLocation(cval, cbb);
         }
         else if(isTruncConstantExpr(ref) || isCmpConstantExpr(ref))
@@ -530,7 +530,7 @@ void SVFIRBuilder::InitialGlobal(const GlobalVariable *gvar, Constant *C,
             addStoreEdge(src, field);
             /// src should not point to anything yet
             if (C->getType()->isPtrOrPtrVectorTy() && src != pag->getNullPtr())
-                addCopyEdge(pag->getNullPtr(), src);
+                addCopyEdge(pag->getNullPtr(), src, CopyStmt::COPYVAL);
         }
     }
     else if (SVFUtil::isa<ConstantArray, ConstantStruct>(C))
@@ -615,7 +615,7 @@ void SVFIRBuilder::visitGlobal(SVFModule* svfModule)
             NodeID src = pag->getValueNode(LLVMModuleSet::getLLVMModuleSet()->getSVFValue(alias->getAliasee()));
             processCE(alias->getAliasee());
             setCurrentLocation(alias, nullptr);
-            addCopyEdge(src,dst);
+            addCopyEdge(src, dst, CopyStmt::COPYVAL);
         }
     }
 }
@@ -743,7 +743,7 @@ void SVFIRBuilder::visitCastInst(CastInst &inst)
             opnd = stripAllCasts(opnd);
 
         NodeID src = getValueNode(opnd);
-        addCopyEdge(src, dst);
+        addCopyEdge(src, dst, getCopyKind(&inst));
     }
 }
 
@@ -980,7 +980,7 @@ void SVFIRBuilder::visitVAArgInst(VAArgInst &inst)
     NodeID dst = getValueNode(&inst);
     Value* opnd = inst.getPointerOperand();
     NodeID src = getValueNode(opnd);
-    addCopyEdge(src,dst);
+    addCopyEdge(src, dst, CopyStmt::COPYVAL);
 }
 
 /// <result> = freeze ty <val>
@@ -994,7 +994,7 @@ void SVFIRBuilder::visitFreezeInst(FreezeInst &inst)
     {
         Value* opnd = inst.getOperand(i);
         NodeID src = getValueNode(opnd);
-        addCopyEdge(src,dst);
+        addCopyEdge(src, dst, CopyStmt::COPYVAL);
     }
 }
 

package/svf-llvm/lib/SVFIRExtAPI.cpp

@@ -165,7 +165,7 @@ void SVFIRBuilder::handleExtCall(const CallBase* cs, const SVFFunction* svfCalle
         else
             addComplexConsForExt(cs->getArgOperand(0), cs->getArgOperand(1), nullptr);
         if(SVFUtil::isa<PointerType>(cs->getType()))
-            addCopyEdge(getValueNode(cs->getArgOperand(0)), getValueNode(cs));
+            addCopyEdge(getValueNode(cs->getArgOperand(0)), getValueNode(cs), CopyStmt::COPYVAL);
     }
     else if(isMemsetExtFun(svfCallee))
     {
@@ -184,7 +184,7 @@ void SVFIRBuilder::handleExtCall(const CallBase* cs, const SVFFunction* svfCalle
             addStoreEdge(getValueNode(cs->getArgOperand(1)),dField);
         }
         if(SVFUtil::isa<PointerType>(cs->getType()))
-            addCopyEdge(getValueNode(cs->getArgOperand(0)), getValueNode(cs));
+            addCopyEdge(getValueNode(cs->getArgOperand(0)), getValueNode(cs), CopyStmt::COPYVAL);
     }
     else if(svfCallee->getName().compare("dlsym") == 0)
     {
@@ -221,7 +221,7 @@ void SVFIRBuilder::handleExtCall(const CallBase* cs, const SVFFunction* svfCalle
         if (const Function *fn = getHookFn(src))
         {
             NodeID srcNode = getValueNode(fn);
-            addCopyEdge(srcNode,  getValueNode(cs));
+            addCopyEdge(srcNode,  getValueNode(cs), CopyStmt::COPYVAL);
         }
     }
     else if(svfCallee->getName().find("_ZSt29_Rb_tree_insert_and_rebalancebPSt18_Rb_tree_node_baseS0_RS_") != std::string::npos)