PCG.h

Go to the documentation of this file.

//===- PCG.h -- Procedure creation graph-------------//
//
//                     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/>.
//
//===----------------------------------------------------------------------===//
 
/*
 * MHP.h
 *
 *  Created on: Jan 21, 2014
 *      Author: Yulei Sui, Peng Di
 */
 
#ifndef PCG_H_
#define PCG_H_
 
#include "Util/ThreadAPI.h"
#include "Graphs/PTACallGraph.h"
#include "Util/WorkList.h"
#include "WPA/Andersen.h"
#include <set>
#include <vector>
 
#include "MHP.h"
 
namespace SVF
{
 
class PCG
{
 
public:
    typedef Set<const SVFFunction*> FunSet;
    typedef std::vector<const SVFFunction*> FunVec;
    typedef Set<const SVFInstruction*> CallInstSet;
    typedef FIFOWorkList<const SVFFunction*> FunWorkList;
    typedef FIFOWorkList<const SVFBasicBlock*> BBWorkList;
 
private:
    FunSet spawners;
    FunSet spawnees;
    FunSet followers;
    FunSet mhpfuns;
    PTACallGraph* callgraph;
    SVFModule* mod;
    PointerAnalysis* pta;
    ThreadAPI* tdAPI;
 
    CallInstSet spawnCallSites;
 
 
    inline bool isSpawnerFun(const SVFFunction* fun) const
    {
        return spawners.find(fun) != spawners.end();
    }
    inline bool isSpawneeFun(const SVFFunction* fun) const
    {
        return spawnees.find(fun) != spawnees.end();
    }
    inline bool isFollowerFun(const SVFFunction* fun) const
    {
        return followers.find(fun) != followers.end();
    }
    inline bool addSpawnerFun(const SVFFunction* fun)
    {
        if (fun->isDeclaration())
            return false;
        return spawners.insert(fun).second;
    }
    inline bool addSpawneeFun(const SVFFunction* fun)
    {
        if (fun->isDeclaration())
            return false;
        return spawnees.insert(fun).second;
    }
    inline bool addFollowerFun(const SVFFunction* fun)
    {
        if (fun->isDeclaration())
            return false;
        return followers.insert(fun).second;
    }
 
 
    inline bool addSpawnsite(const SVFInstruction* callInst)
    {
        return spawnCallSites.insert(callInst).second;
    }
    inline bool isSpawnsite(const SVFInstruction* callInst)
    {
        return spawnCallSites.find(callInst) != spawnCallSites.end();
    }
 
    inline CallInstSet::const_iterator spawnSitesBegin() const
    {
        return spawnCallSites.begin();
    }
    inline CallInstSet::const_iterator spawnSitesEnd() const
    {
        return spawnCallSites.end();
    }
 
public:
 
    PCG(PointerAnalysis* an) : pta(an)
    {
        mod = pta->getModule();
        tdAPI=ThreadAPI::getThreadAPI();
        callgraph = pta->getPTACallGraph();
    }
 
    virtual bool analyze();
 
    virtual ~PCG()
    {
    }
 
    CallICFGNode* getCallICFGNode(const SVFInstruction* inst)
    {
        return pta->getICFG()->getCallICFGNode(inst);
    }
    virtual bool mayHappenInParallel(const SVFInstruction* i1, const SVFInstruction* i2) const;
    bool mayHappenInParallelBetweenFunctions(const SVFFunction* fun1, const SVFFunction* fun2) const;
    inline const FunSet& getMHPFunctions() const
    {
        return mhpfuns;
    }
 
    void initFromThreadAPI(SVFModule* module);
 
 
    void inferFromCallGraph();
    void collectSpawners();
    void collectSpawnees();
    void collectFollowers();
    void identifyFollowers();
 
 
    inline const FunSet& getSpawners() const
    {
        return spawners;
    }
    inline const FunSet& getSpawnees() const
    {
        return spawnees;
    }
    inline const FunSet& getFollowers() const
    {
        return followers;
    }
 
 
    inline FunSet::const_iterator spawnersBegin(const SVFFunction* fun) const
    {
        return spawners.begin();
    }
    inline FunSet::const_iterator spawnersEnd(const SVFFunction* fun) const
    {
        return spawners.end();
    }
    inline FunSet::const_iterator spawneesBegin(const SVFFunction* fun) const
    {
        return spawnees.begin();
    }
    inline FunSet::const_iterator spawneesEnd(const SVFFunction* fun) const
    {
        return spawnees.end();
    }
    inline FunSet::const_iterator followersBegin(const SVFFunction* fun) const
    {
        return followers.begin();
    }
    inline FunSet::const_iterator followersEnd(const SVFFunction* fun) const
    {
        return followers.end();
    }
 
    void interferenceAnalysis();
 
    void printResults();
    void printTDFuns();
};
 
} // End namespace SVF
 
#endif /* PCG_H_ */