SVF::LLVMLoopAnalysis Class Reference

#include <LLVMLoopAnalysis.h>

Public Member Functions
	LLVMLoopAnalysis ()=default
	Constructor.
virtual	~LLVMLoopAnalysis ()=default
	Destructor.
virtual void	buildLLVMLoops (ICFG *icfg)
	Build llvm loops based on LoopInfo analysis.
virtual void	build (ICFG *icfg)
	Start from here.
virtual void	buildSVFLoops (ICFG *icfg, std::vector< const Loop * > &llvmLoops)
	Build SVF loops based on llvm loops.

Detailed Description

Definition at line 39 of file LLVMLoopAnalysis.h.

Constructor & Destructor Documentation

LLVMLoopAnalysis()

SVF::LLVMLoopAnalysis::LLVMLoopAnalysis ( )

default

Constructor.

~LLVMLoopAnalysis()

virtual SVF::LLVMLoopAnalysis::~LLVMLoopAnalysis ( )

virtualdefault

Destructor.

Member Function Documentation

build()

void LLVMLoopAnalysis::build ( ICFG *  icfg )

virtual

Start from here.

We start from here

Parameters

icfg

ICFG

Definition at line 89 of file LLVMLoopAnalysis.cpp.

{
    std::vector<const Loop *> llvmLoops;
    buildLLVMLoops(icfg);
}

buildLLVMLoops()

void LLVMLoopAnalysis::buildLLVMLoops ( ICFG *  icfg )

virtual

Build llvm loops based on LoopInfo analysis.

Build llvm loops based on LoopInfo analysis

Parameters

mod	SVF module
llvmLoops	output llvm loops

Definition at line 49 of file LLVMLoopAnalysis.cpp.

{
    std::vector<const Loop *> loop_stack;
    for (Module& M : LLVMModuleSet::getLLVMModuleSet()->getLLVMModules())
    {
        for (Module::const_iterator F = M.begin(), E = M.end(); F != E; ++F)
        {
            const Function* func = &*F;
            const FunObjVar* svffun = LLVMModuleSet::getLLVMModuleSet()->getFunObjVar(func);
            if (func->isDeclaration()) continue;
            // do not analyze external call
            if (SVFUtil::isExtCall(svffun)) continue;
            llvm::DominatorTree& DT = LLVMModuleSet::getLLVMModuleSet()->getDomTree(func);
            llvm::LoopInfoBase<llvm::BasicBlock, llvm::Loop> loopInfo;
            std::vector<const Loop*> llvmLoops;
            loopInfo.analyze(DT);
            for (const auto &loop: loopInfo)
            {
                loop_stack.push_back(loop);
            }
            // pre-order traversal on loop-subloop tree
            while (!loop_stack.empty())
            {
                const Loop *loop = loop_stack.back();
                loop_stack.pop_back();
                llvmLoops.push_back(loop);
                for (const auto &subloop: loop->getSubLoops())
                {
                    loop_stack.push_back(subloop);
                }
            }
            buildSVFLoops(icfg, llvmLoops);
        }
    }
}

buildSVFLoops()

void LLVMLoopAnalysis::buildSVFLoops ( ICFG *  icfg, std::vector< const Loop * > &  llvmLoops  )

virtual

Build SVF loops based on llvm loops.

Build SVF loops based on llvm loops

Parameters

icfg	ICFG
llvmLoops	input llvm loops

Definition at line 100 of file LLVMLoopAnalysis.cpp.

{
    for (const auto &llvmLoop: llvmLoops)
    {
        DBOUT(DPAGBuild, outs() << "loop name: " << llvmLoop->getName().data() << "\n");
        // count all node id in loop
        Set<ICFGNode *> loop_ids;
        Set<const ICFGNode *> nodes;
        for (const auto &BB: llvmLoop->getBlocks())
        {
            for (const auto &ins: *BB)
            {
                if(LLVMUtil::isIntrinsicInst(&ins))
                    continue;
                loop_ids.insert(LLVMModuleSet::getLLVMModuleSet()->getICFGNode(&ins));
                nodes.insert(LLVMModuleSet::getLLVMModuleSet()->getICFGNode(&ins));
            }
        }
        SVFLoop *svf_loop = new SVFLoop(nodes, Options::LoopBound());
        for (const auto &node: nodes)
        {
            icfg->addNodeToSVFLoop(node, svf_loop);
        }
        // mark loop header's first inst
        BasicBlock* header_blk = llvmLoop->getHeader();
        Instruction* in_ins = &(*header_blk->begin());
 
        while(LLVMUtil::isIntrinsicInst(in_ins))
        {
            in_ins = in_ins->getNextNode();
        }
        ICFGNode *in_node = LLVMModuleSet::getLLVMModuleSet()->getICFGNode(in_ins);
        for (const auto &edge: in_node->getInEdges())
        {
            if (loop_ids.find(edge->getSrcNode()) == loop_ids.end())
            {
                // entry edge
                svf_loop->addEntryICFGEdge(edge);
                DBOUT(DPAGBuild, outs() << "  entry edge: " << edge->toString() << "\n");
            }
            else
            {
                // back edge
                svf_loop->addBackICFGEdge(edge);
                DBOUT(DPAGBuild, outs() << "  back edge: " << edge->toString() << "\n");
            }
        }
        // handle in edge
        llvm::Instruction &br_ins = header_blk->back();
        ICFGNode *br_node = LLVMModuleSet::getLLVMModuleSet()->getICFGNode(&br_ins);
        for (const auto &edge: br_node->getOutEdges())
        {
            if (loop_ids.find(edge->getDstNode()) != loop_ids.end())
            {
                svf_loop->addInICFGEdge(edge);
                DBOUT(DPAGBuild, outs() << "  in edge: " << edge->toString() << "\n");
            }
            else
            {
                continue;
            }
        }
        // mark loop end's first inst
        llvm::SmallVector<BasicBlock*, 8> ExitBlocks;
        llvmLoop->getExitBlocks(ExitBlocks);
        for (const auto& exit_blk: ExitBlocks)
        {
            assert(!exit_blk->empty() && "exit block is empty?");
            llvm::Instruction* out_ins = &(*exit_blk->begin());
 
            while(LLVMUtil::isIntrinsicInst(out_ins))
            {
                out_ins = out_ins->getNextNode();
            }
 
            ICFGNode *out_node = LLVMModuleSet::getLLVMModuleSet()->getICFGNode(out_ins);
            for (const auto &edge: out_node->getInEdges())
            {
                svf_loop->addOutICFGEdge(edge);
                DBOUT(DPAGBuild, outs() << "  out edge: " << edge->toString() << "\n");
            }
        }
    }
}

---

The documentation for this class was generated from the following files:

• /home/runner/work/SVF/SVF/svf-llvm/include/SVF-LLVM/LLVMLoopAnalysis.h
• /home/runner/work/SVF/SVF/svf-llvm/lib/LLVMLoopAnalysis.cpp