svf-lib 1.0.2093 → 1.0.2095

package/SVF-linux/Release-build/include/CFL/CFLAlias.h

@@ -42,7 +42,7 @@ class CFLAlias : public CFLBase
 {
 
 public:
-    typedef OrderedMap<CallSite, NodeID> CallSite2DummyValPN;
+    typedef OrderedMap<const CallICFGNode*, NodeID> CallSite2DummyValPN;
 
     CFLAlias(SVFIR* ir) : CFLBase(ir, PointerAnalysis::CFLFICI_WPA)
     {
@@ -143,9 +143,9 @@ public:
     virtual void onTheFlyCallGraphSolve(const CallSiteToFunPtrMap& callsites, CallEdgeMap& newEdges);
 
     /// Connect formal and actual parameters for indirect callsites
-    void connectCaller2CalleeParams(CallSite cs, const SVFFunction* F);
+    void connectCaller2CalleeParams(const CallICFGNode* cs, const SVFFunction* F);
 
-    void heapAllocatorViaIndCall(CallSite cs);
+    void heapAllocatorViaIndCall(const CallICFGNode* cs);
 
 private:
     CallSite2DummyValPN callsite2DummyValPN;        ///< Map an instruction to a dummy obj which created at an indirect callsite, which invokes a heap allocator

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

@@ -57,11 +57,11 @@ public:
         DI
     };
 
-    virtual bool csHasVFnsBasedonCHA(CallSite cs) = 0;
-    virtual const VFunSet &getCSVFsBasedonCHA(CallSite cs) = 0;
-    virtual bool csHasVtblsBasedonCHA(CallSite cs) = 0;
-    virtual const VTableSet &getCSVtblsBasedonCHA(CallSite cs) = 0;
-    virtual void getVFnsFromVtbls(CallSite cs, const VTableSet& vtbls,
+    virtual bool csHasVFnsBasedonCHA(const CallICFGNode* cs) = 0;
+    virtual const VFunSet &getCSVFsBasedonCHA(const CallICFGNode* cs) = 0;
+    virtual bool csHasVtblsBasedonCHA(const CallICFGNode* cs) = 0;
+    virtual const VTableSet &getCSVtblsBasedonCHA(const CallICFGNode* cs) = 0;
+    virtual void getVFnsFromVtbls(const SVFCallInst* cs, const VTableSet& vtbls,
                                   VFunSet& virtualFunctions) = 0;
 
     CHGKind getKind(void) const
@@ -222,9 +222,9 @@ public:
     typedef Set<const CHNode*> CHNodeSetTy;
     typedef FIFOWorkList<const CHNode*> WorkList;
     typedef Map<std::string, CHNodeSetTy> NameToCHNodesMap;
-    typedef Map<CallSite, CHNodeSetTy> CallSiteToCHNodesMap;
-    typedef Map<CallSite, VTableSet> CallSiteToVTableSetMap;
-    typedef Map<CallSite, VFunSet> CallSiteToVFunSetMap;
+    typedef Map<const SVFInstruction*, CHNodeSetTy> CallSiteToCHNodesMap;
+    typedef Map<const SVFInstruction*, VTableSet> CallSiteToVTableSetMap;
+    typedef Map<const SVFInstruction*, VFunSet> CallSiteToVFunSetMap;
 
     typedef enum
     {
@@ -242,7 +242,7 @@ public:
                  const std::string baseClassName,
                  CHEdge::CHEDGETYPE edgeType);
     CHNode *getNode(const std::string name) const;
-    void getVFnsFromVtbls(CallSite cs, const VTableSet &vtbls, VFunSet &virtualFunctions) override;
+    void getVFnsFromVtbls(const SVFCallInst* cs, const VTableSet &vtbls, VFunSet &virtualFunctions) override;
     void dump(const std::string& filename);
     void view();
     void printCH();
@@ -286,28 +286,10 @@ public:
         return templateNameToInstancesMap[className];
     }
 
-    inline bool csHasVtblsBasedonCHA(CallSite cs) override
-    {
-        CallSiteToVTableSetMap::const_iterator it = csToCHAVtblsMap.find(cs);
-        return it != csToCHAVtblsMap.end();
-    }
-    inline bool csHasVFnsBasedonCHA(CallSite cs) override
-    {
-        CallSiteToVFunSetMap::const_iterator it = csToCHAVFnsMap.find(cs);
-        return it != csToCHAVFnsMap.end();
-    }
-    inline const VTableSet &getCSVtblsBasedonCHA(CallSite cs) override
-    {
-        CallSiteToVTableSetMap::const_iterator it = csToCHAVtblsMap.find(cs);
-        assert(it != csToCHAVtblsMap.end() && "cs does not have vtabls based on CHA.");
-        return it->second;
-    }
-    inline const VFunSet &getCSVFsBasedonCHA(CallSite cs) override
-    {
-        CallSiteToVFunSetMap::const_iterator it = csToCHAVFnsMap.find(cs);
-        assert(it != csToCHAVFnsMap.end() && "cs does not have vfns based on CHA.");
-        return it->second;
-    }
+    bool csHasVtblsBasedonCHA(const CallICFGNode* cs) override;
+    bool csHasVFnsBasedonCHA(const CallICFGNode* cs) override;
+    const VTableSet &getCSVtblsBasedonCHA(const CallICFGNode* cs) override;
+    const VFunSet &getCSVFsBasedonCHA(const CallICFGNode* cs) override;
 
     static inline bool classof(const CommonCHGraph *chg)
     {

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

@@ -156,8 +156,8 @@ protected:
     //@{
     ICFGEdge* addIntraEdge(ICFGNode* srcNode, ICFGNode* dstNode);
     ICFGEdge* addConditionalIntraEdge(ICFGNode* srcNode, ICFGNode* dstNode, const SVFValue* condition, s32_t branchCondVal);
-    ICFGEdge* addCallEdge(ICFGNode* srcNode, ICFGNode* dstNode, const SVFInstruction* cs);
-    ICFGEdge* addRetEdge(ICFGNode* srcNode, ICFGNode* dstNode, const SVFInstruction* cs);
+    ICFGEdge* addCallEdge(ICFGNode* srcNode, ICFGNode* dstNode);
+    ICFGEdge* addRetEdge(ICFGNode* srcNode, ICFGNode* dstNode);
     //@}
     /// Remove a ICFG edge
     inline void removeICFGEdge(ICFGEdge* edge)

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

@@ -179,20 +179,14 @@ class CallCFGEdge : public ICFGEdge
     friend class SVFIRReader;
 
 private:
-    const SVFInstruction* cs;
     std::vector<const CallPE*> callPEs;
 
 public:
     /// Constructor
-    CallCFGEdge(ICFGNode* s, ICFGNode* d, const SVFInstruction* c)
-        : ICFGEdge(s, d, CallCF), cs(c)
+    CallCFGEdge(ICFGNode* s, ICFGNode* d)
+        : ICFGEdge(s, d, CallCF)
     {
     }
-    /// Return callsite ID
-    inline const SVFInstruction* getCallSite() const
-    {
-        return cs;
-    }
     /// Add call parameter edge to this CallCFGEdge
     inline void addCallPE(const CallPE* callPE)
     {
@@ -230,19 +224,13 @@ class RetCFGEdge : public ICFGEdge
     friend class SVFIRReader;
 
 private:
-    const SVFInstruction* cs;
     const RetPE* retPE;
 
 public:
     /// Constructor
-    RetCFGEdge(ICFGNode* s, ICFGNode* d, const SVFInstruction* c)
-        : ICFGEdge(s, d, RetCF), cs(c), retPE(nullptr)
-    {
-    }
-    /// Return callsite ID
-    inline const SVFInstruction* getCallSite() const
+    RetCFGEdge(ICFGNode* s, ICFGNode* d)
+        : ICFGEdge(s, d, RetCF), retPE(nullptr)
     {
-        return cs;
     }
     /// Add call parameter edge to this CallCFGEdge
     inline void addRetPE(const RetPE* ret)

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

@@ -476,6 +476,64 @@ public:
     {
         APNodes.push_back(ap);
     }
+    /// Parameter operations
+    //@{
+    const SVFValue* getArgument(u32_t ArgNo) const
+    {
+        return SVFUtil::cast<SVFCallInst>(cs)->getArgOperand(ArgNo);
+    }
+    const SVFType* getType() const
+    {
+        return SVFUtil::cast<SVFCallInst>(cs)->getType();
+    }
+    u32_t arg_size() const
+    {
+        return SVFUtil::cast<SVFCallInst>(cs)->arg_size();
+    }
+    bool arg_empty() const
+    {
+        return SVFUtil::cast<SVFCallInst>(cs)->arg_empty();
+    }
+    const SVFValue* getArgOperand(u32_t i) const
+    {
+        return SVFUtil::cast<SVFCallInst>(cs)->getArgOperand(i);
+    }
+    u32_t getNumArgOperands() const
+    {
+        return SVFUtil::cast<SVFCallInst>(cs)->arg_size();
+    }
+    const SVFFunction* getCalledFunction() const
+    {
+        return SVFUtil::cast<SVFCallInst>(cs)->getCalledFunction();
+    }
+    const SVFValue* getCalledValue() const
+    {
+        return SVFUtil::cast<SVFCallInst>(cs)->getCalledOperand();
+    }
+    bool isVarArg() const
+    {
+        return SVFUtil::cast<SVFCallInst>(cs)->isVarArg();
+    }
+    bool isVirtualCall() const
+    {
+        return SVFUtil::isa<SVFVirtualCallInst>(cs);
+    }
+    const SVFValue* getVtablePtr() const
+    {
+        assert(isVirtualCall() && "not a virtual call?");
+        return SVFUtil::cast<SVFVirtualCallInst>(cs)->getVtablePtr();
+    }
+    s32_t getFunIdxInVtable() const
+    {
+        assert(isVirtualCall() && "not a virtual call?");
+        return SVFUtil::cast<SVFVirtualCallInst>(cs)->getFunIdxInVtable();
+    }
+    const std::string& getFunNameOfVirtualCall() const
+    {
+        assert(isVirtualCall() && "not a virtual call?");
+        return SVFUtil::cast<SVFVirtualCallInst>(cs)->getFunNameOfVirtualCall();
+    }
+    //@}
 
     ///Methods for support type inquiry through isa, cast, and dyn_cast:
     //@{

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

@@ -72,9 +72,9 @@ public:
         std::string str;
         std::stringstream rawstr(str);
         rawstr << "ThreadForkEdge ";
-        rawstr << "CallSite ID: " << getCallSiteID();
-        rawstr << " srcNode ID " << getSrcID() << " (fun: " << getSrcNode()->getFunction()->getName() << ")";
-        rawstr << " dstNode ID " << getDstID() << " (fun: " << getDstNode()->getFunction()->getName() << ")";
+        rawstr << "CallSiteID: " << getCallSiteID();
+        rawstr << " srcNodeID " << getSrcID() << " (fun: " << getSrcNode()->getFunction()->getName() << ")";
+        rawstr << " dstNodeID " << getDstID() << " (fun: " << getDstNode()->getFunction()->getName() << ")";
         return rawstr.str();
     }
 
@@ -112,9 +112,9 @@ public:
         std::string str;
         std::stringstream rawstr(str);
         rawstr << "ThreadJoinEdge ";
-        rawstr << "CallSite ID: " << getCallSiteID();
-        rawstr << " srcNode ID " << getSrcID() << " (fun: " << getSrcNode()->getFunction()->getName() << ")";
-        rawstr << " dstNode ID " << getDstID() << " (fun: " << getDstNode()->getFunction()->getName() << ")";
+        rawstr << "CallSiteID: " << getCallSiteID();
+        rawstr << " srcNodeID " << getSrcID() << " (fun: " << getSrcNode()->getFunction()->getName() << ")";
+        rawstr << " dstNodeID " << getDstID() << " (fun: " << getDstNode()->getFunction()->getName() << ")";
         return rawstr.str();
     }
 

package/SVF-linux/Release-build/include/MTA/MHP.h

@@ -377,7 +377,7 @@ private:
     bool sameLoopTripCount(const ICFGNode* forkSite, const ICFGNode* joinSite);
 
     /// Whether it is a matched fork join pair
-    bool isAliasedForkJoin(const ICFGNode* forkSite, const ICFGNode* joinSite)
+    bool isAliasedForkJoin(const CallICFGNode* forkSite, const CallICFGNode* joinSite)
     {
         return tct->getPTA()->alias(getForkedThread(forkSite), getJoinedThread(joinSite)) && isSameSCEV(forkSite,joinSite);
     }
@@ -469,12 +469,12 @@ private:
         return getTCG()->getThreadAPI()->isTDJoin(call);
     }
     /// Get forked thread
-    inline const SVFValue* getForkedThread(const ICFGNode* call)
+    inline const SVFValue* getForkedThread(const CallICFGNode* call)
     {
         return getTCG()->getThreadAPI()->getForkedThread(call);
     }
     /// Get joined thread
-    inline const SVFValue* getJoinedThread(const ICFGNode* call)
+    inline const SVFValue* getJoinedThread(const CallICFGNode* call)
     {
         return getTCG()->getThreadAPI()->getJoinedThread(call);
     }

package/SVF-linux/Release-build/include/MTA/TCT.h

@@ -246,7 +246,7 @@ public:
     inline bool isExtCall(const ICFGNode* inst)
     {
         if(const CallICFGNode* call = SVFUtil::dyn_cast<CallICFGNode>(inst))
-            return SVFUtil::isExtCall(call->getCallSite());
+            return SVFUtil::isExtCall(call);
         return false;
     }
     /// Whether it is a callsite

package/SVF-linux/Release-build/include/SVF-LLVM/DCHG.h

@@ -249,12 +249,12 @@ public:
 
     void print(void);
 
-    virtual bool csHasVFnsBasedonCHA(CallSite cs) override
+    virtual bool csHasVFnsBasedonCHA(const CallICFGNode* cs) override
     {
         return csHasVtblsBasedonCHA(cs);
     }
 
-    virtual const VFunSet &getCSVFsBasedonCHA(CallSite cs) override;
+    virtual const VFunSet &getCSVFsBasedonCHA(const CallICFGNode* cs) override;
 
     virtual bool csHasVtblsBasedonCHA(CallBase* cs)
     {
@@ -268,14 +268,14 @@ public:
         return getNode(type)->getVTable() != nullptr;
     }
 
-    virtual bool csHasVtblsBasedonCHA(CallSite cs) override
+    virtual bool csHasVtblsBasedonCHA(const CallICFGNode* cs) override
     {
         assert(false && "not supported!");
         abort();
     }
 
-    virtual const VTableSet &getCSVtblsBasedonCHA(CallSite cs) override;
-    virtual void getVFnsFromVtbls(CallSite cs, const VTableSet &vtbls, VFunSet &virtualFunctions) override;
+    virtual const VTableSet &getCSVtblsBasedonCHA(const CallICFGNode* cs) override;
+    virtual void getVFnsFromVtbls(const SVFCallInst* cs, const VTableSet &vtbls, VFunSet &virtualFunctions) override;
 
     /// Returns true if a is a transitive base of b. firstField determines
     /// whether to consider first-field edges.
@@ -373,7 +373,7 @@ protected:
     /// Maps types to a set with their vtable and all their children's.
     Map<const DIType*, VTableSet> vtblCHAMap;
     /// Maps callsites to a set of potential virtual functions based on CHA.
-    Map<CallSite, VFunSet> csCHAMap;
+    Map<const CallICFGNode*, VFunSet> csCHAMap;
     /// Maps types to their canonical type (many-to-one).
     Map<const DIType*, const DIType*> canonicalTypeMap;
     /// Set of all possible canonical types (i.e. values of canonicalTypeMap).
@@ -414,7 +414,7 @@ private:
     /// Retrieves the metadata associated with a *virtual* callsite.
     const DIType* getCSStaticType(CallBase* cs) const;
 
-    const DIType *getCSStaticType(CallSite cs) const
+    const DIType *getCSStaticType(const CallICFGNode* cs) const
     {
         assert(false && "not supported!");
         abort();

package/SVF-linux/Release-build/include/SVF-LLVM/LLVMUtil.h

@@ -287,14 +287,6 @@ inline static DataLayout* getDataLayout(Module* mod)
     return dl;
 }
 
-/// Get the next instructions following control flow
-void getNextInsts(const Instruction* curInst,
-                  std::vector<const SVFInstruction*>& instList);
-
-/// Get the previous instructions following control flow
-void getPrevInsts(const Instruction* curInst,
-                  std::vector<const SVFInstruction*>& instList);
-
 /// Get the next instructions following control flow
 void getNextInsts(const Instruction* curInst,
                   std::vector<const Instruction*>& instList);

package/SVF-linux/Release-build/include/SVFIR/SVFFileSystem.h

@@ -421,7 +421,6 @@ private:
     cJSON* toJson(const CHNode* node);         // CHGraph Node
     cJSON* toJson(const CHEdge* edge);         // CHGraph Edge
 
-    cJSON* toJson(const CallSite& cs);
     cJSON* toJson(const AccessPath& ap);
     cJSON* toJson(const SVFLoop* loop);
     cJSON* toJson(const MemObj* memObj);
@@ -1104,7 +1103,6 @@ private:
     void readJson(const cJSON* obj, ICFGEdge*& edge); // ICFG Edge
     void readJson(const cJSON* obj, CHNode*& node); // CHGraph Node
     void readJson(const cJSON* obj, CHEdge*& edge); // CHGraph Edge
-    void readJson(const cJSON* obj, CallSite& cs); // CHGraph's csToClassMap
 
     void readJson(const cJSON* obj, AccessPath& ap);
     void readJson(const cJSON* obj, SVFLoop*& loop);

package/SVF-linux/Release-build/include/SVFIR/SVFValue.h

@@ -637,15 +637,11 @@ class SVFInstruction : public SVFValue
 {
     friend class SVFIRWriter;
     friend class SVFIRReader;
-public:
-    typedef std::vector<const SVFInstruction*> InstVec;
 
 private:
     const SVFBasicBlock* bb;    /// The BasicBlock where this Instruction resides
     bool terminator;    /// return true if this is a terminator instruction
     bool ret;           /// return true if this is an return instruction of a function
-    InstVec succInsts;  /// successor Instructions
-    InstVec predInsts;  /// predecessor Instructions
 
 public:
     /// Constructor without name, set name with setName()
@@ -665,36 +661,11 @@ public:
         return bb;
     }
 
-    inline InstVec& getSuccInstructions()
-    {
-        return succInsts;
-    }
-
-    inline InstVec& getPredInstructions()
-    {
-        return predInsts;
-    }
-
-    inline const InstVec& getSuccInstructions() const
-    {
-        return succInsts;
-    }
-
-    inline const InstVec& getPredInstructions() const
-    {
-        return predInsts;
-    }
-
     inline const SVFFunction* getFunction() const
     {
         return bb->getParent();
     }
 
-    inline bool isTerminator() const
-    {
-        return terminator;
-    }
-
     inline bool isRetInst() const
     {
         return ret;
@@ -1115,98 +1086,6 @@ public:
 };
 
 
-class CallSite
-{
-    friend class SVFIRReader;
-
-private:
-    const SVFCallInst* CB;
-
-    /// Constructs empty CallSite (for SVFIRReader/deserialization)
-    CallSite() : CB{} {}
-
-public:
-    CallSite(const SVFInstruction* I) : CB(SVFUtil::dyn_cast<SVFCallInst>(I))
-    {
-        assert(CB && "not a callsite?");
-    }
-    const SVFInstruction* getInstruction() const
-    {
-        return CB;
-    }
-    const SVFValue* getArgument(u32_t ArgNo) const
-    {
-        return CB->getArgOperand(ArgNo);
-    }
-    const SVFType* getType() const
-    {
-        return CB->getType();
-    }
-    u32_t arg_size() const
-    {
-        return CB->arg_size();
-    }
-    bool arg_empty() const
-    {
-        return CB->arg_empty();
-    }
-    const SVFValue* getArgOperand(u32_t i) const
-    {
-        return CB->getArgOperand(i);
-    }
-    u32_t getNumArgOperands() const
-    {
-        return CB->arg_size();
-    }
-    const SVFFunction* getCalledFunction() const
-    {
-        return CB->getCalledFunction();
-    }
-    const SVFValue* getCalledValue() const
-    {
-        return CB->getCalledOperand();
-    }
-    const SVFFunction* getCaller() const
-    {
-        return CB->getCaller();
-    }
-    bool isVarArg() const
-    {
-        return CB->isVarArg();
-    }
-    bool isVirtualCall() const
-    {
-        return SVFUtil::isa<SVFVirtualCallInst>(CB);
-    }
-    const SVFValue* getVtablePtr() const
-    {
-        assert(isVirtualCall() && "not a virtual call?");
-        return SVFUtil::cast<SVFVirtualCallInst>(CB)->getVtablePtr();
-    }
-    s32_t getFunIdxInVtable() const
-    {
-        assert(isVirtualCall() && "not a virtual call?");
-        return SVFUtil::cast<SVFVirtualCallInst>(CB)->getFunIdxInVtable();
-    }
-    const std::string& getFunNameOfVirtualCall() const
-    {
-        assert(isVirtualCall() && "not a virtual call?");
-        return SVFUtil::cast<SVFVirtualCallInst>(CB)->getFunNameOfVirtualCall();
-    }
-    bool operator==(const CallSite& CS) const
-    {
-        return CB == CS.CB;
-    }
-    bool operator!=(const CallSite& CS) const
-    {
-        return CB != CS.CB;
-    }
-    bool operator<(const CallSite& CS) const
-    {
-        return getInstruction() < CS.getInstruction();
-    }
-};
-
 /// [FOR DEBUG ONLY, DON'T USE IT UNSIDE `svf`!]
 /// Converts an SVFValue to corresponding LLVM::Value, then get the string
 /// representation of it. Use it only when you are debugging. Don't use
@@ -1222,14 +1101,4 @@ OutStream& operator<< (OutStream &o, const std::pair<F, S> &var)
 
 } // End namespace SVF
 
-/// Specialise hash for CallSites.
-template <> struct std::hash<SVF::CallSite>
-{
-    size_t operator()(const SVF::CallSite &cs) const
-    {
-        std::hash<const SVF::SVFInstruction *> h;
-        return h(cs.getInstruction());
-    }
-};
-
 #endif /* INCLUDE_SVFIR_SVFVALUE_H_ */