SVF::MemSSA Class Reference

#include <MemSSA.h>

Public Types
enum	MemPartition { Distinct , IntraDisjoint , InterDisjoint }
typedef MemRegion::Condition	Condition
	define condition here changes needed if we add new type
typedef MSSAMU< Condition >	MU
typedef RetMU< Condition >	RETMU
typedef LoadMU< Condition >	LOADMU
typedef CallMU< Condition >	CALLMU
typedef MSSACHI< Condition >	CHI
typedef EntryCHI< Condition >	ENTRYCHI
typedef StoreCHI< Condition >	STORECHI
typedef CallCHI< Condition >	CALLCHI
typedef MSSAPHI< Condition >	PHI
typedef MSSADEF	MDEF
typedef Set< MU * >	MUSet
typedef Set< CHI * >	CHISet
typedef Set< PHI * >	PHISet
typedef MRGenerator::MRSet	MRSet
	Define mem region set.
typedef std::vector< const MemRegion * >	MRVector
typedef Map< const LoadStmt *, MUSet >	LoadToMUSetMap
typedef Map< const StoreStmt *, CHISet >	StoreToChiSetMap
typedef Map< const CallICFGNode *, MUSet >	CallSiteToMUSetMap
typedef Map< const CallICFGNode *, CHISet >	CallSiteToCHISetMap
typedef OrderedMap< const SVFBasicBlock *, PHISet >	BBToPhiSetMap
typedef Map< const SVFFunction *, CHISet >	FunToEntryChiSetMap
	Map from fun to its entry chi set and return mu set.
typedef Map< const SVFFunction *, MUSet >	FunToReturnMuSetMap
typedef std::vector< const SVFBasicBlock * >	BBList
	For phi insertion.
typedef Map< const SVFBasicBlock *, MRSet >	BBToMRSetMap
typedef Map< const MemRegion *, BBList >	MemRegToBBsMap
typedef Map< const MemRegion *, std::vector< MRVer * > >	MemRegToVerStackMap
	For SSA renaming.
typedef Map< const MemRegion *, MRVERSION >	MemRegToCounterMap
typedef SVFIR::SVFStmtList	SVFStmtList
	SVFIR edge list.

Static Public Attributes
static double	timeOfGeneratingMemRegions = 0
	Statistics.
static double	timeOfCreateMUCHI = 0
	Time for generating mu/chi for load/store/calls.
static double	timeOfInsertingPHI = 0
	Time for inserting phis.
static double	timeOfSSARenaming = 0
	Time for SSA rename.

Protected Member Functions
virtual void	createMUCHI (const SVFFunction &fun)
	Create mu chi for candidate regions in a function.
virtual void	insertPHI (const SVFFunction &fun)
	Insert phi for candidate regions in a function.
virtual void	SSARename (const SVFFunction &fun)
	SSA rename for a function.
virtual void	SSARenameBB (const SVFBasicBlock &bb)
	SSA rename for a basic block.

Protected Attributes
BVDataPTAImpl *	pta
MRGenerator *	mrGen
MemSSAStat *	stat

Private Attributes
LoadToMUSetMap	load2MuSetMap
StoreToChiSetMap	store2ChiSetMap
CallSiteToMUSetMap	callsiteToMuSetMap
CallSiteToCHISetMap	callsiteToChiSetMap
BBToPhiSetMap	bb2PhiSetMap
FunToEntryChiSetMap	funToEntryChiSetMap
FunToReturnMuSetMap	funToReturnMuSetMap
MemRegToVerStackMap	mr2VerStackMap
MemRegToCounterMap	mr2CounterMap
MRSet	usedRegs
	The following three set are used for prune SSA phi insertion.
MemRegToBBsMap	reg2BBMap
	Maps memory region to its basic block.
MRSet	varKills
	Collect memory regions whose definition killed.
std::vector< std::unique_ptr< MRVer > >	usedMRVers
void	destroy ()
	Release the memory.
MRVer *	newSSAName (const MemRegion *mr, MSSADEF *def)
	Get a new SSA name of a memory region.
MRVer *	getTopStackVer (const MemRegion *mr)
	Get the last version of the SSA ver of memory region.
void	collectRegUses (const MemRegion *mr)
	Collect region uses and region defs according to mus/chis, in order to insert phis.
void	collectRegDefs (const SVFBasicBlock *bb, const MemRegion *mr)
void	AddLoadMU (const SVFBasicBlock *bb, const LoadStmt *load, const MRSet &mrSet)
	Add methods for mus/chis/phis.
void	AddStoreCHI (const SVFBasicBlock *bb, const StoreStmt *store, const MRSet &mrSet)
void	AddCallSiteMU (const CallICFGNode *cs, const MRSet &mrSet)
void	AddCallSiteCHI (const CallICFGNode *cs, const MRSet &mrSet)
void	AddMSSAPHI (const SVFBasicBlock *bb, const MRSet &mrSet)
void	AddLoadMU (const SVFBasicBlock *bb, const LoadStmt *load, const MemRegion *mr)
void	AddStoreCHI (const SVFBasicBlock *bb, const StoreStmt *store, const MemRegion *mr)
void	AddCallSiteMU (const CallICFGNode *cs, const MemRegion *mr)
void	AddCallSiteCHI (const CallICFGNode *cs, const MemRegion *mr)
void	AddMSSAPHI (const SVFBasicBlock *bb, const MemRegion *mr)
void	RenameMuSet (const MUSet &muSet)
	Rename mus, chis and phis.
void	RenameChiSet (const CHISet &chiSet, MRVector &memRegs)
	Rename chi set.
void	RenamePhiRes (const PHISet &phiSet, MRVector &memRegs)
	Rename result (LHS) of phis.
void	RenamePhiOps (const PHISet &phiSet, u32_t pos, MRVector &)
	Rename operands (RHS) of phis.
	MemSSA (BVDataPTAImpl *p, bool ptrOnlyMSSA)
	Constructor.
SVFIR *	getPAG ()
	Return SVFIR.
BVDataPTAImpl *	getPTA () const
	Return PTA.
MRGenerator *	getMRGenerator ()
	Return MRGenerator.
virtual void	buildMemSSA (const SVFFunction &fun)
	We start from here.
void	performStat ()
	Perform statistics.
bool	hasMU (const PAGEdge *inst) const
	Has mu/chi methods.
bool	hasCHI (const PAGEdge *inst) const
bool	hasMU (const CallICFGNode *cs) const
bool	hasCHI (const CallICFGNode *cs) const
bool	hasFuncEntryChi (const SVFFunction *fun) const
	Has function entry chi or return mu.
bool	hasReturnMu (const SVFFunction *fun) const
CHISet &	getFuncEntryChiSet (const SVFFunction *fun)
MUSet &	getReturnMuSet (const SVFFunction *fun)
MUSet &	getMUSet (const LoadStmt *ld)
	Get methods of mu/chi/phi.
CHISet &	getCHISet (const StoreStmt *st)
MUSet &	getMUSet (const CallICFGNode *cs)
CHISet &	getCHISet (const CallICFGNode *cs)
PHISet &	getPHISet (const SVFBasicBlock *bb)
bool	hasPHISet (const SVFBasicBlock *bb) const
LoadToMUSetMap &	getLoadToMUSetMap ()
StoreToChiSetMap &	getStoreToChiSetMap ()
FunToReturnMuSetMap &	getFunToRetMuSetMap ()
FunToEntryChiSetMap &	getFunToEntryChiSetMap ()
CallSiteToMUSetMap &	getCallSiteToMuSetMap ()
CallSiteToCHISetMap &	getCallSiteToChiSetMap ()
BBToPhiSetMap &	getBBToPhiSetMap ()
u32_t	getLoadMuNum () const
	Stat methods.
u32_t	getStoreChiNum () const
u32_t	getFunEntryChiNum () const
u32_t	getFunRetMuNum () const
u32_t	getCallSiteMuNum () const
u32_t	getCallSiteChiNum () const
u32_t	getBBPhiNum () const
void	dumpMSSA (OutStream &Out=SVFUtil::outs())
	Print Memory SSA.

Detailed Description

Definition at line 52 of file MemSSA.h.

Member Typedef Documentation

BBList

typedef std::vector<const SVFBasicBlock*> SVF::MemSSA::BBList

For phi insertion.

Definition at line 93 of file MemSSA.h.

BBToMRSetMap

typedef Map<const SVFBasicBlock*, MRSet> SVF::MemSSA::BBToMRSetMap

Definition at line 94 of file MemSSA.h.

BBToPhiSetMap

typedef OrderedMap<const SVFBasicBlock*, PHISet> SVF::MemSSA::BBToPhiSetMap

Definition at line 84 of file MemSSA.h.

CALLCHI

typedef CallCHI<Condition> SVF::MemSSA::CALLCHI

Definition at line 66 of file MemSSA.h.

CALLMU

typedef CallMU<Condition> SVF::MemSSA::CALLMU

Definition at line 62 of file MemSSA.h.

CallSiteToCHISetMap

typedef Map<const CallICFGNode*, CHISet> SVF::MemSSA::CallSiteToCHISetMap

Definition at line 83 of file MemSSA.h.

CallSiteToMUSetMap

typedef Map<const CallICFGNode*, MUSet> SVF::MemSSA::CallSiteToMUSetMap

Definition at line 82 of file MemSSA.h.

CHI

typedef MSSACHI<Condition> SVF::MemSSA::CHI

Definition at line 63 of file MemSSA.h.

CHISet

typedef Set<CHI*> SVF::MemSSA::CHISet

Definition at line 71 of file MemSSA.h.

Condition

typedef MemRegion::Condition SVF::MemSSA::Condition

define condition here changes needed if we add new type

Definition at line 58 of file MemSSA.h.

ENTRYCHI

typedef EntryCHI<Condition> SVF::MemSSA::ENTRYCHI

Definition at line 64 of file MemSSA.h.

FunToEntryChiSetMap

typedef Map<const SVFFunction*, CHISet> SVF::MemSSA::FunToEntryChiSetMap

Map from fun to its entry chi set and return mu set.

Definition at line 88 of file MemSSA.h.

FunToReturnMuSetMap

typedef Map<const SVFFunction*, MUSet> SVF::MemSSA::FunToReturnMuSetMap

Definition at line 89 of file MemSSA.h.

LOADMU

typedef LoadMU<Condition> SVF::MemSSA::LOADMU

Definition at line 61 of file MemSSA.h.

LoadToMUSetMap

typedef Map<const LoadStmt*, MUSet> SVF::MemSSA::LoadToMUSetMap

Map loads/stores to its mem regions, TODO:visitAtomicCmpXchgInst, visitAtomicRMWInst??

Definition at line 80 of file MemSSA.h.

MDEF

typedef MSSADEF SVF::MemSSA::MDEF

Definition at line 68 of file MemSSA.h.

MemRegToBBsMap

typedef Map<const MemRegion*, BBList> SVF::MemSSA::MemRegToBBsMap

Definition at line 95 of file MemSSA.h.

MemRegToCounterMap

typedef Map<const MemRegion*, MRVERSION> SVF::MemSSA::MemRegToCounterMap

Definition at line 100 of file MemSSA.h.

MemRegToVerStackMap

typedef Map<const MemRegion*, std::vector<MRVer*> > SVF::MemSSA::MemRegToVerStackMap

For SSA renaming.

Definition at line 99 of file MemSSA.h.

MRSet

typedef MRGenerator::MRSet SVF::MemSSA::MRSet

Define mem region set.

Definition at line 75 of file MemSSA.h.

MRVector

typedef std::vector<const MemRegion*> SVF::MemSSA::MRVector

Definition at line 76 of file MemSSA.h.

MU

typedef MSSAMU<Condition> SVF::MemSSA::MU

Definition at line 59 of file MemSSA.h.

MUSet

typedef Set<MU*> SVF::MemSSA::MUSet

Definition at line 70 of file MemSSA.h.

PHI

typedef MSSAPHI<Condition> SVF::MemSSA::PHI

Definition at line 67 of file MemSSA.h.

PHISet

typedef Set<PHI*> SVF::MemSSA::PHISet

Definition at line 72 of file MemSSA.h.

RETMU

typedef RetMU<Condition> SVF::MemSSA::RETMU

Definition at line 60 of file MemSSA.h.

STORECHI

typedef StoreCHI<Condition> SVF::MemSSA::STORECHI

Definition at line 65 of file MemSSA.h.

StoreToChiSetMap

typedef Map<const StoreStmt*, CHISet> SVF::MemSSA::StoreToChiSetMap

Definition at line 81 of file MemSSA.h.

SVFStmtList

typedef SVFIR::SVFStmtList SVF::MemSSA::SVFStmtList

SVFIR edge list.

Definition at line 103 of file MemSSA.h.

Member Enumeration Documentation

MemPartition

enum SVF::MemSSA::MemPartition

Enumerator
Distinct
IntraDisjoint
InterDisjoint

Definition at line 113 of file MemSSA.h.

    {
        Distinct,
        IntraDisjoint,
        InterDisjoint
    };

Constructor & Destructor Documentation

MemSSA()

MemSSA::MemSSA	(	BVDataPTAImpl *	p,
		bool	ptrOnlyMSSA
	)

Constructor.

Constructor

Generate whole program memory regions

Definition at line 47 of file MemSSA.cpp.

{
    pta = p;
    assert((pta->getAnalysisTy()!=PointerAnalysis::Default_PTA)
           && "please specify a pointer analysis");
 
    if (Options::MemPar() == MemPartition::Distinct)
        mrGen = new DistinctMRG(pta, ptrOnlyMSSA);
    else if (Options::MemPar() == MemPartition::IntraDisjoint)
        mrGen = new IntraDisjointMRG(pta, ptrOnlyMSSA);
    else if (Options::MemPar() == MemPartition::InterDisjoint)
        mrGen = new InterDisjointMRG(pta, ptrOnlyMSSA);
    else
        assert(false && "unrecognised memory partition strategy");
 
 
    stat = new MemSSAStat(this);
 
    double mrStart = stat->getClk(true);
    mrGen->generateMRs();
    double mrEnd = stat->getClk(true);
    timeOfGeneratingMemRegions = (mrEnd - mrStart)/TIMEINTERVAL;
}

~MemSSA()

virtual SVF::MemSSA::~MemSSA ( )

inlinevirtual

Destructor.

Definition at line 301 of file MemSSA.h.

    {
        destroy();
    }

Member Function Documentation

AddCallSiteCHI() [1/2]

void SVF::MemSSA::AddCallSiteCHI ( const CallICFGNode *  cs, const MemRegion *  mr  )

inlineprivate

Definition at line 233 of file MemSSA.h.

    {
        CALLCHI* chi = new CALLCHI(cs, mr);
        callsiteToChiSetMap[cs].insert(chi);
        collectRegUses(mr);
        collectRegDefs(chi->getBasicBlock(),mr);
    }

AddCallSiteCHI() [2/2]

void SVF::MemSSA::AddCallSiteCHI ( const CallICFGNode *  cs, const MRSet &  mrSet  )

inlineprivate

Definition at line 204 of file MemSSA.h.

    {
        for (MRSet::iterator iter = mrSet.begin(), eiter = mrSet.end(); iter != eiter; ++iter)
            AddCallSiteCHI(cs,*iter);
    }

AddCallSiteMU() [1/2]

void SVF::MemSSA::AddCallSiteMU ( const CallICFGNode *  cs, const MemRegion *  mr  )

inlineprivate

Definition at line 227 of file MemSSA.h.

    {
        CALLMU* mu = new CALLMU(cs, mr);
        callsiteToMuSetMap[cs].insert(mu);
        collectRegUses(mr);
    }

AddCallSiteMU() [2/2]

void SVF::MemSSA::AddCallSiteMU ( const CallICFGNode *  cs, const MRSet &  mrSet  )

inlineprivate

Definition at line 199 of file MemSSA.h.

    {
        for (MRSet::iterator iter = mrSet.begin(), eiter = mrSet.end(); iter != eiter; ++iter)
            AddCallSiteMU(cs,*iter);
    }

AddLoadMU() [1/2]

void SVF::MemSSA::AddLoadMU ( const SVFBasicBlock *  bb, const LoadStmt *  load, const MemRegion *  mr  )

inlineprivate

Definition at line 214 of file MemSSA.h.

    {
        LOADMU* mu = new LOADMU(bb,load, mr);
        load2MuSetMap[load].insert(mu);
        collectRegUses(mr);
    }

AddLoadMU() [2/2]

void SVF::MemSSA::AddLoadMU ( const SVFBasicBlock *  bb, const LoadStmt *  load, const MRSet &  mrSet  )

inlineprivate

Add methods for mus/chis/phis.

Definition at line 189 of file MemSSA.h.

    {
        for (MRSet::iterator iter = mrSet.begin(), eiter = mrSet.end(); iter != eiter; ++iter)
            AddLoadMU(bb,load,*iter);
    }

AddMSSAPHI() [1/2]

void SVF::MemSSA::AddMSSAPHI ( const SVFBasicBlock *  bb, const MemRegion *  mr  )

inlineprivate

Definition at line 240 of file MemSSA.h.

    {
        bb2PhiSetMap[bb].insert(new PHI(bb, mr));
    }

AddMSSAPHI() [2/2]

void SVF::MemSSA::AddMSSAPHI ( const SVFBasicBlock *  bb, const MRSet &  mrSet  )

inlineprivate

Definition at line 209 of file MemSSA.h.

    {
        for (MRSet::iterator iter = mrSet.begin(), eiter = mrSet.end(); iter != eiter; ++iter)
            AddMSSAPHI(bb,*iter);
    }

AddStoreCHI() [1/2]

void SVF::MemSSA::AddStoreCHI ( const SVFBasicBlock *  bb, const StoreStmt *  store, const MemRegion *  mr  )

inlineprivate

Definition at line 220 of file MemSSA.h.

    {
        STORECHI* chi = new STORECHI(bb,store, mr);
        store2ChiSetMap[store].insert(chi);
        collectRegUses(mr);
        collectRegDefs(bb,mr);
    }

AddStoreCHI() [2/2]

void SVF::MemSSA::AddStoreCHI ( const SVFBasicBlock *  bb, const StoreStmt *  store, const MRSet &  mrSet  )

inlineprivate

Definition at line 194 of file MemSSA.h.

    {
        for (MRSet::iterator iter = mrSet.begin(), eiter = mrSet.end(); iter != eiter; ++iter)
            AddStoreCHI(bb,store,*iter);
    }

buildMemSSA()

void MemSSA::buildMemSSA ( const SVFFunction &  fun )

virtual

We start from here.

Start building memory SSA

Create mus/chis for loads/stores/calls for memory regions

Insert PHI for memory regions

SSA rename for memory regions

Definition at line 80 of file MemSSA.cpp.

{
 
    assert(!isExtCall(&fun) && "we do not build memory ssa for external functions");
 
    DBOUT(DMSSA, outs() << "Building Memory SSA for function " << fun.getName()
          << " \n");
 
    usedRegs.clear();
    reg2BBMap.clear();
 
    double muchiStart = stat->getClk(true);
    createMUCHI(fun);
    double muchiEnd = stat->getClk(true);
    timeOfCreateMUCHI += (muchiEnd - muchiStart)/TIMEINTERVAL;
 
    double phiStart = stat->getClk(true);
    insertPHI(fun);
    double phiEnd = stat->getClk(true);
    timeOfInsertingPHI += (phiEnd - phiStart)/TIMEINTERVAL;
 
    double renameStart = stat->getClk(true);
    SSARename(fun);
    double renameEnd = stat->getClk(true);
    timeOfSSARenaming += (renameEnd - renameStart)/TIMEINTERVAL;
 
}

collectRegDefs()

void SVF::MemSSA::collectRegDefs ( const SVFBasicBlock *  bb, const MemRegion *  mr  )

inlineprivate

Definition at line 180 of file MemSSA.h.

    {
        varKills.insert(mr);
        reg2BBMap[mr].push_back(bb);
    }

collectRegUses()

void SVF::MemSSA::collectRegUses ( const MemRegion *  mr )

inlineprivate

Collect region uses and region defs according to mus/chis, in order to insert phis.

Definition at line 175 of file MemSSA.h.

    {
        if (0 == varKills.count(mr))
            usedRegs.insert(mr);
    }

createMUCHI()

void MemSSA::createMUCHI ( const SVFFunction &  fun )

protectedvirtual

Create mu chi for candidate regions in a function.

Create mu/chi according to memory regions collect used mrs in usedRegs and construction map from region to BB for prune SSA phi insertion

get all reachable basic blocks from function entry ignore dead basic blocks

if the function does not have a reachable return instruction from function entry then we won't create return mu for it

Definition at line 115 of file MemSSA.cpp.

{
 
 
    DBOUT(DMSSA,
          outs() << "\t creating mu chi for function " << fun.getName()
          << "\n");
    // 1. create mu/chi
    //  insert a set of mus for memory regions at each load
    //  inset a set of chis for memory regions at each store
 
    // 2. find global names (region name before renaming) of each memory region,
    // collect used mrs in usedRegs, and collect its def basic block in reg2BBMap
    // in the form of mu(r) and r = chi (r)
    // a) mu(r):
    //      if(r \not\in varKills) global = global \cup r
    // b) r = chi(r):
    //      if(r \not\in varKills) global = global \cup r
    //      varKills = varKills \cup r
    //      block(r) = block(r) \cup bb_{chi}
 
    BBList reachableBBs = fun.getReachableBBs();
 
    for (BBList::const_iterator iter = reachableBBs.begin(), eiter = reachableBBs.end();
            iter != eiter; ++iter)
    {
        const SVFBasicBlock* bb = *iter;
        varKills.clear();
        for (const auto& inst: bb->getICFGNodeList())
        {
            if(mrGen->hasSVFStmtList(inst))
            {
                SVFStmtList& pagEdgeList = mrGen->getPAGEdgesFromInst(inst);
                for (SVFStmtList::const_iterator bit = pagEdgeList.begin(),
                        ebit = pagEdgeList.end(); bit != ebit; ++bit)
                {
                    const PAGEdge* inst = *bit;
                    if (const LoadStmt* load = SVFUtil::dyn_cast<LoadStmt>(inst))
                        AddLoadMU(bb, load, mrGen->getLoadMRSet(load));
                    else if (const StoreStmt* store = SVFUtil::dyn_cast<StoreStmt>(inst))
                        AddStoreCHI(bb, store, mrGen->getStoreMRSet(store));
                }
            }
            if (isNonInstricCallSite(inst))
            {
                const CallICFGNode* cs = cast<CallICFGNode>(inst);
                if(mrGen->hasRefMRSet(cs))
                    AddCallSiteMU(cs,mrGen->getCallSiteRefMRSet(cs));
 
                if(mrGen->hasModMRSet(cs))
                    AddCallSiteCHI(cs,mrGen->getCallSiteModMRSet(cs));
            }
        }
    }
 
    // create entry chi for this function including all memory regions
    // initialize them with version 0 and 1 r_1 = chi (r_0)
    for (MRSet::iterator iter = usedRegs.begin(), eiter = usedRegs.end();
            iter != eiter; ++iter)
    {
        const MemRegion* mr = *iter;
        // initialize mem region version and stack for renaming phase
        mr2CounterMap[mr] = 0;
        mr2VerStackMap[mr].clear();
        ENTRYCHI* chi = new ENTRYCHI(&fun, mr);
        chi->setOpVer(newSSAName(mr,chi));
        chi->setResVer(newSSAName(mr,chi));
        funToEntryChiSetMap[&fun].insert(chi);
 
        if(fun.hasReturn())
        {
            RETMU* mu = new RETMU(&fun, mr);
            funToReturnMuSetMap[&fun].insert(mu);
        }
 
    }
 
}

destroy()

void MemSSA::destroy ( )

private

Release the memory.

Clean up memory

Definition at line 366 of file MemSSA.cpp.

{
 
    for (LoadToMUSetMap::iterator iter = load2MuSetMap.begin(), eiter =
                load2MuSetMap.end(); iter != eiter; ++iter)
    {
        for (MUSet::iterator it = iter->second.begin(), eit =
                    iter->second.end(); it != eit; ++it)
        {
            delete *it;
        }
    }
 
    for (StoreToChiSetMap::iterator iter = store2ChiSetMap.begin(), eiter =
                store2ChiSetMap.end(); iter != eiter; ++iter)
    {
        for (CHISet::iterator it = iter->second.begin(), eit =
                    iter->second.end(); it != eit; ++it)
        {
            delete *it;
        }
    }
 
    for (CallSiteToMUSetMap::iterator iter = callsiteToMuSetMap.begin(),
            eiter = callsiteToMuSetMap.end(); iter != eiter; ++iter)
    {
        for (MUSet::iterator it = iter->second.begin(), eit =
                    iter->second.end(); it != eit; ++it)
        {
            delete *it;
        }
    }
 
    for (CallSiteToCHISetMap::iterator iter = callsiteToChiSetMap.begin(),
            eiter = callsiteToChiSetMap.end(); iter != eiter; ++iter)
    {
        for (CHISet::iterator it = iter->second.begin(), eit =
                    iter->second.end(); it != eit; ++it)
        {
            delete *it;
        }
    }
 
    for (FunToEntryChiSetMap::iterator iter = funToEntryChiSetMap.begin(),
            eiter = funToEntryChiSetMap.end(); iter != eiter; ++iter)
    {
        for (CHISet::iterator it = iter->second.begin(), eit =
                    iter->second.end(); it != eit; ++it)
        {
            delete *it;
        }
    }
 
    for (FunToReturnMuSetMap::iterator iter = funToReturnMuSetMap.begin(),
            eiter = funToReturnMuSetMap.end(); iter != eiter; ++iter)
    {
        for (MUSet::iterator it = iter->second.begin(), eit =
                    iter->second.end(); it != eit; ++it)
        {
            delete *it;
        }
    }
 
    for (BBToPhiSetMap::iterator iter = bb2PhiSetMap.begin(), eiter =
                bb2PhiSetMap.end(); iter != eiter; ++iter)
    {
        for (PHISet::iterator it = iter->second.begin(), eit =
                    iter->second.end(); it != eit; ++it)
        {
            delete *it;
        }
    }
 
    delete mrGen;
    mrGen = nullptr;
    delete stat;
    stat = nullptr;
    pta = nullptr;
}

dumpMSSA()

void MemSSA::dumpMSSA

(

OutStream &

Out = SVFUtil::outs()

)

Print Memory SSA.

Print SSA

Definition at line 576 of file MemSSA.cpp.

{
 
    CallGraph* svfirCallGraph = PAG::getPAG()->getCallGraph();
    for (const auto& item: *svfirCallGraph)
    {
        const SVFFunction* fun = item.second->getFunction();
        if(Options::MSSAFun()!="" && Options::MSSAFun()!=fun->getName())
            continue;
 
        Out << "==========FUNCTION: " << fun->getName() << "==========\n";
        // dump function entry chi nodes
        if (hasFuncEntryChi(fun))
        {
            CHISet & entry_chis = getFuncEntryChiSet(fun);
            for (CHISet::iterator chi_it = entry_chis.begin(); chi_it != entry_chis.end(); chi_it++)
            {
                (*chi_it)->dump();
            }
        }
 
        for (SVFFunction::const_iterator bit = fun->begin(), ebit = fun->end();
                bit != ebit; ++bit)
        {
            const SVFBasicBlock* bb = *bit;
            Out << bb->getName() << "\n";
            PHISet& phiSet = getPHISet(bb);
            for(PHISet::iterator pi = phiSet.begin(), epi = phiSet.end(); pi !=epi; ++pi)
            {
                (*pi)->dump();
            }
 
            bool last_is_chi = false;
            for (const auto& inst: bb->getICFGNodeList())
            {
                bool isAppCall = isNonInstricCallSite(inst) && !isExtCall(inst);
                if (isAppCall || isHeapAllocExtCall(inst))
                {
                    const CallICFGNode* cs = cast<CallICFGNode>(inst);
                    if(hasMU(cs))
                    {
                        if (!last_is_chi)
                        {
                            Out << "\n";
                        }
                        for (MUSet::iterator mit = getMUSet(cs).begin(), emit = getMUSet(cs).end();
                                mit != emit; ++mit)
                        {
                            (*mit)->dump();
                        }
                    }
 
                    Out << inst->toString() << "\n";
 
                    if(hasCHI(cs))
                    {
                        for (CHISet::iterator cit = getCHISet(cs).begin(), ecit = getCHISet(cs).end();
                                cit != ecit; ++cit)
                        {
                            (*cit)->dump();
                        }
                        Out << "\n";
                        last_is_chi = true;
                    }
                    else
                        last_is_chi = false;
                }
                else
                {
                    bool dump_preamble = false;
                    SVFStmtList& pagEdgeList = mrGen->getPAGEdgesFromInst(inst);
                    for(SVFStmtList::const_iterator bit = pagEdgeList.begin(), ebit= pagEdgeList.end();
                            bit!=ebit; ++bit)
                    {
                        const PAGEdge* edge = *bit;
                        if (const LoadStmt* load = SVFUtil::dyn_cast<LoadStmt>(edge))
                        {
                            MUSet& muSet = getMUSet(load);
                            for(MUSet::iterator it = muSet.begin(), eit = muSet.end(); it!=eit; ++it)
                            {
                                if (!dump_preamble && !last_is_chi)
                                {
                                    Out << "\n";
                                    dump_preamble = true;
                                }
                                (*it)->dump();
                            }
                        }
                    }
 
                    Out << inst->toString() << "\n";
 
                    bool has_chi = false;
                    for(SVFStmtList::const_iterator bit = pagEdgeList.begin(), ebit= pagEdgeList.end();
                            bit!=ebit; ++bit)
                    {
                        const PAGEdge* edge = *bit;
                        if (const StoreStmt* store = SVFUtil::dyn_cast<StoreStmt>(edge))
                        {
                            CHISet& chiSet = getCHISet(store);
                            for(CHISet::iterator it = chiSet.begin(), eit = chiSet.end(); it!=eit; ++it)
                            {
                                has_chi = true;
                                (*it)->dump();
                            }
                        }
                    }
                    if (has_chi)
                    {
                        Out << "\n";
                        last_is_chi = true;
                    }
                    else
                        last_is_chi = false;
                }
            }
        }
 
        // dump return mu nodes
        if (hasReturnMu(fun))
        {
            MUSet & return_mus = getReturnMuSet(fun);
            for (MUSet::iterator mu_it = return_mus.begin(); mu_it != return_mus.end(); mu_it++)
            {
                (*mu_it)->dump();
            }
        }
    }
}

getBBPhiNum()

u32_t MemSSA::getBBPhiNum

(

)

const

Get PHI numbers

Definition at line 560 of file MemSSA.cpp.

{
    u32_t num = 0;
    BBToPhiSetMap::const_iterator it = bb2PhiSetMap.begin();
    BBToPhiSetMap::const_iterator eit = bb2PhiSetMap.end();
    for (; it != eit; it++)
    {
        const PHISet & phiSet = it->second;
        num+= phiSet.size();
    }
    return num;
}

getBBToPhiSetMap()

BBToPhiSetMap & SVF::MemSSA::getBBToPhiSetMap ( )

inline

Definition at line 429 of file MemSSA.h.

    {
        return bb2PhiSetMap;
    }

getCallSiteChiNum()

u32_t MemSSA::getCallSiteChiNum

(

)

const

Get CallCHI numbers

Definition at line 543 of file MemSSA.cpp.

{
    u32_t num = 0;
    CallSiteToCHISetMap::const_iterator it = callsiteToChiSetMap.begin();
    CallSiteToCHISetMap::const_iterator eit = callsiteToChiSetMap.end();
    for (; it != eit; it++)
    {
        const CHISet & chiSet = it->second;
        num+= chiSet.size();
    }
    return num;
}

getCallSiteMuNum()

u32_t MemSSA::getCallSiteMuNum

(

)

const

Get CallMU numbers

Definition at line 526 of file MemSSA.cpp.

{
    u32_t num = 0;
    CallSiteToMUSetMap::const_iterator it = callsiteToMuSetMap.begin();
    CallSiteToMUSetMap::const_iterator eit = callsiteToMuSetMap.end();
    for (; it != eit; it++)
    {
        const MUSet & muSet = it->second;
        num+= muSet.size();
    }
    return num;
}

getCallSiteToChiSetMap()

CallSiteToCHISetMap & SVF::MemSSA::getCallSiteToChiSetMap ( )

inline

Definition at line 425 of file MemSSA.h.

    {
        return callsiteToChiSetMap;
    }

getCallSiteToMuSetMap()

CallSiteToMUSetMap & SVF::MemSSA::getCallSiteToMuSetMap ( )

inline

Definition at line 421 of file MemSSA.h.

    {
        return callsiteToMuSetMap;
    }

getCHISet() [1/2]

CHISet & SVF::MemSSA::getCHISet ( const CallICFGNode *  cs )

inline

Definition at line 393 of file MemSSA.h.

    {
        return callsiteToChiSetMap[cs];
    }

getCHISet() [2/2]

CHISet & SVF::MemSSA::getCHISet ( const StoreStmt *  st )

inline

Definition at line 385 of file MemSSA.h.

    {
        return store2ChiSetMap[st];
    }

getFuncEntryChiSet()

CHISet & SVF::MemSSA::getFuncEntryChiSet ( const SVFFunction *  fun )

inline

Definition at line 369 of file MemSSA.h.

    {
        return funToEntryChiSetMap[fun];
    }

getFunEntryChiNum()

u32_t MemSSA::getFunEntryChiNum

(

)

const

Get EntryCHI numbers

Definition at line 492 of file MemSSA.cpp.

{
    u32_t num = 0;
    FunToEntryChiSetMap::const_iterator it = funToEntryChiSetMap.begin();
    FunToEntryChiSetMap::const_iterator eit = funToEntryChiSetMap.end();
    for (; it != eit; it++)
    {
        const CHISet& chiSet = it->second;
        num += chiSet.size();
    }
    return num;
}

getFunRetMuNum()

u32_t MemSSA::getFunRetMuNum

(

)

const

Get RetMU numbers

Definition at line 509 of file MemSSA.cpp.

{
    u32_t num = 0;
    FunToReturnMuSetMap::const_iterator it = funToReturnMuSetMap.begin();
    FunToReturnMuSetMap::const_iterator eit = funToReturnMuSetMap.end();
    for (; it != eit; it++)
    {
        const MUSet & muSet = it->second;
        num+= muSet.size();
    }
    return num;
}

getFunToEntryChiSetMap()

FunToEntryChiSetMap & SVF::MemSSA::getFunToEntryChiSetMap ( )

inline

Definition at line 417 of file MemSSA.h.

    {
        return funToEntryChiSetMap;
    }

getFunToRetMuSetMap()

FunToReturnMuSetMap & SVF::MemSSA::getFunToRetMuSetMap ( )

inline

Definition at line 413 of file MemSSA.h.

    {
        return funToReturnMuSetMap;
    }

getLoadMuNum()

u32_t MemSSA::getLoadMuNum

(

)

const

Stat methods.

Get loadMU numbers

Definition at line 458 of file MemSSA.cpp.

{
    u32_t num = 0;
    LoadToMUSetMap::const_iterator it = load2MuSetMap.begin();
    LoadToMUSetMap::const_iterator eit = load2MuSetMap.end();
    for (; it != eit; it++)
    {
        const MUSet & muSet = it->second;
        num+= muSet.size();
    }
    return num;
}

getLoadToMUSetMap()

LoadToMUSetMap & SVF::MemSSA::getLoadToMUSetMap ( )

inline

Definition at line 405 of file MemSSA.h.

    {
        return load2MuSetMap;
    }

getMRGenerator()

MRGenerator * SVF::MemSSA::getMRGenerator ( )

inline

Return MRGenerator.

Definition at line 313 of file MemSSA.h.

    {
        return mrGen;
    }

getMUSet() [1/2]

MUSet & SVF::MemSSA::getMUSet ( const CallICFGNode *  cs )

inline

Definition at line 389 of file MemSSA.h.

    {
        return callsiteToMuSetMap[cs];
    }

getMUSet() [2/2]

MUSet & SVF::MemSSA::getMUSet ( const LoadStmt *  ld )

inline

Get methods of mu/chi/phi.

Definition at line 381 of file MemSSA.h.

    {
        return load2MuSetMap[ld];
    }

getPAG()

SVFIR * MemSSA::getPAG ( )

inline

Return SVFIR.

Definition at line 72 of file MemSSA.cpp.

{
    return pta->getPAG();
}

getPHISet()

PHISet & SVF::MemSSA::getPHISet ( const SVFBasicBlock *  bb )

inline

Definition at line 397 of file MemSSA.h.

    {
        return bb2PhiSetMap[bb];
    }

getPTA()

BVDataPTAImpl * SVF::MemSSA::getPTA ( ) const

inline

Return PTA.

Definition at line 308 of file MemSSA.h.

    {
        return pta;
    }

getReturnMuSet()

MUSet & SVF::MemSSA::getReturnMuSet ( const SVFFunction *  fun )

inline

Definition at line 373 of file MemSSA.h.

    {
        return funToReturnMuSetMap[fun];
    }

getStoreChiNum()

u32_t MemSSA::getStoreChiNum

(

)

const

Get StoreCHI numbers

Definition at line 475 of file MemSSA.cpp.

{
    u32_t num = 0;
    StoreToChiSetMap::const_iterator it = store2ChiSetMap.begin();
    StoreToChiSetMap::const_iterator eit = store2ChiSetMap.end();
    for (; it != eit; it++)
    {
        const CHISet& chiSet = it->second;
        num += chiSet.size();
    }
    return num;
}

getStoreToChiSetMap()

StoreToChiSetMap & SVF::MemSSA::getStoreToChiSetMap ( )

inline

Definition at line 409 of file MemSSA.h.

    {
        return store2ChiSetMap;
    }

getTopStackVer()

MRVer * SVF::MemSSA::getTopStackVer ( const MemRegion *  mr )

inlineprivate

Get the last version of the SSA ver of memory region.

Definition at line 166 of file MemSSA.h.

    {
        std::vector<MRVer*> &stack = mr2VerStackMap[mr];
        assert(!stack.empty() && "stack is empty!!");
        return stack.back();
    }

hasCHI() [1/2]

bool SVF::MemSSA::hasCHI ( const CallICFGNode *  cs ) const

inline

Definition at line 352 of file MemSSA.h.

    {
        return callsiteToChiSetMap.find(cs)!=callsiteToChiSetMap.end();
    }

hasCHI() [2/2]

bool SVF::MemSSA::hasCHI ( const PAGEdge *  inst ) const

inline

Definition at line 336 of file MemSSA.h.

    {
        if (const StoreStmt* store = SVFUtil::dyn_cast<StoreStmt>(
                                         inst))
        {
            bool has_store = store2ChiSetMap.count(store) != 0;
            assert(has_store && "not associated with mem region!");
            return has_store;
        }
        else
            return false;
    }

hasFuncEntryChi()

bool SVF::MemSSA::hasFuncEntryChi ( const SVFFunction *  fun ) const

inline

Has function entry chi or return mu.

Definition at line 360 of file MemSSA.h.

    {
        return (funToEntryChiSetMap.find(fun) != funToEntryChiSetMap.end());
    }

hasMU() [1/2]

bool SVF::MemSSA::hasMU ( const CallICFGNode *  cs ) const

inline

Definition at line 348 of file MemSSA.h.

    {
        return callsiteToMuSetMap.find(cs)!=callsiteToMuSetMap.end();
    }

hasMU() [2/2]

bool SVF::MemSSA::hasMU ( const PAGEdge *  inst ) const

inline

Has mu/chi methods.

Definition at line 325 of file MemSSA.h.

    {
        if (const LoadStmt* load = SVFUtil::dyn_cast<LoadStmt>(inst))
        {
            bool hasMu = load2MuSetMap.count(load) != 0;
            assert(hasMu && "not associated with mem region!");
            return hasMu;
        }
        else
            return false;
    }

hasPHISet()

bool SVF::MemSSA::hasPHISet ( const SVFBasicBlock *  bb ) const

inline

Definition at line 401 of file MemSSA.h.

    {
        return bb2PhiSetMap.find(bb)!=bb2PhiSetMap.end();
    }

hasReturnMu()

bool SVF::MemSSA::hasReturnMu ( const SVFFunction *  fun ) const

inline

Definition at line 364 of file MemSSA.h.

    {
        return (funToReturnMuSetMap.find(fun) != funToReturnMuSetMap.end());
    }

insertPHI()

void MemSSA::insertPHI ( const SVFFunction &  fun )

protectedvirtual

Insert phi for candidate regions in a function.

Definition at line 201 of file MemSSA.cpp.

{
 
    DBOUT(DMSSA,
          outs() << "\t insert phi for function " << fun.getName() << "\n");
 
    const Map<const SVFBasicBlock*,Set<const SVFBasicBlock*>>& df = fun.getDomFrontierMap();
    // record whether a phi of mr has already been inserted into the bb.
    BBToMRSetMap bb2MRSetMap;
 
    // start inserting phi node
    for (MRSet::iterator iter = usedRegs.begin(), eiter = usedRegs.end();
            iter != eiter; ++iter)
    {
        const MemRegion* mr = *iter;
 
        BBList bbs = reg2BBMap[mr];
        while (!bbs.empty())
        {
            const SVFBasicBlock* bb = bbs.back();
            bbs.pop_back();
            Map<const SVFBasicBlock*,Set<const SVFBasicBlock*>>::const_iterator it = df.find(bb);
            if(it == df.end())
            {
                writeWrnMsg("bb not in the dominance frontier map??");
                continue;
            }
            const Set<const SVFBasicBlock*>& domSet = it->second;
            for (const SVFBasicBlock* pbb : domSet)
            {
                // if we never insert this phi node before
                if (0 == bb2MRSetMap[pbb].count(mr))
                {
                    bb2MRSetMap[pbb].insert(mr);
                    // insert phi node
                    AddMSSAPHI(pbb,mr);
                    // continue to insert phi in its iterative dominate frontiers
                    bbs.push_back(pbb);
                }
            }
        }
    }
 
}

newSSAName()

MRVer * MemSSA::newSSAName ( const MemRegion *  mr, MSSADEF *  def  )

private

Get a new SSA name of a memory region.

Definition at line 347 of file MemSSA.cpp.

{
    assert(0 != mr2CounterMap.count(mr)
           && "did not find initial version in map? ");
    assert(0 != mr2VerStackMap.count(mr)
           && "did not find initial stack in map? ");
 
    MRVERSION version = mr2CounterMap[mr];
    mr2CounterMap[mr] = version + 1;
    auto mrVer = std::make_unique<MRVer>(mr, version, def);
    auto mrVerPtr = mrVer.get();
    mr2VerStackMap[mr].push_back(mrVerPtr);
    usedMRVers.push_back(std::move(mrVer));
    return mrVerPtr;
}

performStat()

void MemSSA::performStat

(

)

Perform statistics.

Perform statistics

Definition at line 449 of file MemSSA.cpp.

{
    if(pta->printStat())
        stat->performStat();
}

RenameChiSet()

void SVF::MemSSA::RenameChiSet ( const CHISet &  chiSet, MRVector &  memRegs  )

inlineprivate

Rename chi set.

Definition at line 260 of file MemSSA.h.

    {
        for (CHISet::const_iterator cit = chiSet.begin(), ecit = chiSet.end();
                cit != ecit; ++cit)
        {
            CHI* chi = (*cit);
            chi->setOpVer(getTopStackVer(chi->getMR()));
            chi->setResVer(newSSAName(chi->getMR(),chi));
            memRegs.push_back(chi->getMR());
        }
    }

RenameMuSet()

void SVF::MemSSA::RenameMuSet ( const MUSet &  muSet )

inlineprivate

Rename mus, chis and phis.

Rename mu set

Definition at line 249 of file MemSSA.h.

    {
        for (MUSet::const_iterator mit = muSet.begin(), emit = muSet.end();
                mit != emit; ++mit)
        {
            MU* mu = (*mit);
            mu->setVer(getTopStackVer(mu->getMR()));
        }
    }

RenamePhiOps()

void SVF::MemSSA::RenamePhiOps ( const PHISet &  phiSet, u32_t  pos, MRVector &    )

inlineprivate

Rename operands (RHS) of phis.

Definition at line 285 of file MemSSA.h.

    {
        for (PHISet::const_iterator iter = phiSet.begin(), eiter = phiSet.end();
                iter != eiter; ++iter)
        {
            PHI* phi = *iter;
            phi->setOpVer(getTopStackVer(phi->getMR()), pos);
        }
    }

RenamePhiRes()

void SVF::MemSSA::RenamePhiRes ( const PHISet &  phiSet, MRVector &  memRegs  )

inlineprivate

Rename result (LHS) of phis.

Definition at line 273 of file MemSSA.h.

    {
        for (PHISet::const_iterator iter = phiSet.begin(), eiter = phiSet.end();
                iter != eiter; ++iter)
        {
            PHI* phi = *iter;
            phi->setResVer(newSSAName(phi->getMR(),phi));
            memRegs.push_back(phi->getMR());
        }
    }

SSARename()

void MemSSA::SSARename ( const SVFFunction &  fun )

protectedvirtual

SSA rename for a function.

SSA construction algorithm

Definition at line 249 of file MemSSA.cpp.

{
 
    DBOUT(DMSSA,
          outs() << "\t ssa rename for function " << fun.getName() << "\n");
 
    SSARenameBB(*fun.getEntryBlock());
}

SSARenameBB()

void MemSSA::SSARenameBB ( const SVFBasicBlock &  bb )

protectedvirtual

SSA rename for a basic block.

Renaming for each memory regions See the renaming algorithm in book Engineering A Compiler (Figure 9.12)

Definition at line 262 of file MemSSA.cpp.

{
 
    // record which mem region needs to pop stack
    MRVector memRegs;
 
    // rename phi result op
    // for each r = phi (...)
    //      rewrite r as new name
    if (hasPHISet(&bb))
        RenamePhiRes(getPHISet(&bb),memRegs);
 
 
    // process mu and chi
    // for each mu(r)
    //      rewrite r with top mrver of stack(r)
    // for each r = chi(r')
    //      rewrite r' with top mrver of stack(r)
    //      rewrite r with new name
 
    for (const auto& pNode: bb.getICFGNodeList())
    {
        if(mrGen->hasSVFStmtList(pNode))
        {
            SVFStmtList& pagEdgeList = mrGen->getPAGEdgesFromInst(pNode);
            for(SVFStmtList::const_iterator bit = pagEdgeList.begin(), ebit= pagEdgeList.end();
                    bit!=ebit; ++bit)
            {
                const PAGEdge* inst = *bit;
                if (const LoadStmt* load = SVFUtil::dyn_cast<LoadStmt>(inst))
                    RenameMuSet(getMUSet(load));
 
                else if (const StoreStmt* store = SVFUtil::dyn_cast<StoreStmt>(inst))
                    RenameChiSet(getCHISet(store),memRegs);
 
            }
        }
        if (isNonInstricCallSite(pNode))
        {
            const CallICFGNode* cs = cast<CallICFGNode>(pNode);
            if(mrGen->hasRefMRSet(cs))
                RenameMuSet(getMUSet(cs));
 
            if(mrGen->hasModMRSet(cs))
                RenameChiSet(getCHISet(cs),memRegs);
        }
        else if(isRetInstNode(pNode))
        {
            const SVFFunction* fun = bb.getParent();
            RenameMuSet(getReturnMuSet(fun));
        }
    }
 
 
    // fill phi operands of succ basic blocks
    for (const SVFBasicBlock* succ : bb.getSuccessors())
    {
        u32_t pos = bb.getBBPredecessorPos(succ);
        if (hasPHISet(succ))
            RenamePhiOps(getPHISet(succ),pos,memRegs);
    }
 
    // for succ basic block in dominator tree
    const SVFFunction* fun = bb.getParent();
    const Map<const SVFBasicBlock*,Set<const SVFBasicBlock*>>& dtBBsMap = fun->getDomTreeMap();
    Map<const SVFBasicBlock*,Set<const SVFBasicBlock*>>::const_iterator mapIter = dtBBsMap.find(&bb);
    if (mapIter != dtBBsMap.end())
    {
        const Set<const SVFBasicBlock*>& dtBBs = mapIter->second;
        for (const SVFBasicBlock* dtbb : dtBBs)
        {
            SSARenameBB(*dtbb);
        }
    }
    // for each r = chi(..), and r = phi(..)
    //      pop ver stack(r)
    while (!memRegs.empty())
    {
        const MemRegion* mr = memRegs.back();
        memRegs.pop_back();
        mr2VerStackMap[mr].pop_back();
    }
 
}

Member Data Documentation

bb2PhiSetMap

BBToPhiSetMap SVF::MemSSA::bb2PhiSetMap

private

Definition at line 138 of file MemSSA.h.

callsiteToChiSetMap

CallSiteToCHISetMap SVF::MemSSA::callsiteToChiSetMap

private

Definition at line 137 of file MemSSA.h.

callsiteToMuSetMap

CallSiteToMUSetMap SVF::MemSSA::callsiteToMuSetMap

private

Definition at line 136 of file MemSSA.h.

funToEntryChiSetMap

FunToEntryChiSetMap SVF::MemSSA::funToEntryChiSetMap

private

Definition at line 140 of file MemSSA.h.

funToReturnMuSetMap

FunToReturnMuSetMap SVF::MemSSA::funToReturnMuSetMap

private

Definition at line 141 of file MemSSA.h.

load2MuSetMap

LoadToMUSetMap SVF::MemSSA::load2MuSetMap

private

Definition at line 134 of file MemSSA.h.

mr2CounterMap

MemRegToCounterMap SVF::MemSSA::mr2CounterMap

private

Definition at line 144 of file MemSSA.h.

mr2VerStackMap

MemRegToVerStackMap SVF::MemSSA::mr2VerStackMap

private

Definition at line 143 of file MemSSA.h.

mrGen

MRGenerator* SVF::MemSSA::mrGen

protected

Definition at line 122 of file MemSSA.h.

pta

BVDataPTAImpl* SVF::MemSSA::pta

protected

Definition at line 121 of file MemSSA.h.

reg2BBMap

MemRegToBBsMap SVF::MemSSA::reg2BBMap

private

Maps memory region to its basic block.

Definition at line 152 of file MemSSA.h.

stat

MemSSAStat* SVF::MemSSA::stat

protected

Definition at line 123 of file MemSSA.h.

store2ChiSetMap

StoreToChiSetMap SVF::MemSSA::store2ChiSetMap

private

Definition at line 135 of file MemSSA.h.

timeOfCreateMUCHI

double MemSSA::timeOfCreateMUCHI = 0

static

Time for generating mu/chi for load/store/calls.

Definition at line 108 of file MemSSA.h.

timeOfGeneratingMemRegions

double MemSSA::timeOfGeneratingMemRegions = 0

static

Statistics.

Time for allocating regions.

Time for allocating regions

Definition at line 107 of file MemSSA.h.

timeOfInsertingPHI

double MemSSA::timeOfInsertingPHI = 0

static

Time for inserting phis.

Definition at line 109 of file MemSSA.h.

timeOfSSARenaming

double MemSSA::timeOfSSARenaming = 0

static

Time for SSA rename.

Definition at line 110 of file MemSSA.h.

usedMRVers

std::vector<std::unique_ptr<MRVer> > SVF::MemSSA::usedMRVers

private

Definition at line 157 of file MemSSA.h.

usedRegs

MRSet SVF::MemSSA::usedRegs

private

The following three set are used for prune SSA phi insertion.

Collects used memory regions

Definition at line 150 of file MemSSA.h.

varKills

MRSet SVF::MemSSA::varKills

private

Collect memory regions whose definition killed.

Definition at line 154 of file MemSSA.h.

---

The documentation for this class was generated from the following files:

• /home/runner/work/SVF/SVF/svf/include/MSSA/MemSSA.h
• /home/runner/work/SVF/SVF/svf/lib/MSSA/MemSSA.cpp