svf-lib 1.0.1827 → 1.0.1829

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

@@ -261,27 +261,25 @@ public:
 
 public:
 
-    inline static SVFType* getPtrTy()
+    inline static SVFType* getSVFPtrType()
     {
-        assert(ptrTy && "ptr type not set?");
-        return ptrTy;
+        assert(svfPtrTy && "ptr type not set?");
+        return svfPtrTy;
     }
 
-    inline static SVFType* getI8Ty()
+    inline static SVFType* getSVFInt8Type()
     {
-        assert(i8Ty && "int8 type not set?");
-        return i8Ty;
+        assert(svfI8Ty && "int8 type not set?");
+        return svfI8Ty;
     }
 
 private:
 
-    static SVFType* ptrTy; ///< ptr type
-    static SVFType* i8Ty; ///< 8-bit int type
+    static SVFType* svfPtrTy; ///< ptr type
+    static SVFType* svfI8Ty; ///< 8-bit int type
 
 private:
     GNodeK kind; ///< used for classof
-    const SVFPointerType*
-    getPointerToTy; /// Return a pointer to the current type
     StInfo* typeinfo;   ///< SVF's TypeInfo
     bool isSingleValTy; ///< The type represents a single value, not struct or
     u32_t byteSize; ///< LLVM Byte Size
@@ -289,7 +287,7 @@ private:
 
 protected:
     SVFType(bool svt, SVFTyKind k, u32_t Sz = 1)
-        : kind(k), getPointerToTy(nullptr), typeinfo(nullptr),
+        : kind(k), typeinfo(nullptr),
           isSingleValTy(svt), byteSize(Sz)
     {
     }
@@ -309,17 +307,6 @@ public:
 
     virtual void print(std::ostream& os) const = 0;
 
-    inline void setPointerTo(const SVFPointerType* ty)
-    {
-        getPointerToTy = ty;
-    }
-
-    inline const SVFPointerType* getPointerTo() const
-    {
-        assert(getPointerToTy && "set the getPointerToTy first");
-        return getPointerToTy;
-    }
-
 
     inline void setTypeInfo(StInfo* ti)
     {
@@ -373,12 +360,9 @@ class SVFPointerType : public SVFType
     friend class SVFIRWriter;
     friend class SVFIRReader;
 
-private:
-    const SVFType* ptrElementType;
-
 public:
     SVFPointerType(u32_t byteSize = 1)
-        : SVFType(true, SVFPointerTy, byteSize), ptrElementType(nullptr)
+        : SVFType(true, SVFPointerTy, byteSize)
     {
     }
 
@@ -386,16 +370,6 @@ public:
     {
         return node->getKind() == SVFPointerTy;
     }
-    inline const SVFType* getPtrElementType() const
-    {
-        assert(ptrElementType && "ptrElementType is nullptr");
-        return ptrElementType;
-    }
-
-    inline void setPtrElementType(SVFType* _ptrElementType)
-    {
-        ptrElementType = _ptrElementType;
-    }
 
     void print(std::ostream& os) const override;
 };

package/SVF-linux/svf/include/Util/Options.h

@@ -128,6 +128,7 @@ public:
     static const Option<u32_t> IndirectCallLimit;
     static const Option<bool> UsePreCompFieldSensitive;
     static const Option<bool> EnableAliasCheck;
+    static const Option<bool> EnableTypeCheck;
     static const Option<bool> EnableThreadCallGraph;
     static const Option<bool> ConnectVCallOnCHA;
 

package/SVF-linux/svf-llvm/include/SVF-LLVM/LLVMModule.h

@@ -39,6 +39,7 @@ namespace SVF
 {
 
 class SymbolTableInfo;
+class ObjTypeInference;
 
 class LLVMModuleSet
 {
@@ -88,6 +89,7 @@ private:
     SVFValue2LLVMValueMap SVFValue2LLVMValue;
     LLVMType2SVFTypeMap LLVMType2SVFType;
     Type2TypeInfoMap Type2TypeInfo;
+    ObjTypeInference* typeInference;
 
     /// Constructor
     LLVMModuleSet();
@@ -95,7 +97,7 @@ private:
     void build();
 
 public:
-    ~LLVMModuleSet() = default;
+    ~LLVMModuleSet();
 
     static inline LLVMModuleSet* getLLVMModuleSet()
     {
@@ -343,6 +345,8 @@ public:
     /// Get LLVM Type
     const Type* getLLVMType(const SVFType* T) const;
 
+    ObjTypeInference* getTypeInference();
+
 private:
     /// Create SVFTypes
     SVFType* addSVFTypeInfo(const Type* t);

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

@@ -106,10 +106,9 @@ static inline Type* getPtrElementType(const PointerType* pty)
 #endif
 }
 
-/// Get the reference type of heap/static object from an allocation site.
-//@{
-const Type *inferTypeOfHeapObjOrStaticObj(const Instruction* inst);
-//@}
+/// Return size of this object based on LLVM value
+u32_t getNumOfElements(const Type* ety);
+
 
 /// Return true if this value refers to a object
 bool isObject(const Value* ref);
@@ -362,6 +361,7 @@ std::string dumpValue(const Value* val);
 
 std::string dumpType(const Type* type);
 
+std::string dumpValueAndDbgInfo(const Value* val);
 
 /**
  * See more: https://github.com/SVF-tools/SVF/pull/1191

package/SVF-linux/svf-llvm/include/SVF-LLVM/ObjTypeInference.h

@@ -0,0 +1,110 @@
+//===- ObjTypeInference.h -- Type inference----------------------------//
+//
+//                     SVF: Static Value-Flow Analysis
+//
+// Copyright (C) <2013->  <Yulei Sui>
+//
+
+// This program is free software: you can redistribute it and/or modify
+// it under the terms of the GNU Affero 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 Affero General Public License for more details.
+
+// You should have received a copy of the GNU Affero General Public License
+// along with this program.  If not, see <http://www.gnu.org/licenses/>.
+//
+//===----------------------------------------------------------------------===//
+
+/*
+ * ObjTypeInference.h
+ *
+ *  Created by Xiao Cheng on 10/01/24.
+ *
+ */
+
+#ifndef SVF_OBJTYPEINFERENCE_H
+#define SVF_OBJTYPEINFERENCE_H
+
+#include "Util/SVFUtil.h"
+#include "SVF-LLVM/BasicTypes.h"
+#include "SVFIR/SVFValue.h"
+#include "Util/ThreadAPI.h"
+
+namespace SVF
+{
+class ObjTypeInference
+{
+
+public:
+    typedef Set<const Value *> ValueSet;
+    typedef Map<const Value *, ValueSet> ValueToValueSet;
+    typedef ValueToValueSet ValueToInferSites;
+    typedef ValueToValueSet ValueToSources;
+    typedef Map<const Value *, const Type *> ValueToType;
+    typedef std::pair<const Value *, bool> ValueBoolPair;
+
+
+private:
+    ValueToInferSites _valueToInferSites; // value inference site cache
+    ValueToType _valueToType; // value type cache
+    ValueToSources _valueToAllocs; // value allocations (stack, static, heap) cache
+
+
+public:
+
+    explicit ObjTypeInference() = default;
+
+    ~ObjTypeInference() = default;
+
+
+    /// get or infer the type of a value
+    const Type *inferObjType(const Value *startValue);
+
+    /// Validate type inference
+    void validateTypeCheck(const CallBase *cs);
+
+    void typeSizeDiffTest(const PointerType *oPTy, const Type *iTy, const Value *val);
+
+    /// Default type
+    const Type *defaultType(const Value *val);
+
+    /// Pointer type
+    inline const Type *ptrType()
+    {
+        return PointerType::getUnqual(getLLVMCtx());
+    }
+
+    /// Int8 type
+    inline const IntegerType *int8Type()
+    {
+        return Type::getInt8Ty(getLLVMCtx());
+    }
+
+    LLVMContext &getLLVMCtx();
+
+private:
+
+    /// Forward collect all possible infer sites starting from a value
+    const Type *fwInferObjType(const Value *startValue);
+
+    /// Backward collect all possible allocation sites (stack, static, heap) starting from a value
+    Set<const Value *> bwfindAllocations(const Value *startValue);
+
+    bool isAllocation(const Value *val);
+
+public:
+    /// Select the largest (conservative) type from all types
+    const Type *selectLargestType(Set<const Type *> &objTys);
+
+    u32_t objTyToNumFields(const Type *objTy);
+
+    u32_t getArgPosInCall(const CallBase *callBase, const Value *arg);
+
+};
+}
+#endif //SVF_OBJTYPEINFERENCE_H

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

@@ -271,7 +271,7 @@ protected:
     inline NodeID addNullPtrNode()
     {
         LLVMContext& cxt = LLVMModuleSet::getLLVMModuleSet()->getContext();
-        ConstantPointerNull* constNull = ConstantPointerNull::get(Type::getInt8PtrTy(cxt));
+        ConstantPointerNull* constNull = ConstantPointerNull::get(PointerType::getUnqual(cxt));
         NodeID nullPtr = pag->addValNode(LLVMModuleSet::getLLVMModuleSet()->getSVFValue(constNull),pag->getNullPtr());
         setCurrentLocation(constNull, nullptr);
         addBlackHoleAddrEdge(pag->getBlkPtr());

package/SVF-linux/svf-llvm/include/SVF-LLVM/SymbolTableBuilder.h

@@ -39,6 +39,8 @@
 namespace SVF
 {
 
+class ObjTypeInference;
+
 class SymbolTableBuilder
 {
     friend class SVFIRBuilder;
@@ -82,6 +84,18 @@ protected:
     void handleCE(const Value* val);
     // @}
 
+
+    ObjTypeInference* getTypeInference();
+
+    /// Forward collect all possible infer sites starting from a value
+    const Type* inferObjType(const Value *startValue);
+
+    /// Get the reference type of heap/static object from an allocation site.
+    //@{
+    const Type *inferTypeOfHeapObjOrStaticObj(const Instruction* inst);
+    //@}
+
+
     /// Create an objectInfo based on LLVM value
     ObjTypeInfo* createObjTypeInfo(const Value* val);