MemPartition.h

Go to the documentation of this file.

//===- MemPartition.h -- Memory region partition-----------------------------//
//
//                     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/>.
//
//===----------------------------------------------------------------------===//
 
/*
 * @file: DisnctMRGenerator.h
 * @author: yesen
 * @date: 07/12/2013
 * @version: 1.0
 *
 * @section LICENSE
 *
 * @section DESCRIPTION
 *
 */
 
 
#ifndef DISNCTMRGENERATOR_H_
#define DISNCTMRGENERATOR_H_
 
#include "MSSA/MemRegion.h"
 
namespace SVF
{
 
class DistinctMRG : public MRGenerator
{
public:
    DistinctMRG(BVDataPTAImpl* p, bool ptrOnly) : MRGenerator(p, ptrOnly)
    {}
 
    ~DistinctMRG() {}
 
protected:
    virtual void partitionMRs();
 
    virtual void getMRsForLoad(MRSet& aliasMRs, const NodeBS& cpts, const SVFFunction* fun);
 
    virtual void getMRsForCallSiteRef(MRSet& aliasMRs, const NodeBS& cpts, const SVFFunction* fun);
private:
    void createDistinctMR(const SVFFunction* func, const NodeBS& cpts);
 
};
 
class IntraDisjointMRG : public MRGenerator
{
public:
    typedef OrderedMap<NodeBS, PointsToList> PtsToSubPtsMap;
    typedef Map<const SVFFunction*, PtsToSubPtsMap> FunToPtsMap;
    typedef Map<const SVFFunction*, PointsToList> FunToInterMap;
 
    IntraDisjointMRG(BVDataPTAImpl* p, bool ptrOnly) : MRGenerator(p, ptrOnly)
    {}
 
    ~IntraDisjointMRG() {}
 
protected:
 
    virtual void partitionMRs();
 
    virtual inline void getMRsForLoad(MRSet& aliasMRs, const NodeBS& cpts,
                                      const SVFFunction* fun)
    {
        const PointsToList& inters = getIntersList(fun);
        getMRsForLoadFromInterList(aliasMRs, cpts, inters);
    }
 
    void getMRsForLoadFromInterList(MRSet& mrs, const NodeBS& cpts, const PointsToList& inters);
 
    virtual void getMRsForCallSiteRef(MRSet& aliasMRs, const NodeBS& cpts, const SVFFunction* fun);
 
    void createDisjointMR(const SVFFunction* func, const NodeBS& cpts);
 
    void computeIntersections(const NodeBS& cpts, PointsToList& inters);
 
private:
    inline PtsToSubPtsMap& getPtsSubSetMap(const SVFFunction* func)
    {
        return funcToPtsMap[func];
    }
 
    inline PointsToList& getIntersList(const SVFFunction* func)
    {
        return funcToInterMap[func];
    }
 
    inline const PtsToSubPtsMap& getPtsSubSetMap(const SVFFunction* func) const
    {
        FunToPtsMap::const_iterator it = funcToPtsMap.find(func);
        assert(it != funcToPtsMap.end() && "can not find pts map for specified function");
        return it->second;
    }
 
    FunToPtsMap funcToPtsMap;
    FunToInterMap funcToInterMap;
};
 
class InterDisjointMRG : public IntraDisjointMRG
{
public:
    InterDisjointMRG(BVDataPTAImpl* p, bool ptrOnly) : IntraDisjointMRG(p, ptrOnly)
    {}
 
    ~InterDisjointMRG() {}
 
protected:
    virtual void partitionMRs();
 
    virtual inline void getMRsForLoad(MRSet& aliasMRs, const NodeBS& cpts,
                                      const SVFFunction*)
    {
        getMRsForLoadFromInterList(aliasMRs, cpts, inters);
    }
 
private:
    PointsToList inters;
};
 
} // End namespace SVF
 
#endif /* DISNCTMRGENERATOR_H_ */