svf-lib 1.0.2213 → 1.0.2215

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

@@ -32,897 +32,300 @@
 
 #include "SVFIR/SVFType.h"
 #include "Graphs/GraphPrinter.h"
-#include "Util/Casting.h"
-#include "Graphs/BasicBlockG.h"
+
 
 namespace SVF
 {
 
-/// LLVM Aliases and constants
-typedef SVF::GraphPrinter GraphPrinter;
-
-class CallGraphNode;
-class SVFInstruction;
-class SVFBasicBlock;
-class SVFArgument;
-class SVFFunction;
-class SVFType;
 
-class SVFLoopAndDomInfo
+class SVFBaseNode
 {
-    friend class SVFIRWriter;
-    friend class SVFIRReader;
-public:
-    typedef Set<const SVFBasicBlock*> BBSet;
-    typedef std::vector<const SVFBasicBlock*> BBList;
-    typedef BBList LoopBBs;
-
-private:
-    BBList reachableBBs;    ///< reachable BasicBlocks from the function entry.
-    Map<const SVFBasicBlock*,BBSet> dtBBsMap;   ///< map a BasicBlock to BasicBlocks it Dominates
-    Map<const SVFBasicBlock*,BBSet> pdtBBsMap;   ///< map a BasicBlock to BasicBlocks it PostDominates
-    Map<const SVFBasicBlock*,BBSet> dfBBsMap;    ///< map a BasicBlock to its Dominate Frontier BasicBlocks
-    Map<const SVFBasicBlock*, LoopBBs> bb2LoopMap;  ///< map a BasicBlock (if it is in a loop) to all the BasicBlocks in this loop
-    Map<const SVFBasicBlock*, u32_t> bb2PdomLevel;  ///< map a BasicBlock to its level in pdom tree, used in findNearestCommonPDominator
-    Map<const SVFBasicBlock*, const SVFBasicBlock*> bb2PIdom;  ///< map a BasicBlock to its immediate dominator in pdom tree, used in findNearestCommonPDominator
 
 public:
-    SVFLoopAndDomInfo()
-    {
-    }
-
-    virtual ~SVFLoopAndDomInfo() {}
-
-    inline const Map<const SVFBasicBlock*,BBSet>& getDomFrontierMap() const
-    {
-        return dfBBsMap;
-    }
-
-    inline Map<const SVFBasicBlock*,BBSet>& getDomFrontierMap()
-    {
-        return dfBBsMap;
-    }
-
-    inline bool hasLoopInfo(const SVFBasicBlock* bb) const
-    {
-        return bb2LoopMap.find(bb) != bb2LoopMap.end();
-    }
-
-    const LoopBBs& getLoopInfo(const SVFBasicBlock* bb) const;
-
-    inline const SVFBasicBlock* getLoopHeader(const LoopBBs& lp) const
-    {
-        assert(!lp.empty() && "this is not a loop, empty basic block");
-        return lp.front();
-    }
-
-    inline bool loopContainsBB(const LoopBBs& lp, const SVFBasicBlock* bb) const
-    {
-        return std::find(lp.begin(), lp.end(), bb) != lp.end();
-    }
 
-    inline void addToBB2LoopMap(const SVFBasicBlock* bb, const SVFBasicBlock* loopBB)
-    {
-        bb2LoopMap[bb].push_back(loopBB);
-    }
-
-    inline const Map<const SVFBasicBlock*,BBSet>& getPostDomTreeMap() const
-    {
-        return pdtBBsMap;
-    }
-
-    inline Map<const SVFBasicBlock*,BBSet>& getPostDomTreeMap()
-    {
-        return pdtBBsMap;
-    }
-
-    inline const Map<const SVFBasicBlock*,u32_t>& getBBPDomLevel() const
-    {
-        return bb2PdomLevel;
-    }
+    enum GNodeK
+    {
+        // ┌─────────────────────────────────────────────────────────────────────────┐
+        // │ ICFGNode: Classes of inter-procedural and intra-procedural control flow │
+        // │ graph nodes (Parent class: ICFGNode)                                   │
+        // └─────────────────────────────────────────────────────────────────────────┘
+        IntraBlock,       // ├── Represents a node within a single procedure
+        GlobalBlock,      // ├── Represents a global-level block
+        // │   └─ Subclass: InterICFGNode
+        FunEntryBlock,    // │   ├── Entry point of a function
+        FunExitBlock,     // │   ├── Exit point of a function
+        FunCallBlock,     // │   ├── Call site in the function
+        FunRetBlock,      // │   └── Return site in the function
+
+        // ┌─────────────────────────────────────────────────────────────────────────┐
+        // │ SVFVar: Classes of variable nodes (Parent class: SVFVar)               │
+        // │   Includes two main subclasses: ValVar and ObjVar                      │
+        // └─────────────────────────────────────────────────────────────────────────┘
+        // └─ Subclass: ValVar (Top-level variable nodes)
+        ValNode,                 // ├── Represents a standard value variable
+        ArgValNode,              // ├── Represents an argument value variable
+        FunValNode,              // ├── Represents a function value variable
+        GepValNode,              // ├── Represents a GEP value variable
+        RetValNode,              // ├── Represents a return value node
+        VarargValNode,           // ├── Represents a variadic argument node
+        GlobalValNode,           // ├── Represents a global variable node
+        ConstAggValNode,         // ├── Represents a constant aggregate value node
+        // │   └─ Subclass: ConstDataValVar
+        ConstDataValNode,        // │   ├── Represents a constant data variable
+        BlackHoleValNode,        // │   ├── Represents a black hole node
+        ConstFPValNode,          // │   ├── Represents a constant floating-point value node
+        ConstIntValNode,         // │   ├── Represents a constant integer value node
+        ConstNullptrValNode,     // │   └── Represents a constant nullptr value node
+        // │   └─ Subclass: DummyValVar
+        DummyValNode,            // │   └── Dummy node for uninitialized values
+
+        // └─ Subclass: ObjVar (Object variable nodes)
+        ObjNode,                 // ├── Represents an object variable
+        // │   └─ Subclass: GepObjVar
+        GepObjNode,              // │   ├── Represents a GEP object variable
+        // │   └─ Subclass: BaseObjVar
+        BaseObjNode,             // │   ├── Represents a base object node
+        FunObjNode,              // │   ├── Represents a function object
+        HeapObjNode,             // │   ├── Represents a heap object
+        StackObjNode,            // │   ├── Represents a stack object
+        GlobalObjNode,           // │   ├── Represents a global object
+        ConstAggObjNode,         // │   ├── Represents a constant aggregate object
+        // │   └─ Subclass: ConstDataObjVar
+        ConstDataObjNode,        // │   ├── Represents a constant data object
+        ConstFPObjNode,          // │   ├── Represents a constant floating-point object
+        ConstIntObjNode,         // │   ├── Represents a constant integer object
+        ConstNullptrObjNode,     // │   └── Represents a constant nullptr object
+        // │   └─ Subclass: DummyObjVar
+        DummyObjNode,            // │   └── Dummy node for uninitialized objects
+
+        // ┌─────────────────────────────────────────────────────────────────────────┐
+        // │ VFGNode: Classes of Value Flow Graph (VFG) node kinds (Parent class:   │
+        // │ VFGNode)                                                               │
+        // │   Includes operation nodes and specialized subclasses                  │
+        // └─────────────────────────────────────────────────────────────────────────┘
+        Cmp,              // ├── Represents a comparison operation
+        BinaryOp,         // ├── Represents a binary operation
+        UnaryOp,          // ├── Represents a unary operation
+        Branch,           // ├── Represents a branch operation
+        DummyVProp,       // ├── Dummy node for value propagation
+        NPtr,             // ├── Represents a null pointer operation
+        // │   └─ Subclass: ArgumentVFGNode
+        FRet,             // │   ├── Represents a function return value
+        ARet,             // │   ├── Represents an argument return value
+        AParm,            // │   ├── Represents an argument parameter
+        FParm,            // │   └── Represents a function parameter
+        // │   └─ Subclass: StmtVFGNode
+        Addr,             // │   ├── Represents an address operation
+        Copy,             // │   ├── Represents a copy operation
+        Gep,              // │   ├── Represents a GEP operation
+        Store,            // │   ├── Represents a store operation
+        Load,             // │   └── Represents a load operation
+        // │   └─ Subclass: PHIVFGNode
+        TPhi,             // │   ├── Represents a type-based PHI node
+        TIntraPhi,        // │   ├── Represents an intra-procedural PHI node
+        TInterPhi,        // │   └── Represents an inter-procedural PHI node
+        // │   └─ Subclass: MRSVFGNode
+        FPIN,             // │   ├── Function parameter input
+        FPOUT,            // │   ├── Function parameter output
+        APIN,             // │   ├── Argument parameter input
+        APOUT,            // │   └── Argument parameter output
+        // │       └─ Subclass: MSSAPHISVFGNode
+        MPhi,             // │       ├── Memory PHI node
+        MIntraPhi,        // │       ├── Intra-procedural memory PHI node
+        MInterPhi,        // │       └── Inter-procedural memory PHI node
+
+        // ┌─────────────────────────────────────────────────────────────────────────┐
+        // │ Additional specific graph node types                                   │
+        // └─────────────────────────────────────────────────────────────────────────┘
+        CallNodeKd,       // Callgraph node
+        CDNodeKd,         // Control dependence graph node
+        CFLNodeKd,        // CFL graph node
+        CHNodeKd,         // Class hierarchy graph node
+        ConstraintNodeKd, // Constraint graph node
+        TCTNodeKd,        // Thread creation tree node
+        DCHNodeKd,        // DCHG node
+        BasicBlockKd,     // Basic block node
+        OtherKd           // Other node kind
+    };
 
-    inline Map<const SVFBasicBlock*,u32_t>& getBBPDomLevel()
-    {
-        return bb2PdomLevel;
-    }
 
-    inline const Map<const SVFBasicBlock*,const SVFBasicBlock*>& getBB2PIdom() const
+    SVFBaseNode(NodeID i, GNodeK k, const SVFType* ty = nullptr): id(i),nodeKind(k), type(ty)
     {
-        return bb2PIdom;
-    }
 
-    inline Map<const SVFBasicBlock*,const SVFBasicBlock*>& getBB2PIdom()
-    {
-        return bb2PIdom;
     }
 
-
-    inline Map<const SVFBasicBlock*,BBSet>& getDomTreeMap()
+    /// Get ID
+    inline NodeID getId() const
     {
-        return dtBBsMap;
+        return id;
     }
 
-    inline const Map<const SVFBasicBlock*,BBSet>& getDomTreeMap() const
+    /// Get node kind
+    inline GNodeK getNodeKind() const
     {
-        return dtBBsMap;
+        return nodeKind;
     }
 
-    inline bool isUnreachable(const SVFBasicBlock* bb) const
+    virtual const SVFType* getType() const
     {
-        return std::find(reachableBBs.begin(), reachableBBs.end(), bb) ==
-               reachableBBs.end();
-    }
-
-    inline const BBList& getReachableBBs() const
-    {
-        return reachableBBs;
-    }
-
-    inline void setReachableBBs(BBList& bbs)
-    {
-        reachableBBs = bbs;
+        return type;
     }
 
-    void getExitBlocksOfLoop(const SVFBasicBlock* bb, BBList& exitbbs) const;
-
-    bool isLoopHeader(const SVFBasicBlock* bb) const;
-
-    bool dominate(const SVFBasicBlock* bbKey, const SVFBasicBlock* bbValue) const;
-
-    bool postDominate(const SVFBasicBlock* bbKey, const SVFBasicBlock* bbValue) const;
-
-    /// find nearest common post dominator of two basic blocks
-    const SVFBasicBlock *findNearestCommonPDominator(const SVFBasicBlock *A, const SVFBasicBlock *B) const;
-};
-
-class SVFValue
-{
-    friend class SVFIRWriter;
-    friend class SVFIRReader;
-    friend class LLVMModuleSet;
-
-public:
-    typedef s64_t GNodeK;
-
-    enum SVFValKind
-    {
-        SVFVal,
-        SVFFunc,
-        SVFBB,
-        SVFInst,
-        SVFCall,
-        SVFVCall,
-        SVFGlob,
-        SVFArg,
-        SVFConst,
-        SVFConstData,
-        SVFConstInt,
-        SVFConstFP,
-        SVFNullPtr,
-        SVFBlackHole,
-        SVFMetaAsValue,
-        SVFOther
-    };
-
-private:
-    GNodeK kind;	///< used for classof
-    bool ptrInUncalledFun;  ///< true if this pointer is in an uncalled function
-    bool constDataOrAggData;    ///< true if this value is a ConstantData (e.g., numbers, string, floats) or a constantAggregate
-
-protected:
-    const SVFType* type;   ///< Type of this SVFValue
-    std::string name;       ///< Short name of value for printing & debugging
-    std::string sourceLoc;  ///< Source code information of this value
-    /// Constructor without name
-    SVFValue(const SVFType* ty, SVFValKind k)
-        : kind(k), ptrInUncalledFun(false),
-          constDataOrAggData(SVFConstData == k), type(ty), sourceLoc("NoLoc")
+    inline virtual void setName(const std::string& nameInfo)
     {
+        name = nameInfo;
     }
 
-    ///@{ attributes to be set only through Module builders e.g.,
-    /// LLVMModule
-    inline void setConstDataOrAggData()
-    {
-        constDataOrAggData = true;
-    }
-    inline void setPtrInUncalledFunction()
+    inline virtual void setName(std::string&& nameInfo)
     {
-        ptrInUncalledFun = true;
+        name = std::move(nameInfo);
     }
-    ///@}
-public:
-    SVFValue() = delete;
-    virtual ~SVFValue() = default;
 
-    /// Get the type of this SVFValue
-    inline GNodeK getKind() const
-    {
-        return kind;
-    }
-
-    inline const std::string &getName() const
+    virtual const std::string& getName() const
     {
         return name;
     }
 
-    inline void setName(std::string&& n)
-    {
-        name = std::move(n);
-    }
-
-    inline virtual const SVFType* getType() const
-    {
-        return type;
-    }
-    inline bool isConstDataOrAggData() const
-    {
-        return constDataOrAggData;
-    }
-    inline bool ptrInUncalledFunction() const
-    {
-        return ptrInUncalledFun;
-    }
-    inline bool isblackHole() const
-    {
-        return getKind() == SVFBlackHole;;
-    }
-    inline bool isNullPtr() const
-    {
-        return getKind() == SVFNullPtr;
-    }
     inline virtual void setSourceLoc(const std::string& sourceCodeInfo)
     {
         sourceLoc = sourceCodeInfo;
     }
-    inline virtual const std::string getSourceLoc() const
-    {
-        return sourceLoc;
-    }
 
-    /// Needs to be implemented by a SVF front end
-    std::string toString() const;
-
-    /// Overloading operator << for dumping ICFG node ID
-    //@{
-    friend OutStream& operator<<(OutStream &os, const SVFValue &value)
+    virtual const std::string getSourceLoc() const
     {
-        return os << value.toString();
-    }
-    //@}
-};
-
-class ArgValVar;
-
-class SVFFunction : public SVFValue
-{
-    friend class LLVMModuleSet;
-    friend class SVFIRWriter;
-    friend class SVFIRReader;
-    friend class SVFIRBuilder;
-
-public:
-    typename BasicBlockGraph::IDToNodeMapTy::iterator iterator;
-    typedef BasicBlockGraph::IDToNodeMapTy::const_iterator const_iterator;
-    typedef SVFLoopAndDomInfo::BBSet BBSet;
-    typedef SVFLoopAndDomInfo::BBList BBList;
-    typedef SVFLoopAndDomInfo::LoopBBs LoopBBs;
-
-private:
-    bool isDecl;   /// return true if this function does not have a body
-    bool intrinsic; /// return true if this function is an intrinsic function (e.g., llvm.dbg), which does not reside in the application code
-    bool addrTaken; /// return true if this function is address-taken (for indirect call purposes)
-    bool isUncalled;    /// return true if this function is never called
-    bool isNotRet;   /// return true if this function never returns
-    bool varArg;    /// return true if this function supports variable arguments
-    const SVFFunctionType* funcType; /// FunctionType, which is different from the type (PointerType) of this SVFFunction
-    SVFLoopAndDomInfo* loopAndDom;  /// the loop and dominate information
-    const SVFFunction* realDefFun;  /// the definition of a function across multiple modules
-    std::vector<const ArgValVar*> allArgs;    /// all formal arguments of this function
-    SVFBasicBlock *exitBlock;             /// a 'single' basic block having no successors and containing return instruction in a function
-    BasicBlockGraph* bbGraph; /// the basic block graph of this function
-
-protected:
-
-    inline void addArgument(const ArgValVar* arg)
-    {
-        allArgs.push_back(arg);
-    }
-
-    inline void setIsUncalledFunction(bool uncalledFunction)
-    {
-        isUncalled = uncalledFunction;
-    }
-
-    inline void setIsNotRet(bool notRet)
-    {
-        isNotRet = notRet;
-    }
-
-    inline void setDefFunForMultipleModule(const SVFFunction* deffun)
-    {
-        realDefFun = deffun;
-    }
-    /// @}
-
-public:
-    SVFFunction(const SVFType* ty,const SVFFunctionType* ft, bool declare, bool intrinsic, bool addrTaken, bool varg, SVFLoopAndDomInfo* ld);
-    SVFFunction(void) = delete;
-    virtual ~SVFFunction();
-
-    static inline bool classof(const SVFValue *node)
-    {
-        return node->getKind() == SVFFunc;
-    }
-
-    inline SVFLoopAndDomInfo* getLoopAndDomInfo()
-    {
-        return loopAndDom;
-    }
-    inline bool isDeclaration() const
-    {
-        return isDecl;
-    }
-
-    void setBasicBlockGraph(BasicBlockGraph* graph)
-    {
-        this->bbGraph = graph;
-    }
-
-    BasicBlockGraph* getBasicBlockGraph()
-    {
-        return bbGraph;
-    }
-
-    const BasicBlockGraph* getBasicBlockGraph() const
-    {
-        return bbGraph;
-    }
-
-    inline bool isIntrinsic() const
-    {
-        return intrinsic;
-    }
-
-    inline bool hasAddressTaken() const
-    {
-        return addrTaken;
-    }
-
-    /// Returns the FunctionType
-    inline const SVFFunctionType* getFunctionType() const
-    {
-        return funcType;
-    }
-
-    /// Returns the FunctionType
-    inline const SVFType* getReturnType() const
-    {
-        return funcType->getReturnType();
-    }
-
-    inline const SVFFunction* getDefFunForMultipleModule() const
-    {
-        if(realDefFun==nullptr)
-            return this;
-        return realDefFun;
-    }
-
-    u32_t arg_size() const;
-    const ArgValVar* getArg(u32_t idx) const;
-    bool isVarArg() const;
-
-    inline bool hasBasicBlock() const
-    {
-        return bbGraph && bbGraph->begin() != bbGraph->end();
-    }
-
-    inline const SVFBasicBlock* getEntryBlock() const
-    {
-        assert(hasBasicBlock() && "function does not have any Basicblock, external function?");
-        assert(bbGraph->begin()->second->getInEdges().size() == 0 && "the first basic block is not entry block");
-        return bbGraph->begin()->second;
-    }
-
-    /// Carefully! when you call getExitBB, you need ensure the function has return instruction
-    /// more refer to: https://github.com/SVF-tools/SVF/pull/1262
-    const SVFBasicBlock* getExitBB() const;
-
-    void setExitBlock(SVFBasicBlock *bb);
-
-    inline const SVFBasicBlock* front() const
-    {
-        return getEntryBlock();
-    }
-
-    inline const SVFBasicBlock* back() const
-    {
-        assert(hasBasicBlock() && "function does not have any Basicblock, external function?");
-        /// Carefully! 'back' is just the last basic block of function,
-        /// but not necessarily a exit basic block
-        /// more refer to: https://github.com/SVF-tools/SVF/pull/1262
-        return std::prev(bbGraph->end())->second;
-    }
-
-    inline const_iterator begin() const
-    {
-        return bbGraph->begin();
-    }
-
-    inline const_iterator end() const
-    {
-        return bbGraph->end();
-    }
-
-
-    inline const std::vector<const SVFBasicBlock*>& getReachableBBs() const
-    {
-        return loopAndDom->getReachableBBs();
-    }
-
-    inline bool isUncalledFunction() const
-    {
-        return isUncalled;
-    }
-
-    inline bool hasReturn() const
-    {
-        return  !isNotRet;
-    }
-
-    inline void getExitBlocksOfLoop(const SVFBasicBlock* bb, BBList& exitbbs) const
-    {
-        return loopAndDom->getExitBlocksOfLoop(bb,exitbbs);
-    }
-
-    inline bool hasLoopInfo(const SVFBasicBlock* bb) const
-    {
-        return loopAndDom->hasLoopInfo(bb);
-    }
-
-    const LoopBBs& getLoopInfo(const SVFBasicBlock* bb) const
-    {
-        return loopAndDom->getLoopInfo(bb);
-    }
-
-    inline const SVFBasicBlock* getLoopHeader(const BBList& lp) const
-    {
-        return loopAndDom->getLoopHeader(lp);
-    }
-
-    inline bool loopContainsBB(const BBList& lp, const SVFBasicBlock* bb) const
-    {
-        return loopAndDom->loopContainsBB(lp,bb);
-    }
-
-    inline const Map<const SVFBasicBlock*,BBSet>& getDomTreeMap() const
-    {
-        return loopAndDom->getDomTreeMap();
-    }
-
-    inline const Map<const SVFBasicBlock*,BBSet>& getDomFrontierMap() const
-    {
-        return loopAndDom->getDomFrontierMap();
-    }
-
-    inline bool isLoopHeader(const SVFBasicBlock* bb) const
-    {
-        return loopAndDom->isLoopHeader(bb);
-    }
-
-    inline bool dominate(const SVFBasicBlock* bbKey, const SVFBasicBlock* bbValue) const
-    {
-        return loopAndDom->dominate(bbKey,bbValue);
-    }
-
-    inline bool postDominate(const SVFBasicBlock* bbKey, const SVFBasicBlock* bbValue) const
-    {
-        return loopAndDom->postDominate(bbKey,bbValue);
-    }
-};
-
-class ICFGNode;
-class FunObjVar;
-
-class SVFInstruction : public SVFValue
-{
-    friend class SVFIRWriter;
-    friend class SVFIRReader;
-
-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
-
-public:
-    /// Constructor without name, set name with setName()
-    SVFInstruction(const SVFType* ty, const SVFBasicBlock* b, bool tm,
-                   bool isRet, SVFValKind k = SVFInst);
-    SVFInstruction(void) = delete;
-
-    static inline bool classof(const SVFValue *node)
-    {
-        return node->getKind() == SVFInst ||
-               node->getKind() == SVFCall ||
-               node->getKind() == SVFVCall;
-    }
-
-    inline const SVFBasicBlock* getParent() const
-    {
-        return bb;
-    }
-
-    inline const FunObjVar* getFunction() const
-    {
-        return bb->getParent();
-    }
-
-    inline bool isRetInst() const
-    {
-        return ret;
-    }
-};
-
-class SVFCallInst : public SVFInstruction
-{
-    friend class SVFIRWriter;
-    friend class SVFIRReader;
-    friend class LLVMModuleSet;
-    friend class SVFIRBuilder;
-
-private:
-    std::vector<const SVFValue*> args;
-    bool varArg;
-    const SVFValue* calledVal;
-
-protected:
-    ///@{ attributes to be set only through Module builders e.g., LLVMModule
-    inline void addArgument(const SVFValue* a)
-    {
-        args.push_back(a);
-    }
-    inline void setCalledOperand(const SVFValue* v)
-    {
-        calledVal = v;
-    }
-    /// @}
-
-public:
-    SVFCallInst(const SVFType* ty, const SVFBasicBlock* b, bool va, bool tm, SVFValKind k = SVFCall) :
-        SVFInstruction(ty, b, tm, false, k), varArg(va), calledVal(nullptr)
-    {
-    }
-    SVFCallInst(void) = delete;
-
-    static inline bool classof(const SVFValue *node)
-    {
-        return node->getKind() == SVFCall || node->getKind() == SVFVCall;
-    }
-    static inline bool classof(const SVFInstruction *node)
-    {
-        return node->getKind() == SVFCall || node->getKind() == SVFVCall;
-    }
-    inline u32_t arg_size() const
-    {
-        return args.size();
-    }
-    inline bool arg_empty() const
-    {
-        return args.empty();
-    }
-    inline const SVFValue* getArgOperand(u32_t i) const
-    {
-        assert(i < arg_size() && "out of bound access of the argument");
-        return args[i];
-    }
-    inline u32_t getNumArgOperands() const
-    {
-        return arg_size();
-    }
-    inline const SVFValue* getCalledOperand() const
-    {
-        return calledVal;
-    }
-    inline bool isVarArg() const
-    {
-        return varArg;
-    }
-    inline const SVFFunction* getCalledFunction() const
-    {
-        return SVFUtil::dyn_cast<SVFFunction>(calledVal);
-    }
-    inline  const FunObjVar* getCaller() const
-    {
-        return getFunction();
-    }
-};
-
-class SVFConstant : public SVFValue
-{
-    friend class SVFIRWriter;
-    friend class SVFIRReader;
-public:
-    SVFConstant(const SVFType* ty, SVFValKind k = SVFConst): SVFValue(ty, k)
-    {
-    }
-    SVFConstant() = delete;
-
-    static inline bool classof(const SVFValue *node)
-    {
-        return node->getKind() == SVFConst ||
-               node->getKind() == SVFGlob ||
-               node->getKind() == SVFConstData ||
-               node->getKind() == SVFConstInt ||
-               node->getKind() == SVFConstFP ||
-               node->getKind() == SVFNullPtr ||
-               node->getKind() == SVFBlackHole;
+        return sourceLoc;
     }
 
-};
+    const std::string valueOnlyToString() const;
 
-class SVFGlobalValue : public SVFConstant
-{
-    friend class SVFIRWriter;
-    friend class SVFIRReader;
-    friend class LLVMModuleSet;
-
-private:
-    const SVFValue* realDefGlobal;  /// the definition of a function across multiple modules
 
 protected:
-    inline void setDefGlobalForMultipleModule(const SVFValue* defg)
-    {
-        realDefGlobal = defg;
-    }
+    NodeID id;		///< Node ID
+    GNodeK nodeKind;	///< Node kind
+    const SVFType* type; ///< SVF type
 
-public:
-    SVFGlobalValue(const SVFType* ty): SVFConstant(ty, SVFValue::SVFGlob), realDefGlobal(nullptr)
-    {
-    }
-    SVFGlobalValue(std::string&& name, const SVFType* ty) : SVFGlobalValue(ty)
-    {
-        setName(std::move(name));
-    }
-    SVFGlobalValue() = delete;
-
-    inline const SVFValue* getDefGlobalForMultipleModule() const
-    {
-        if(realDefGlobal==nullptr)
-            return this;
-        return realDefGlobal;
-    }
-    static inline bool classof(const SVFValue *node)
-    {
-        return node->getKind() == SVFGlob;
-    }
-    static inline bool classof(const SVFConstant *node)
-    {
-        return node->getKind() == SVFGlob;
-    }
-};
-
-class SVFArgument : public SVFValue
-{
-    friend class SVFIRWriter;
-    friend class SVFIRReader;
-private:
-    const SVFFunction* fun;
-    u32_t argNo;
-    bool uncalled;
-public:
-    SVFArgument(const SVFType* ty, const SVFFunction* fun, u32_t argNo,
-                bool uncalled)
-        : SVFValue(ty, SVFValue::SVFArg), fun(fun), argNo(argNo),
-          uncalled(uncalled)
-    {
-    }
-    SVFArgument() = delete;
-
-    inline const SVFFunction* getParent() const
-    {
-        return fun;
-    }
-
-    ///  Return the index of this formal argument in its containing function.
-    /// For example in "void foo(int a, float b)" a is 0 and b is 1.
-    inline u32_t getArgNo() const
-    {
-        return argNo;
-    }
+    std::string name;
+    std::string sourceLoc;  ///< Source code information of this value
 
-    inline bool isArgOfUncalledFunction() const
+    /// Helper functions to check node kinds
+    //{@ Check node kind
+    static inline bool isICFGNodeKinds(GNodeK n)
     {
-        return uncalled;
+        static_assert(FunRetBlock - IntraBlock == 5,
+                      "the number of ICFGNodeKinds has changed, make sure "
+                      "the range is correct");
+        return n <= FunRetBlock && n >= IntraBlock;
     }
 
-    static inline bool classof(const SVFValue *node)
+    static inline bool isInterICFGNodeKind(GNodeK n)
     {
-        return node->getKind() == SVFArg;
+        static_assert(FunRetBlock - FunEntryBlock == 3,
+                      "the number of InterICFGNodeKind has changed, make sure "
+                      "the range is correct");
+        return n <= FunRetBlock && n >= FunEntryBlock;
     }
-};
 
-class SVFConstantData : public SVFConstant
-{
-    friend class SVFIRWriter;
-    friend class SVFIRReader;
-public:
-    SVFConstantData(const SVFType* ty, SVFValKind k = SVFConstData)
-        : SVFConstant(ty, k)
+    static inline bool isSVFVarKind(GNodeK n)
     {
-    }
-    SVFConstantData() = delete;
+        static_assert(DummyObjNode - ValNode == 26,
+                      "The number of SVFVarKinds has changed, make sure the "
+                      "range is correct");
 
-    static inline bool classof(const SVFValue *node)
-    {
-        return node->getKind() == SVFConstData ||
-               node->getKind() == SVFConstInt ||
-               node->getKind() == SVFConstFP ||
-               node->getKind() == SVFNullPtr ||
-               node->getKind() == SVFBlackHole;
-    }
-    static inline bool classof(const SVFConstantData *node)
-    {
-        return node->getKind() == SVFConstData ||
-               node->getKind() == SVFConstInt ||
-               node->getKind() == SVFConstFP ||
-               node->getKind() == SVFNullPtr ||
-               node->getKind() == SVFBlackHole;
+        return n <= DummyObjNode && n >= ValNode;
     }
-};
 
-class SVFConstantInt : public SVFConstantData
-{
-    friend class SVFIRWriter;
-    friend class SVFIRReader;
-private:
-    u64_t zval;
-    s64_t sval;
-public:
-    SVFConstantInt(const SVFType* ty, u64_t z, s64_t s)
-        : SVFConstantData(ty, SVFValue::SVFConstInt), zval(z), sval(s)
+    static inline bool isValVarKinds(GNodeK n)
     {
+        static_assert(DummyValNode - ValNode == 13,
+                      "The number of ValVarKinds has changed, make sure the "
+                      "range is correct");
+        return n <= DummyValNode && n >= ValNode;
     }
-    SVFConstantInt() = delete;
 
-    static inline bool classof(const SVFValue *node)
-    {
-        return node->getKind() == SVFConstInt;
-    }
-    static inline bool classof(const SVFConstantData *node)
-    {
-        return node->getKind() == SVFConstInt;
-    }
-    //  Return the constant as a 64-bit unsigned integer value after it has been zero extended as appropriate for the type of this constant.
-    inline u64_t getZExtValue () const
-    {
-        return zval;
-    }
-    // Return the constant as a 64-bit integer value after it has been sign extended as appropriate for the type of this constant
-    inline s64_t getSExtValue () const
-    {
-        return sval;
-    }
-};
 
-class SVFConstantFP : public SVFConstantData
-{
-    friend class SVFIRWriter;
-    friend class SVFIRReader;
-private:
-    float dval;
-public:
-    SVFConstantFP(const SVFType* ty, double d)
-        : SVFConstantData(ty, SVFValue::SVFConstFP), dval(d)
+    static inline bool isConstantDataValVar(GNodeK n)
     {
+        static_assert(ConstNullptrValNode - ConstDataValNode == 4,
+                      "The number of ConstantDataValVarKinds has changed, make "
+                      "sure the range is correct");
+        return n <= ConstNullptrValNode && n >= ConstDataValNode;
     }
-    SVFConstantFP() = delete;
 
-    inline double getFPValue () const
-    {
-        return dval;
-    }
-    static inline bool classof(const SVFValue *node)
+    static inline bool isObjVarKinds(GNodeK n)
     {
-        return node->getKind() == SVFConstFP;
+        static_assert(DummyObjNode - ObjNode == 12,
+                      "The number of ObjVarKinds has changed, make sure the "
+                      "range is correct");
+        return n <= DummyObjNode && n >= ObjNode;
     }
-    static inline bool classof(const SVFConstantData *node)
-    {
-        return node->getKind() == SVFConstFP;
-    }
-};
-
-class SVFConstantNullPtr : public SVFConstantData
-{
-    friend class SVFIRWriter;
-    friend class SVFIRReader;
 
-public:
-    SVFConstantNullPtr(const SVFType* ty)
-        : SVFConstantData(ty, SVFValue::SVFNullPtr)
+    static inline bool isBaseObjVarKinds(GNodeK n)
     {
+        static_assert(DummyObjNode - BaseObjNode == 10,
+                      "The number of BaseObjVarKinds has changed, make sure the "
+                      "range is correct");
+        return n <= DummyObjNode && n >= BaseObjNode;
     }
-    SVFConstantNullPtr() = delete;
 
-    static inline bool classof(const SVFValue *node)
-    {
-        return node->getKind() == SVFNullPtr;
-    }
-    static inline bool classof(const SVFConstantData *node)
+    static inline bool isConstantDataObjVarKinds(GNodeK n)
     {
-        return node->getKind() == SVFNullPtr;
+        static_assert(ConstNullptrObjNode - ConstDataObjNode == 3,
+                      "The number of ConstantDataObjVarKinds has changed, make "
+                      "sure the range is correct");
+        return n <= ConstNullptrObjNode && n >= ConstDataObjNode;
     }
-};
-
-class SVFBlackHoleValue : public SVFConstantData
-{
-    friend class SVFIRWriter;
-    friend class SVFIRReader;
 
-public:
-    SVFBlackHoleValue(const SVFType* ty)
-        : SVFConstantData(ty, SVFValue::SVFBlackHole)
+    static inline bool isVFGNodeKinds(GNodeK n)
     {
+        static_assert(MInterPhi - Cmp == 24,
+                      "The number of VFGNodeKinds has changed, make sure the "
+                      "range is correct");
+        return n <= MInterPhi && n >= Cmp;
     }
-    SVFBlackHoleValue() = delete;
 
-    static inline bool classof(const SVFValue *node)
-    {
-        return node->getKind() == SVFBlackHole;
-    }
-    static inline bool classof(const SVFConstantData *node)
+    static inline bool isArgumentVFGNodeKinds(GNodeK n)
     {
-        return node->getKind() == SVFBlackHole;
+        static_assert(FParm - FRet == 3,
+                      "The number of ArgumentVFGNodeKinds has changed, make "
+                      "sure the range is correct");
+        return n <= FParm && n >= FRet;
     }
-};
 
-class SVFOtherValue : public SVFValue
-{
-    friend class SVFIRWriter;
-    friend class SVFIRReader;
-public:
-    SVFOtherValue(const SVFType* ty, SVFValKind k = SVFValue::SVFOther)
-        : SVFValue(ty, k)
+    static inline bool isStmtVFGNodeKinds(GNodeK n)
     {
+        static_assert(Load - Addr == 4,
+                      "The number of StmtVFGNodeKinds has changed, make sure "
+                      "the range is correct");
+        return n <= Load && n >= Addr;
     }
-    SVFOtherValue() = delete;
 
-    static inline bool classof(const SVFValue *node)
+    static inline bool isPHIVFGNodeKinds(GNodeK n)
     {
-        return node->getKind() == SVFOther || node->getKind() == SVFMetaAsValue;
+        static_assert(TInterPhi - TPhi == 2,
+                      "The number of PHIVFGNodeKinds has changed, make sure "
+                      "the range is correct");
+        return n <= TInterPhi && n >= TPhi;
     }
-};
 
-/*
- * This class is only for LLVM's MetadataAsValue
-*/
-class SVFMetadataAsValue : public SVFOtherValue
-{
-    friend class SVFIRWriter;
-    friend class SVFIRReader;
-public:
-    SVFMetadataAsValue(const SVFType* ty)
-        : SVFOtherValue(ty, SVFValue::SVFMetaAsValue)
+    static inline bool isMRSVFGNodeKinds(GNodeK n)
     {
+        static_assert(MInterPhi - FPIN == 6,
+                      "The number of MRSVFGNodeKinds has changed, make sure "
+                      "the range is correct");
+        return n <= MInterPhi && n >= FPIN;
     }
-    SVFMetadataAsValue() = delete;
 
-    static inline bool classof(const SVFValue *node)
+    static inline bool isMSSAPHISVFGNodeKinds(GNodeK n)
     {
-        return node->getKind() == SVFMetaAsValue;
-    }
-    static inline bool classof(const SVFOtherValue *node)
-    {
-        return node->getKind() == SVFMetaAsValue;
+        static_assert(MInterPhi - MPhi == 2,
+                      "The number of MSSAPHISVFGNodeKinds has changed, make "
+                      "sure the range is correct");
+        return n <= MInterPhi && n >= MPhi;
     }
+    //@}
 };
 
 
-/// [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
-/// it in any SVF algorithm because it relies on information stored in LLVM bc.
-std::string dumpLLVMValue(const SVFValue* svfValue);
-
 template <typename F, typename S>
 OutStream& operator<< (OutStream &o, const std::pair<F, S> &var)
 {
@@ -930,6 +333,6 @@ OutStream& operator<< (OutStream &o, const std::pair<F, S> &var)
     return o;
 }
 
-} // End namespace SVF
+}
 
 #endif /* INCLUDE_SVFIR_SVFVALUE_H_ */