svf-tools 1.0.317 → 1.0.321

package/include/MemoryModel/SVFStatements.h

@@ -53,7 +53,7 @@ public:
     /// ThreadFork/ThreadJoin is to model parameter passings between thread spawners and spawnees.
     enum PEDGEK
     {
-        Addr, Copy, Store, Load, Call, Ret, NormalGep, VariantGep, ThreadFork, ThreadJoin, Cmp, BinaryOp, UnaryOp
+        Addr, Copy, Store, Load, Call, Ret, NormalGep, VariantGep, Phi, Cmp, BinaryOp, UnaryOp, Branch, ThreadFork, ThreadJoin
     };
 
 private:
@@ -87,11 +87,11 @@ public:
                edge->getEdgeKind() == SVFStmt::Ret ||
                edge->getEdgeKind() == SVFStmt::NormalGep ||
                edge->getEdgeKind() == SVFStmt::VariantGep ||
-               edge->getEdgeKind() == SVFStmt::ThreadFork ||
-               edge->getEdgeKind() == SVFStmt::ThreadJoin ||
                edge->getEdgeKind() == SVFStmt::Cmp ||
                edge->getEdgeKind() == SVFStmt::BinaryOp ||
-               edge->getEdgeKind() == SVFStmt::UnaryOp;
+               edge->getEdgeKind() == SVFStmt::UnaryOp  ||
+               edge->getEdgeKind() == SVFStmt::ThreadFork ||
+               edge->getEdgeKind() == SVFStmt::ThreadJoin;
     }
     ///@}
 
@@ -135,6 +135,15 @@ public:
     }
     //@}
 
+    /// Compute the unique edgeFlag value from edge kind and second variable operand for MultiOpndStmt.
+    static inline GEdgeFlag makeEdgeFlagWithAddionalOpnd(GEdgeKind k, const SVFVar* var)
+    {
+        Var2LabelMap::const_iterator iter = var2LabelMap.find(var);
+        u64_t label = (iter != var2LabelMap.end()) ?
+                      iter->second : multiOpndLabelCounter++;
+        return (label << EdgeKindMaskBits) | k;
+    }
+
     /// Compute the unique edgeFlag value from edge kind and call site Instruction.
     static inline GEdgeFlag makeEdgeFlagWithCallInst(GEdgeKind k, const ICFGNode* cs)
     {
@@ -172,13 +181,15 @@ public:
 
 private:
     typedef Map<const ICFGNode*, u32_t> Inst2LabelMap;
+    typedef Map<const SVFVar*, u32_t> Var2LabelMap;
     static Inst2LabelMap inst2LabelMap; ///< Call site Instruction to label map
+    static Var2LabelMap var2LabelMap;  ///< Second operand of MultiOpndStmt to label map
     static u64_t callEdgeLabelCounter;  ///< Call site Instruction counter
     static u64_t storeEdgeLabelCounter;  ///< Store Instruction counter
+    static u64_t multiOpndLabelCounter;  ///< MultiOpndStmt counter
 };
 
 
-
 /*!
  * Copy edge
  */
@@ -210,7 +221,7 @@ public:
     {
     }
 
-    virtual const std::string toString() const;
+    virtual const std::string toString() const override;
 };
 
 
@@ -245,19 +256,133 @@ public:
     {
     }
 
-    virtual const std::string toString() const;
+    virtual const std::string toString() const override;
+};
+
+class MultiOpndStmt : public SVFStmt{
+public:
+    typedef std::vector<SVFVar*> OPVars;
+protected:
+    OPVars opVars;
+public:
+    /// Constructor, only used by subclassess but not external users
+    MultiOpndStmt(SVFVar* r, const OPVars& opnds, GEdgeFlag k): SVFStmt(opnds.at(0), r, k), opVars(opnds)
+    {
+    }
+    /// Methods for support type inquiry through isa, cast, and dyn_cast:
+    //@{
+    static inline bool classof(const MultiOpndStmt *)
+    {
+        return true;
+    }
+    static inline bool classof(const SVFStmt *node)
+    {
+        return node->getEdgeKind() == Phi ||
+               node->getEdgeKind() == BinaryOp ||
+               node->getEdgeKind() == Cmp;
+    }
+    static inline bool classof(const GenericPAGEdgeTy *node)
+    {
+        return node->getEdgeKind() == Phi ||
+               node->getEdgeKind() == BinaryOp ||
+               node->getEdgeKind() == Cmp;
+    }
+    //@}
+    /// Operands and result at a BinaryNode e.g., p = q + r, `p` is resVar and `r` is OpVar
+    //@{
+    /// Operand SVFVars
+    inline const SVFVar* getOpVar(u32_t pos) const
+    {
+        return opVars.at(pos);
+    }
+    /// Result SVFVar
+    inline const SVFVar* getRes() const
+    {
+        return getDstNode();
+    }
+    
+    NodeID getOpVarID(u32_t pos) const;
+    NodeID getResID() const;
+
+    inline u32_t getOpVarNum() const
+    {
+        return opVars.size();
+    }
+    inline const OPVars& getOpndVars() const{
+        return opVars;
+    }
+    inline OPVars::const_iterator opVarBegin() const
+    {
+        return opVars.begin();
+    }
+    inline OPVars::const_iterator opVerEnd() const
+    {
+        return opVars.end();
+    }
+    //@}
+};
+
+/*!
+ * Phi instruction edge
+ */
+class PhiPE: public MultiOpndStmt
+{
+private:
+    PhiPE();                      ///< place holder
+    PhiPE(const PhiPE &);  ///< place holder
+    void operator=(const PhiPE &); ///< place holder
+    SVFVar* getSrcNode();  ///< place holder, not allowed since this SVFStmt has multiple operands but not a single source
+    SVFVar* getDstNode();    ///< place holder, use getRes() instead
+    SVFVar* getSrcID();  ///< place holder, use getOpVarID(pos) instead
+    SVFVar* getDstID();    ///< place holder, use getResID() instead
+
+public:
+    /// Methods for support type inquiry through isa, cast, and dyn_cast:
+    //@{
+    static inline bool classof(const PhiPE *)
+    {
+        return true;
+    }
+    static inline bool classof(const SVFStmt *edge)
+    {
+        return edge->getEdgeKind() == SVFStmt::Phi;
+    }
+    static inline bool classof(const MultiOpndStmt *edge)
+    {
+        return edge->getEdgeKind() == SVFStmt::Phi;
+    }
+    static inline bool classof(const GenericPAGEdgeTy *edge)
+    {
+        return edge->getEdgeKind() == SVFStmt::Phi;
+    }
+    //@}
+
+    /// constructor
+    PhiPE(SVFVar* s, const OPVars& opnds) : MultiOpndStmt(s,opnds,SVFStmt::Phi)
+    {
+    }
+    void addOpVar(SVFVar* op){
+        opVars.push_back(op);
+    }
+    virtual const std::string toString() const override;
 };
 
 
 /*!
  * Compare instruction edge
  */
-class CmpPE: public SVFStmt
+class CmpPE: public MultiOpndStmt
 {
 private:
     CmpPE();                      ///< place holder
     CmpPE(const CmpPE &);  ///< place holder
     void operator=(const CmpPE &); ///< place holder
+    SVFVar* getSrcNode();  ///< place holder, not allowed since this SVFStmt has multiple operands but not a single source
+    SVFVar* getDstNode();    ///< place holder, use getRes() instead
+    SVFVar* getSrcID();  ///< place holder, use getOpVarID(pos) instead
+    SVFVar* getDstID();    ///< place holder, use getResID() instead
+
+    u32_t opcode;
 public:
     /// Methods for support type inquiry through isa, cast, and dyn_cast:
     //@{
@@ -269,6 +394,10 @@ public:
     {
         return edge->getEdgeKind() == SVFStmt::Cmp;
     }
+    static inline bool classof(const MultiOpndStmt *edge)
+    {
+        return edge->getEdgeKind() == SVFStmt::Cmp;
+    }
     static inline bool classof(const GenericPAGEdgeTy *edge)
     {
         return edge->getEdgeKind() == SVFStmt::Cmp;
@@ -276,23 +405,35 @@ public:
     //@}
 
     /// constructor
-    CmpPE(SVFVar* s, SVFVar* d) : SVFStmt(s,d,SVFStmt::Cmp)
+    CmpPE(SVFVar* s, const OPVars& opnds, u32_t oc) : MultiOpndStmt(s,opnds,SVFStmt::Cmp), opcode(oc)
     {
     }
 
-    virtual const std::string toString() const;
+    u32_t getOpcode() const
+    {
+        return opcode;
+    }
+    
+    virtual const std::string toString() const override;
 };
 
 
 /*!
  * Binary instruction edge
  */
-class BinaryOPPE: public SVFStmt
+class BinaryOPPE: public MultiOpndStmt
 {
 private:
     BinaryOPPE();                      ///< place holder
     BinaryOPPE(const BinaryOPPE &);  ///< place holder
     void operator=(const BinaryOPPE &); ///< place holder
+    SVFVar* getSrcNode();  ///< place holder, not allowed since this SVFStmt has multiple operands but not a single source
+    SVFVar* getDstNode();    ///< place holder, use getRes() instead
+    SVFVar* getSrcID();  ///< place holder, use getOpVarID(pos) instead
+    SVFVar* getDstID();    ///< place holder, use getResID() instead
+
+    u32_t opcode;
+
 public:
     /// Methods for support type inquiry through isa, cast, and dyn_cast:
     //@{
@@ -304,6 +445,10 @@ public:
     {
         return edge->getEdgeKind() == SVFStmt::BinaryOp;
     }
+    static inline bool classof(const MultiOpndStmt *edge)
+    {
+        return edge->getEdgeKind() == SVFStmt::BinaryOp;
+    }
     static inline bool classof(const GenericPAGEdgeTy *edge)
     {
         return edge->getEdgeKind() == SVFStmt::BinaryOp;
@@ -311,11 +456,16 @@ public:
     //@}
 
     /// constructor
-    BinaryOPPE(SVFVar* s, SVFVar* d) : SVFStmt(s,d,SVFStmt::BinaryOp)
+    BinaryOPPE(SVFVar* s, const OPVars& opnds, u32_t oc) : MultiOpndStmt(s,opnds,SVFStmt::BinaryOp), opcode(oc)
     {
     }
 
-    virtual const std::string toString() const;
+    u32_t getOpcode() const
+    {
+        return opcode;
+    }
+
+    virtual const std::string toString() const override;
 };
 
 /*!
@@ -327,6 +477,12 @@ private:
     UnaryOPPE();                      ///< place holder
     UnaryOPPE(const UnaryOPPE &);  ///< place holder
     void operator=(const UnaryOPPE &); ///< place holder
+    SVFVar* getSrcNode();  ///< place holder, use getOpVar() instead
+    SVFVar* getDstNode();    ///< place holder, use getRes() instead
+    SVFVar* getSrcID();  ///< place holder, use getOpVarID() instead
+    SVFVar* getDstID();    ///< place holder, use getResID() instead
+
+    u32_t opcode;
 public:
     /// Methods for support type inquiry through isa, cast, and dyn_cast:
     //@{
@@ -345,14 +501,90 @@ public:
     //@}
 
     /// constructor
-    UnaryOPPE(SVFVar* s, SVFVar* d) : SVFStmt(s,d,SVFStmt::UnaryOp)
+    UnaryOPPE(SVFVar* s, SVFVar* d, u32_t oc) : SVFStmt(s,d,SVFStmt::UnaryOp), opcode(oc)
     {
     }
 
-    virtual const std::string toString() const;
+    u32_t getOpcode() const
+    {
+        return opcode;
+    }
+    inline const SVFVar* getOpVar() const{
+        return SVFStmt::getSrcNode();
+    }
+    inline const SVFVar* getRes() const{
+        return SVFStmt::getDstNode();
+    }
+    NodeID getOpVarID() const;
+    NodeID getResID() const;
+
+    virtual const std::string toString() const override;
 };
 
 
+/*!
+ * Branch statements including if/else and switch 
+ */
+class BranchStmt: public SVFStmt
+{
+private:
+    BranchStmt();                      ///< place holder
+    BranchStmt(const BranchStmt &);  ///< place holder
+    void operator=(const BranchStmt &); ///< place holder
+    SVFVar* getSrcNode();  ///< place holder, not allowed 
+    SVFVar* getDstNode();    ///< place holder, not allowed 
+    SVFVar* getSrcID();  ///< place holder, not allowed 
+    SVFVar* getDstID();    ///< place holder, not allowed 
+
+    std::vector<const ICFGNode*> successors;
+    const SVFVar* cond;
+    const SVFVar* brInst;
+public:
+    /// 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 *edge)
+    {
+        return edge->getEdgeKind() == SVFStmt::Branch;
+    }
+    static inline bool classof(const GenericPAGEdgeTy *edge)
+    {
+        return edge->getEdgeKind() == SVFStmt::Branch;
+    }
+    //@}
+
+    /// constructor
+    BranchStmt(SVFVar* inst, SVFVar* c, const std::vector<const ICFGNode*>& succs) : SVFStmt(c,inst,SVFStmt::Branch), successors(succs), cond(c), brInst(inst)
+    {
+    }
+
+    /// The branch is unconditional if cond is a null value
+    bool isUnconditional() const;
+    /// The branch is conditional if cond is not a null value
+    bool isConditional() const;
+    /// Return the condition 
+    const SVFVar* getCondition() const;
+    const SVFVar* getBranchInst() const{
+        return brInst;
+    }
+    /// Successors of this branch statement
+    ///@{
+    u32_t getNumSuccessors() const{
+        return successors.size();
+    }
+    const std::vector<const ICFGNode*>& getSuccessors() const{
+        return successors;
+    }
+    const ICFGNode* getSuccessor (u32_t i) const{
+        return successors.at(i);
+    }
+    ///@}
+    virtual const std::string toString() const override;
+};
+
 /*!
  * Store edge
  */
@@ -386,7 +618,7 @@ public:
     {
     }
 
-    virtual const std::string toString() const;
+    virtual const std::string toString() const override;
 };
 
 
@@ -422,7 +654,7 @@ public:
     {
     }
 
-    virtual const std::string toString() const;
+    virtual const std::string toString() const override;
 };
 
 
@@ -513,7 +745,7 @@ public:
         return ls;
     }
 
-    virtual const std::string toString() const;
+    virtual const std::string toString() const override;
 };
 
 /*!
@@ -550,7 +782,7 @@ public:
     /// constructor
     VariantGepPE(SVFVar* s, SVFVar* d) : GepPE(s,d,SVFStmt::VariantGep) {}
 
-    virtual const std::string toString() const;
+    virtual const std::string toString() const override;
 
 };
 
@@ -603,7 +835,7 @@ public:
     }
     //@}
 
-    virtual const std::string toString() const;
+    virtual const std::string toString() const override;
 };
 
 
@@ -655,7 +887,7 @@ public:
     }
     //@}
 
-    virtual const std::string toString() const;
+    virtual const std::string toString() const override;
 };
 
 

package/include/SVF-FE/CHGBuilder.h

@@ -0,0 +1,69 @@
+//===----- CHGBuiler.h -- Class hierarchy graph builder ---------------------------//
+//
+//                     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/>.
+//
+//===----------------------------------------------------------------------===//
+
+/*
+ * CHGBuiler.h
+ *
+ *  Created on: Jun 4, 2021
+ *      Author: Yulei Sui
+ */
+
+#include "Graphs/CHG.h"
+
+namespace SVF{
+
+class CHGBuilder{
+
+private:
+    CHGraph* chg;
+
+public:
+    typedef CHGraph::CHNodeSetTy CHNodeSetTy;
+    typedef CHGraph::WorkList WorkList;
+
+    CHGBuilder(CHGraph* c): chg(c)
+    {
+
+    }
+    void buildCHG();
+    void buildCHGNodes(const GlobalValue *V);
+    void buildCHGNodes(const SVFFunction* F);
+    void buildCHGEdges(const SVFFunction* F);
+    void buildInternalMaps();
+    void readInheritanceMetadataFromModule(const Module &M);
+
+    CHNode *createNode(const std::string name);
+
+    void connectInheritEdgeViaCall(const SVFFunction* caller, CallSite cs);
+    void connectInheritEdgeViaStore(const SVFFunction* caller, const StoreInst* store);
+
+    void buildClassNameToAncestorsDescendantsMap();
+    const CHGraph::CHNodeSetTy& getInstancesAndDescendants(const std::string className);
+
+    void analyzeVTables(const Module &M);
+    void buildVirtualFunctionToIDMap();
+    void buildCSToCHAVtblsAndVfnsMap();
+    const CHNodeSetTy& getCSClasses(CallSite cs);
+    void addFuncToFuncVector(CHNode::FuncVector &v, const SVFFunction *f);
+};
+
+}

package/include/SVF-FE/DCHG.h

@@ -15,7 +15,7 @@
 #define DCHG_H_
 
 #include "Graphs/GenericGraph.h"
-#include "SVF-FE/CommonCHG.h"
+#include "Graphs/CHG.h"
 #include "SVF-FE/CPPUtil.h"
 #include "Util/SVFModule.h"
 #include "Util/SVFUtil.h"

package/include/SVF-FE/SVFIRBuilder.h

@@ -267,6 +267,8 @@ public:
         return nullPtr;
     }
 
+public:
+
     NodeID getGepValNode(const Value* val, const LocationSet& ls, const Type *baseType, u32_t fieldidx);
 
     void setCurrentBBAndValueForPAGEdge(PAGEdge* edge);
@@ -293,23 +295,36 @@ public:
         return edge;
     }
     /// Add Copy edge
-    inline CmpPE* addCmpEdge(NodeID src, NodeID dst)
+    inline PhiPE* addPhiNode(NodeID res, NodeID opnd)
     {
-        CmpPE *edge = pag->addCmpPE(src, dst);
+        PhiPE *edge = pag->addPhiNode(res,opnd);
         setCurrentBBAndValueForPAGEdge(edge);
         return edge;
     }
     /// Add Copy edge
-    inline BinaryOPPE* addBinaryOPEdge(NodeID src, NodeID dst)
+    inline CmpPE* addCmpEdge(NodeID op1, NodeID op2, NodeID dst, u32_t opcode)
     {
-        BinaryOPPE *edge = pag->addBinaryOPPE(src, dst);
+        CmpPE *edge = pag->addCmpPE(op1, op2, dst, opcode);
+        setCurrentBBAndValueForPAGEdge(edge);
+        return edge;
+    }
+    /// Add Copy edge
+    inline BinaryOPPE* addBinaryOPEdge(NodeID op1, NodeID op2, NodeID dst, u32_t opcode)
+    {
+        BinaryOPPE *edge = pag->addBinaryOPPE(op1, op2, dst, opcode);
         setCurrentBBAndValueForPAGEdge(edge);
         return edge;
     }
     /// Add Unary edge
-    inline UnaryOPPE* addUnaryOPEdge(NodeID src, NodeID dst)
+    inline UnaryOPPE* addUnaryOPEdge(NodeID src, NodeID dst, u32_t opcode)
     {
-        UnaryOPPE *edge = pag->addUnaryOPPE(src, dst);
+        UnaryOPPE *edge = pag->addUnaryOPPE(src, dst, opcode);
+        setCurrentBBAndValueForPAGEdge(edge);
+        return edge;
+    }
+    /// Add Branch statement 
+    inline BranchStmt* addBranchStmt(NodeID br, NodeID cond, const std::vector<const ICFGNode*> succs){
+        BranchStmt *edge = pag->addBranchStmt(br, cond, succs);
         setCurrentBBAndValueForPAGEdge(edge);
         return edge;
     }
@@ -385,8 +400,6 @@ public:
 
 };
 
-typedef SVFIRBuilder PAGBuilder;
-
 } // End namespace SVF
 
 #endif /* PAGBUILDER_H_ */