svf-lib 1.0.2125 → 1.0.2127

package/SVF-linux/Release-build/include/Graphs/ICFG.h

@@ -172,6 +172,49 @@ protected:
         }
     }
 
+    virtual inline IntraICFGNode* addIntraICFGNode(const SVFBasicBlock* bb, bool isRet)
+    {
+        IntraICFGNode* intraIcfgNode =
+            new IntraICFGNode(totalICFGNode++, bb, isRet);
+        addICFGNode(intraIcfgNode);
+        return intraIcfgNode;
+    }
+
+    virtual inline CallICFGNode* addCallICFGNode(
+        const SVFBasicBlock* bb, const SVFType* ty,
+        const SVFFunction* calledFunc, bool isVararg, bool isvcall,
+        s32_t vcallIdx, const std::string& funNameOfVcall)
+    {
+
+        CallICFGNode* callICFGNode =
+            new CallICFGNode(totalICFGNode++, bb, ty, calledFunc, isVararg,
+                             isvcall, vcallIdx, funNameOfVcall);
+        addICFGNode(callICFGNode);
+        return callICFGNode;
+    }
+
+    virtual inline RetICFGNode* addRetICFGNode(CallICFGNode* call)
+    {
+        RetICFGNode* retICFGNode = new RetICFGNode(totalICFGNode++, call);
+        call->setRetICFGNode(retICFGNode);
+        addICFGNode(retICFGNode);
+        return retICFGNode;
+    }
+
+    virtual inline FunEntryICFGNode* addFunEntryICFGNode(const SVFFunction* svfFunc)
+    {
+        FunEntryICFGNode* sNode = new FunEntryICFGNode(totalICFGNode++,svfFunc);
+        addICFGNode(sNode);
+        return FunToFunEntryNodeMap[svfFunc] = sNode;
+    }
+
+    virtual inline FunExitICFGNode* addFunExitICFGNode(const SVFFunction* svfFunc)
+    {
+        FunExitICFGNode* sNode = new FunExitICFGNode(totalICFGNode++, svfFunc);
+        addICFGNode(sNode);
+        return FunToFunExitNodeMap[svfFunc] = sNode;
+    }
+
     /// Add a ICFG node
     virtual inline void addICFGNode(ICFGNode* node)
     {

package/SVF-linux/Release-build/include/Graphs/ICFGNode.h

@@ -428,19 +428,28 @@ public:
     typedef std::vector<const SVFVar *> ActualParmNodeVec;
 
 protected:
-    const SVFInstruction* cs;
     const RetICFGNode* ret;
-    ActualParmNodeVec APNodes;
+    ActualParmNodeVec APNodes;      /// arguments
+    const SVFFunction* calledFunc;  /// called function
+    bool isvararg;                  /// is variable argument
+    bool isVirCallInst;             /// is virtual call inst
+    SVFVar* vtabPtr;                /// virtual table pointer
+    s32_t virtualFunIdx;            /// virtual function index of the virtual table(s) at a virtual call
+    std::string funNameOfVcall;     /// the function name of this virtual call
 
     /// Constructor to create empty CallICFGNode (for SVFIRReader/deserialization)
-    CallICFGNode(NodeID id) : InterICFGNode(id, FunCallBlock), cs{}, ret{} {}
+    CallICFGNode(NodeID id) : InterICFGNode(id, FunCallBlock), ret{} {}
 
 public:
-    CallICFGNode(NodeID id, const SVFInstruction* c, const SVFType* ty)
-        : InterICFGNode(id, FunCallBlock), cs(c), ret(nullptr)
+    CallICFGNode(NodeID id, const SVFBasicBlock* b, const SVFType* ty,
+                 const SVFFunction* cf, bool iv, bool ivc, s32_t vfi,
+                 const std::string& fnv)
+        : InterICFGNode(id, FunCallBlock), ret(nullptr), calledFunc(cf),
+          isvararg(iv), isVirCallInst(ivc), vtabPtr(nullptr),
+          virtualFunIdx(vfi), funNameOfVcall(fnv)
     {
-        fun = cs->getFunction();
-        bb = cs->getParent();
+        fun = b->getFunction();
+        bb = b;
         type = ty;
     }
 
@@ -472,7 +481,7 @@ public:
     /// Return true if this is an indirect call
     inline bool isIndirectCall() const
     {
-        return nullptr == SVFUtil::cast<SVFCallInst>(cs)->getCalledFunction();
+        return nullptr == calledFunc;
     }
 
     /// Return the set of actual parameters
@@ -488,54 +497,61 @@ public:
     }
     /// Parameter operations
     //@{
-    const SVFVar* getArgument(u32_t ArgNo) const
+    inline const SVFVar* getArgument(u32_t ArgNo) const
     {
         return getActualParms()[ArgNo];
     }
 
-    u32_t arg_size() const
+    inline u32_t arg_size() const
     {
         return APNodes.size();
     }
-    bool arg_empty() const
+    inline bool arg_empty() const
     {
         return APNodes.empty();
     }
 
-    u32_t getNumArgOperands() const
+    inline u32_t getNumArgOperands() const
     {
         return arg_size();
     }
-    const SVFFunction* getCalledFunction() const
+    inline const SVFFunction* getCalledFunction() const
     {
-        return SVFUtil::cast<SVFCallInst>(cs)->getCalledFunction();
+        return calledFunc;
     }
-    const SVFValue* getCalledValue() const
+
+    inline bool isVarArg() const
     {
-        return SVFUtil::cast<SVFCallInst>(cs)->getCalledOperand();
+        return isvararg;
     }
-    bool isVarArg() const
+    inline bool isVirtualCall() const
     {
-        return SVFUtil::cast<SVFCallInst>(cs)->isVarArg();
+        return isVirCallInst;
     }
-    bool isVirtualCall() const
+
+    inline void setVtablePtr(SVFVar* v)
     {
-        return SVFUtil::isa<SVFVirtualCallInst>(cs);
+        vtabPtr = v;
     }
-    const SVFValue* getVtablePtr() const
+
+    inline const SVFVar* getVtablePtr() const
     {
         assert(isVirtualCall() && "not a virtual call?");
-        return SVFUtil::cast<SVFVirtualCallInst>(cs)->getVtablePtr();
+        return vtabPtr;
     }
-    s32_t getFunIdxInVtable() const
+
+
+    inline s32_t getFunIdxInVtable() const
     {
         assert(isVirtualCall() && "not a virtual call?");
-        return SVFUtil::cast<SVFVirtualCallInst>(cs)->getFunIdxInVtable();
+        assert(virtualFunIdx >=0 && "virtual function idx is less than 0? not set yet?");
+        return virtualFunIdx;
     }
-    const std::string& getFunNameOfVirtualCall() const
+
+    inline const std::string& getFunNameOfVirtualCall() const
     {
         assert(isVirtualCall() && "not a virtual call?");
-        return SVFUtil::cast<SVFVirtualCallInst>(cs)->getFunNameOfVirtualCall();
+        return funNameOfVcall;
     }
     //@}
 
@@ -585,23 +601,22 @@ class RetICFGNode : public InterICFGNode
     friend class SVFIRReader;
 
 private:
-    const SVFInstruction* cs;
     const SVFVar *actualRet;
     const CallICFGNode* callBlockNode;
 
     /// Constructor to create empty RetICFGNode (for SVFIRReader/deserialization)
     RetICFGNode(NodeID id)
-        : InterICFGNode(id, FunRetBlock), cs{}, actualRet{}, callBlockNode{}
+        : InterICFGNode(id, FunRetBlock), actualRet{}, callBlockNode{}
     {
     }
 
 public:
-    RetICFGNode(NodeID id, const SVFInstruction* c, CallICFGNode* cb) :
-        InterICFGNode(id, FunRetBlock), cs(c), actualRet(nullptr), callBlockNode(cb)
+    RetICFGNode(NodeID id, CallICFGNode* cb) :
+        InterICFGNode(id, FunRetBlock), actualRet(nullptr), callBlockNode(cb)
     {
-        fun = cs->getFunction();
-        bb = cs->getParent();
-        type = callBlockNode->getType();
+        fun = cb->getFun();
+        bb = cb->getBB();
+        type = cb->getType();
     }
 
     inline const CallICFGNode* getCallICFGNode() const

package/SVF-osx/Release-build/include/AE/Core/IntervalValue.h

@@ -1002,7 +1002,7 @@ inline IntervalValue operator|(const IntervalValue &lhs, const IntervalValue &rh
     else if (lhs.is_numeral() && rhs.is_numeral())
         return IntervalValue(lhs.lb() | rhs.lb());
     else if (lhs.lb().getNumeral() >= 0 && !lhs.ub().is_infinity() &&
-             rhs.lb().getNumeral() >= 0 && !rhs.ub().is_infinity())
+                                      rhs.lb().getNumeral() >= 0 && !rhs.ub().is_infinity())
     {
         s64_t m = std::max(lhs.ub().getNumeral(), rhs.ub().getNumeral());
         s64_t ub = next_power_of_2(s64_t(m)) - 1;
@@ -1031,7 +1031,7 @@ inline IntervalValue operator^(const IntervalValue &lhs, const IntervalValue &rh
     else if (lhs.is_numeral() && rhs.is_numeral())
         return IntervalValue(lhs.lb() ^ rhs.lb());
     else if (lhs.lb().getNumeral() >= 0 && !lhs.ub().is_infinity() &&
-             rhs.lb().getNumeral() >= 0 && !rhs.ub().is_infinity())
+                                      rhs.lb().getNumeral() >= 0 && !rhs.ub().is_infinity())
     {
         s64_t m = std::max(lhs.ub().getNumeral(), rhs.ub().getNumeral());
         s64_t ub = next_power_of_2(s64_t(m)) - 1;

package/SVF-osx/Release-build/include/AE/Core/NumericValue.h

@@ -908,9 +908,9 @@ public:
     static double safeAdd(double lhs, double rhs)
     {
         if ((lhs == std::numeric_limits<double>::infinity() &&
-                rhs == -std::numeric_limits<double>::infinity()) ||
-                (lhs == -std::numeric_limits<double>::infinity() &&
-                 rhs == std::numeric_limits<double>::infinity()))
+        rhs == -std::numeric_limits<double>::infinity()) ||
+        (lhs == -std::numeric_limits<double>::infinity() &&
+        rhs == std::numeric_limits<double>::infinity()))
         {
             assert(false && "invalid add");
         }

package/SVF-osx/Release-build/include/CFL/CFGrammar.h

@@ -147,17 +147,17 @@ 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>>
-             using SymbolSet = std::unordered_set<Key, Hash, KeyEqual, Allocator>;
+    template <typename Key, typename Hash = SymbolVectorHash, typename KeyEqual = std::equal_to<Key>,
+              typename Allocator = std::allocator<Key>>
+    using SymbolSet = std::unordered_set<Key, Hash, KeyEqual, Allocator>;
 
-             typedef std::vector<Symbol> Production;
-             typedef SymbolSet<Production> Productions;
+    typedef std::vector<Symbol> Production;
+    typedef SymbolSet<Production> Productions;
 
 
-             inline Map<std::string, Kind>& getNonterminals()
+    inline Map<std::string, Kind>& getNonterminals()
     {
         return this->nonterminals;
     }

package/SVF-osx/Release-build/include/CFL/CFLGraphBuilder.h

@@ -117,7 +117,8 @@ public:
 };
 
 /// AliasCFLGraphBuilder: a CFLGraphBuilder specialized for handling aliasing
-class AliasCFLGraphBuilder : public CFLGraphBuilder
+class AliasCFLGraphBuilder :
+    public CFLGraphBuilder
 {
 public:
     /// Builds a bidirectional CFL graph by copying nodes and edges from a const graph that inherits from GenericGraph
@@ -129,17 +130,18 @@ public:
 
 private:
     /// Connects VGep (Variable GEP)
-    void connectVGep(CFLGraph *cflGraph,  ConstraintGraph *graph, ConstraintNode *src, ConstraintNode *dst, u32_t level, SVFIR* pag);
+    void connectVGep(CFLGraph *cflGraph, ConstraintGraph *graph, ConstraintNode *src, ConstraintNode *dst, u32_t level, SVFIR* pag);
 
     /// Handles edges, with the exception of the GEP
-    void addBiCFLEdge(CFLGraph *cflGraph,  ConstraintNode* src, ConstraintNode* dst, CFGrammar::Kind label);
+    void addBiCFLEdge(CFLGraph *cflGraph, ConstraintNode* src, ConstraintNode* dst, CFGrammar::Kind label);
 
     /// Adds bidirectional GEP edges with attributes
-    void addBiGepCFLEdge(CFLGraph *cflGraph,  ConstraintNode* src, ConstraintNode* dst, CFGrammar::Attribute attri);
+    void addBiGepCFLEdge(CFLGraph *cflGraph, ConstraintNode* src, ConstraintNode* dst, CFGrammar::Attribute attri);
 };
 
 /// VFCFLGraphBuilder: a CFLGraphBuilder specialized for handling value-flow
-class VFCFLGraphBuilder : public CFLGraphBuilder
+class VFCFLGraphBuilder :
+    public CFLGraphBuilder
 {
 public:
     /// Builds a bidirectional CFL graph by copying nodes and edges from a const graph that inherits from SVFG
@@ -151,13 +153,13 @@ public:
 
 private:
     /// Connects VGep (Variable GEP)
-    void connectVGep(CFLGraph *cflGraph,  ConstraintGraph *graph, ConstraintNode *src, ConstraintNode *dst, u32_t level, SVFIR* pag);
+    void connectVGep(CFLGraph *cflGraph, ConstraintGraph *graph, ConstraintNode *src, ConstraintNode *dst, u32_t level, SVFIR* pag);
 
     /// Handles edges, with the exception of the GEP
-    void addBiCFLEdge(CFLGraph *cflGraph,  ConstraintNode* src, ConstraintNode* dst, CFGrammar::Kind label);
+    void addBiCFLEdge(CFLGraph *cflGraph, ConstraintNode* src, ConstraintNode* dst, CFGrammar::Kind label);
 
     /// Adds bidirectional GEP edges with attributes
-    void addBiGepCFLEdge(CFLGraph *cflGraph,  ConstraintNode* src, ConstraintNode* dst, CFGrammar::Attribute attri);
+    void addBiGepCFLEdge(CFLGraph *cflGraph, ConstraintNode* src, ConstraintNode* dst, CFGrammar::Attribute attri);
 };
 
 

package/SVF-osx/Release-build/include/Graphs/CallGraph.h

@@ -147,8 +147,8 @@ public:
     static inline bool classof(const GenericCallGraphEdgeTy *edge)
     {
         return edge->getEdgeKind() == CallGraphEdge::CallRetEdge ||
-               edge->getEdgeKind() == CallGraphEdge::TDForkEdge ||
-               edge->getEdgeKind() == CallGraphEdge::TDJoinEdge;
+        edge->getEdgeKind() == CallGraphEdge::TDForkEdge ||
+        edge->getEdgeKind() == CallGraphEdge::TDJoinEdge;
     }
     //@}
 
@@ -420,14 +420,14 @@ public:
     {
         CallInstToCallGraphEdgesMap::const_iterator it = callinstToCallGraphEdgesMap.find(inst);
         assert(it!=callinstToCallGraphEdgesMap.end()
-               && "call instruction does not have a valid callee");
+                   && "call instruction does not have a valid callee");
         return it->second.begin();
     }
     inline CallGraphEdgeSet::const_iterator getCallEdgeEnd(const CallICFGNode* inst) const
     {
         CallInstToCallGraphEdgesMap::const_iterator it = callinstToCallGraphEdgesMap.find(inst);
         assert(it!=callinstToCallGraphEdgesMap.end()
-               && "call instruction does not have a valid callee");
+                   && "call instruction does not have a valid callee");
         return it->second.end();
     }
     //@}

package/SVF-osx/Release-build/include/Graphs/ConsG.h

@@ -131,7 +131,7 @@ public:
     {
         ConstraintEdge edge(src,dst,kind);
         if(kind == ConstraintEdge::Copy ||
-                kind == ConstraintEdge::NormalGep || kind == ConstraintEdge::VariantGep)
+        kind == ConstraintEdge::NormalGep || kind == ConstraintEdge::VariantGep)
             return directEdgeSet.find(&edge) != directEdgeSet.end();
         else if(kind == ConstraintEdge::Addr)
             return AddrCGEdgeSet.find(&edge) != AddrCGEdgeSet.end();

package/SVF-osx/Release-build/include/Graphs/ConsGEdge.h

@@ -75,11 +75,11 @@ public:
     static inline bool classof(const GenericConsEdgeTy *edge)
     {
         return edge->getEdgeKind() == Addr ||
-               edge->getEdgeKind() == Copy ||
-               edge->getEdgeKind() == Store ||
-               edge->getEdgeKind() == Load ||
-               edge->getEdgeKind() == NormalGep ||
-               edge->getEdgeKind() == VariantGep;
+        edge->getEdgeKind() == Copy ||
+        edge->getEdgeKind() == Store ||
+        edge->getEdgeKind() == Load ||
+        edge->getEdgeKind() == NormalGep ||
+        edge->getEdgeKind() == VariantGep;
     }
     /// Constraint edge type
     typedef GenericNode<ConstraintNode, ConstraintEdge>::GEdgeSetTy ConstraintEdgeSetTy;
@@ -248,12 +248,12 @@ public:
     static inline bool classof(const ConstraintEdge *edge)
     {
         return edge->getEdgeKind() == NormalGep ||
-               edge->getEdgeKind() == VariantGep;
+        edge->getEdgeKind() == VariantGep;
     }
     static inline bool classof(const GenericConsEdgeTy *edge)
     {
         return edge->getEdgeKind() == NormalGep ||
-               edge->getEdgeKind() == VariantGep;
+        edge->getEdgeKind() == VariantGep;
     }
     //@}
 

package/SVF-osx/Release-build/include/Graphs/GenericGraph.h

@@ -123,8 +123,8 @@ public:
     virtual inline bool operator==(const GenericEdge<NodeType>* rhs) const
     {
         return (rhs->edgeFlag == this->edgeFlag &&
-                rhs->getSrcID() == this->getSrcID() &&
-                rhs->getDstID() == this->getDstID());
+        rhs->getSrcID() == this->getSrcID() &&
+        rhs->getDstID() == this->getDstID());
     }
     //@}
 
@@ -668,8 +668,8 @@ public:
     inline void removeGNode(NodeType* node)
     {
         assert(node->hasIncomingEdge() == false
-               && node->hasOutgoingEdge() == false
-               && "node which have edges can't be deleted");
+        && node->hasOutgoingEdge() == false
+                                          && "node which have edges can't be deleted");
         iterator it = IDToNodeMap.find(node->getId());
         assert(it != IDToNodeMap.end() && "can not find the node");
         IDToNodeMap.erase(it);

package/SVF-osx/Release-build/include/Graphs/ICFG.h

@@ -172,6 +172,49 @@ protected:
         }
     }
 
+    virtual inline IntraICFGNode* addIntraICFGNode(const SVFBasicBlock* bb, bool isRet)
+    {
+        IntraICFGNode* intraIcfgNode =
+            new IntraICFGNode(totalICFGNode++, bb, isRet);
+        addICFGNode(intraIcfgNode);
+        return intraIcfgNode;
+    }
+
+    virtual inline CallICFGNode* addCallICFGNode(
+        const SVFBasicBlock* bb, const SVFType* ty,
+        const SVFFunction* calledFunc, bool isVararg, bool isvcall,
+        s32_t vcallIdx, const std::string& funNameOfVcall)
+    {
+
+        CallICFGNode* callICFGNode =
+            new CallICFGNode(totalICFGNode++, bb, ty, calledFunc, isVararg,
+                             isvcall, vcallIdx, funNameOfVcall);
+        addICFGNode(callICFGNode);
+        return callICFGNode;
+    }
+
+    virtual inline RetICFGNode* addRetICFGNode(CallICFGNode* call)
+    {
+        RetICFGNode* retICFGNode = new RetICFGNode(totalICFGNode++, call);
+        call->setRetICFGNode(retICFGNode);
+        addICFGNode(retICFGNode);
+        return retICFGNode;
+    }
+
+    virtual inline FunEntryICFGNode* addFunEntryICFGNode(const SVFFunction* svfFunc)
+    {
+        FunEntryICFGNode* sNode = new FunEntryICFGNode(totalICFGNode++,svfFunc);
+        addICFGNode(sNode);
+        return FunToFunEntryNodeMap[svfFunc] = sNode;
+    }
+
+    virtual inline FunExitICFGNode* addFunExitICFGNode(const SVFFunction* svfFunc)
+    {
+        FunExitICFGNode* sNode = new FunExitICFGNode(totalICFGNode++, svfFunc);
+        addICFGNode(sNode);
+        return FunToFunExitNodeMap[svfFunc] = sNode;
+    }
+
     /// Add a ICFG node
     virtual inline void addICFGNode(ICFGNode* node)
     {

package/SVF-osx/Release-build/include/Graphs/ICFGEdge.h

@@ -72,7 +72,7 @@ public:
     inline bool isCFGEdge() const
     {
         return getEdgeKind() == IntraCF || getEdgeKind() == CallCF ||
-               getEdgeKind() == RetCF;
+        getEdgeKind() == RetCF;
     }
     inline bool isCallCFGEdge() const
     {