svf-lib 1.0.1301 → 1.0.1302

package/SVF-linux/include/SVF-FE/GEPTypeBridgeIterator.h

@@ -1,183 +0,0 @@
-// GEPTypeBridgeIterator
-//
-//
-#ifndef SVF_GEPTYPEBRIDGEITERATOR_H
-#define SVF_GEPTYPEBRIDGEITERATOR_H
-
-#include "llvm/IR/DerivedTypes.h"
-#include "llvm/IR/Operator.h"
-#include "llvm/IR/User.h"
-#include "llvm/ADT/PointerIntPair.h"
-#include "llvm/IR/GetElementPtrTypeIterator.h"
-
-namespace llvm
-{
-
-template<typename ItTy = User::const_op_iterator>
-class generic_bridge_gep_type_iterator : public std::iterator<std::forward_iterator_tag, Type *, ptrdiff_t>
-{
-
-    typedef std::iterator<std::forward_iterator_tag,Type *, ptrdiff_t> super;
-    ItTy OpIt;
-    PointerIntPair<Type *,1> CurTy;
-    unsigned AddrSpace;
-    generic_bridge_gep_type_iterator() {}
-public:
-
-    static generic_bridge_gep_type_iterator begin(Type *Ty, ItTy It)
-    {
-        generic_bridge_gep_type_iterator I;
-        I.CurTy.setPointer(Ty);
-        I.OpIt = It;
-        return I;
-    }
-
-    static generic_bridge_gep_type_iterator begin(Type *Ty, unsigned AddrSpace,
-            ItTy It)
-    {
-        generic_bridge_gep_type_iterator I;
-        I.CurTy.setPointer(Ty);
-        I.CurTy.setInt(true);
-        I.AddrSpace = AddrSpace;
-        I.OpIt = It;
-        return I;
-    }
-
-    static generic_bridge_gep_type_iterator end(ItTy It)
-    {
-        generic_bridge_gep_type_iterator I;
-        I.OpIt = It;
-        return I;
-    }
-
-    bool operator==(const generic_bridge_gep_type_iterator& x) const
-    {
-        return OpIt == x.OpIt;
-    }
-
-    bool operator!=(const generic_bridge_gep_type_iterator& x) const
-    {
-        return !operator==(x);
-    }
-
-    Type *operator*() const
-    {
-        if ( CurTy.getInt() )
-            return CurTy.getPointer()->getPointerTo(AddrSpace);
-        return CurTy.getPointer();
-    }
-
-    Type *getIndexedType() const
-    {
-        assert(false && "needs to be refactored");
-        if ( CurTy.getInt() )
-            return CurTy.getPointer();
-#if LLVM_VERSION_MAJOR >= 11
-        Type * CT = CurTy.getPointer();
-        if (auto ST = dyn_cast<StructType>(CT))
-            return ST->getTypeAtIndex(getOperand());
-        else if (auto Array = dyn_cast<ArrayType>(CT))
-            return Array->getElementType();
-        else if (auto Vector = dyn_cast<VectorType>(CT))
-            return Vector->getElementType();
-        else
-            return CT;
-#else
-        CompositeType *CT = llvm::cast<CompositeType>( CurTy.getPointer() );
-        return CT->getTypeAtIndex(getOperand());
-#endif
-    }
-
-    // non-standard operators, these may not need be bridged but seems it's
-    // predunt to do so...
-    Type *operator->() const
-    {
-        return operator*();
-    }
-
-    Value* getOperand() const
-    {
-        return const_cast<Value*>(&**OpIt);
-    }
-
-
-    generic_bridge_gep_type_iterator& operator++()
-    {
-        if ( CurTy.getInt() )
-        {
-            CurTy.setInt(false);
-        }
-#if LLVM_VERSION_MAJOR >= 11
-        else if ( Type * CT = CurTy.getPointer() )
-        {
-            if (auto ST = dyn_cast<StructType>(CT))
-                CurTy.setPointer(ST->getTypeAtIndex(getOperand()));
-            else if (auto Array = dyn_cast<ArrayType>(CT))
-                CurTy.setPointer(Array->getElementType());
-            else if (auto Vector = dyn_cast<VectorType>(CT))
-                CurTy.setPointer(Vector->getElementType());
-            else
-                CurTy.setPointer(nullptr);
-        }
-#else
-        else if ( CompositeType * CT = dyn_cast<CompositeType>(CurTy.getPointer()) )
-        {
-            CurTy.setPointer(CT->getTypeAtIndex(getOperand()));
-        }
-#endif
-        else
-        {
-            CurTy.setPointer(nullptr);
-        }
-        ++OpIt;
-        return *this;
-    }
-
-
-    generic_bridge_gep_type_iterator operator++(int)
-    {
-        generic_bridge_gep_type_iterator tmp = *this;
-        ++*this;
-        return tmp;
-    }
-
-};
-
-
-typedef generic_bridge_gep_type_iterator<> bridge_gep_iterator;
-
-inline bridge_gep_iterator bridge_gep_begin(const User* GEP)
-{
-    auto *GEPOp = llvm::cast<GEPOperator>(GEP);
-    return bridge_gep_iterator::begin(GEPOp->getSourceElementType(),
-                                      llvm::cast<PointerType>(GEPOp->getPointerOperandType()->getScalarType())->getAddressSpace(),
-                                      GEP->op_begin() + 1);
-}
-
-inline bridge_gep_iterator bridge_gep_end(const User* GEP)
-{
-    return bridge_gep_iterator::end(GEP->op_end());
-}
-
-inline bridge_gep_iterator bridge_gep_begin(const User &GEP)
-{
-    auto &GEPOp = llvm::cast<GEPOperator>(GEP);
-    return bridge_gep_iterator::begin( GEPOp.getSourceElementType(),
-                                       llvm::cast<PointerType>(GEPOp.getPointerOperandType()->getScalarType())->getAddressSpace(),
-                                       GEP.op_begin() + 1);
-}
-
-inline bridge_gep_iterator bridge_gep_end(const User &GEP)
-{
-    return bridge_gep_iterator::end(GEP.op_end());
-}
-
-template<typename T>
-inline generic_bridge_gep_type_iterator<const T*> bridge_gep_end( Type * /*Op0*/, ArrayRef<T> A )
-{
-    return generic_bridge_gep_type_iterator<const T*>::end(A.end());
-}
-
-} // End namespace llvm
-
-#endif

package/SVF-linux/include/SVF-FE/Graph2Json.h

@@ -1,30 +0,0 @@
-#ifndef INCLUDE_SVF_FE_GRAPH2JSON_H_
-#define INCLUDE_SVF_FE_GRAPH2JSON_H_
-
-#include "MemoryModel/SVFIR.h"
-#include "Graphs/ICFG.h"
-#include "Graphs/ICFGNode.h"
-#include "Graphs/ICFGEdge.h"
-#include "Util/SVFUtil.h"
-
-namespace SVF
-{
-
-class GraphWriter;
-class ICFGPrinter : public ICFG
-{
-public:
-    ICFGPrinter();
-
-    void printICFGToJson(const std::string& filename);
-
-    std::string getPAGNodeKindValue(int kind);
-
-    std::string getPAGEdgeKindValue(int kind);
-
-    std::string getICFGKind(const int kind);
-};
-
-} // End namespace SVF
-
-#endif

package/SVF-linux/include/SVF-FE/ICFGBuilder.h

@@ -1,106 +0,0 @@
-//===- ICFGBuilder.h ----------------------------------------------------------------//
-//
-//                     SVF: Static Value-Flow Analysis
-//
-// Copyright (C) <2013->  <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/>.
-//
-//===----------------------------------------------------------------------===//
-
-/*
- * ICFGBuilder.h
- *
- *  Created on:
- *      Author: yulei
- */
-
-#ifndef INCLUDE_UTIL_ICFGBUILDER_H_
-#define INCLUDE_UTIL_ICFGBUILDER_H_
-
-#include "Graphs/ICFG.h"
-#include "Util/WorkList.h"
-
-namespace SVF
-{
-
-class ICFGBuilder
-{
-
-public:
-
-    typedef std::vector<const SVFInstruction*> InstVec;
-    typedef Set<const SVFInstruction*> BBSet;
-
-private:
-    ICFG* icfg;
-
-public:
-    typedef FIFOWorkList<const SVFInstruction*> WorkList;
-
-    ICFGBuilder(ICFG* i): icfg(i)
-    {
-
-    }
-    void build(SVFModule* svfModule);
-
-private:
-    /// Create edges between ICFG nodes within a function
-    ///@{
-    void processFunEntry(const SVFFunction*  fun, WorkList& worklist);
-
-    void processFunBody(WorkList& worklist);
-
-    void processFunExit(const SVFFunction*  fun);
-    //@}
-
-    void connectGlobalToProgEntry(SVFModule* svfModule);
-
-    /// Add/Get an inter block ICFGNode
-    InterICFGNode* getOrAddInterBlockICFGNode(const SVFInstruction* inst);
-
-    /// Add/Get a basic block ICFGNode
-    inline ICFGNode* getOrAddBlockICFGNode(const SVFInstruction* inst)
-    {
-        if(SVFUtil::isNonInstricCallSite(inst))
-            return getOrAddInterBlockICFGNode(inst);
-        else
-            return getOrAddIntraBlockICFGNode(inst);
-    }
-
-    /// Create edges between ICFG nodes across functions
-    void addICFGInterEdges(const SVFInstruction*  cs, const SVFFunction*  callee);
-
-    /// Add a call node
-    inline CallICFGNode* getCallICFGNode(const SVFInstruction*  cs)
-    {
-        return icfg->getCallICFGNode(cs);
-    }
-    /// Add a return node
-    inline RetICFGNode* getRetICFGNode(const SVFInstruction*  cs)
-    {
-        return icfg->getRetICFGNode(cs);
-    }
-
-    /// Add and get IntraBlock ICFGNode
-    IntraICFGNode* getOrAddIntraBlockICFGNode(const SVFInstruction* inst)
-    {
-        return icfg->getIntraICFGNode(inst);
-    }
-};
-
-} // End namespace SVF
-
-#endif /* INCLUDE_UTIL_ICFGBUILDER_H_ */

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

@@ -1,323 +0,0 @@
-/*
- * 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);
-
-            bool idEq = (nodeId == gepnodeId);
-            (void)idEq; // Suppress warning of unused variable under release build
-            assert(idEq && "nodeId is not equal to 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-linux/include/SVF-FE/LLVMLoopAnalysis.h

@@ -1,59 +0,0 @@
-//===- LLVMLoopAnalysis.h -- LoopAnalysis of SVF --------------------//
-//
-//                     SVF: Static Value-Flow Analysis
-//
-// Copyright (C) <2013-2022>  <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/>.
-//
-//===----------------------------------------------------------------------===//
-
-/*
- * LLVMLoopAnalysis.h
- *
- *  Created on: 14, 06, 2022
- *      Author: Jiawei Wang, Xiao Cheng
- */
-
-#ifndef SVF_LLVMLOOPANALYSIS_H
-#define SVF_LLVMLOOPANALYSIS_H
-
-#include "MemoryModel/SVFIR.h"
-#include "MemoryModel/SVFLoop.h"
-
-namespace SVF
-{
-class LLVMLoopAnalysis
-{
-public:
-
-    /// Constructor
-    LLVMLoopAnalysis() = default;;
-
-    /// Destructor
-    virtual ~LLVMLoopAnalysis() = default;
-
-    /// Build llvm loops based on LoopInfo analysis
-    virtual void buildLLVMLoops(SVFModule *mod, std::vector<const Loop *> &llvmLoops);
-
-    /// Start from here
-    virtual void build(ICFG *icfg);
-
-    /// Build SVF loops based on llvm loops
-    virtual void buildSVFLoops(ICFG *icfg, std::vector<const Loop *> &llvmLoops);
-};
-} // End namespace SVF
-
-#endif //SVF_LLVMLOOPANALYSIS_H