ICFGBuilder.h

Go to the documentation of this file.

//===- 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 Affero 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 Affero General Public License for more details.
 
// You should have received a copy of the GNU Affero 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"
#include "BasicTypes.h"
#include "LLVMModule.h"
 
namespace SVF
{
 
class ICFGBuilder
{
 
public:
 
    typedef std::vector<const Instruction*> InstVec;
    typedef Set<const Instruction*> BBSet;
    typedef Map<const Instruction*, CallICFGNode *> CSToCallNodeMapTy;
    typedef Map<const Instruction*, RetICFGNode *> CSToRetNodeMapTy;
    typedef Map<const Instruction*, IntraICFGNode *> InstToBlockNodeMapTy;
    typedef Map<const Function*, FunEntryICFGNode *> FunToFunEntryNodeMapTy;
    typedef Map<const Function*, FunExitICFGNode *> FunToFunExitNodeMapTy;
 
 
private:
    ICFG* icfg;
 
public:
    typedef FIFOWorkList<const Instruction*> WorkList;
 
    ICFGBuilder(): icfg(new ICFG())
    {
 
    }
    ICFG* build();
 
private:
 
    LLVMModuleSet* llvmModuleSet()
    {
        return LLVMModuleSet::getLLVMModuleSet();
    }
 
    CSToRetNodeMapTy& csToRetNodeMap()
    {
        return llvmModuleSet()->CSToRetNodeMap;
    }
 
    CSToCallNodeMapTy& csToCallNodeMap()
    {
        return llvmModuleSet()->CSToCallNodeMap;
    }
 
    InstToBlockNodeMapTy& instToBlockNodeMap()
    {
        return llvmModuleSet()->InstToBlockNodeMap;
    }
 
    FunToFunEntryNodeMapTy& funToFunEntryNodeMap()
    {
        return llvmModuleSet()->FunToFunEntryNodeMap;
    }
 
    FunToFunExitNodeMapTy& funToFunExitNodeMap()
    {
        return llvmModuleSet()->FunToFunExitNodeMap;
    }
 
private:
 
    void processFunEntry(const Function*  fun, WorkList& worklist);
 
    void processNoPrecessorBasicBlocks(const Function*  fun, WorkList& worklist);
 
    void processFunBody(WorkList& worklist);
 
    void processFunExit(const Function*  fun);
 
    void checkICFGNodesVisited(const Function* fun);
 
    void connectGlobalToProgEntry();
 
 
    void addICFGInterEdges(const Instruction*  cs, const Function*  callee);
 
    inline ICFGNode* getICFGNode(const Instruction* inst)
    {
        return llvmModuleSet()->getICFGNode(inst);
    }
 
    inline bool hasICFGNode(const Instruction* inst)
    {
        return llvmModuleSet()->hasICFGNode(inst);
    }
 
    inline CallICFGNode* getCallICFGNode(const Instruction*  cs)
    {
        return llvmModuleSet()->getCallICFGNode(cs);
    }
    inline RetICFGNode* getRetICFGNode(const Instruction*  cs)
    {
        return llvmModuleSet()->getRetICFGNode(cs);
    }
    inline IntraICFGNode* getIntraICFGNode(const Instruction* inst)
    {
        return llvmModuleSet()->getIntraICFGNode(inst);
    }
 
    inline FunEntryICFGNode* getFunEntryICFGNode(const Function*  fun)
    {
        return llvmModuleSet()->getFunEntryICFGNode(fun);
    }
    inline FunExitICFGNode* getFunExitICFGNode(const Function*  fun)
    {
        return llvmModuleSet()->getFunExitICFGNode(fun);
    }
 
    inline GlobalICFGNode* getGlobalICFGNode() const
    {
        return icfg->getGlobalICFGNode();
    }
 
    InterICFGNode* addInterBlockICFGNode(const Instruction* inst);
 
    inline ICFGNode* addBlockICFGNode(const Instruction* inst);
 
    IntraICFGNode* addIntraBlockICFGNode(const Instruction* inst);
 
    FunEntryICFGNode* addFunEntryBlock(const Function* fun);
 
    FunExitICFGNode* addFunExitBlock(const Function* fun);
 
    inline void addGlobalICFGNode()
    {
        icfg->globalBlockNode = new GlobalICFGNode(icfg->totalICFGNode++);
        icfg->addICFGNode(icfg->globalBlockNode);
    }
 
private:
    BBSet visited;
};
 
} // End namespace SVF
 
#endif /* INCLUDE_UTIL_ICFGBUILDER_H_ */