svf-lib 1.0.1696 → 1.0.1698

package/SVF-linux/svf/include/Graphs/CDG.h

@@ -266,7 +266,7 @@ public:
         bool added1 = edge->getDstNode()->addIncomingEdge(edge);
         bool added2 = edge->getSrcNode()->addOutgoingEdge(edge);
         assert(added1 && added2 && "edge not added??");
-        return true;
+        return added1 && added2;
     }
 
     /// Add a CDG node
@@ -438,8 +438,7 @@ struct DOTGraphTraits<SVF::CDG *> : public DOTGraphTraits<SVF::PAG *>
     template<class EdgeIter>
     static std::string getEdgeAttributes(NodeType *, EdgeIter EI, SVF::CDG *)
     {
-        SVF::CDGEdge *edge = *(EI.getCurrent());
-        assert(edge && "No edge found!!");
+        assert(*(EI.getCurrent()) && "No edge found!!");
         return "style=solid";
     }
 

package/SVF-linux/svf/include/Graphs/CFBasicBlockG.h

@@ -312,15 +312,13 @@ public:
     ///@{
     inline u32_t removeIncomingEdge(CFBasicBlockEdge *edge)
     {
-        iterator it = InEdges.find(edge);
-        assert(it != InEdges.end() && "can not find in edge in SVFG node");
+        assert(InEdges.find(edge) != InEdges.end() && "can not find in edge in SVFG node");
         return InEdges.erase(edge);
     }
 
     inline u32_t removeOutgoingEdge(CFBasicBlockEdge *edge)
     {
-        iterator it = OutEdges.find(edge);
-        assert(it != OutEdges.end() && "can not find out edge in SVFG node");
+        assert(OutEdges.find(edge) != OutEdges.end() && "can not find out edge in SVFG node");
         return OutEdges.erase(edge);
     }
     ///@}
@@ -457,7 +455,7 @@ public:
         bool added2 = edge->getSrcNode()->addOutgoingEdge(edge);
         assert(added1 && added2 && "edge not added??");
         _totalCFBasicBlockEdge++;
-        return true;
+        return added1 && added2;
     }
 
     /// Add a ICFGNodeWrapper

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

@@ -74,17 +74,17 @@ public:
     VAddrs getGepObjAddress(u32_t pointer, APOffset offset);
 
     /// Return the byte offset from one gep param offset
-    std::pair<APOffset, APOffset> getBytefromGepTypePair(const AccessPath::VarAndGepTypePair& gep_pair, const GepStmt *gep, APOffset elem_bytesize);
+    std::pair<APOffset, APOffset> getBytefromGepTypePair(const AccessPath::VarAndGepTypePair& gep_pair, const GepStmt *gep);
 
     /// Return the Index offset from one gep param offset
     std::pair<APOffset, APOffset> 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<APOffset, APOffset> getGepByteOffset(const GepStmt *gep, APOffset elemBytesize);
+    /// e.g. GepStmt* gep = [i32*10], x, and x is [0,3]
+    /// std::pair<s32_t, s32_t> byteOffset = getGepByteOffset(gep);
+    /// byteOffset should be [0, 12] since i32 is 4 bytes.
+    std::pair<APOffset, APOffset> getGepByteOffset(const GepStmt *gep);
 
     /// Return the offset expression of a GepStmt
     std::pair<APOffset, APOffset> getGepOffset(const GepStmt *gep);

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

@@ -635,7 +635,7 @@ protected:
         void visit(const CFBasicBlockGWTONode &node) override
         {
             _nodeToWTOCycleDepth.insert(
-                std::make_pair(node.node(), _wtoCycleDepth));
+                                    std::make_pair(node.node(), _wtoCycleDepth));
         }
 
     }; // end class WTOCycleDepthBuilder

package/SVF-osx/svf/include/CFL/CFGrammar.h

@@ -146,7 +146,7 @@ public:
     template<typename Key, typename Value, typename Hash = SymbolHash,
              typename KeyEqual = std::equal_to<Key>,
              typename Allocator = std::allocator<std::pair<const Key, Value>>>
-                     using SymbolMap = std::unordered_map<Key, Value, Hash, KeyEqual, Allocator>;
+                 using SymbolMap = std::unordered_map<Key, Value, Hash, KeyEqual, Allocator>;
 
              template <typename Key, typename Hash = SymbolVectorHash, typename KeyEqual = std::equal_to<Key>,
                        typename Allocator = std::allocator<Key>>

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

@@ -105,13 +105,31 @@ 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;
+    /**
+     * Computes the total constant byte offset of an access path.
+     * This function iterates over the offset-variable-type pairs in reverse order,
+     * accumulating the total byte offset for constant offsets. For each pair,
+     * it retrieves the corresponding SVFValue and determines the type of offset
+     * (whether it's an array, pointer, or structure). If the offset corresponds
+     * to a structure, it further resolves the actual element type based on the
+     * offset value. It then multiplies the offset value by the size of the type
+     * to compute the byte offset. This is used to handle composite types where
+     * offsets are derived from the type's internal structure, such as arrays
+     * or structures with fields of various types and sizes. The function asserts
+     * that the access path must have a constant offset, and it is intended to be
+     * used when the offset is known to be constant at compile time.
+     *
+     * @return APOffset representing the computed total constant byte offset.
+     */
+    /// e.g. GepStmt* gep = [i32*4], 2
+    /// APOffset byteOffset = gep->accumulateConstantByteOffset();
+    /// byteOffset should be 8 since i32 is 4 bytes and index is 2.
+    APOffset computeConstantByteOffset() const;
     /// Return accumulated constant offset given OffsetVarVec
+    /// compard to computeConstantByteOffset, it is field offset rather than byte offset
+    /// e.g. GepStmt* gep = [i32*4], 2
+    /// APOffset byteOffset = gep->computeConstantOffset();
+    /// byteOffset should be 2 since it is field offset.
     APOffset computeConstantOffset() const;
 
     /// Return element number of a type.

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

@@ -504,9 +504,9 @@ public:
     /// 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
+    inline APOffset accumulateConstantByteOffset() const
     {
-        return getAccessPath().computeConstantByteOffset(elemBytesize);
+        return getAccessPath().computeConstantByteOffset();
     }
 
     /// Return accumulated constant offset (when accessing array or struct) if this offset is a constant.

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

@@ -299,6 +299,8 @@ public:
         return getPointerToTy;
     }
 
+    u32_t getLLVMByteSize() const;
+
     inline void setTypeInfo(StInfo* ti)
     {
         typeinfo = ti;
@@ -321,6 +323,16 @@ public:
         return kind == SVFPointerTy;
     }
 
+    inline bool isArrayTy() const
+    {
+        return kind == SVFArrayTy;
+    }
+
+    inline bool isStructTy() const
+    {
+        return kind == SVFStructTy;
+    }
+
     inline bool isSingleValueType() const
     {
         return isSingleValTy;
@@ -462,6 +474,11 @@ public:
 
     void print(std::ostream& os) const override;
 
+    const SVFType* getTypeOfElement() const
+    {
+        return typeOfElement;
+    }
+
     void setTypeOfElement(const SVFType* elemType)
     {
         typeOfElement = elemType;
@@ -471,6 +488,7 @@ public:
     {
         numOfElement = elemNum;
     }
+
 };
 
 class SVFOtherType : public SVFType

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

@@ -331,7 +331,7 @@ public:
 /// \endcode
 template <typename WrappedIteratorT,
           typename T = std::remove_reference_t<decltype(
-                      **std::declval<WrappedIteratorT>())>>
+                  **std::declval<WrappedIteratorT>())>>
 struct pointee_iter
     : iter_adaptor_base<
       pointee_iter<WrappedIteratorT, T>, WrappedIteratorT,
@@ -397,7 +397,7 @@ iter_range<pointer_iterator<WrappedIteratorT>>
 
 template <typename WrappedIteratorT,
           typename T1 = std::remove_reference_t<decltype(
-                      **std::declval<WrappedIteratorT>())>,
+                  **std::declval<WrappedIteratorT>())>,
           typename T2 = std::add_pointer_t<T1>>
 using raw_pointer_iterator =
     pointer_iterator<pointee_iter<WrappedIteratorT, T1>, T2>;

package/package.json

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