svf-tools 1.0.983 → 1.0.985

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "svf-tools",
-  "version": "1.0.983",
+  "version": "1.0.985",
   "description": "* <b>[TypeClone](https://github.com/SVF-tools/SVF/wiki/TypeClone) published in our [ECOOP paper](https://yuleisui.github.io/publications/ecoop20.pdf) is now available in SVF </b> * <b>SVF now uses a single script for its build. Just type [`source ./build.sh`](https://github.com/SVF-tools/SVF/blob/master/build.sh) in your terminal, that's it!</b> * <b>SVF now supports LLVM-10.0.0! </b> * <b>We thank [bsauce](https://github.com/bsauce) for writing a user manual of SVF ([link1](https://www.jianshu.com/p/068a08ec749c) and [link2](https://www.jianshu.com/p/777c30d4240e)) in Chinese </b> * <b>SVF now supports LLVM-9.0.0 (Thank [Byoungyoung Lee](https://github.com/SVF-tools/SVF/issues/142) for his help!). </b> * <b>SVF now supports a set of [field-sensitive pointer analyses](https://yuleisui.github.io/publications/sas2019a.pdf). </b> * <b>[Use SVF as an external lib](https://github.com/SVF-tools/SVF/wiki/Using-SVF-as-a-lib-in-your-own-tool) for your own project (Contributed by [Hongxu Chen](https://github.com/HongxuChen)). </b> * <b>SVF now supports LLVM-7.0.0. </b> * <b>SVF now supports Docker. [Try SVF in Docker](https://github.com/SVF-tools/SVF/wiki/Try-SVF-in-Docker)! </b> * <b>SVF now supports [LLVM-6.0.0](https://github.com/svf-tools/SVF/pull/38) (Contributed by [Jack Anthony](https://github.com/jackanth)). </b> * <b>SVF now supports [LLVM-4.0.0](https://github.com/svf-tools/SVF/pull/23) (Contributed by Jared Carlson. Thank [Jared](https://github.com/jcarlson23) and [Will](https://github.com/dtzWill) for their in-depth [discussions](https://github.com/svf-tools/SVF/pull/18) about updating SVF!) </b> * <b>SVF now supports analysis for C++ programs.</b> <br />",
   "main": "index.js",
   "scripts": {

package/svf/include/AE/Svfexe/AbstractInterpretation.h

@@ -358,7 +358,7 @@ protected:
 
 protected:
     // there data should be shared with subclasses
-    Map<std::string, std::function<void(const CallSite &)>> func_map;
+    Map<std::string, std::function<void(const CallICFGNode*)>> func_map;
     Set<const CallICFGNode*> checkpoints;
     Set<std::string> checkpoint_names;
     Map<const ICFGNode*, AbstractState>

package/svf/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/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/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/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/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/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/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/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/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/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_ */

package/svf/include/Util/SVFUtil.h

@@ -200,11 +200,6 @@ inline bool isNonInstricCallSite(const ICFGNode* inst)
     return isCallSite(inst);
 }
 
-
-/// Return callsite given an instruction
-CallSite getSVFCallSite(const ICFGNode* inst);
-
-
 /// Match arguments for callsite at caller and callee
 /// if the arg size does not match then we do not need to connect this parameter
 /// unless the callee is a variadic function (the first parameter of variadic function is its parameter number)
@@ -235,19 +230,20 @@ inline std::vector<std::string> split(const std::string& s, char separator)
 
 /// Return callee of a callsite. Return null if this is an indirect call
 //@{
-inline const SVFFunction* getCallee(const CallSite cs)
+inline const SVFFunction* getCallee(const SVFCallInst* cs)
 {
-    return cs.getCalledFunction();
+    return cs->getCalledFunction();
 }
 
 inline const SVFFunction* getCallee(const SVFInstruction *inst)
 {
     if (!isCallSite(inst))
         return nullptr;
-    CallSite cs(inst);
-    return getCallee(cs);
+    return getCallee(cast<SVFCallInst>(inst));
 }
 
+const SVFFunction* getCallee(const CallICFGNode *inst);
+
 const SVFFunction* getCallee(const ICFGNode *inst);
 //@}
 
@@ -401,47 +397,37 @@ inline bool isArgOfUncalledFunction(const SVFValue* svfval)
 
 /// Return thread fork function
 //@{
-inline const SVFValue* getForkedFun(const ICFGNode *inst)
+inline const SVFValue* getForkedFun(const CallICFGNode *inst)
 {
     return ThreadAPI::getThreadAPI()->getForkedFun(inst);
 }
 //@}
 
 
-inline bool isExtCall(const CallSite cs)
+inline bool isExtCall(const CallICFGNode* cs)
 {
     return isExtCall(getCallee(cs));
 }
 
 bool isExtCall(const ICFGNode* node);
 
-inline bool isExtCall(const SVFInstruction *inst)
-{
-    return isExtCall(getCallee(inst));
-}
-
-inline bool isHeapAllocExtCallViaArg(const CallSite cs)
+inline bool isHeapAllocExtCallViaArg(const CallICFGNode* cs)
 {
     return isHeapAllocExtFunViaArg(getCallee(cs));
 }
 
 inline bool isHeapAllocExtCallViaArg(const SVFInstruction *inst)
 {
-    return isHeapAllocExtFunViaArg(getCallee(inst));
+    if(const SVFCallInst* call = SVFUtil::dyn_cast<SVFCallInst>(inst))
+        return isHeapAllocExtFunViaArg(call->getCalledFunction());
+    else
+        return false;
 }
 
-/// interfaces to be used externally
-inline bool isHeapAllocExtCallViaRet(const CallSite cs)
-{
-    bool isPtrTy = cs.getInstruction()->getType()->isPointerTy();
-    return isPtrTy && isHeapAllocExtFunViaRet(getCallee(cs));
-}
+bool isHeapAllocExtCallViaRet(const SVFInstruction *inst);
 
-inline bool isHeapAllocExtCallViaRet(const SVFInstruction *inst)
-{
-    bool isPtrTy = inst->getType()->isPointerTy();
-    return isPtrTy && isHeapAllocExtFunViaRet(getCallee(inst));
-}
+/// interfaces to be used externally
+bool isHeapAllocExtCallViaRet(const CallICFGNode* cs);
 
 bool isHeapAllocExtCall(const ICFGNode* cs);
 
@@ -449,19 +435,16 @@ inline bool isHeapAllocExtCall(const SVFInstruction *inst)
 {
     return isHeapAllocExtCallViaRet(inst) || isHeapAllocExtCallViaArg(inst);
 }
+
 //@}
 
-inline int getHeapAllocHoldingArgPosition(const CallSite cs)
+inline int getHeapAllocHoldingArgPosition(const CallICFGNode* cs)
 {
     return getHeapAllocHoldingArgPosition(getCallee(cs));
 }
 //@}
 
-inline bool isReallocExtCall(const CallSite cs)
-{
-    bool isPtrTy = cs.getInstruction()->getType()->isPointerTy();
-    return isPtrTy && isReallocExtFun(getCallee(cs));
-}
+bool isReallocExtCall(const CallICFGNode* cs);
 //@}
 
 /// Return true if this is a thread creation call
@@ -514,14 +497,14 @@ inline bool isBarrierWaitCall(const ICFGNode* cs)
 
 /// Return sole argument of the thread routine
 //@{
-inline const SVFValue* getActualParmAtForkSite(const ICFGNode* cs)
+inline const SVFValue* getActualParmAtForkSite(const CallICFGNode* cs)
 {
     return ThreadAPI::getThreadAPI()->getActualParmAtForkSite(cs);
 }
 //@}
 
 
-inline bool isProgExitCall(const CallSite cs)
+inline bool isProgExitCall(const CallICFGNode* cs)
 {
     return isProgExitFunction(getCallee(cs));
 }

package/svf/include/Util/ThreadAPI.h

@@ -122,7 +122,6 @@ public:
     /// Return the callee/callsite/func
     //@{
     const SVFFunction* getCallee(const ICFGNode *inst) const;
-    const CallSite getSVFCallSite(const ICFGNode *inst) const;
     //@}
 
     /// Return true if this call create a new thread
@@ -137,29 +136,14 @@ public:
     //@{
     /// Return the first argument of the call,
     /// Note that, it is the pthread_t pointer
-    inline const SVFValue* getForkedThread(const ICFGNode *inst) const
-    {
-        assert(isTDFork(inst) && "not a thread fork function!");
-        CallSite cs = getSVFCallSite(inst);
-        return cs.getArgument(0);
-    }
+    const SVFValue* getForkedThread(const CallICFGNode *inst) const;
     /// Return the third argument of the call,
     /// Note that, it could be function type or a void* pointer
-    inline const SVFValue* getForkedFun(const ICFGNode *inst) const
-    {
-        assert(isTDFork(inst) && "not a thread fork function!");
-        CallSite cs = getSVFCallSite(inst);
-        return cs.getArgument(2);
-    }
+    const SVFValue* getForkedFun(const CallICFGNode *inst) const;
 
     /// Return the forth argument of the call,
     /// Note that, it is the sole argument of start routine ( a void* pointer )
-    inline const SVFValue* getActualParmAtForkSite(const ICFGNode *inst) const
-    {
-        assert(isTDFork(inst) && "not a thread fork function!");
-        CallSite cs = getSVFCallSite(inst);
-        return cs.getArgument(3);
-    }
+    const SVFValue* getActualParmAtForkSite(const CallICFGNode *inst) const;
     //@}
 
     /// Return true if this call wait for a worker thread
@@ -174,15 +158,10 @@ public:
     //@{
     /// Return the first argument of the call,
     /// Note that, it is the pthread_t pointer
-    const SVFValue* getJoinedThread(const ICFGNode *inst) const;
+    const SVFValue* getJoinedThread(const CallICFGNode *inst) const;
     /// Return the send argument of the call,
     /// Note that, it is the pthread_t pointer
-    inline const SVFValue* getRetParmAtJoinedSite(const ICFGNode *inst) const
-    {
-        assert(isTDJoin(inst) && "not a thread join function!");
-        CallSite cs = getSVFCallSite(inst);
-        return cs.getArgument(1);
-    }
+    const SVFValue* getRetParmAtJoinedSite(const CallICFGNode *inst) const;
     //@}