svf-lib 1.0.726 → 1.0.730

package/SVF-linux/include/Util/NodeIDAllocator.h

@@ -68,7 +68,7 @@ public:
     NodeID allocateValueId(void);
 
     /// Notify the allocator that all symbols have had IDs allocated.
-    void endSymbolAllocation(void);
+    NodeID endSymbolAllocation(void);
 
     /// Returns the total number of memory objects.
     NodeID getNumObjects(void) const { return numObjects; }

package/SVF-linux/include/Util/SVFUtil.h

@@ -241,6 +241,17 @@ inline const SVFFunction* getFunction(StringRef name)
     return nullptr;
 }
 
+/// find the unique defined global across multiple modules
+inline const Value* getGlobalRep(const Value* val) 
+{
+    if(const GlobalVariable* gvar = SVFUtil::dyn_cast<GlobalVariable>(val))
+    {
+        if (LLVMModuleSet::getLLVMModuleSet()->hasGlobalRep(gvar))
+            val = LLVMModuleSet::getLLVMModuleSet()->getGlobalRep(gvar);
+    }
+    return val;
+}
+
 /// Get the definition of a function across multiple modules
 inline const SVFFunction* getDefFunForMultipleModule(const Function* fun)
 {

package/SVF-linux/include/WPA/Andersen.h

@@ -40,7 +40,6 @@
 namespace SVF
 {
 
-class PTAType;
 class SVFModule;
 
 /*!
@@ -464,94 +463,6 @@ protected:
 };
 
 
-
-/**
- * Wave propagation with diff points-to set with type filter.
- */
-class AndersenWaveDiffWithType : public AndersenWaveDiff
-{
-
-private:
-
-    typedef Map<NodeID, Set<const GepCGEdge*>> TypeMismatchedObjToEdgeTy;
-
-    TypeMismatchedObjToEdgeTy typeMismatchedObjToEdges;
-
-    void recordTypeMismatchedGep(NodeID obj, const GepCGEdge* gepEdge)
-    {
-        TypeMismatchedObjToEdgeTy::iterator it = typeMismatchedObjToEdges.find(obj);
-        if (it != typeMismatchedObjToEdges.end())
-        {
-            Set<const GepCGEdge*> &edges = it->second;
-            edges.insert(gepEdge);
-        }
-        else
-        {
-            Set<const GepCGEdge*> edges;
-            edges.insert(gepEdge);
-            typeMismatchedObjToEdges[obj] = edges;
-        }
-    }
-
-    static AndersenWaveDiffWithType* diffWaveWithType; // static instance
-
-    /// Handle diff points-to set.
-    //@{
-    virtual inline void computeDiffPts(NodeID id)
-    {
-        NodeID rep = sccRepNode(id);
-        getDiffPTDataTy()->computeDiffPts(rep, getDiffPTDataTy()->getPts(rep));
-    }
-    virtual inline const PointsTo& getDiffPts(NodeID id)
-    {
-        NodeID rep = sccRepNode(id);
-        return getDiffPTDataTy()->getDiffPts(rep);
-    }
-    //@}
-
-public:
-    AndersenWaveDiffWithType(PAG* _pag, PTATY type = AndersenWaveDiffWithType_WPA): AndersenWaveDiff(_pag,type)
-    {
-        assert(getTypeSystem()!=nullptr && "a type system is required for this pointer analysis");
-    }
-
-    /// Create an singleton instance directly instead of invoking llvm pass manager
-    static AndersenWaveDiffWithType* createAndersenWaveDiffWithType(PAG* p)
-    {
-        if(diffWaveWithType==nullptr)
-        {
-            diffWaveWithType = new AndersenWaveDiffWithType(p);
-            diffWaveWithType->analyze();
-            return diffWaveWithType;
-        }
-        return diffWaveWithType;
-    }
-    static void releaseAndersenWaveDiffWithType()
-    {
-        if (diffWaveWithType)
-            delete diffWaveWithType;
-        diffWaveWithType = nullptr;
-    }
-
-protected:
-    /// SCC detection
-    virtual NodeStack& SCCDetect();
-    /// merge types of nodes in a cycle
-    void mergeTypeOfNodes(const NodeBS &nodes);
-    /// process "bitcast" CopyCGEdge
-    virtual void processCast(const ConstraintEdge *edge);
-    /// update type of objects when process "bitcast" CopyCGEdge
-    void updateObjType(const Type *type, const PointsTo &objs);
-    /// process mismatched gep edges
-    void processTypeMismatchedGep(NodeID obj, const Type *type);
-    /// match types for Gep Edges
-    virtual bool matchType(NodeID ptrid, NodeID objid, const NormalGepCGEdge *normalGepEdge);
-    /// add type for newly created GepObjNode
-    virtual void addTypeForGepObjNode(NodeID id, const NormalGepCGEdge* normalGepEdge);
-};
-
-
-
 /*
  * Lazy Cycle Detection Based Andersen Analysis
  */

package/SVF-osx/include/Graphs/PAGNode.h

@@ -32,7 +32,7 @@
 
 #include "Graphs/GenericGraph.h"
 #include "MemoryModel/MemModel.h"
-#include "SVF-FE/SymbolTableInfo.h"
+#include "MemoryModel/SymbolTableInfo.h"
 #include "SVF-FE/LLVMUtil.h"
 #include "Graphs/PAGEdge.h"
 

package/SVF-osx/include/MemoryModel/LocationSet.h

@@ -93,7 +93,6 @@ public:
 class LocationSet
 {
     friend class SymbolTableInfo;
-    friend class LocSymTableInfo;
 public:
     enum LSRelation
     {

package/SVF-osx/include/MemoryModel/SVFIR.h

@@ -0,0 +1,380 @@
+//===- SVFIR.h -- IR of SVF ---------------------------------------------//
+//
+//                     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 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 General Public License for more details.
+
+// You should have received a copy of the GNU General Public License
+// along with this program.  If not, see <http://www.gnu.org/licenses/>.
+//
+//===----------------------------------------------------------------------===//
+
+/*
+ * SVFIR.h
+ *
+ *  Created on: 31, 12, 2021
+ *      Author: Yulei Sui
+ */
+
+#ifndef SVFIR_H_
+#define SVFIR_H_
+
+#include <set>
+#include <map>
+#include "Util/BasicTypes.h"
+
+namespace SVF
+{
+
+class SVFStmt{
+
+public:
+    enum SVFSTMTK
+    {
+        Alloc, Copy, Phi, Store, Load, Call, FunRet, Gep, Cmp, Binary, Unary, Branch
+    };
+
+    SVFStmt(u32_t k): kind(k){
+
+    }
+
+    /// ClassOf
+    //@{
+    static inline bool classof(const SVFStmt*)
+    {
+        return true;
+    }
+    ///@}
+    virtual const std::string toString() const;
+    //@}
+    
+    /// Overloading operator << for printing
+    //@{
+    friend raw_ostream& operator<< (raw_ostream &o, const SVFStmt &stmt)
+    {
+        o << stmt.toString();
+        return o;
+    }
+    //@}
+
+    inline u32_t getKind() const {
+        return kind;
+    }
+
+private:
+    u32_t kind;
+};
+
+class AllocStmt : public SVFStmt{
+
+public:
+
+    AllocStmt(SymID src, SymID dst) : SVFStmt(SVFSTMTK::Alloc), srcVar(src), dstVar(dst){
+    }
+
+    /// Methods for support type inquiry through isa, cast, and dyn_cast:
+    //@{
+    static inline bool classof(const AllocStmt *)
+    {
+        return true;
+    }
+    static inline bool classof(const SVFStmt *stmt)
+    {
+        return stmt->getKind() == SVFSTMTK::Alloc;
+    }
+    //@}
+
+    virtual const std::string toString() const;
+
+private:
+    SymID srcVar;
+    SymID dstVar;
+};
+
+class CopyStmt : public SVFStmt{
+
+    CopyStmt(SymID src, SymID dst) : SVFStmt(SVFSTMTK::Copy), srcVar(src), dstVar(dst){
+    }
+
+    /// Methods for support type inquiry through isa, cast, and dyn_cast:
+    //@{
+    static inline bool classof(const CopyStmt *)
+    {
+        return true;
+    }
+    static inline bool classof(const SVFStmt *stmt)
+    {
+        return stmt->getKind() == SVFSTMTK::Copy;
+    }
+    //@}
+
+    virtual const std::string toString() const;
+
+private:
+    SymID srcVar;
+    SymID dstVar;
+};
+
+class PhiStmt : public SVFStmt{
+
+    PhiStmt(SymID res, SymID op1, SymID op2) : SVFStmt(SVFSTMTK::Phi), resVar(res), op1Var(op1), op2Var(op2){
+    }
+
+    /// Methods for support type inquiry through isa, cast, and dyn_cast:
+    //@{
+    static inline bool classof(const PhiStmt *)
+    {
+        return true;
+    }
+    static inline bool classof(const SVFStmt *stmt)
+    {
+        return stmt->getKind() == SVFSTMTK::Phi;
+    }
+    //@}
+
+    virtual const std::string toString() const;
+
+private:
+    SymID resVar;
+    SymID op1Var;
+    SymID op2Var;
+};
+
+class LoadStmt : public SVFStmt{
+
+    LoadStmt(SymID src, SymID dst) : SVFStmt(SVFSTMTK::Load), srcVar(src), dstVar(dst){
+    }
+
+    /// Methods for support type inquiry through isa, cast, and dyn_cast:
+    //@{
+    static inline bool classof(const LoadStmt *)
+    {
+        return true;
+    }
+    static inline bool classof(const SVFStmt *stmt)
+    {
+        return stmt->getKind() == SVFSTMTK::Load;
+    }
+    //@}
+
+    virtual const std::string toString() const;
+
+private:
+    SymID srcVar;
+    SymID dstVar;
+};
+
+class StoreStmt : public SVFStmt{
+
+    StoreStmt(SymID src, SymID dst) : SVFStmt(SVFSTMTK::Store), srcVar(src), dstVar(dst){
+    }
+
+    /// Methods for support type inquiry through isa, cast, and dyn_cast:
+    //@{
+    static inline bool classof(const StoreStmt *)
+    {
+        return true;
+    }
+    static inline bool classof(const SVFStmt *stmt)
+    {
+        return stmt->getKind() == SVFSTMTK::Store;
+    }
+    //@}
+
+    virtual const std::string toString() const;
+
+private:
+    SymID srcVar;
+    SymID dstVar;
+};
+
+class GepStmt : public SVFStmt{
+
+    GepStmt(SymID res, SymID ptr, SymID offset) : SVFStmt(SVFSTMTK::Gep), resVar(res), ptrVar(ptr), offsetVar(offset){
+    }
+
+    /// Methods for support type inquiry through isa, cast, and dyn_cast:
+    //@{
+    static inline bool classof(const GepStmt *)
+    {
+        return true;
+    }
+    static inline bool classof(const SVFStmt *stmt)
+    {
+        return stmt->getKind() == SVFSTMTK::Gep;
+    }
+    //@}
+
+    virtual const std::string toString() const;
+
+private:
+    SymID resVar;
+    SymID ptrVar;
+    SymID offsetVar;
+};
+
+class CmpStmt : public SVFStmt{
+
+    CmpStmt(SymID res, SymID op1, SymID op2) : SVFStmt(SVFSTMTK::Cmp), resVar(res), op1Var(op1), op2Var(op2){
+    }
+
+    /// Methods for support type inquiry through isa, cast, and dyn_cast:
+    //@{
+    static inline bool classof(const CmpStmt *)
+    {
+        return true;
+    }
+    static inline bool classof(const SVFStmt *stmt)
+    {
+        return stmt->getKind() == SVFSTMTK::Cmp;
+    }
+    //@}
+
+    virtual const std::string toString() const;
+
+private:
+    SymID resVar;
+    SymID op1Var;
+    SymID op2Var;
+};
+
+class BinaryStmt : public SVFStmt{
+
+    BinaryStmt(SymID res, SymID op1, SymID op2) : SVFStmt(SVFSTMTK::Binary), resVar(res), op1Var(op1), op2Var(op2){
+    }
+
+    /// Methods for support type inquiry through isa, cast, and dyn_cast:
+    //@{
+    static inline bool classof(const BinaryStmt *)
+    {
+        return true;
+    }
+    static inline bool classof(const SVFStmt *stmt)
+    {
+        return stmt->getKind() == SVFSTMTK::Binary;
+    }
+    //@}
+
+    virtual const std::string toString() const;
+
+private:
+    SymID resVar;
+    SymID op1Var;
+    SymID op2Var;
+};
+
+class UnaryStmt : public SVFStmt{
+
+    UnaryStmt(SymID res, SymID op) : SVFStmt(SVFSTMTK::Unary), resVar(res), opVar(op){
+    }
+
+    /// Methods for support type inquiry through isa, cast, and dyn_cast:
+    //@{
+    static inline bool classof(const UnaryStmt *)
+    {
+        return true;
+    }
+    static inline bool classof(const SVFStmt *stmt)
+    {
+        return stmt->getKind() == SVFSTMTK::Unary;
+    }
+    //@}
+
+    virtual const std::string toString() const;
+
+private:
+    SymID resVar;
+    SymID opVar;
+};
+
+class CallStmt : public SVFStmt{
+
+    CallStmt(CallSite cs) : SVFStmt(SVFSTMTK::Call), callsite(cs){
+    }
+
+    /// Methods for support type inquiry through isa, cast, and dyn_cast:
+    //@{
+    static inline bool classof(const CallStmt *)
+    {
+        return true;
+    }
+    static inline bool classof(const SVFStmt *stmt)
+    {
+        return stmt->getKind() == SVFSTMTK::Call;
+    }
+    //@}
+
+    virtual const std::string toString() const;
+
+private:
+    CallSite callsite;
+};
+
+class FunRetStmt : public SVFStmt{
+
+    FunRetStmt(SVFFunction* f) : SVFStmt(SVFSTMTK::FunRet), fun(f){
+    }
+
+    /// Methods for support type inquiry through isa, cast, and dyn_cast:
+    //@{
+    static inline bool classof(const FunRetStmt *)
+    {
+        return true;
+    }
+    static inline bool classof(const SVFStmt *stmt)
+    {
+        return stmt->getKind() == SVFSTMTK::FunRet;
+    }
+    //@}
+
+    virtual const std::string toString() const;
+
+private:
+    SVFFunction* fun;
+};
+
+class BranchStmt : public SVFStmt{
+
+    BranchStmt(SymID cond, SVFStmt* b1, SVFStmt* b2) : SVFStmt(SVFSTMTK::Branch), condition(cond),br1(b1),br2(b2){
+    }
+
+    /// Methods for support type inquiry through isa, cast, and dyn_cast:
+    //@{
+    static inline bool classof(const BranchStmt *)
+    {
+        return true;
+    }
+    static inline bool classof(const SVFStmt *stmt)
+    {
+        return stmt->getKind() == SVFSTMTK::Branch;
+    }
+    //@}
+
+    virtual const std::string toString() const;
+
+private:
+    SymID condition;
+    SVFStmt* br1;
+    SVFStmt* br2;
+};
+
+
+class SVFIR{
+
+
+};
+
+} // End namespace SVF
+
+#endif /* SVFIR_H_ */