svf-lib 1.0.2125 → 1.0.2127

package/SVF-osx/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/Graphs/SVFGEdge.h

@@ -72,16 +72,16 @@ public:
     static inline bool classof(const VFGEdge *edge)
     {
         return edge->getEdgeKind() == IntraIndirectVF  ||
-               edge->getEdgeKind() == CallIndVF ||
-               edge->getEdgeKind() == RetIndVF ||
-               edge->getEdgeKind() == TheadMHPIndirectVF;
+        edge->getEdgeKind() == CallIndVF ||
+        edge->getEdgeKind() == RetIndVF ||
+        edge->getEdgeKind() == TheadMHPIndirectVF;
     }
     static inline bool classof(const GenericVFGEdgeTy *edge)
     {
         return edge->getEdgeKind() == IntraIndirectVF  ||
-               edge->getEdgeKind() == CallIndVF ||
-               edge->getEdgeKind() == RetIndVF ||
-               edge->getEdgeKind() == TheadMHPIndirectVF;
+        edge->getEdgeKind() == CallIndVF ||
+        edge->getEdgeKind() == RetIndVF ||
+        edge->getEdgeKind() == TheadMHPIndirectVF;
     }
     //@}
 

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

@@ -202,7 +202,7 @@ public:
     inline bool hasThreadForkEdge(const CallICFGNode* cs) const
     {
         return callinstToThreadForkEdgesMap.find(cs) !=
-               callinstToThreadForkEdgesMap.end();
+                   callinstToThreadForkEdgesMap.end();
     }
     inline ForkEdgeSet::const_iterator getForkEdgeBegin(const CallICFGNode* cs) const
     {

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

@@ -155,14 +155,14 @@ public:
     static inline bool classof(const VFGEdge *edge)
     {
         return edge->getEdgeKind() == IntraDirectVF  ||
-               edge->getEdgeKind() == CallDirVF ||
-               edge->getEdgeKind() == RetDirVF;
+        edge->getEdgeKind() == CallDirVF ||
+        edge->getEdgeKind() == RetDirVF;
     }
     static inline bool classof(const GenericVFGEdgeTy *edge)
     {
         return edge->getEdgeKind() == IntraDirectVF  ||
-               edge->getEdgeKind() == CallDirVF ||
-               edge->getEdgeKind() == RetDirVF;
+        edge->getEdgeKind() == CallDirVF ||
+        edge->getEdgeKind() == RetDirVF;
     }
     //@}
 

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

@@ -494,7 +494,7 @@ public:
 
     /// Copy assignment operator
     WTOComponentVisitor& operator=(const WTOComponentVisitor&) noexcept =
-        default;
+    default;
 
     /// Move assignment operator
     WTOComponentVisitor& operator=(WTOComponentVisitor&&) noexcept = default;
@@ -702,7 +702,7 @@ protected:
             WTOCycleDepthPtr previous_cycleDepth = _wtoCycleDepth;
             _nodeToWTOCycleDepth.insert(std::make_pair(head, _wtoCycleDepth));
             _wtoCycleDepth =
-                std::make_shared<GraphTWTOCycleDepth>(*_wtoCycleDepth);
+            std::make_shared<GraphTWTOCycleDepth>(*_wtoCycleDepth);
             _wtoCycleDepth->add(head);
             for (auto it = cycle.begin(), et = cycle.end(); it != et; ++it)
             {

package/SVF-osx/Release-build/include/MSSA/MSSAMuChi.h

@@ -439,8 +439,8 @@ public:
     static inline bool classof(const MSSADEF *chi)
     {
         return chi->getType() == MSSADEF::EntryMSSACHI ||
-               chi->getType() == MSSADEF::StoreMSSACHI ||
-               chi->getType() == MSSADEF::SSACHI ;
+        chi->getType() == MSSADEF::StoreMSSACHI ||
+        chi->getType() == MSSADEF::SSACHI ;
     }
     //@}
 

package/SVF-osx/Release-build/include/MemoryModel/AbstractPointsToDS.h

@@ -180,8 +180,8 @@ public:
     static inline bool classof(const PTData<Key, KeySet, Data, DataSet>* ptd)
     {
         return ptd->getPTDTY() == PTDataTy::Diff
-               || ptd->getPTDTY() == PTDataTy::MutDiff
-               || ptd->getPTDTY() == PTDataTy::PersDiff;
+        || ptd->getPTDTY() == PTDataTy::MutDiff
+        || ptd->getPTDTY() == PTDataTy::PersDiff;
     }
     ///@}
 };
@@ -254,10 +254,10 @@ public:
     static inline bool classof(const PTData<Key, KeySet, Data, DataSet>* ptd)
     {
         return ptd->getPTDTY() == BasePTData::DataFlow
-               || ptd->getPTDTY() == BasePTData::MutDataFlow
-               || ptd->getPTDTY() == BasePTData::MutIncDataFlow
-               || ptd->getPTDTY() == BasePTData::PersDataFlow
-               || ptd->getPTDTY() == BasePTData::PersIncDataFlow;
+        || ptd->getPTDTY() == BasePTData::MutDataFlow
+        || ptd->getPTDTY() == BasePTData::MutIncDataFlow
+        || ptd->getPTDTY() == BasePTData::PersDataFlow
+        || ptd->getPTDTY() == BasePTData::PersIncDataFlow;
     }
     ///@}
 };
@@ -299,8 +299,8 @@ public:
     static inline bool classof(const PTData<Key, KeySet, Data, DataSet>* ptd)
     {
         return ptd->getPTDTY() == PTDataTy::Versioned
-               || ptd->getPTDTY() == PTDataTy::MutVersioned
-               || ptd->getPTDTY() == PTDataTy::PersVersioned;
+        || ptd->getPTDTY() == PTDataTy::MutVersioned
+        || ptd->getPTDTY() == PTDataTy::PersVersioned;
     }
 private:
     using BasePTData::getPts;

package/SVF-osx/Release-build/include/MemoryModel/AccessPath.h

@@ -91,7 +91,7 @@ public:
     inline bool operator==(const AccessPath& rhs) const
     {
         return this->fldIdx == rhs.fldIdx &&
-               this->idxOperandPairs == rhs.idxOperandPairs && this->gepPointeeType == rhs.gepPointeeType;
+        this->idxOperandPairs == rhs.idxOperandPairs && this->gepPointeeType == rhs.gepPointeeType;
     }
     //@}
 

package/SVF-osx/Release-build/include/MemoryModel/MutablePointsToDS.h

@@ -589,7 +589,7 @@ public:
     static inline bool classof(const PTData<Key, KeySet, Data, DataSet>* ptd)
     {
         return ptd->getPTDTY() == BaseDFPTData::MutDataFlow
-               || ptd->getPTDTY() == BaseDFPTData::MutIncDataFlow;
+        || ptd->getPTDTY() == BaseDFPTData::MutIncDataFlow;
     }
     ///@}
 

package/SVF-osx/Release-build/include/MemoryModel/PersistentPointsToDS.h

@@ -541,7 +541,7 @@ public:
     static inline bool classof(const PTData<Key, KeySet, Data, DataSet> *ptd)
     {
         return ptd->getPTDTY() == PTDataTy::PersDataFlow
-               || ptd->getPTDTY() == PTDataTy::PersIncDataFlow;
+        || ptd->getPTDTY() == PTDataTy::PersIncDataFlow;
     }
     ///@}
 

package/SVF-osx/Release-build/include/SABER/SaberCondAllocator.h

@@ -86,11 +86,11 @@ public:
     //@{
     inline Condition condAnd(const Condition& lhs, const Condition& rhs)
     {
-        return Condition::AND(lhs,rhs);
+        return Condition::AND(lhs, rhs);
     }
     inline Condition condOr(const Condition& lhs, const Condition& rhs)
     {
-        return Condition::OR(lhs,rhs);
+        return Condition::OR(lhs, rhs);
     }
     inline Condition condNeg(const Condition& cond)
     {
@@ -151,7 +151,7 @@ public:
         bool funcEq = (keyFunc == valueFunc);
         (void)funcEq; // Suppress warning of unused variable under release build
         assert(funcEq && "two basicblocks should be in the same function!");
-        return keyFunc->postDominate(bbKey,bbValue);
+        return keyFunc->postDominate(bbKey, bbValue);
     }
 
     inline bool dominate(const SVFBasicBlock* bbKey, const SVFBasicBlock* bbValue) const
@@ -161,7 +161,7 @@ public:
         bool funcEq = (keyFunc == valueFunc);
         (void)funcEq; // Suppress warning of unused variable under release build
         assert(funcEq && "two basicblocks should be in the same function!");
-        return keyFunc->dominate(bbKey,bbValue);
+        return keyFunc->dominate(bbKey, bbValue);
     }
 
     /// Guard Computation for a value-flow (between two basic blocks)

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

@@ -205,7 +205,8 @@ private:
 };
 
 /// Dwarf based CHG.
-class DCHGraph : public CommonCHGraph, public GenericGraph<DCHNode, DCHEdge>
+class DCHGraph :
+    public CommonCHGraph, public GenericGraph<DCHNode, DCHEdge>
 {
 public:
     /// Returns the DIType beneath the qualifiers. Does not strip away "DW_TAG_members".
@@ -320,7 +321,7 @@ public:
         }
 
         if (!(base->getTag() == dwarf::DW_TAG_class_type ||
-                base->getTag() == dwarf::DW_TAG_structure_type))
+        base->getTag() == dwarf::DW_TAG_structure_type))
         {
             return nullptr;
         }

package/SVF-osx/Release-build/include/SVF-LLVM/LLVMModule.h

@@ -166,22 +166,22 @@ public:
     inline void addFunctionMap(const Function* func, SVFFunction* svfFunc)
     {
         LLVMFunc2SVFFunc[func] = svfFunc;
-        setValueAttr(func,svfFunc);
+        setValueAttr(func, svfFunc);
     }
     inline void addBasicBlockMap(const BasicBlock* bb, SVFBasicBlock* svfBB)
     {
         LLVMBB2SVFBB[bb] = svfBB;
-        setValueAttr(bb,svfBB);
+        setValueAttr(bb, svfBB);
     }
     inline void addInstructionMap(const Instruction* inst, SVFInstruction* svfInst)
     {
         LLVMInst2SVFInst[inst] = svfInst;
-        setValueAttr(inst,svfInst);
+        setValueAttr(inst, svfInst);
     }
     inline void addArgumentMap(const Argument* arg, SVFArgument* svfArg)
     {
         LLVMArgument2SVFArgument[arg] = svfArg;
-        setValueAttr(arg,svfArg);
+        setValueAttr(arg, svfArg);
     }
     inline void addGlobalValueMap(const GlobalValue* glob, SVFGlobalValue* svfglob)
     {

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

@@ -233,10 +233,10 @@ inline const ConstantExpr* isTruncConstantExpr(const Value* val)
     if (const ConstantExpr* constExpr = SVFUtil::dyn_cast<ConstantExpr>(val))
     {
         if (constExpr->getOpcode() == Instruction::Trunc ||
-                constExpr->getOpcode() == Instruction::FPTrunc ||
-                constExpr->getOpcode() == Instruction::ZExt ||
-                constExpr->getOpcode() == Instruction::SExt ||
-                constExpr->getOpcode() == Instruction::FPExt)
+        constExpr->getOpcode() == Instruction::FPTrunc ||
+        constExpr->getOpcode() == Instruction::ZExt ||
+        constExpr->getOpcode() == Instruction::SExt ||
+        constExpr->getOpcode() == Instruction::FPExt)
             return constExpr;
     }
     return nullptr;
@@ -247,7 +247,7 @@ inline const ConstantExpr* isCmpConstantExpr(const Value* val)
     if (const ConstantExpr* constExpr = SVFUtil::dyn_cast<ConstantExpr>(val))
     {
         if (constExpr->getOpcode() == Instruction::ICmp ||
-                constExpr->getOpcode() == Instruction::FCmp)
+        constExpr->getOpcode() == Instruction::FCmp)
             return constExpr;
     }
     return nullptr;
@@ -297,7 +297,7 @@ void getNextInsts(const Instruction* curInst,
 inline bool isNoPrecessorBasicBlock(const BasicBlock* bb)
 {
     return bb != &bb->getParent()->getEntryBlock() &&
-           pred_empty(bb);
+                 pred_empty(bb);
 }
 
 /// Check whether a file is an LLVM IR file

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

@@ -620,7 +620,7 @@ private:
 
     template <typename T,
               typename = std::enable_if_t<SVFUtil::is_iterable_v<T>>>
-                                          cJSON* toJson(const T& container)
+    cJSON* toJson(const T& container)
     {
         cJSON* array = jsonCreateArray();
         for (const auto& item : container)
@@ -792,7 +792,7 @@ public:
     template <typename FillFunc> void fillObjs(FillFunc fillFunc)
     {
         assert(jsonArray.size() == ptrPool.size() &&
-               "jsonArray and ptrPool should have same size");
+                                   "jsonArray and ptrPool should have same size");
         for (size_t i = 0; i < jsonArray.size(); ++i)
         {
             const cJSON*& objFieldJson = jsonArray[i];

package/SVF-osx/Release-build/include/SVFIR/SVFIR.h

@@ -202,7 +202,7 @@ public:
     inline bool hasPTASVFStmtList(const ICFGNode* inst) const
     {
         return icfgNode2PTASVFStmtsMap.find(inst) !=
-               icfgNode2PTASVFStmtsMap.end();
+                   icfgNode2PTASVFStmtsMap.end();
     }
     /// Given an instruction, get all its PAGEdges
     inline SVFStmtList& getSVFStmtList(const ICFGNode* inst)
@@ -601,16 +601,16 @@ private:
     inline NodeID addValNode(const SVFValue*, SVFVar *node, NodeID i)
     {
         assert(hasGNode(i) == false &&
-               "This NodeID clashes here. Please check NodeIDAllocator. Switch "
-               "Strategy::DBUG to SEQ or DENSE");
+                              "This NodeID clashes here. Please check NodeIDAllocator. Switch "
+                              "Strategy::DBUG to SEQ or DENSE");
         return addNode(node, i);
     }
     /// Add a memory obj node
     inline NodeID addObjNode(const SVFValue*, SVFVar *node, NodeID i)
     {
         assert(hasGNode(i) == false &&
-               "This NodeID clashes here. Please check NodeIDAllocator. Switch "
-               "Strategy::DBUG to SEQ or DENSE");
+                              "This NodeID clashes here. Please check NodeIDAllocator. Switch "
+                              "Strategy::DBUG to SEQ or DENSE");
         return addNode(node, i);
     }
     /// Add a unique return node for a procedure

package/SVF-osx/Release-build/include/SVFIR/SVFStatements.h

@@ -107,20 +107,20 @@ public:
     static inline bool classof(const GenericPAGEdgeTy* edge)
     {
         return edge->getEdgeKind() == SVFStmt::Addr ||
-               edge->getEdgeKind() == SVFStmt::Copy ||
-               edge->getEdgeKind() == SVFStmt::Store ||
-               edge->getEdgeKind() == SVFStmt::Load ||
-               edge->getEdgeKind() == SVFStmt::Call ||
-               edge->getEdgeKind() == SVFStmt::Ret ||
-               edge->getEdgeKind() == SVFStmt::Gep ||
-               edge->getEdgeKind() == SVFStmt::Phi ||
-               edge->getEdgeKind() == SVFStmt::Select ||
-               edge->getEdgeKind() == SVFStmt::Cmp ||
-               edge->getEdgeKind() == SVFStmt::BinaryOp ||
-               edge->getEdgeKind() == SVFStmt::UnaryOp ||
-               edge->getEdgeKind() == SVFStmt::Branch ||
-               edge->getEdgeKind() == SVFStmt::ThreadFork ||
-               edge->getEdgeKind() == SVFStmt::ThreadJoin;
+        edge->getEdgeKind() == SVFStmt::Copy ||
+        edge->getEdgeKind() == SVFStmt::Store ||
+        edge->getEdgeKind() == SVFStmt::Load ||
+        edge->getEdgeKind() == SVFStmt::Call ||
+        edge->getEdgeKind() == SVFStmt::Ret ||
+        edge->getEdgeKind() == SVFStmt::Gep ||
+        edge->getEdgeKind() == SVFStmt::Phi ||
+        edge->getEdgeKind() == SVFStmt::Select ||
+        edge->getEdgeKind() == SVFStmt::Cmp ||
+        edge->getEdgeKind() == SVFStmt::BinaryOp ||
+        edge->getEdgeKind() == SVFStmt::UnaryOp ||
+        edge->getEdgeKind() == SVFStmt::Branch ||
+        edge->getEdgeKind() == SVFStmt::ThreadFork ||
+        edge->getEdgeKind() == SVFStmt::ThreadJoin;
     }
     ///@}
 
@@ -264,26 +264,26 @@ public:
     static inline bool classof(const SVFStmt* edge)
     {
         return edge->getEdgeKind() == SVFStmt::Addr ||
-               edge->getEdgeKind() == SVFStmt::Copy ||
-               edge->getEdgeKind() == SVFStmt::Store ||
-               edge->getEdgeKind() == SVFStmt::Load ||
-               edge->getEdgeKind() == SVFStmt::Call ||
-               edge->getEdgeKind() == SVFStmt::Ret ||
-               edge->getEdgeKind() == SVFStmt::Gep ||
-               edge->getEdgeKind() == SVFStmt::ThreadFork ||
-               edge->getEdgeKind() == SVFStmt::ThreadJoin;
+        edge->getEdgeKind() == SVFStmt::Copy ||
+        edge->getEdgeKind() == SVFStmt::Store ||
+        edge->getEdgeKind() == SVFStmt::Load ||
+        edge->getEdgeKind() == SVFStmt::Call ||
+        edge->getEdgeKind() == SVFStmt::Ret ||
+        edge->getEdgeKind() == SVFStmt::Gep ||
+        edge->getEdgeKind() == SVFStmt::ThreadFork ||
+        edge->getEdgeKind() == SVFStmt::ThreadJoin;
     }
     static inline bool classof(const GenericPAGEdgeTy* edge)
     {
         return edge->getEdgeKind() == SVFStmt::Addr ||
-               edge->getEdgeKind() == SVFStmt::Copy ||
-               edge->getEdgeKind() == SVFStmt::Store ||
-               edge->getEdgeKind() == SVFStmt::Load ||
-               edge->getEdgeKind() == SVFStmt::Call ||
-               edge->getEdgeKind() == SVFStmt::Ret ||
-               edge->getEdgeKind() == SVFStmt::Gep ||
-               edge->getEdgeKind() == SVFStmt::ThreadFork ||
-               edge->getEdgeKind() == SVFStmt::ThreadJoin;
+        edge->getEdgeKind() == SVFStmt::Copy ||
+        edge->getEdgeKind() == SVFStmt::Store ||
+        edge->getEdgeKind() == SVFStmt::Load ||
+        edge->getEdgeKind() == SVFStmt::Call ||
+        edge->getEdgeKind() == SVFStmt::Ret ||
+        edge->getEdgeKind() == SVFStmt::Gep ||
+        edge->getEdgeKind() == SVFStmt::ThreadFork ||
+        edge->getEdgeKind() == SVFStmt::ThreadJoin;
     }
     //@}
 
@@ -633,12 +633,12 @@ public:
     static inline bool classof(const SVFStmt* edge)
     {
         return edge->getEdgeKind() == SVFStmt::Call ||
-               edge->getEdgeKind() == SVFStmt::ThreadFork;
+        edge->getEdgeKind() == SVFStmt::ThreadFork;
     }
     static inline bool classof(const GenericPAGEdgeTy* edge)
     {
         return edge->getEdgeKind() == SVFStmt::Call ||
-               edge->getEdgeKind() == SVFStmt::ThreadFork;
+        edge->getEdgeKind() == SVFStmt::ThreadFork;
     }
     //@}
 
@@ -694,12 +694,12 @@ public:
     static inline bool classof(const SVFStmt* edge)
     {
         return edge->getEdgeKind() == SVFStmt::Ret ||
-               edge->getEdgeKind() == SVFStmt::ThreadJoin;
+        edge->getEdgeKind() == SVFStmt::ThreadJoin;
     }
     static inline bool classof(const GenericPAGEdgeTy* edge)
     {
         return edge->getEdgeKind() == SVFStmt::Ret ||
-               edge->getEdgeKind() == SVFStmt::ThreadJoin;
+        edge->getEdgeKind() == SVFStmt::ThreadJoin;
     }
     //@}
 
@@ -763,12 +763,12 @@ public:
     static inline bool classof(const SVFStmt* node)
     {
         return node->getEdgeKind() == Phi || node->getEdgeKind() == Select ||
-               node->getEdgeKind() == BinaryOp || node->getEdgeKind() == Cmp;
+        node->getEdgeKind() == BinaryOp || node->getEdgeKind() == Cmp;
     }
     static inline bool classof(const GenericPAGEdgeTy* node)
     {
         return node->getEdgeKind() == Phi || node->getEdgeKind() == Select ||
-               node->getEdgeKind() == BinaryOp || node->getEdgeKind() == Cmp;
+        node->getEdgeKind() == BinaryOp || node->getEdgeKind() == Cmp;
     }
     //@}
     /// Operands and result at a BinaryNode e.g., p = q + r, `p` is resVar and
@@ -853,14 +853,14 @@ public:
         : MultiOpndStmt(s, opnds, SVFStmt::Phi), opICFGNodes(icfgNodes)
     {
         assert(opnds.size() == icfgNodes.size() &&
-               "Numbers of operands and their ICFGNodes are not consistent?");
+                               "Numbers of operands and their ICFGNodes are not consistent?");
     }
     void addOpVar(SVFVar* op, const ICFGNode* inode)
     {
         opVars.push_back(op);
         opICFGNodes.push_back(inode);
         assert(opVars.size() == opICFGNodes.size() &&
-               "Numbers of operands and their ICFGNodes are not consistent?");
+                                "Numbers of operands and their ICFGNodes are not consistent?");
     }
 
     /// Return the corresponding ICFGNode of this operand
@@ -1247,7 +1247,8 @@ public:
 /*!
  * Thread Fork
  */
-class TDForkPE: public CallPE
+class TDForkPE:
+    public CallPE
 {
     friend class SVFIRWriter;
     friend class SVFIRReader;
@@ -1288,7 +1289,8 @@ public:
 /*!
  * Thread Join
  */
-class TDJoinPE: public RetPE
+class TDJoinPE:
+    public RetPE
 {
     friend class SVFIRWriter;
     friend class SVFIRReader;