SVFLLVMValue.h

Go to the documentation of this file.

//===- BasicTypes.h -- Basic types used in SVF-------------------------------//
//
//                     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 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/>.
//
//===----------------------------------------------------------------------===//
 
/*
 * BasicTypes.h
 *
 *  Created on: Apr 1, 2014
 *      Author: Yulei Sui
 */
 
#ifndef INCLUDE_SVFLLVM_SVFVALUE_H_
#define INCLUDE_SVFLLVM_SVFVALUE_H_
 
#include "SVFIR/SVFType.h"
#include "Graphs/GraphPrinter.h"
#include "Util/Casting.h"
#include "Graphs/BasicBlockG.h"
#include "SVFIR/SVFValue.h"
#include "Util/SVFLoopAndDomInfo.h"
 
namespace SVF
{
 
typedef SVF::GraphPrinter GraphPrinter;
 
class CallGraphNode;
class SVFInstruction;
class SVFBasicBlock;
class SVFArgument;
class SVFFunction;
class SVFType;
 
class SVFLLVMValue
{
    friend class SVFIRWriter;
    friend class SVFIRReader;
    friend class LLVMModuleSet;
 
public:
    typedef s64_t GNodeK;
 
    enum SVFValKind
    {
        SVFVal,
        SVFFunc,
    };
 
private:
    GNodeK kind;    
    bool ptrInUncalledFun;  
    bool constDataOrAggData;    
 
protected:
    const SVFType* type;   
    std::string name;       
    std::string sourceLoc;  
    SVFLLVMValue(const SVFType* ty, SVFValKind k = SVFVal)
        : kind(k), ptrInUncalledFun(false),
          constDataOrAggData(false), type(ty), sourceLoc("NoLoc")
    {
    }
 
    inline void setConstDataOrAggData()
    {
        constDataOrAggData = true;
    }
    inline void setPtrInUncalledFunction()
    {
        ptrInUncalledFun = true;
    }
public:
    SVFLLVMValue() = delete;
    virtual ~SVFLLVMValue() = default;
 
    inline GNodeK getKind() const
    {
        return kind;
    }
 
    inline 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 virtual void setSourceLoc(const std::string& sourceCodeInfo)
    {
        sourceLoc = sourceCodeInfo;
    }
    inline virtual const std::string getSourceLoc() const
    {
        return sourceLoc;
    }
 
    std::string toString() const;
 
 
    friend OutStream& operator<<(OutStream &os, const SVFLLVMValue &value)
    {
        return os << value.toString();
    }
};
 
class ArgValVar;
 
class SVFFunction : public SVFLLVMValue
{
    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;   
    bool intrinsic; 
    bool addrTaken; 
    bool isUncalled;    
    bool isNotRet;   
    bool varArg;    
    const SVFFunctionType* funcType; 
    SVFLoopAndDomInfo* loopAndDom;  
    const SVFFunction* realDefFun;  
    std::vector<const ArgValVar*> allArgs;    
    SVFBasicBlock *exitBlock;             
    BasicBlockGraph* bbGraph; 
 
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 SVFLLVMValue *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;
    }
 
    inline const SVFFunctionType* getFunctionType() const
    {
        return funcType;
    }
 
    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;
    }
 
    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?");
        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);
    }
};
 
std::string dumpLLVMValue(const SVFLLVMValue* svfValue);
 
 
 
} // End namespace SVF
 
#endif /* INCLUDE_SVFLLVM_SVFVALUE_H_ */