#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 FunObjVar *, CHISet >	FunToEntryChiSetMap
	Map from fun to its entry chi set and return mu set.

typedef Map< const FunObjVar *, 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 FunObjVar &fun)
	Create mu chi for candidate regions in a function.

virtual void	insertPHI (const FunObjVar &fun)
	Insert phi for candidate regions in a function.

virtual void	SSARename (const FunObjVar &fun)
	SSA rename for a function.

virtual void	SSARenameBB (const SVFBasicBlock &bb)
	SSA rename for a basic block.

Protected Attributes
BVDataPTAImpl *	pta

std::unique_ptr< 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, std::unique_ptr< MRGenerator > mrGenerator)

SVFIR *	getPAG ()
	Return SVFIR.

BVDataPTAImpl *	getPTA () const
	Return PTA.

MRGenerator *	getMRGenerator ()
	Return MRGenerator (non-owning; MemSSA retains ownership)

virtual void	buildMemSSA (const FunObjVar &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 FunObjVar *fun) const
	Has function entry chi or return mu.

bool	hasReturnMu (const FunObjVar *fun) const

CHISet &	getFuncEntryChiSet (const FunObjVar *fun)

MUSet &	getReturnMuSet (const FunObjVar *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 FunObjVar*, 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 FunObjVar*, 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,
		std::unique_ptr< MRGenerator >	mrGenerator
	)

Constructor. The builder (SVFGBuilder::createMRGenerator) supplies the MRGenerator and decides the partition strategy / thread-awareness; MemSSA takes ownership of it via unique_ptr. mrGenerator must not be null.

Constructor

Generate whole program memory regions

Definition at line 49 of file MemSSA.cpp.

{
    pta = p;
    assert((pta->getAnalysisTy() != PTATY::Default_PTA)
           && "please specify a pointer analysis");
    assert(mrGenerator != nullptr && "builder must supply an MRGenerator");
    mrGen = std::move(mrGenerator);
 
    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 303 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 FunObjVar & 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 74 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 FunObjVar & 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 109 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->getSVFStmtsFromInst(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 360 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;
        }
    }
 
    mrGen.reset();
    delete stat;
    stat = nullptr;
    pta = nullptr;
}

◆ dumpMSSA()

void MemSSA::dumpMSSA ( OutStream & Out = SVFUtil::outs() )

Print Memory SSA.

Print SSA

Definition at line 569 of file MemSSA.cpp.

{
 
    const CallGraph* svfirCallGraph = PAG::getPAG()->getCallGraph();
    for (const auto& item: *svfirCallGraph)
    {
        const FunObjVar* 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 (FunObjVar::const_bb_iterator bit = fun->begin(), ebit = fun->end();
                bit != ebit; ++bit)
        {
            const SVFBasicBlock* bb = bit->second;
            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->getSVFStmtsFromInst(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 553 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 431 of file MemSSA.h.

    {
        return bb2PhiSetMap;
    }

◆ getCallSiteChiNum()

u32_t MemSSA::getCallSiteChiNum ( ) const

Get CallCHI numbers

Definition at line 536 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 519 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 427 of file MemSSA.h.

    {
        return callsiteToChiSetMap;
    }

◆ getCallSiteToMuSetMap()

CallSiteToMUSetMap & SVF::MemSSA::getCallSiteToMuSetMap ( )

inline

Definition at line 423 of file MemSSA.h.

    {
        return callsiteToMuSetMap;
    }

◆ getCHISet() [1/2]

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

inline

Definition at line 395 of file MemSSA.h.

    {
        return callsiteToChiSetMap[cs];
    }

◆ getCHISet() [2/2]

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

inline

Definition at line 387 of file MemSSA.h.

    {
        return store2ChiSetMap[st];
    }

◆ getFuncEntryChiSet()

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

inline

Definition at line 371 of file MemSSA.h.

    {
        return funToEntryChiSetMap[fun];
    }

◆ getFunEntryChiNum()

u32_t MemSSA::getFunEntryChiNum ( ) const

Get EntryCHI numbers

Definition at line 485 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 502 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 419 of file MemSSA.h.

    {
        return funToEntryChiSetMap;
    }

◆ getFunToRetMuSetMap()

FunToReturnMuSetMap & SVF::MemSSA::getFunToRetMuSetMap ( )

inline

Definition at line 415 of file MemSSA.h.

    {
        return funToReturnMuSetMap;
    }

◆ getLoadMuNum()

u32_t MemSSA::getLoadMuNum ( ) const

Stat methods.

Get loadMU numbers

Definition at line 451 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 407 of file MemSSA.h.

    {
        return load2MuSetMap;
    }

◆ getMRGenerator()

MRGenerator * SVF::MemSSA::getMRGenerator ( )

inline

Return MRGenerator (non-owning; MemSSA retains ownership)

Definition at line 315 of file MemSSA.h.

    {
        return mrGen.get();
    }

◆ getMUSet() [1/2]

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

inline

Definition at line 391 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 383 of file MemSSA.h.

    {
        return load2MuSetMap[ld];
    }

◆ getPAG()

SVFIR * MemSSA::getPAG ( )

inline

Return SVFIR.

Definition at line 66 of file MemSSA.cpp.

{
    return pta->getPAG();
}

◆ getPHISet()

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

inline

Definition at line 399 of file MemSSA.h.

    {
        return bb2PhiSetMap[bb];
    }

◆ getPTA()

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

inline

Return PTA.

Definition at line 310 of file MemSSA.h.

    {
        return pta;
    }

◆ getReturnMuSet()

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

inline

Definition at line 375 of file MemSSA.h.

    {
        return funToReturnMuSetMap[fun];
    }

◆ getStoreChiNum()

u32_t MemSSA::getStoreChiNum ( ) const

Get StoreCHI numbers

Definition at line 468 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 411 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 354 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 338 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 FunObjVar * fun ) const

inline

Has function entry chi or return mu.

Definition at line 362 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 350 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 327 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 403 of file MemSSA.h.

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

◆ hasReturnMu()

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

inline

Definition at line 366 of file MemSSA.h.

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

◆ insertPHI()

void MemSSA::insertPHI ( const FunObjVar & fun )

protectedvirtual

Insert phi for candidate regions in a function.

Definition at line 195 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 341 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 442 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 FunObjVar & fun )

protectedvirtual

SSA rename for a function.

SSA construction algorithm

Definition at line 243 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 256 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->getSVFStmtsFromInst(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 FunObjVar* 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 FunObjVar* 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

std::unique_ptr<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

Public Types

Static Public Attributes

Protected Member Functions

Protected Attributes

Private Attributes

Detailed Description

Member Typedef Documentation

◆ BBList

◆ BBToMRSetMap

◆ BBToPhiSetMap

◆ CALLCHI

◆ CALLMU

◆ CallSiteToCHISetMap

◆ CallSiteToMUSetMap

◆ CHI

◆ CHISet

◆ Condition

◆ ENTRYCHI

◆ FunToEntryChiSetMap

◆ FunToReturnMuSetMap

◆ LOADMU

◆ LoadToMUSetMap

◆ MDEF

◆ MemRegToBBsMap

◆ MemRegToCounterMap

◆ MemRegToVerStackMap

◆ MRSet

◆ MRVector

◆ MU

◆ MUSet

◆ PHI

◆ PHISet

◆ RETMU

◆ STORECHI

◆ StoreToChiSetMap

◆ SVFStmtList

Member Enumeration Documentation

◆ MemPartition

Constructor & Destructor Documentation

◆ MemSSA()

◆ ~MemSSA()

Member Function Documentation

◆ AddCallSiteCHI() [1/2]

◆ AddCallSiteCHI() [2/2]

◆ AddCallSiteMU() [1/2]

◆ AddCallSiteMU() [2/2]

◆ AddLoadMU() [1/2]

◆ AddLoadMU() [2/2]

◆ AddMSSAPHI() [1/2]

◆ AddMSSAPHI() [2/2]

◆ AddStoreCHI() [1/2]

◆ AddStoreCHI() [2/2]

◆ buildMemSSA()

◆ collectRegDefs()

◆ collectRegUses()

◆ createMUCHI()

◆ destroy()

◆ dumpMSSA()

◆ getBBPhiNum()

◆ getBBToPhiSetMap()

◆ getCallSiteChiNum()

◆ getCallSiteMuNum()

◆ getCallSiteToChiSetMap()

◆ getCallSiteToMuSetMap()

◆ getCHISet() [1/2]

◆ getCHISet() [2/2]

◆ getFuncEntryChiSet()

◆ getFunEntryChiNum()

◆ getFunRetMuNum()

◆ getFunToEntryChiSetMap()

◆ getFunToRetMuSetMap()

◆ getLoadMuNum()

◆ getLoadToMUSetMap()

◆ getMRGenerator()

◆ getMUSet() [1/2]

◆ getMUSet() [2/2]

◆ getPAG()

◆ getPHISet()

◆ getPTA()

◆ getReturnMuSet()