SVFGBuilder.cpp

Go to the documentation of this file.

//===- SVFGBuilder.cpp -- SVFG builder----------------------------------------//
//
//                     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/>.
//
//===----------------------------------------------------------------------===//
 
/*
 * SVFGBuilder.cpp
 *
 *  Created on: Apr 15, 2014
 *      Author: Yulei Sui
 */
#include "MSSA/SVFGBuilder.h"
#include "Graphs/CallGraph.h"
#include "Graphs/SVFG.h"
#include "MSSA/MemPartition.h"
#include "Graphs/SVFGOPT.h"
#include "MSSA/MemSSA.h"
#include "Util/Options.h"
#include "Util/SVFUtil.h"
#include "WPA/Andersen.h"
 
using namespace SVF;
using namespace SVFUtil;
 
SVFG* SVFGBuilder::buildPTROnlySVFG(BVDataPTAImpl* pta)
{
    return this->SVFGWithPostOpts ? build(pta, VFG::PTRONLYSVFG_OPT)
           : build(pta, VFG::PTRONLYSVFG);
}
 
SVFG* SVFGBuilder::buildFullSVFG(BVDataPTAImpl* pta)
{
    return this->SVFGWithPostOpts ? build(pta, VFG::FULLSVFG_OPT)
           : build(pta, VFG::FULLSVFG);
}
 
void SVFGBuilder::buildSVFG()
{
    svfg->buildSVFG();
}
 
SVFG* SVFGBuilder::build(BVDataPTAImpl* pta, VFG::VFGK kind)
{
 
    auto mssa = buildMSSA(
                    pta, (VFG::PTRONLYSVFG == kind || VFG::PTRONLYSVFG_OPT == kind));
 
    DBOUT(DGENERAL, outs() << pasMsg("Build Sparse Value-Flow Graph \n"));
    if (kind == VFG::FULLSVFG_OPT || kind == VFG::PTRONLYSVFG_OPT)
        svfg = std::make_unique<SVFGOPT>(std::move(mssa), kind);
    else
        svfg = std::unique_ptr<SVFG>(new SVFG(std::move(mssa), kind));
    buildSVFG();
 
    if (SVFGWithIndCall)
        svfg->updateCallGraph(pta);
 
    if (svfg->getMSSA()->getPTA()->printStat())
        svfg->performStat();
 
    if (Options::DumpVFG())
        svfg->dump("svfg_final");
 
    return svfg.get();
}
 
void SVFGBuilder::releaseMemory()
{
    svfg->clearMSSA();
}
 
std::unique_ptr<MRGenerator> SVFGBuilder::createMRGenerator(BVDataPTAImpl* pta, bool ptrOnlyMSSA)
{
    switch (Options::MemPar())
    {
    case MemSSA::MemPartition::Distinct:
        return std::make_unique<DistinctMRG>(pta, ptrOnlyMSSA);
    case MemSSA::MemPartition::IntraDisjoint:
        return std::make_unique<IntraDisjointMRG>(pta, ptrOnlyMSSA);
    case MemSSA::MemPartition::InterDisjoint:
        return std::make_unique<InterDisjointMRG>(pta, ptrOnlyMSSA);
    default:
        assert(false && "unrecognised memory partition strategy");
        return nullptr;
    }
}
 
std::unique_ptr<MemSSA> SVFGBuilder::buildMSSA(BVDataPTAImpl* pta,
        bool ptrOnlyMSSA)
{
 
    DBOUT(DGENERAL, outs() << pasMsg("Build Memory SSA \n"));
 
    auto mssa = std::make_unique<MemSSA>(pta, createMRGenerator(pta, ptrOnlyMSSA));
 
    const CallGraph* svfirCallGraph = PAG::getPAG()->getCallGraph();
    for (const auto& item : *svfirCallGraph)
    {
 
        const FunObjVar* fun = item.second->getFunction();
        if (isExtCall(fun))
            continue;
 
        mssa->buildMemSSA(*fun);
    }
 
    mssa->performStat();
    if (Options::DumpMSSA())
    {
        mssa->dumpMSSA();
    }
 
    return mssa;
}