svf-lib 1.0.973 → 1.0.976

package/SVF-osx/include/SVF-FE/IRAnnotator.h

@@ -0,0 +1,321 @@
+/*
+ * Annotator.h
+ *
+ *  Created on: March 22, 2021
+ *      Author: Nicholas Tsom
+ */
+
+#ifndef IRANNOTATOR_H_
+#define IRANNOTATOR_H_
+
+#include "MemoryModel/SVFIR.h"
+#include "MemoryModel/PointerAnalysisImpl.h"
+#include "Util/SVFUtil.h"
+#include "llvm/IR/Metadata.h"
+
+
+namespace SVF
+{
+/*!
+ * Program annotator to write metadata information on LLVM IR
+ */
+class IRAnnotator
+{
+public:
+    IRAnnotator():
+        mainModule(nullptr),
+        ptsTo(nullptr)
+    {}
+    ~IRAnnotator() {}
+
+    void processAndersenResults(SVFIR *pag, BVDataPTAImpl *ptsTo, bool writeFlag)
+    {
+        this->ptsTo = ptsTo;
+        mainModule = LLVMModuleSet::getLLVMModuleSet()->getMainLLVMModule();
+
+        // Add a named metadata node used to check whether or not 
+        // this IR has been annotated with Andersen information
+        if (writeFlag)
+            mainModule->getOrInsertNamedMetadata("SVFIR-Annotated");
+
+        for (auto it = pag->begin(); it != pag->end(); ++it)
+        {
+            auto nodeId = it->first;
+            auto pagNode = it->second;
+            auto gepNode = SVFUtil::dyn_cast<GepObjVar>(pagNode);
+
+            if (gepNode && writeFlag)
+            {
+                writePAGgepNode(nodeId, gepNode);
+            }
+            else if (pagNode->hasValue())
+            {
+                processPAGNode(pagNode->getValue(), nodeId, writeFlag);
+            }
+        }
+
+        if (!writeFlag)
+            readPAGgepNodes(pag);
+    }
+
+private:
+    // Write the PAGgepNode to the IR such that metadata name is the SVFIR node id and the operands
+    // are its base node's id and location offset
+    void writePAGgepNode(SVF::NodeID nodeId, GepObjVar* gepNode)
+    {
+        auto baseNodeId = gepNode->getBaseNode();
+        auto locationSetOffset = gepNode->getConstantFieldIdx();
+
+        LLVMContext &context = mainModule->getContext();
+        llvm::SmallVector<llvm::Metadata *, 32> operands;
+        operands.push_back(llvm::MDString::get(context, std::to_string(baseNodeId)));
+        operands.push_back(llvm::MDString::get(context, std::to_string(locationSetOffset)));
+
+        llvm::MDTuple *metadata = llvm::MDTuple::get(context, operands);
+        std::string label = "gepnode-" + std::to_string(nodeId);
+
+        mainModule->getOrInsertNamedMetadata(label)->addOperand(metadata);
+    }
+
+    // Reads the PAGGepNodes in the annotated IR and creates a new SVFIR Node based on the
+    // data contained in the operands of the metadata node
+    void readPAGgepNodes(SVFIR *pag)
+    {
+        for (auto it = mainModule->named_metadata_begin(); it != mainModule->named_metadata_end(); ++it)
+        {
+            std::string label = it->getName().str();
+            std::string toErase = "gepnode-";
+            std::size_t pos = label.find(toErase);
+            if (pos == std::string::npos)
+            {
+                continue;
+            }
+            label.erase(pos, toErase.length());
+
+            SVF::NodeID nodeId = std::stoi(label);
+            auto mdNode = it->getOperand(0);
+
+            SVF::NodeID baseNodeId = std::stoi(llvm::cast<llvm::MDString>(mdNode->getOperand(0))->getString().str());
+            SVF::s32_t locationSetOffset = std::stoi(llvm::cast<llvm::MDString>(mdNode->getOperand(1))->getString().str());
+
+            LocationSet locationSet = LocationSet(locationSetOffset);
+            SVF::NodeID gepnodeId = pag->getGepObjVar(baseNodeId, locationSet);
+
+            assert(nodeId == gepnodeId && "nodeId != gepnodeId");
+        }
+    }
+
+    // Deduce the LLVM value's type, and process the metadata accordingly
+    void processPAGNode(const Value *value, SVF::NodeID nodeId, bool writeFlag)
+    {
+        if (auto instruction = const_cast<Instruction *>(SVFUtil::dyn_cast<Instruction>(value)))
+        {
+            processInstructionNode(instruction, nodeId, writeFlag);
+        }
+        else if (auto argument = const_cast<Argument *>(SVFUtil::dyn_cast<Argument>(value)))
+        {
+            processArgumentNode(argument, nodeId, writeFlag);
+        }
+        else if (auto function = const_cast<Function *>(SVFUtil::dyn_cast<Function>(value)))
+        {
+            processFunctionNode(function, nodeId, writeFlag);
+        }
+        else if (auto globalVar = const_cast<GlobalVariable *>(SVFUtil::dyn_cast<GlobalVariable>(value)))
+        {
+            processGlobalVarNode(globalVar, nodeId, writeFlag);
+        }
+        else if (auto basicBlock = const_cast<BasicBlock *>(SVFUtil::dyn_cast<BasicBlock>(value)))
+        {
+            processBasicBlockNode(basicBlock, nodeId, writeFlag);
+        }
+        else if (SVFUtil::isa<Constant>(value))
+        {
+            processConstantNode(nodeId, writeFlag);
+        }
+        else if (auto inlineAsm = const_cast<llvm::InlineAsm *>(SVFUtil::dyn_cast<llvm::InlineAsm>(value)))
+        {
+            processInlineAsmNode(inlineAsm, nodeId, writeFlag);
+        }
+        else
+        {
+            SVFUtil::outs() << "Value is NOT a Instruction, Argument, Function, GlobalVariable, BasicBlock, Constant or InlineAsm" << std::endl;
+            SVFUtil::outs() << SVFUtil::value2String(value) << "\n";
+        }
+    }
+
+    void processInstructionNode(Instruction *instruction, const SVF::NodeID &nodeId, bool writeFlag)
+    {
+        std::string label = "inode-" + std::to_string(nodeId);
+        
+        if (writeFlag)
+        {
+            LLVMContext &context = instruction->getContext();
+            auto mdNodePts = getMdNodePts(nodeId, context);
+            instruction->setMetadata(label, mdNodePts);
+        }
+        else
+        {
+            auto mdNode = instruction->getMetadata(label);
+            assert(mdNode != nullptr && "Failed to retrive valid node id at instruction");
+            addAndersenMetadata(nodeId, mdNode);
+        }
+    }
+
+    void processArgumentNode(Argument *argument, const SVF::NodeID &nodeId, bool writeFlag)
+    {
+        std::string label = "anode-" + std::to_string(nodeId);
+        
+        if (writeFlag)
+        {
+            LLVMContext &context = argument->getContext();
+            auto mdNodePts = getMdNodePts(nodeId, context);
+            argument->getParent()->setMetadata(label, mdNodePts);
+        }
+        else
+        {
+            auto mdNode = argument->getParent()->getMetadata(label);
+            assert(mdNode != nullptr && "Failed to retrive valid node id at argument");
+            addAndersenMetadata(nodeId, mdNode);
+        }
+    }
+
+    void processFunctionNode(Function *function, const SVF::NodeID &nodeId, bool writeFlag)
+    {
+        std::string label = "fnode-" + std::to_string(nodeId);
+        
+        if (writeFlag)
+        {
+            LLVMContext &context = function->getContext();
+            auto mdNodePts = getMdNodePts(nodeId, context);
+            function->setMetadata(label, mdNodePts);
+        }
+        else
+        {
+            auto mdNode = function->getMetadata(label);
+            assert(mdNode != nullptr && "Failed to retrive valid node id at function");
+            addAndersenMetadata(nodeId, mdNode);
+        }
+    }
+
+    void processGlobalVarNode(GlobalVariable *globalVar, const SVF::NodeID &nodeId, bool writeFlag)
+    {
+        std::string label = "gnode-" + std::to_string(nodeId);
+        
+        if (writeFlag)
+        {
+            LLVMContext &context = globalVar->getContext();
+            auto mdNodePts = getMdNodePts(nodeId, context);
+            globalVar->setMetadata(label, mdNodePts);
+        }
+        else
+        {
+            auto mdNode = globalVar->getMetadata(label);
+            assert(mdNode != nullptr && "Failed to retrive valid node id at instruction");
+            addAndersenMetadata(nodeId, mdNode);
+        }
+    }
+
+    void processBasicBlockNode(BasicBlock *basicBlock, const SVF::NodeID &nodeId, bool writeFlag)
+    {
+        std::string label = "bnode-" + std::to_string(nodeId);
+        
+        if (writeFlag)
+        {
+            LLVMContext &context = basicBlock->getContext();
+            auto mdNodePts = getMdNodePts(nodeId, context);
+            basicBlock->getParent()->setMetadata(label, mdNodePts);
+        }
+        else
+        {
+            auto mdNode = basicBlock->getParent()->getMetadata(label);
+            assert(mdNode != nullptr && "Failed to retrive valid node id at basicBlock");
+            addAndersenMetadata(nodeId, mdNode);
+        }
+    }
+
+    void processConstantNode(const SVF::NodeID &nodeId, bool writeFlag)
+    {
+        std::string label = "cnode-" + std::to_string(nodeId);
+        
+        if (writeFlag)
+        {
+            LLVMContext &context = mainModule->getContext();
+            auto mdNodePts = getMdNodePts(nodeId, context);
+            mainModule->getOrInsertNamedMetadata(label)->addOperand(mdNodePts);
+        }
+        else
+        {
+            auto mdNode = mainModule->getNamedMetadata(label);
+            assert(mdNode != nullptr && "Failed to retrive valid node id at instruction");
+            addAndersenNamedMetdata(nodeId, mdNode);
+        }
+    }
+
+    void processInlineAsmNode(llvm::InlineAsm *inlineAsm, const SVF::NodeID &nodeId, bool writeFlag)
+    {
+        std::string label = "iAsmnode-" + std::to_string(nodeId);
+        
+        if (writeFlag)
+        {
+            LLVMContext &context = mainModule->getContext();
+            auto mdNodePts = getMdNodePts(nodeId, context);
+            mainModule->getOrInsertNamedMetadata(label)->addOperand(mdNodePts);
+        }
+        else
+        {
+            auto mdNode = mainModule->getNamedMetadata(label);
+            assert(mdNode != nullptr && "Failed to retrive valid node id at inlineAsm");
+            addAndersenNamedMetdata(nodeId, mdNode);
+        }
+    }
+
+    void addAndersenMetadata(const SVF::NodeID &nodeId, MDNode *mdNode)
+    {
+        if (mdNode)
+        {
+            for (unsigned int i = 0; i < mdNode->getNumOperands(); i++)
+            {
+                auto anderNodeIdStr = llvm::cast<llvm::MDString>(mdNode->getOperand(i))->getString().str();
+                auto anderNodeId = SVF::NodeID(std::stoul(anderNodeIdStr));
+                ptsTo->addPts(nodeId, anderNodeId);
+            }
+        }
+    }
+
+    void addAndersenNamedMetdata(const SVF::NodeID &nodeId, NamedMDNode *mdNode)
+    {
+        if (mdNode)
+        {
+            for (unsigned int i = 0; i < mdNode->getNumOperands(); i++)
+            {
+                auto node = mdNode->getOperand(i);
+
+                for (unsigned int j = 0; j < node->getNumOperands(); j++)
+                {
+                    auto anderNodeIdStr = llvm::cast<llvm::MDString>(node->getOperand(j))->getString().str();
+                    auto anderNodeId = SVF::NodeID(std::stoul(anderNodeIdStr));
+                    ptsTo->addPts(nodeId, anderNodeId);
+                }
+            }
+        }
+    }
+
+    inline llvm::MDTuple* getMdNodePts(const SVF::NodeID &nodeId, LLVMContext &context)
+    {
+        llvm::SmallVector<llvm::Metadata *, 32> operands;
+        auto &ptTo = ptsTo->getPts(nodeId);
+        for (const auto p : ptTo)
+        {
+            operands.push_back(llvm::MDString::get(context, std::to_string(p)));
+        }
+        return llvm::MDTuple::get(context, operands);
+    }
+
+    Module* mainModule;
+    BVDataPTAImpl *ptsTo;
+
+};
+
+} // End namespace SVF
+
+#endif /* IRANNOTATOR_H_ */

package/SVF-osx/include/Util/BDDExpr.h

@@ -0,0 +1,182 @@
+//===- BDDExpr.h -- Context/Path BDD conditions----------------------------//
+//
+//                     SVF: Static Value-Flow Analysis
+//
+// Copyright (C) <2013-2017>  <Yulei Sui>
+//
+
+// This program is free software: you can redistribute it and/or modify
+// it under the terms of the GNU General Public License as published by
+// the Free Software Foundation, either version 3 of the License, or
+// (at your option) any later version.
+
+// This program is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+// GNU General Public License for more details.
+
+// You should have received a copy of the GNU General Public License
+// along with this program.  If not, see <http://www.gnu.org/licenses/>.
+//
+//===----------------------------------------------------------------------===//
+
+/*
+ * Condition.h
+ *
+ *  Created on: Oct 19, 2021
+ *      Author: Yulei and Xiao
+ */
+
+#ifndef BITVECTORCOND_H_
+#define BITVECTORCOND_H_
+
+#include "Util/BasicTypes.h"
+#include <cstdio>
+
+#include "CUDD/cuddInt.h"
+#include "z3++.h"
+
+namespace SVF {
+
+class BDDExprManager {
+public:
+    typedef DdNode BDDExpr;
+    typedef Map<u32_t, BDDExpr *> IndexToBDDExpr;
+private:
+    static BDDExprManager *bddExprMgr;
+    IndexToBDDExpr indexToBddCondMap;
+    DdManager *m_bdd_mgr;
+
+    inline BDDExpr *BddOne() const {
+        return Cudd_ReadOne(m_bdd_mgr);
+    }
+
+    inline BDDExpr *BddZero() const {
+        return Cudd_ReadLogicZero(m_bdd_mgr);
+    }
+
+    /// Constructor
+    BDDExprManager();
+
+public:
+    typedef Map<const BDDExpr *, const Instruction *> CondToTermInstMap;    // map a condition to its branch instruction
+    static u32_t totalCondNum; // a counter for fresh condition
+    /// Singleton design here to make sure we only have one instance during any analysis
+    //@{
+    static BDDExprManager *getBDDExprMgr();
+
+    static void releaseBDDExprMgr() {
+        delete bddExprMgr;
+        bddExprMgr = nullptr;
+    }
+    //@}
+
+    /// Destructor
+    virtual ~BDDExprManager();
+
+    BDDExpr *createCond(u32_t i) {
+        assert(indexToBddCondMap.find(i) == indexToBddCondMap.end() &&
+               "This should be fresh index to create new BDD");
+        BDDExpr *bddCond = Cudd_bddIthVar(m_bdd_mgr, i);
+        return indexToBddCondMap.emplace(i, bddCond).first->second;
+    }
+
+    /// Create a fresh condition to encode each program branch
+    virtual BDDExpr *createFreshBranchCond(const Instruction *inst);
+
+    /// Return the number of condition expressions
+    virtual inline u32_t getCondNumber() {
+        return Cudd_ReadNodeCount(m_bdd_mgr);
+    }
+
+
+    /// Return the unique true condition
+    inline BDDExpr *getTrueCond() const {
+        return trueCond;
+    }
+
+    /// Return the unique false condition
+    inline BDDExpr *getFalseCond() const {
+        return falseCond;
+    }
+
+    /// Operations on conditions.
+    //@{
+    virtual BDDExpr *AND(BDDExpr *lhs, BDDExpr *rhs);
+
+    virtual BDDExpr *OR(BDDExpr *lhs, BDDExpr *rhs);
+
+    virtual BDDExpr *NEG(BDDExpr *lhs);
+    //@}
+
+    virtual bool isNegCond(const BDDExpr *cond) {
+        return false;
+    }
+
+    /// Whether the condition is satisfiable
+    virtual bool isSatisfiable(const BDDExpr *cond) {
+        return cond != getFalseCond();
+    }
+
+    /// Whether lhs and rhs are equivalent branch conditions
+    virtual bool isEquivalentBranchCond(const BDDExpr *lhs, const BDDExpr *rhs){
+        return lhs == rhs;
+    }
+
+    /// Whether **All Paths** are reachable
+    bool isAllPathReachable(const BDDExpr *e);
+
+    /// Get condition using condition id (z3 ast id)
+    virtual BDDExpr *getCond(u32_t id) {
+        auto it = indexToBddCondMap.find(id);
+        assert(it != indexToBddCondMap.end() && "condition not found!");
+        return it->second;
+    }
+
+    /// Get/Set llvm conditional expression
+    //{@
+    inline const Instruction *getCondInst(const BDDExpr *cond) const {
+        CondToTermInstMap::const_iterator it = condToInstMap.find(cond);
+        assert(it != condToInstMap.end() && "this should be a fresh condition");
+        return it->second;
+    }
+
+    inline void setCondInst(const BDDExpr *cond, const Instruction *inst) {
+        assert(condToInstMap.find(cond) == condToInstMap.end() && "this should be a fresh condition");
+        condToInstMap[cond] = inst;
+    }
+    //@}
+
+    /**
+     * Utilities for dumping conditions. These methods use global functions from CUDD
+     * package and they can be removed outside this class scope to be used by others.
+     */
+    void ddClearFlag(BDDExpr *f) const;
+
+    void BddSupportStep(BDDExpr *f, NodeBS &support) const;
+
+    void extractSubConds(const BDDExpr *f, NodeBS &support) const;
+
+    void dump(const BDDExpr *lhs, OutStream &O);
+
+    std::string dumpStr(const BDDExpr *e) const;
+
+    inline std::string getMemUsage() {
+        return std::to_string(Cudd_ReadMemoryInUse(m_bdd_mgr));
+    }
+
+protected:
+    static BDDExpr *trueCond;
+    static BDDExpr *falseCond;
+
+private:
+
+    CondToTermInstMap condToInstMap; ///< map condition to llvm instruction
+
+};
+
+
+
+} // End namespace SVF
+
+#endif /* BITVECTORCOND_H_ */

package/SVF-osx/include/Util/DPItem.h

@@ -30,7 +30,7 @@
 #ifndef DPITEM_H_
 #define DPITEM_H_
 
-#include "Util/Conditions.h"
+#include "Util/BDDExpr.h"
 #include "MemoryModel/ConditionalPT.h"
 #include <algorithm>    // std::sort
 

package/SVF-osx/include/Util/ExeState.h

@@ -0,0 +1,172 @@
+//===- ExeState.h -- Execution State ----------------------------//
+//
+//                     SVF: Static Value-Flow Analysis
+//
+// Copyright (C) <2013-2017>  <Yulei Sui>
+//
+
+// This program is free software: you can redistribute it and/or modify
+// it under the terms of the GNU General Public License as published by
+// the Free Software Foundation, either version 3 of the License, or
+// (at your option) any later version.
+
+// This program is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+// GNU General Public License for more details.
+
+// You should have received a copy of the GNU General Public License
+// along with this program.  If not, see <http://www.gnu.org/licenses/>.
+//
+//===----------------------------------------------------------------------===//
+/*
+ * ExeState.h
+ *
+ *  Created on: April 29, 2022
+ *      Author: Xiao
+ */
+
+#ifndef SVF_EXESTATE_H
+#define SVF_EXESTATE_H
+#include "Util/Z3Expr.h"
+#include "MemoryModel/SVFVariables.h"
+
+namespace SVF {
+
+#define AddressMask 0x7f000000
+#define FlippedAddressMask (AddressMask^0xffffffff)
+
+class ExeState {
+public:
+    typedef Map<u32_t, Z3Expr> VarToValMap;
+    typedef Map<u32_t, Z3Expr> LocToValMap;
+
+protected:
+    VarToValMap varToVal;
+    LocToValMap locToVal;
+    Z3Expr pathConstraint;
+
+public:
+    ExeState() : pathConstraint(getContext().bool_val(true)) {}
+
+    ExeState(const Z3Expr &_pc, VarToValMap &_varToValMap, LocToValMap &_locToValMap) : varToVal(_varToValMap),
+                                                                                        locToVal(_locToValMap),
+                                                                                        pathConstraint(_pc) {}
+
+    ExeState(const ExeState &rhs) : varToVal(rhs.getVarToVal()), locToVal(rhs.getLocToVal()),
+                                    pathConstraint(rhs.getPathConstraint()) {
+
+    }
+
+    virtual ~ExeState() = default;
+
+    ExeState &operator=(const ExeState &rhs);
+
+    /// Overloading Operator==
+    bool operator==(const ExeState &rhs) const;
+
+    /// Overloading Operator!=
+    inline bool operator!=(const ExeState &rhs) const {
+        return !(*this == rhs);
+    }
+
+    /// Overloading Operator==
+    bool operator<(const ExeState &rhs) const;
+
+    z3::context &getContext() {
+        return Z3Expr::getContext();
+    }
+
+    const VarToValMap &getVarToVal() const {
+        return varToVal;
+    }
+
+    const LocToValMap &getLocToVal() const {
+        return locToVal;
+    }
+
+    const Z3Expr &getPathConstraint() const {
+        return pathConstraint;
+    }
+
+    void setPathConstraint(const Z3Expr &pc) {
+        pathConstraint = pc.simplify();
+    }
+
+    inline Z3Expr &operator[](u32_t varId) {
+        return getZ3Expr(varId);
+    }
+
+    /// Init Z3Expr for ValVar
+    void initValVar(const ValVar *valVar, Z3Expr &e);
+
+    /// Init Z3Expr for ObjVar
+    void initObjVar(const ObjVar *objVar, Z3Expr &e);
+
+    /// Return Z3 expression based on SVFVar ID
+    Z3Expr &getZ3Expr(u32_t varId);
+
+    /// Store value to location
+    void store(const Z3Expr &loc, const Z3Expr &value);
+
+    /// Load value at location
+    Z3Expr &load(const Z3Expr &loc);
+
+    /// The physical address starts with 0x7f...... + idx
+    inline u32_t getVirtualMemAddress(u32_t idx) const {
+        return AddressMask + idx;
+    }
+
+    /// Check bit value of val start with 0x7F000000, filter by 0xFF000000
+    inline bool isVirtualMemAddress(u32_t val) {
+        return (val & 0xff000000) == AddressMask;
+    }
+
+    /// Return the internal index if idx is an address otherwise return the value of idx
+    inline u32_t getInternalID(u32_t idx) const {
+        return (idx & FlippedAddressMask);
+    }
+
+    /// Return int value from an expression if it is a numeral, otherwise return an approximate value
+    inline s32_t z3Expr2NumValue(const Z3Expr &e) {
+        assert(e.is_numeral() && "not numeral?");
+        return e.get_numeral_int64();
+    }
+
+    /// Print values of all expressions
+    void printExprValues();
+
+protected:
+    inline void store(u32_t objId, const Z3Expr &z3Expr) {
+        locToVal[objId] = z3Expr.simplify();
+    }
+
+    inline Z3Expr &load(u32_t objId) {
+        return locToVal[objId];
+    }
+};
+}
+
+template<>
+struct std::hash<SVF::ExeState> {
+    size_t operator()(const SVF::ExeState &exeState) const {
+
+        size_t h = exeState.getVarToVal().size() * 2;
+        SVF::Hash<SVF::u32_t> hf;
+        for (const auto &t: exeState.getVarToVal()) {
+            h ^= hf(t.first) + 0x9e3779b9 + (h << 6) + (h >> 2);
+            h ^= hf(t.second.id()) + 0x9e3779b9 + (h << 6) + (h >> 2);
+        }
+
+        size_t h2 = exeState.getVarToVal().size() * 2;
+
+        for (const auto &t: exeState.getLocToVal()) {
+            h2 ^= hf(t.first) + 0x9e3779b9 + (h2 << 6) + (h2 >> 2);
+            h2 ^= hf(t.second.id()) + 0x9e3779b9 + (h2 << 6) + (h2 >> 2);
+        }
+        SVF::Hash<std::pair<SVF::u32_t, SVF::u32_t>> pairH;
+
+        return pairH(make_pair(pairH(make_pair(h, h2)), exeState.getPathConstraint().id()));
+    }
+};
+#endif //SVF_EXESTATE_H

package/SVF-osx/include/Util/Options.h

@@ -10,7 +10,6 @@
 #include "Util/NodeIDAllocator.h"
 #include "MSSA/MemSSA.h"
 #include "WPA/WPAPass.h"
-#include "Util/Conditions.h"
 
 namespace SVF
 {
@@ -255,8 +254,6 @@ public:
     // DOTGraphTraits
     static const llvm::cl::opt<bool> ShowHiddenNode;
 
-    // Conditions
-    static const llvm::cl::opt<CondManager::CondMgrKind> ConditionType;
 };
 }  // namespace SVF