svf-lib 1.0.1644 → 1.0.1646

package/SVF-osx/svf/include/AbstractExecution/SVFIR2ItvExeState.h

@@ -73,6 +73,19 @@ public:
     /// Return the field address given a pointer points to a struct object and an offset
     VAddrs getGepObjAddress(u32_t pointer, s32_t offset);
 
+    /// Return the byte offset from one gep param offset
+    std::pair<s32_t, s32_t> getBytefromGepTypePair(const AccessPath::VarAndGepTypePair& gep_pair, const GepStmt *gep, s32_t elem_bytesize);
+
+    /// Return the Index offset from one gep param offset
+    std::pair<s32_t, s32_t> getIndexfromGepTypePair(const AccessPath::VarAndGepTypePair& gep_pair, const GepStmt *gep);
+
+    /// Return the byte offset expression of a GepStmt
+    /// elemBytesize is the element byte size of an static alloc or heap alloc array
+    /// e.g. GepStmt* gep = **,
+    /// s32_t elemBytesize = LLVMUtil::SVFType2ByteSize(gep->getRHSVar()->getValue()->getType());
+    /// std::pair<s32_t, s32_t> byteOffset = getGepByteOffset(gep, elemBytesize);
+    std::pair<s32_t, s32_t> getGepByteOffset(const GepStmt *gep, s32_t elemBytesize);
+
     /// Return the offset expression of a GepStmt
     std::pair<s32_t, s32_t> getGepOffset(const GepStmt *gep);
 

package/SVF-osx/svf/include/MemoryModel/AccessPath.h

@@ -105,6 +105,12 @@ public:
     }
     //@}
 
+    /// Return accumulated constant byte offset given OffsetVarVec and elemByteSize
+    /// elemBytesize is the element byte size of an static alloc or heap alloc array
+    /// e.g. GepStmt* gep = **,
+    /// s32_t elemBytesize = LLVMUtil::SVFType2ByteSize(gep->getRHSVar()->getValue()->getType());
+    /// APOffset byteOffset = gep->accumulateConstantByteOffset(elemBytesize);
+    APOffset computeConstantByteOffset(u32_t elemBytesize) const;
     /// Return accumulated constant offset given OffsetVarVec
     APOffset computeConstantOffset() const;
 

package/SVF-osx/svf/include/SVFIR/SVFStatements.h

@@ -499,6 +499,16 @@ public:
     {
         return getAccessPath().isConstantOffset();
     }
+    /// Return accumulated constant offset (when accessing array or struct) if this offset is a constant.
+    /// elemBytesize is the element byte size of an static alloc or heap alloc array
+    /// e.g. GepStmt* gep = **,
+    /// s32_t elemBytesize = LLVMUtil::SVFType2ByteSize(gep->getRHSVar()->getValue()->getType());
+    /// APOffset byteOffset = gep->accumulateConstantByteOffset(elemBytesize);
+    inline APOffset accumulateConstantByteOffset(u32_t elemBytesize) const
+    {
+        return getAccessPath().computeConstantByteOffset(elemBytesize);
+    }
+
     /// Return accumulated constant offset (when accessing array or struct) if this offset is a constant.
     inline APOffset accumulateConstantOffset() const
     {

package/SVF-osx/svf/include/Util/SVFUtil.h

@@ -350,14 +350,6 @@ inline bool isReallocExtFun(const SVFFunction* fun)
     return fun && (ExtAPI::getExtAPI()->is_realloc(fun));
 }
 
-/// Return true if the call is a static global call
-//@{
-/// note that this function is not suppose to be used externally
-inline bool isStaticExtFun(const SVFFunction* fun)
-{
-    return fun && ExtAPI::getExtAPI()->has_static(fun);
-}
-
 /// Program entry function e.g. main
 //@{
 /// Return true if this is a program entry function (e.g. main)
@@ -494,32 +486,6 @@ inline bool isReallocExtCall(const SVFInstruction *inst)
 }
 //@}
 
-inline bool isStaticExtCall(const CallSite cs)
-{
-    bool isPtrTy = cs.getInstruction()->getType()->isPointerTy();
-    return isPtrTy && isStaticExtFun(getCallee(cs));
-}
-
-inline bool isStaticExtCall(const SVFInstruction *inst)
-{
-    bool isPtrTy = inst->getType()->isPointerTy();
-    return isPtrTy && isStaticExtFun(getCallee(inst));
-}
-//@}
-
-/// Return true if the call is a static global call
-//@{
-inline bool isHeapAllocOrStaticExtCall(const CallSite cs)
-{
-    return isStaticExtCall(cs) || isHeapAllocExtCall(cs);
-}
-
-inline bool isHeapAllocOrStaticExtCall(const SVFInstruction *inst)
-{
-    return isStaticExtCall(inst) || isHeapAllocExtCall(inst);
-}
-//@}
-
 /// Return true if this is a thread creation call
 ///@{
 inline bool isThreadForkCall(const CallSite cs)

package/SVF-osx/svf-llvm/include/SVF-LLVM/LLVMUtil.h

@@ -141,10 +141,10 @@ inline const PointerType *getRefTypeOfHeapAllocOrStatic(const CallBase* cs)
         if (const PointerType *argType = SVFUtil::dyn_cast<PointerType>(arg->getType()))
             refType = SVFUtil::dyn_cast<PointerType>(getPtrElementType(argType));
     }
-    // Case 2: heap/static object held by return value.
+    // Case 2: heap object held by return value.
     else
     {
-        assert((SVFUtil::isStaticExtCall(svfcs) || SVFUtil::isHeapAllocExtCallViaRet(svfcs))
+        assert(SVFUtil::isHeapAllocExtCallViaRet(svfcs)
                && "Must be heap alloc via ret, or static allocation site");
         refType = SVFUtil::dyn_cast<PointerType>(cs->getType());
     }
@@ -377,6 +377,23 @@ std::vector<const Function *> getCalledFunctions(const Function *F);
 std::vector<std::string> getFunAnnotations(const Function* fun);
 void removeFunAnnotations(std::vector<Function*>& removedFuncList);
 
+inline u32_t SVFType2ByteSize(const SVFType* type)
+{
+    const llvm::Type* llvm_rhs = LLVMModuleSet::getLLVMModuleSet()->getLLVMType(type);
+    u32_t llvm_rhs_size = LLVMUtil::getTypeSizeInBytes(llvm_rhs->getPointerElementType());
+    u32_t llvm_elem_size = -1;
+    if (llvm_rhs->getPointerElementType()->isArrayTy() && llvm_rhs_size > 0)
+    {
+        size_t array_len = llvm_rhs->getPointerElementType()->getArrayNumElements();
+        llvm_elem_size = llvm_rhs_size / array_len;
+    }
+    else
+    {
+        llvm_elem_size =llvm_rhs_size;
+    }
+    return llvm_elem_size;
+}
+
 inline void removeUnusedFuncsAndAnnotations(std::vector<Function*> removedFuncList)
 {
     /// Remove unused function annotations in extapi.bc

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "svf-lib",
-  "version": "1.0.1644",
+  "version": "1.0.1646",
   "description": "SVF's npm support",
   "main": "index.js",
   "scripts": {