svf-tools 1.0.678 → 1.0.680

package/svf/include/SVFIR/SVFStatements.h

@@ -50,30 +50,44 @@ class FunExitICFGNode;
 typedef GenericEdge<SVFVar> GenericPAGEdgeTy;
 class SVFStmt : public GenericPAGEdgeTy
 {
+    friend class SVFIRWriter;
 
 public:
     /// Types of SVFIR statements
     /// Gep represents (base + offset) for field sensitivity
-    /// ThreadFork/ThreadJoin is to model parameter passings between thread spawners and spawnees.
+    /// ThreadFork/ThreadJoin is to model parameter passings between thread
+    /// spawners and spawnees.
     enum PEDGEK
     {
-        Addr, Copy, Store, Load, Call, Ret, Gep, Phi, Select, Cmp, BinaryOp, UnaryOp, Branch, ThreadFork, ThreadJoin
+        Addr,
+        Copy,
+        Store,
+        Load,
+        Call,
+        Ret,
+        Gep,
+        Phi,
+        Select,
+        Cmp,
+        BinaryOp,
+        UnaryOp,
+        Branch,
+        ThreadFork,
+        ThreadJoin
     };
 
 private:
-    const SVFValue* value;	///< LLVM value
-    const SVFBasicBlock* basicBlock;   ///< LLVM BasicBlock
-    ICFGNode *icfgNode;   ///< ICFGNode
-    EdgeID edgeId;					///< Edge ID
+    const SVFValue* value;           ///< LLVM value
+    const SVFBasicBlock* basicBlock; ///< LLVM BasicBlock
+    ICFGNode* icfgNode;              ///< ICFGNode
+    EdgeID edgeId;                   ///< Edge ID
 public:
-    static u32_t totalEdgeNum;		///< Total edge number
+    static u32_t totalEdgeNum; ///< Total edge number
 
     /// Constructor
-    SVFStmt(SVFVar* s, SVFVar* d, GEdgeFlag k, bool real=true);
+    SVFStmt(SVFVar* s, SVFVar* d, GEdgeFlag k, bool real = true);
     /// Destructor
-    ~SVFStmt()
-    {
-    }
+    ~SVFStmt() {}
 
     /// ClassOf
     //@{
@@ -81,7 +95,7 @@ public:
     {
         return true;
     }
-    static inline bool classof(const GenericPAGEdgeTy *edge)
+    static inline bool classof(const GenericPAGEdgeTy* edge)
     {
         return edge->getEdgeKind() == SVFStmt::Addr ||
                edge->getEdgeKind() == SVFStmt::Copy ||
@@ -92,7 +106,7 @@ public:
                edge->getEdgeKind() == SVFStmt::Gep ||
                edge->getEdgeKind() == SVFStmt::Cmp ||
                edge->getEdgeKind() == SVFStmt::BinaryOp ||
-               edge->getEdgeKind() == SVFStmt::UnaryOp  ||
+               edge->getEdgeKind() == SVFStmt::UnaryOp ||
                edge->getEdgeKind() == SVFStmt::ThreadFork ||
                edge->getEdgeKind() == SVFStmt::ThreadJoin;
     }
@@ -130,7 +144,7 @@ public:
     {
         return basicBlock;
     }
-    inline void setICFGNode(ICFGNode *node)
+    inline void setICFGNode(ICFGNode* node)
     {
         icfgNode = node;
     }
@@ -140,31 +154,36 @@ public:
     }
     //@}
 
-    /// Compute the unique edgeFlag value from edge kind and second variable operand for MultiOpndStmt.
-    static inline GEdgeFlag makeEdgeFlagWithAddionalOpnd(GEdgeKind k, const SVFVar* var)
+    /// 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++;
+        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)
+    /// Compute the unique edgeFlag value from edge kind and call site
+    /// Instruction.
+    static inline GEdgeFlag makeEdgeFlagWithCallInst(GEdgeKind k,
+            const ICFGNode* cs)
     {
         Inst2LabelMap::const_iterator iter = inst2LabelMap.find(cs);
-        u64_t label = (iter != inst2LabelMap.end()) ?
-                      iter->second : callEdgeLabelCounter++;
+        u64_t label = (iter != inst2LabelMap.end()) ? iter->second
+                      : callEdgeLabelCounter++;
         return (label << EdgeKindMaskBits) | k;
     }
 
     /// Compute the unique edgeFlag value from edge kind and store Instruction.
     /// Two store instructions may share the same StorePAGEdge
-    static inline GEdgeFlag makeEdgeFlagWithStoreInst(GEdgeKind k, const ICFGNode* store)
+    static inline GEdgeFlag makeEdgeFlagWithStoreInst(GEdgeKind k,
+            const ICFGNode* store)
     {
         Inst2LabelMap::const_iterator iter = inst2LabelMap.find(store);
-        u64_t label = (iter != inst2LabelMap.end()) ?
-                      iter->second : storeEdgeLabelCounter++;
+        u64_t label = (iter != inst2LabelMap.end()) ? iter->second
+                      : storeEdgeLabelCounter++;
         return (label << EdgeKindMaskBits) | k;
     }
 
@@ -202,6 +221,7 @@ private:
 */
 class AssignStmt : public SVFStmt
 {
+    friend class SVFIRWriter;
 
 private:
     AssignStmt();                      ///< place holder
@@ -214,18 +234,16 @@ private:
 
 protected:
     /// constructor
-    AssignStmt(SVFVar* s, SVFVar* d, GEdgeFlag k) : SVFStmt(s,d,k)
-    {
-    }
+    AssignStmt(SVFVar* s, SVFVar* d, GEdgeFlag k) : SVFStmt(s, d, k) {}
 
 public:
     /// Methods for support type inquiry through isa, cast, and dyn_cast:
     //@{
-    static inline bool classof(const AssignStmt *)
+    static inline bool classof(const AssignStmt*)
     {
         return true;
     }
-    static inline bool classof(const SVFStmt *edge)
+    static inline bool classof(const SVFStmt* edge)
     {
         return edge->getEdgeKind() == SVFStmt::Addr ||
                edge->getEdgeKind() == SVFStmt::Copy ||
@@ -237,7 +255,7 @@ public:
                edge->getEdgeKind() == SVFStmt::ThreadFork ||
                edge->getEdgeKind() == SVFStmt::ThreadJoin;
     }
-    static inline bool classof(const GenericPAGEdgeTy *edge)
+    static inline bool classof(const GenericPAGEdgeTy* edge)
     {
         return edge->getEdgeKind() == SVFStmt::Addr ||
                edge->getEdgeKind() == SVFStmt::Copy ||
@@ -276,67 +294,66 @@ public:
  */
 class AddrStmt: public AssignStmt
 {
+    friend class SVFIRWriter;
+
 private:
     AddrStmt();                      ///< place holder
-    AddrStmt(const AddrStmt &);  ///< place holder
-    void operator=(const AddrStmt &); ///< place holder
+    AddrStmt(const AddrStmt&);       ///< place holder
+    void operator=(const AddrStmt&); ///< place holder
 
 public:
     /// Methods for support type inquiry through isa, cast, and dyn_cast:
     //@{
-    static inline bool classof(const AddrStmt *)
+    static inline bool classof(const AddrStmt*)
     {
         return true;
     }
-    static inline bool classof(const SVFStmt *edge)
+    static inline bool classof(const SVFStmt* edge)
     {
         return edge->getEdgeKind() == SVFStmt::Addr;
     }
-    static inline bool classof(const GenericPAGEdgeTy *edge)
+    static inline bool classof(const GenericPAGEdgeTy* edge)
     {
         return edge->getEdgeKind() == SVFStmt::Addr;
     }
     //@}
 
     /// constructor
-    AddrStmt(SVFVar* s, SVFVar* d) : AssignStmt(s,d,SVFStmt::Addr)
-    {
-    }
+    AddrStmt(SVFVar* s, SVFVar* d) : AssignStmt(s, d, SVFStmt::Addr) {}
 
     virtual const std::string toString() const override;
 };
 
-
 /*!
  * Copy statements (simple assignment and casting)
  */
 class CopyStmt: public AssignStmt
 {
+    friend class SVFIRWriter;
+
 private:
     CopyStmt();                      ///< place holder
-    CopyStmt(const CopyStmt &);  ///< place holder
-    void operator=(const CopyStmt &); ///< place holder
+    CopyStmt(const CopyStmt&);       ///< place holder
+    void operator=(const CopyStmt&); ///< place holder
 public:
     /// Methods for support type inquiry through isa, cast, and dyn_cast:
     //@{
-    static inline bool classof(const CopyStmt *)
+    static inline bool classof(const CopyStmt*)
     {
         return true;
     }
-    static inline bool classof(const SVFStmt *edge)
+    static inline bool classof(const SVFStmt* edge)
     {
         return edge->getEdgeKind() == SVFStmt::Copy;
     }
-    static inline bool classof(const GenericPAGEdgeTy *edge)
+    static inline bool classof(const GenericPAGEdgeTy* edge)
     {
         return edge->getEdgeKind() == SVFStmt::Copy;
     }
     //@}
 
     /// constructor
-    CopyStmt(SVFVar* s, SVFVar* d) : AssignStmt(s,d,SVFStmt::Copy)
-    {
-    }
+    CopyStmt(SVFVar* s, SVFVar* d) : AssignStmt(s, d, SVFStmt::Copy) {}
 
     virtual const std::string toString() const override;
 };
@@ -346,23 +363,25 @@ public:
  */
 class StoreStmt: public AssignStmt
 {
+    friend class SVFIRWriter;
+
 private:
     StoreStmt();                      ///< place holder
-    StoreStmt(const StoreStmt &);  ///< place holder
-    void operator=(const StoreStmt &); ///< place holder
+    StoreStmt(const StoreStmt&);      ///< place holder
+    void operator=(const StoreStmt&); ///< place holder
 
 public:
     /// Methods for support type inquiry through isa, cast, and dyn_cast:
     //@{
-    static inline bool classof(const StoreStmt *)
+    static inline bool classof(const StoreStmt*)
     {
         return true;
     }
-    static inline bool classof(const SVFStmt *edge)
+    static inline bool classof(const SVFStmt* edge)
     {
         return edge->getEdgeKind() == SVFStmt::Store;
     }
-    static inline bool classof(const GenericPAGEdgeTy *edge)
+    static inline bool classof(const GenericPAGEdgeTy* edge)
     {
         return edge->getEdgeKind() == SVFStmt::Store;
     }
@@ -374,48 +393,48 @@ public:
     virtual const std::string toString() const override;
 };
 
-
 /*!
  * Load statement
  */
 class LoadStmt: public AssignStmt
 {
+    friend class SVFIRWriter;
+
 private:
     LoadStmt();                      ///< place holder
-    LoadStmt(const LoadStmt &);  ///< place holder
-    void operator=(const LoadStmt &); ///< place holder
+    LoadStmt(const LoadStmt&);       ///< place holder
+    void operator=(const LoadStmt&); ///< place holder
 
 public:
     /// Methods for support type inquiry through isa, cast, and dyn_cast:
     //@{
-    static inline bool classof(const LoadStmt *)
+    static inline bool classof(const LoadStmt*)
     {
         return true;
     }
-    static inline bool classof(const SVFStmt *edge)
+    static inline bool classof(const SVFStmt* edge)
     {
         return edge->getEdgeKind() == SVFStmt::Load;
     }
-    static inline bool classof(const GenericPAGEdgeTy *edge)
+    static inline bool classof(const GenericPAGEdgeTy* edge)
     {
         return edge->getEdgeKind() == SVFStmt::Load;
     }
     //@}
 
     /// constructor
-    LoadStmt(SVFVar* s, SVFVar* d) : AssignStmt(s,d,SVFStmt::Load)
-    {
-    }
+    LoadStmt(SVFVar* s, SVFVar* d) : AssignStmt(s, d, SVFStmt::Load) {}
 
     virtual const std::string toString() const override;
 };
 
-
 /*!
  * Gep statement for struct field access, array access and pointer arithmetic
  */
 class GepStmt: public AssignStmt
 {
+    friend class SVFIRWriter;
+
 private:
     GepStmt();                      ///< place holder
     GepStmt(const GepStmt &);  ///< place holder
@@ -426,15 +445,15 @@ private:
 public:
     /// Methods for support type inquiry through isa, cast, and dyn_cast:
     //@{
-    static inline bool classof(const GepStmt *)
+    static inline bool classof(const GepStmt*)
     {
         return true;
     }
-    static inline bool classof(const SVFStmt *edge)
+    static inline bool classof(const SVFStmt* edge)
     {
         return 	edge->getEdgeKind() == SVFStmt::Gep;
     }
-    static inline bool classof(const GenericPAGEdgeTy *edge)
+    static inline bool classof(const GenericPAGEdgeTy* edge)
     {
         return	edge->getEdgeKind() == SVFStmt::Gep;
     }
@@ -471,7 +490,8 @@ public:
     }
 
     /// constructor
-    GepStmt(SVFVar* s, SVFVar* d, const LocationSet& l, bool varfld=false) : AssignStmt(s,d,SVFStmt::Gep), ls(l), variantField(varfld)
+    GepStmt(SVFVar* s, SVFVar* d, const LocationSet& l, bool varfld = false)
+        : AssignStmt(s, d, SVFStmt::Gep), ls(l), variantField(varfld)
     {
     }
 
@@ -485,29 +505,31 @@ public:
  */
 class CallPE: public AssignStmt
 {
+    friend class SVFIRWriter;
+
 private:
     CallPE();                      ///< place holder
-    CallPE(const CallPE &);  ///< place holder
-    void operator=(const CallPE &); ///< place holder
+    CallPE(const CallPE&);         ///< place holder
+    void operator=(const CallPE&); ///< place holder
 
-    const CallICFGNode* call;		        /// the callsite statement calling from
-    const FunEntryICFGNode* entry;		/// the function exit statement calling to
+    const CallICFGNode* call;      /// the callsite statement calling from
+    const FunEntryICFGNode* entry; /// the function exit statement calling to
 public:
     /// Methods for support type inquiry through isa, cast, and dyn_cast:
     //@{
-    static inline bool classof(const CallPE *)
+    static inline bool classof(const CallPE*)
     {
         return true;
     }
-    static inline bool classof(const SVFStmt *edge)
+    static inline bool classof(const SVFStmt* edge)
     {
-        return edge->getEdgeKind() == SVFStmt::Call
-               || edge->getEdgeKind() == SVFStmt::ThreadFork;
+        return edge->getEdgeKind() == SVFStmt::Call ||
+               edge->getEdgeKind() == SVFStmt::ThreadFork;
     }
-    static inline bool classof(const GenericPAGEdgeTy *edge)
+    static inline bool classof(const GenericPAGEdgeTy* edge)
     {
-        return edge->getEdgeKind() == SVFStmt::Call
-               || edge->getEdgeKind() == SVFStmt::ThreadFork;
+        return edge->getEdgeKind() == SVFStmt::Call ||
+               edge->getEdgeKind() == SVFStmt::ThreadFork;
     }
     //@}
 
@@ -534,35 +556,36 @@ public:
     virtual const std::string toString() const override;
 };
 
-
 /*!
  * Return
  */
 class RetPE: public AssignStmt
 {
+    friend class SVFIRWriter;
+
 private:
     RetPE();                      ///< place holder
-    RetPE(const RetPE &);  ///< place holder
-    void operator=(const RetPE &); ///< place holder
+    RetPE(const RetPE&);          ///< place holder
+    void operator=(const RetPE&); ///< place holder
 
-    const CallICFGNode* call;		        /// the callsite statement returning to
-    const FunExitICFGNode* exit;		/// the function exit statement returned from
+    const CallICFGNode* call;    /// the callsite statement returning to
+    const FunExitICFGNode* exit; /// the function exit statement returned from
 public:
     /// Methods for support type inquiry through isa, cast, and dyn_cast:
     //@{
-    static inline bool classof(const RetPE *)
+    static inline bool classof(const RetPE*)
     {
         return true;
     }
-    static inline bool classof(const SVFStmt *edge)
+    static inline bool classof(const SVFStmt* edge)
     {
-        return edge->getEdgeKind() == SVFStmt::Ret
-               || edge->getEdgeKind() == SVFStmt::ThreadJoin;
+        return edge->getEdgeKind() == SVFStmt::Ret ||
+               edge->getEdgeKind() == SVFStmt::ThreadJoin;
     }
-    static inline bool classof(const GenericPAGEdgeTy *edge)
+    static inline bool classof(const GenericPAGEdgeTy* edge)
     {
-        return edge->getEdgeKind() == SVFStmt::Ret
-               || edge->getEdgeKind() == SVFStmt::ThreadJoin;
+        return edge->getEdgeKind() == SVFStmt::Ret ||
+               edge->getEdgeKind() == SVFStmt::ThreadJoin;
     }
     //@}
 
@@ -594,44 +617,45 @@ public:
 */
 class MultiOpndStmt : public SVFStmt
 {
+    friend class SVFIRWriter;
+
 public:
     typedef std::vector<SVFVar*> OPVars;
+
 private:
     MultiOpndStmt();                      ///< place holder
-    MultiOpndStmt(const MultiOpndStmt &);  ///< place holder
-    void operator=(const MultiOpndStmt &); ///< place holder
-    SVFVar* getSrcNode();  ///< not allowed, use getOpVar(idx) instead
-    SVFVar* getDstNode();    ///< not allowed, use getRes() instead
-    NodeID getSrcID();  ///< not allowed, use getOpVarID(idx) instead
+    MultiOpndStmt(const MultiOpndStmt&);  ///< place holder
+    void operator=(const MultiOpndStmt&); ///< place holder
+    SVFVar* getSrcNode(); ///< not allowed, use getOpVar(idx) instead
+    SVFVar* getDstNode(); ///< not allowed, use getRes() instead
+    NodeID getSrcID();    ///< not allowed, use getOpVarID(idx) instead
     NodeID getDstID();    ///< not allowed, use getResID() instead
 
 protected:
     OPVars opVars;
     /// Constructor, only used by subclassess but not external users
     MultiOpndStmt(SVFVar* r, const OPVars& opnds, GEdgeFlag k);
+
 public:
     /// Methods for support type inquiry through isa, cast, and dyn_cast:
     //@{
-    static inline bool classof(const MultiOpndStmt *)
+    static inline bool classof(const MultiOpndStmt*)
     {
         return true;
     }
-    static inline bool classof(const SVFStmt *node)
+    static inline bool classof(const SVFStmt* node)
     {
-        return node->getEdgeKind() == Phi ||
-               node->getEdgeKind() == Select ||
-               node->getEdgeKind() == BinaryOp ||
-               node->getEdgeKind() == Cmp;
+        return node->getEdgeKind() == Phi || node->getEdgeKind() == Select ||
+               node->getEdgeKind() == BinaryOp || node->getEdgeKind() == Cmp;
     }
-    static inline bool classof(const GenericPAGEdgeTy *node)
+    static inline bool classof(const GenericPAGEdgeTy* node)
     {
-        return node->getEdgeKind() == Phi ||
-               node->getEdgeKind() == Select ||
-               node->getEdgeKind() == BinaryOp ||
-               node->getEdgeKind() == Cmp;
+        return node->getEdgeKind() == Phi || node->getEdgeKind() == Select ||
+               node->getEdgeKind() == BinaryOp || node->getEdgeKind() == Cmp;
     }
     //@}
-    /// Operands and result at a BinaryNode e.g., p = q + r, `p` is resVar and `r` is OpVar
+    /// 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
@@ -672,46 +696,52 @@ public:
  */
 class PhiStmt: public MultiOpndStmt
 {
+    friend class SVFIRWriter;
+
 public:
-    typedef std::vector<const ICFGNode* > OpICFGNodeVec;
+    typedef std::vector<const ICFGNode*> OpICFGNodeVec;
 
 private:
     PhiStmt();                      ///< place holder
-    PhiStmt(const PhiStmt &);  ///< place holder
-    void operator=(const PhiStmt &); ///< place holder
+    PhiStmt(const PhiStmt&);        ///< place holder
+    void operator=(const PhiStmt&); ///< place holder
 
     OpICFGNodeVec opICFGNodes;
+
 public:
     /// Methods for support type inquiry through isa, cast, and dyn_cast:
     //@{
-    static inline bool classof(const PhiStmt *)
+    static inline bool classof(const PhiStmt*)
     {
         return true;
     }
-    static inline bool classof(const SVFStmt *edge)
+    static inline bool classof(const SVFStmt* edge)
     {
         return edge->getEdgeKind() == SVFStmt::Phi;
     }
-    static inline bool classof(const MultiOpndStmt *edge)
+    static inline bool classof(const MultiOpndStmt* edge)
     {
         return edge->getEdgeKind() == SVFStmt::Phi;
     }
-    static inline bool classof(const GenericPAGEdgeTy *edge)
+    static inline bool classof(const GenericPAGEdgeTy* edge)
     {
         return edge->getEdgeKind() == SVFStmt::Phi;
     }
     //@}
 
     /// constructor
-    PhiStmt(SVFVar* s, const OPVars& opnds, const OpICFGNodeVec& icfgNodes) : MultiOpndStmt(s,opnds,SVFStmt::Phi), opICFGNodes(icfgNodes)
+    PhiStmt(SVFVar* s, const OPVars& opnds, const OpICFGNodeVec& icfgNodes)
+        : MultiOpndStmt(s, opnds, SVFStmt::Phi), opICFGNodes(icfgNodes)
     {
-        assert(opnds.size()==icfgNodes.size() && "Numbers of operands and their ICFGNodes are not consistent?");
+        assert(opnds.size() == icfgNodes.size() &&
+               "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?");
+        assert(opVars.size() == opICFGNodes.size() &&
+               "Numbers of operands and their ICFGNodes are not consistent?");
     }
 
     /// Return the corresponding ICFGNode of this operand
@@ -732,28 +762,31 @@ public:
  */
 class SelectStmt: public MultiOpndStmt
 {
+    friend class SVFIRWriter;
+
 private:
     SelectStmt();                      ///< place holder
-    SelectStmt(const SelectStmt &);  ///< place holder
-    void operator=(const SelectStmt &); ///< place holder
+    SelectStmt(const SelectStmt&);     ///< place holder
+    void operator=(const SelectStmt&); ///< place holder
 
     const SVFVar* condition;
+
 public:
     /// Methods for support type inquiry through isa, cast, and dyn_cast:
     //@{
-    static inline bool classof(const SelectStmt *)
+    static inline bool classof(const SelectStmt*)
     {
         return true;
     }
-    static inline bool classof(const SVFStmt *edge)
+    static inline bool classof(const SVFStmt* edge)
     {
         return edge->getEdgeKind() == SVFStmt::Select;
     }
-    static inline bool classof(const MultiOpndStmt *edge)
+    static inline bool classof(const MultiOpndStmt* edge)
     {
         return edge->getEdgeKind() == SVFStmt::Select;
     }
-    static inline bool classof(const GenericPAGEdgeTy *edge)
+    static inline bool classof(const GenericPAGEdgeTy* edge)
     {
         return edge->getEdgeKind() == SVFStmt::Select;
     }
@@ -769,11 +802,11 @@ public:
     }
     inline const SVFVar* getTrueValue() const
     {
-        return  getOpVar(0);
+        return getOpVar(0);
     }
     inline const SVFVar* getFalseValue() const
     {
-        return  getOpVar(1);
+        return getOpVar(1);
     }
 };
 
@@ -782,14 +815,16 @@ public:
  */
 class CmpStmt: public MultiOpndStmt
 {
+    friend class SVFIRWriter;
+
 private:
     CmpStmt();                      ///< place holder
-    CmpStmt(const CmpStmt &);  ///< place holder
-    void operator=(const CmpStmt &); ///< place holder
+    CmpStmt(const CmpStmt&);        ///< place holder
+    void operator=(const CmpStmt&); ///< place holder
 
     u32_t predicate;
-public:
 
+public:
     /// OpCode for CmpStmt, enum value is same to llvm CmpInst
     enum Predicate : unsigned
     {
@@ -830,19 +865,19 @@ public:
 
     /// Methods for support type inquiry through isa, cast, and dyn_cast:
     //@{
-    static inline bool classof(const CmpStmt *)
+    static inline bool classof(const CmpStmt*)
     {
         return true;
     }
-    static inline bool classof(const SVFStmt *edge)
+    static inline bool classof(const SVFStmt* edge)
     {
         return edge->getEdgeKind() == SVFStmt::Cmp;
     }
-    static inline bool classof(const MultiOpndStmt *edge)
+    static inline bool classof(const MultiOpndStmt* edge)
     {
         return edge->getEdgeKind() == SVFStmt::Cmp;
     }
-    static inline bool classof(const GenericPAGEdgeTy *edge)
+    static inline bool classof(const GenericPAGEdgeTy* edge)
     {
         return edge->getEdgeKind() == SVFStmt::Cmp;
     }
@@ -859,41 +894,58 @@ public:
     virtual const std::string toString() const override;
 };
 
-
 /*!
  * Binary statement
  */
 class BinaryOPStmt: public MultiOpndStmt
 {
+    friend class SVFIRWriter;
+
 private:
     BinaryOPStmt();                      ///< place holder
-    BinaryOPStmt(const BinaryOPStmt &);  ///< place holder
-    void operator=(const BinaryOPStmt &); ///< place holder
+    BinaryOPStmt(const BinaryOPStmt&);   ///< place holder
+    void operator=(const BinaryOPStmt&); ///< place holder
     u32_t opcode;
 
 public:
     /// OpCode for BinaryOPStmt, enum value is same to llvm BinaryOperator
-    enum OpCode: unsigned
+    enum OpCode : unsigned
     {
-        Add = 13, FAdd = 14, Sub = 15, FSub = 16, Mul = 17, FMul = 18, UDiv = 19, SDiv = 20, FDiv = 21, URem = 22,
-        SRem = 23, FRem = 24, Shl = 25, LShr = 26, AShr = 27, And = 28, Or = 29, Xor = 30
+        Add = 13,
+        FAdd = 14,
+        Sub = 15,
+        FSub = 16,
+        Mul = 17,
+        FMul = 18,
+        UDiv = 19,
+        SDiv = 20,
+        FDiv = 21,
+        URem = 22,
+        SRem = 23,
+        FRem = 24,
+        Shl = 25,
+        LShr = 26,
+        AShr = 27,
+        And = 28,
+        Or = 29,
+        Xor = 30
     };
 
     /// Methods for support type inquiry through isa, cast, and dyn_cast:
     //@{
-    static inline bool classof(const BinaryOPStmt *)
+    static inline bool classof(const BinaryOPStmt*)
     {
         return true;
     }
-    static inline bool classof(const SVFStmt *edge)
+    static inline bool classof(const SVFStmt* edge)
     {
         return edge->getEdgeKind() == SVFStmt::BinaryOp;
     }
-    static inline bool classof(const MultiOpndStmt *edge)
+    static inline bool classof(const MultiOpndStmt* edge)
     {
         return edge->getEdgeKind() == SVFStmt::BinaryOp;
     }
-    static inline bool classof(const GenericPAGEdgeTy *edge)
+    static inline bool classof(const GenericPAGEdgeTy* edge)
     {
         return edge->getEdgeKind() == SVFStmt::BinaryOp;
     }
@@ -915,16 +967,19 @@ public:
  */
 class UnaryOPStmt: public SVFStmt
 {
+    friend class SVFIRWriter;
+
 private:
     UnaryOPStmt();                      ///< place holder
-    UnaryOPStmt(const UnaryOPStmt &);  ///< place holder
-    void operator=(const UnaryOPStmt &); ///< place holder
-    SVFVar* getSrcNode();  ///< place holder, use getOpVar() instead
-    SVFVar* getDstNode();    ///< place holder, use getRes() instead
-    NodeID getSrcID();  ///< place holder, use getOpVarID(pos) instead
+    UnaryOPStmt(const UnaryOPStmt&);    ///< place holder
+    void operator=(const UnaryOPStmt&); ///< place holder
+    SVFVar* getSrcNode(); ///< place holder, use getOpVar() instead
+    SVFVar* getDstNode(); ///< place holder, use getRes() instead
+    NodeID getSrcID();    ///< place holder, use getOpVarID(pos) instead
     NodeID getDstID();    ///< place holder, use getResID() instead
 
     u32_t opcode;
+
 public:
     /// OpCode for UnaryOPStmt, enum value is same to llvm::UnaryOperator
     enum OpCode : unsigned
@@ -934,22 +989,23 @@ public:
 
     /// Methods for support type inquiry through isa, cast, and dyn_cast:
     //@{
-    static inline bool classof(const UnaryOPStmt *)
+    static inline bool classof(const UnaryOPStmt*)
     {
         return true;
     }
-    static inline bool classof(const SVFStmt *edge)
+    static inline bool classof(const SVFStmt* edge)
     {
         return edge->getEdgeKind() == SVFStmt::UnaryOp;
     }
-    static inline bool classof(const GenericPAGEdgeTy *edge)
+    static inline bool classof(const GenericPAGEdgeTy* edge)
     {
         return edge->getEdgeKind() == SVFStmt::UnaryOp;
     }
     //@}
 
     /// constructor
-    UnaryOPStmt(SVFVar* s, SVFVar* d, u32_t oc) : SVFStmt(s,d,SVFStmt::UnaryOp), opcode(oc)
+    UnaryOPStmt(SVFVar* s, SVFVar* d, u32_t oc)
+        : SVFStmt(s, d, SVFStmt::UnaryOp), opcode(oc)
     {
     }
 
@@ -971,22 +1027,24 @@ public:
     virtual const std::string toString() const override;
 };
 
-
 /*!
  * Branch statements including if/else and switch
  */
 class BranchStmt: public SVFStmt
 {
+    friend class SVFIRWriter;
+
 public:
-    typedef std::vector<std::pair<const ICFGNode*, s32_t> > SuccAndCondPairVec;
+    typedef std::vector<std::pair<const ICFGNode*, s32_t>> SuccAndCondPairVec;
+
 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
-    NodeID getSrcID();  ///< place holder, use getOpVarID(pos) instead
-    NodeID getDstID();    ///< place holder, use getResID() instead
+    BranchStmt(const BranchStmt&);     ///< place holder
+    void operator=(const BranchStmt&); ///< place holder
+    SVFVar* getSrcNode();              ///< place holder, not allowed
+    SVFVar* getDstNode();              ///< place holder, not allowed
+    NodeID getSrcID(); ///< place holder, use getOpVarID(pos) instead
+    NodeID getDstID(); ///< place holder, use getResID() instead
 
     SuccAndCondPairVec successors;
     const SVFVar* cond;
@@ -995,22 +1053,24 @@ private:
 public:
     /// Methods for support type inquiry through isa, cast, and dyn_cast:
     //@{
-    static inline bool classof(const BranchStmt *)
+    static inline bool classof(const BranchStmt*)
     {
         return true;
     }
-    static inline bool classof(const SVFStmt *edge)
+    static inline bool classof(const SVFStmt* edge)
     {
         return edge->getEdgeKind() == SVFStmt::Branch;
     }
-    static inline bool classof(const GenericPAGEdgeTy *edge)
+    static inline bool classof(const GenericPAGEdgeTy* edge)
     {
         return edge->getEdgeKind() == SVFStmt::Branch;
     }
     //@}
 
     /// constructor
-    BranchStmt(SVFVar* inst, SVFVar* c, const SuccAndCondPairVec& succs) : SVFStmt(c,inst,SVFStmt::Branch), successors(succs), cond(c), brInst(inst)
+    BranchStmt(SVFVar* inst, SVFVar* c, const SuccAndCondPairVec& succs)
+        : SVFStmt(c, inst, SVFStmt::Branch), successors(succs), cond(c),
+          brInst(inst)
     {
     }
 
@@ -1029,9 +1089,8 @@ public:
     /// successor(0): stmt1, 1
     /// successor(1): stmt2, 0
 
-    /// For example switch(c) case 0: {stmt1; break;} case 1: {stmt2; break;} default {stmt3: break}
-    /// successor(0): stmt1, 0
-    /// successor(1): stmt2, 1
+    /// For example switch(c) case 0: {stmt1; break;} case 1: {stmt2; break;}
+    /// default {stmt3: break} successor(0): stmt1, 0 successor(1): stmt2, 1
     /// successor(3): stmt3, -1
 
     /// Successors of this branch statement
@@ -1044,11 +1103,11 @@ public:
     {
         return successors;
     }
-    const ICFGNode* getSuccessor (u32_t i) const
+    const ICFGNode* getSuccessor(u32_t i) const
     {
         return successors.at(i).first;
     }
-    s64_t getSuccessorCondValue (u32_t i) const
+    s64_t getSuccessorCondValue(u32_t i) const
     {
         return successors.at(i).second;
     }
@@ -1056,75 +1115,78 @@ public:
     virtual const std::string toString() const override;
 };
 
-
 /*!
  * Thread Fork
  */
 class TDForkPE: public CallPE
 {
+    friend class SVFIRWriter;
+
 private:
     TDForkPE();                      ///< place holder
-    TDForkPE(const TDForkPE &);  ///< place holder
-    void operator=(const TDForkPE &); ///< place holder
+    TDForkPE(const TDForkPE&);       ///< place holder
+    void operator=(const TDForkPE&); ///< place holder
 
 public:
     /// Methods for support type inquiry through isa, cast, and dyn_cast:
     //@{
-    static inline bool classof(const TDForkPE *)
+    static inline bool classof(const TDForkPE*)
     {
         return true;
     }
-    static inline bool classof(const SVFStmt *edge)
+    static inline bool classof(const SVFStmt* edge)
     {
         return edge->getEdgeKind() == SVFStmt::ThreadFork;
     }
-    static inline bool classof(const GenericPAGEdgeTy *edge)
+    static inline bool classof(const GenericPAGEdgeTy* edge)
     {
         return edge->getEdgeKind() == SVFStmt::ThreadFork;
     }
     //@}
 
     /// constructor
-    TDForkPE(SVFVar* s, SVFVar* d, const CallICFGNode* i, const FunEntryICFGNode* entry) :
-        CallPE(s,d,i,entry,SVFStmt::ThreadFork)
+    TDForkPE(SVFVar* s, SVFVar* d, const CallICFGNode* i,
+             const FunEntryICFGNode* entry)
+        : CallPE(s, d, i, entry, SVFStmt::ThreadFork)
     {
     }
 
     virtual const std::string toString() const;
 };
 
-
-
 /*!
  * Thread Join
  */
 class TDJoinPE: public RetPE
 {
+    friend class SVFIRWriter;
+
 private:
     TDJoinPE();                      ///< place holder
-    TDJoinPE(const TDJoinPE &);  ///< place holder
-    void operator=(const TDJoinPE &); ///< place holder
+    TDJoinPE(const TDJoinPE&);       ///< place holder
+    void operator=(const TDJoinPE&); ///< place holder
 
 public:
     /// Methods for support type inquiry through isa, cast, and dyn_cast:
     //@{
-    static inline bool classof(const TDJoinPE *)
+    static inline bool classof(const TDJoinPE*)
     {
         return true;
     }
-    static inline bool classof(const SVFStmt *edge)
+    static inline bool classof(const SVFStmt* edge)
     {
         return edge->getEdgeKind() == SVFStmt::ThreadJoin;
     }
-    static inline bool classof(const GenericPAGEdgeTy *edge)
+    static inline bool classof(const GenericPAGEdgeTy* edge)
     {
         return edge->getEdgeKind() == SVFStmt::ThreadJoin;
     }
     //@}
 
     /// Constructor
-    TDJoinPE(SVFVar* s, SVFVar* d, const CallICFGNode* i, const FunExitICFGNode* e) :
-        RetPE(s,d,i,e, SVFStmt::ThreadJoin)
+    TDJoinPE(SVFVar* s, SVFVar* d, const CallICFGNode* i,
+             const FunExitICFGNode* e)
+        : RetPE(s, d, i, e, SVFStmt::ThreadJoin)
     {
     }