#include <ThreadCallGraph.h>

Inheritance diagram for SVF::ThreadCallGraph:

Classes
struct	CallSiteIdCmp

Public Types
typedef OrderedSet< const CallICFGNode *, CallSiteIdCmp >	InstSet

typedef InstSet	CallSiteSet

typedef Set< CallSiteSet * >	CtxSet

typedef ThreadForkEdge::ForkEdgeSet	ForkEdgeSet

typedef Map< const CallICFGNode *, ForkEdgeSet >	CallInstToForkEdgesMap

typedef ThreadJoinEdge::JoinEdgeSet	JoinEdgeSet

typedef Map< const CallICFGNode *, JoinEdgeSet >	CallInstToJoinEdgesMap

typedef HareParForEdge::ParForEdgeSet	ParForEdgeSet

typedef Map< const CallICFGNode *, ParForEdgeSet >	CallInstToParForEdgesMap

Public Types inherited from SVF::CallGraph
enum	CGEK { NormCallGraph , ThdCallGraph }

typedef CallGraphEdge::CallGraphEdgeSet	CallGraphEdgeSet

typedef Map< const FunObjVar , CallGraphNode >	FunToCallGraphNodeMap

typedef Map< const CallICFGNode *, CallGraphEdgeSet >	CallInstToCallGraphEdgesMap

typedef std::pair< const CallICFGNode , const FunObjVar >	CallSitePair

typedef Map< CallSitePair, CallSiteID >	CallSiteToIdMap

typedef Map< CallSiteID, CallSitePair >	IdToCallSiteMap

typedef Set< const FunObjVar * >	FunctionSet

typedef OrderedMap< const CallICFGNode *, FunctionSet >	CallEdgeMap

typedef CallGraphEdgeSet::iterator	CallGraphEdgeIter

typedef CallGraphEdgeSet::const_iterator	CallGraphEdgeConstIter

Public Types inherited from SVF::GenericGraph< NodeTy, EdgeTy >
typedef NodeTy	NodeType

typedef EdgeTy	EdgeType

typedef OrderedMap< NodeID, NodeType * >	IDToNodeMapTy
	NodeID to GenericNode map.

typedef IDToNodeMapTy::iterator	iterator
	Node Iterators.

typedef IDToNodeMapTy::const_iterator	const_iterator

Public Member Functions
	ThreadCallGraph (const CallGraph &cg)
	Constructor.

	ThreadCallGraph (ThreadCallGraph &cg)=delete

virtual	~ThreadCallGraph ()
	Destructor.

void	updateCallGraph (PointerAnalysis *pta)
	Update call graph using pointer results.

void	updateJoinEdge (PointerAnalysis *pta)
	Update join edge using pointer analysis results.

bool	hasThreadForkEdge (const CallICFGNode *cs) const
	Get call graph edge via call instruction.

ForkEdgeSet::const_iterator	getForkEdgeBegin (const CallICFGNode *cs) const

ForkEdgeSet::const_iterator	getForkEdgeEnd (const CallICFGNode *cs) const

bool	hasThreadJoinEdge (const CallICFGNode *cs) const
	Get call graph edge via call instruction.

JoinEdgeSet::const_iterator	getJoinEdgeBegin (const CallICFGNode *cs) const

JoinEdgeSet::const_iterator	getJoinEdgeEnd (const CallICFGNode *cs) const

void	getJoinSites (const CallGraphNode *routine, InstSet &csSet)

Public Member Functions inherited from SVF::CallGraph
	CallGraph (CGEK k=NormCallGraph)
	Constructor.

	CallGraph (const CallGraph &other)
	Copy constructor.

virtual	~CallGraph ()
	Destructor.

CGEK	getKind () const
	Return type of this callgraph.

CallEdgeMap &	getIndCallMap ()
	Get callees from an indirect callsite.

bool	hasIndCSCallees (const CallICFGNode *cs) const

const FunctionSet &	getIndCSCallees (const CallICFGNode *cs) const

u32_t	getTotalCallSiteNumber () const

u32_t	getNumOfResolvedIndCallEdge () const

const CallInstToCallGraphEdgesMap &	getCallInstToCallGraphEdgesMap () const

void	verifyCallGraph ()
	Issue a warning if the function which has indirect call sites can not be reached from program entry.

void	addDirectCallGraphEdge (const CallICFGNode call, const FunObjVar callerFun, const FunObjVar *calleeFun)
	Add direct call edges.

void	addCallGraphNode (const FunObjVar *fun)

const CallGraphNode *	getCallGraphNode (const std::string &name) const
	Get call graph node.

CallGraphNode *	getCallGraphNode (NodeID id) const

CallGraphNode *	getCallGraphNode (const FunObjVar *fun) const

CallSiteID	getCallSiteID (const CallICFGNode cs, const FunObjVar callee) const
	Get CallSiteID.

bool	hasCallSiteID (const CallICFGNode cs, const FunObjVar callee) const

const CallSitePair &	getCallSitePair (CallSiteID id) const

const CallICFGNode *	getCallSite (CallSiteID id) const

const FunObjVar *	getCallerOfCallSite (CallSiteID id) const

const FunObjVar *	getCalleeOfCallSite (CallSiteID id) const

CallGraphEdge *	hasGraphEdge (CallGraphNode src, CallGraphNode dst, CallGraphEdge::CEDGEK kind, CallSiteID csId) const
	Whether we have already created this call graph edge.

CallGraphEdge *	getGraphEdge (CallGraphNode src, CallGraphNode dst, CallGraphEdge::CEDGEK kind, CallSiteID csId)
	Get call graph edge via nodes.

void	getCallees (const CallICFGNode *cs, FunctionSet &callees)
	Get all callees for a callsite.

bool	hasCallGraphEdge (const CallICFGNode *inst) const
	Get call graph edge via call instruction.

CallGraphEdgeSet::const_iterator	getCallEdgeBegin (const CallICFGNode *inst) const

CallGraphEdgeSet::const_iterator	getCallEdgeEnd (const CallICFGNode *inst) const

void	addIndirectCallGraphEdge (const CallICFGNode cs, const FunObjVar callerFun, const FunObjVar *calleeFun)
	Add indirect call edges.

void	getAllCallSitesInvokingCallee (const FunObjVar *callee, CallGraphEdge::CallInstSet &csSet)
	Get callsites invoking the callee.

void	getDirCallSitesInvokingCallee (const FunObjVar *callee, CallGraphEdge::CallInstSet &csSet)

void	getIndCallSitesInvokingCallee (const FunObjVar *callee, CallGraphEdge::CallInstSet &csSet)

bool	isReachableBetweenFunctions (const FunObjVar srcFn, const FunObjVar dstFn) const
	Whether its reachable between two functions.

void	dump (const std::string &filename)
	Dump the graph.

void	view ()
	View the graph from the debugger.

Public Member Functions inherited from SVF::GenericGraph< NodeTy, EdgeTy >
	GenericGraph ()
	Constructor.

virtual	~GenericGraph ()
	Destructor.

void	destroy ()
	Release memory.

iterator	begin ()
	Iterators.

iterator	end ()

const_iterator	begin () const

const_iterator	end () const

void	addGNode (NodeID id, NodeType *node)
	Add a Node.

NodeType *	getGNode (NodeID id) const
	Get a node.

bool	hasGNode (NodeID id) const
	Has a node.

void	removeGNode (NodeType *node)
	Delete a node.

u32_t	getTotalNodeNum () const
	Get total number of node/edge.

u32_t	getTotalEdgeNum () const

void	incNodeNum ()
	Increase number of node/edge.

void	incEdgeNum ()

Static Public Member Functions
static bool	classof (const ThreadCallGraph *)
	ClassOf.

static bool	classof (const CallGraph *g)

ThreadAPI *	tdAPI
	Thread API.

CallSiteSet	forksites
	all thread fork sites

CallSiteSet	joinsites
	all thread fork sites

CallSiteSet	parForSites
	all parallel for sites

CallInstToForkEdgesMap	callinstToThreadForkEdgesMap
	Map a call instruction to its corresponding fork edges.

CallInstToJoinEdgesMap	callinstToThreadJoinEdgesMap
	Map a call instruction to its corresponding join edges.

CallInstToParForEdgesMap	callinstToHareParForEdgesMap
	Map a call instruction to its corresponding hare_parallel_for edges.

bool	isForksite (const CallICFGNode *csInst)

bool	isJoinsite (const CallICFGNode *csInst)

bool	isParForSite (const CallICFGNode *csInst)

CallSiteSet::const_iterator	forksitesBegin () const
	Fork sites iterators.

CallSiteSet::const_iterator	forksitesEnd () const

CallSiteSet::const_iterator	joinsitesBegin () const
	Join sites iterators.

CallSiteSet::const_iterator	joinsitesEnd () const

CallSiteSet::const_iterator	parForSitesBegin () const
	hare_parallel_for sites iterators

CallSiteSet::const_iterator	parForSitesEnd () const

u32_t	getNumOfForksite () const
	Num of fork/join sites.

u32_t	getNumOfJoinsite () const

u32_t	getNumOfParForSite () const

ThreadAPI *	getThreadAPI () const
	Thread API.

bool	addForksite (const CallICFGNode *cs)
	Add fork sites which directly or indirectly create a thread.

bool	addJoinsite (const CallICFGNode *cs)

bool	addParForSite (const CallICFGNode *cs)

bool	addDirectForkEdge (const CallICFGNode *cs)
	Add direct/indirect thread fork edges.

bool	addIndirectForkEdge (const CallICFGNode cs, const FunObjVar callee)

void	addDirectJoinEdge (const CallICFGNode *cs, const CallSiteSet &forksite)
	Add thread join edges.

void	addThreadForkEdgeSetMap (const CallICFGNode cs, ThreadForkEdge edge)
	map call instruction to its PTACallGraphEdge map

void	addThreadJoinEdgeSetMap (const CallICFGNode cs, ThreadJoinEdge edge)
	map call instruction to its PTACallGraphEdge map

void	addHareParForEdgeSetMap (const CallICFGNode cs, HareParForEdge edge)
	map call instruction to its PTACallGraphEdge map

ThreadJoinEdge *	hasThreadJoinEdge (const CallICFGNode call, CallGraphNode joinFunNode, CallGraphNode *threadRoutineFunNode, CallSiteID csId) const
	has thread join edge

Additional Inherited Members
Public Attributes inherited from SVF::GenericGraph< NodeTy, EdgeTy >
u32_t	edgeNum
	total num of node

u32_t	nodeNum
	total num of edge

Protected Member Functions inherited from SVF::CallGraph
void	destroy ()
	Clean up memory.

CallSiteID	addCallSite (const CallICFGNode cs, const FunObjVar callee)
	Add CallSiteID.

CallSiteID	addCallSite (const CallICFGNode cs, const FunObjVar callee, const CallSiteID csid, std::pair< const CallICFGNode , const FunObjVar > newCS)

void	addEdge (CallGraphEdge *edge)
	Add call graph edge.

void	addDirectCallGraphEdge (CallGraphEdge *cgEdge)
	add direct call graph edge from database [only used this function when loading cgEdges from db results]

void	addCallGraphNode (CallGraphNode *cgNode)
	add call graph node from database [only used this function when loading cgNodes from db results]

CallGraphEdge *	hasGraphEdge (CallGraphEdge *cgEdge) const
	Whether we have already created this call graph edge.

Protected Attributes inherited from SVF::CallGraph
FunToCallGraphNodeMap	funToCallGraphNodeMap
	Call Graph node map.

CallInstToCallGraphEdgesMap	callinstToCallGraphEdgesMap
	Map a call instruction to its corresponding call edges.

NodeID	callGraphNodeNum

u32_t	numOfResolvedIndCallEdge

CGEK	kind

Protected Attributes inherited from SVF::GenericGraph< NodeTy, EdgeTy >
IDToNodeMapTy	IDToNodeMap
	node map

Detailed Description

Thread sensitive call graph

Definition at line 141 of file ThreadCallGraph.h.

Member Typedef Documentation

◆ CallInstToForkEdgesMap

typedef Map<const CallICFGNode*, ForkEdgeSet> SVF::ThreadCallGraph::CallInstToForkEdgesMap

Definition at line 160 of file ThreadCallGraph.h.

◆ CallInstToJoinEdgesMap

typedef Map<const CallICFGNode*, JoinEdgeSet> SVF::ThreadCallGraph::CallInstToJoinEdgesMap

Definition at line 162 of file ThreadCallGraph.h.

◆ CallInstToParForEdgesMap

typedef Map<const CallICFGNode*, ParForEdgeSet> SVF::ThreadCallGraph::CallInstToParForEdgesMap

Definition at line 164 of file ThreadCallGraph.h.

◆ CallSiteSet

typedef InstSet SVF::ThreadCallGraph::CallSiteSet

Definition at line 157 of file ThreadCallGraph.h.

◆ CtxSet

typedef Set<CallSiteSet*> SVF::ThreadCallGraph::CtxSet

Definition at line 158 of file ThreadCallGraph.h.

◆ ForkEdgeSet

typedef ThreadForkEdge::ForkEdgeSet SVF::ThreadCallGraph::ForkEdgeSet

Definition at line 159 of file ThreadCallGraph.h.

◆ InstSet

typedef OrderedSet<const CallICFGNode*, CallSiteIdCmp> SVF::ThreadCallGraph::InstSet

Definition at line 156 of file ThreadCallGraph.h.

◆ JoinEdgeSet

typedef ThreadJoinEdge::JoinEdgeSet SVF::ThreadCallGraph::JoinEdgeSet

Definition at line 161 of file ThreadCallGraph.h.

◆ ParForEdgeSet

typedef HareParForEdge::ParForEdgeSet SVF::ThreadCallGraph::ParForEdgeSet

Definition at line 163 of file ThreadCallGraph.h.

Constructor & Destructor Documentation

◆ ThreadCallGraph() [1/2]

ThreadCallGraph::ThreadCallGraph ( const CallGraph & cg )

Constructor.

Constructor

Definition at line 42 of file ThreadCallGraph.cpp.

                                                    :
    CallGraph(cg), tdAPI(ThreadAPI::getThreadAPI())
{
    kind = ThdCallGraph;
    DBOUT(DGENERAL, outs() << SVFUtil::pasMsg("Building ThreadCallGraph\n"));
}

◆ ThreadCallGraph() [2/2]

SVF::ThreadCallGraph::ThreadCallGraph ( ThreadCallGraph & cg )

delete

◆ ~ThreadCallGraph()

ThreadCallGraph::~ThreadCallGraph ( )

virtual

Destructor.

Definition at line 49 of file ThreadCallGraph.cpp.

{
    for (const auto& entry : callinstToThreadJoinEdgesMap)
        for (ThreadJoinEdge* edge : entry.second)
            delete edge;
}

Member Function Documentation

◆ addDirectForkEdge()

bool ThreadCallGraph::addDirectForkEdge ( const CallICFGNode * cs )

Add direct/indirect thread fork edges.

Add direct fork edges

Definition at line 158 of file ThreadCallGraph.cpp.

{
 
    CallGraphNode* caller = getCallGraphNode(cs->getCaller());
    const FunValVar* funValvar = SVFUtil::dyn_cast<FunValVar>(tdAPI->getForkedFun(cs));
    const FunObjVar* forkee = funValvar->getFunction();
    assert(forkee && "callee does not exist");
    CallGraphNode* callee = getCallGraphNode(forkee->getDefFunForMultipleModule());
    CallSiteID csId = addCallSite(cs, callee->getFunction());
 
    if (!hasGraphEdge(caller, callee, CallGraphEdge::TDForkEdge, csId))
    {
        assert(cs->getCaller() == caller->getFunction() && "callee instruction not inside caller??");
 
        ThreadForkEdge* edge = new ThreadForkEdge(caller, callee, csId);
        edge->addDirectCallSite(cs);
 
        addEdge(edge);
        addThreadForkEdgeSetMap(cs, edge);
        return true;
    }
    else
        return false;
}

◆ addDirectJoinEdge()

void ThreadCallGraph::addDirectJoinEdge	(	const CallICFGNode *	cs,
		const CallSiteSet &	forkset
	)

Add thread join edges.

Add direct fork edges As join edge is a special return which is back to join site(s) rather than its fork site A ThreadJoinEdge is created from the functions where join sites reside in to the start routine function But we don't invoke addEdge() method to add the edge to src and dst, otherwise it makes a scc cycle

Definition at line 214 of file ThreadCallGraph.cpp.

{
 
    CallGraphNode* joinFunNode = getCallGraphNode(cs->getCaller());
 
    for (CallSiteSet::const_iterator it = forkset.begin(), eit = forkset.end(); it != eit; ++it)
    {
        // The start routine(s) joined here are exactly the targets of the fork
        // edges already resolved for this fork site (direct, or indirect via
        // points-to in updateCallGraph). Reuse them rather than re-resolving the
        // fork target from getForkedFun, which is not a FunValVar for an indirect
        // fork (function pointer). An unresolved fork site simply has no edges.
        if (!hasThreadForkEdge(*it))
            continue;
        for (ForkEdgeSet::const_iterator eit2 = getForkEdgeBegin(*it),
                eeit2 = getForkEdgeEnd(*it); eit2 != eeit2; ++eit2)
        {
            CallGraphNode* threadRoutineFunNode = (*eit2)->getDstNode();
            CallSiteID csId = addCallSite(cs, threadRoutineFunNode->getFunction());
 
            if (!hasThreadJoinEdge(cs,joinFunNode,threadRoutineFunNode, csId))
            {
                assert(cs->getCaller() == joinFunNode->getFunction() && "callee instruction not inside caller??");
                ThreadJoinEdge* edge = new ThreadJoinEdge(joinFunNode,threadRoutineFunNode,csId);
                edge->addDirectCallSite(cs);
 
                addThreadJoinEdgeSetMap(cs, edge);
            }
        }
    }
}

◆ addForksite()

bool SVF::ThreadCallGraph::addForksite ( const CallICFGNode * cs )

inline

Add fork sites which directly or indirectly create a thread.

Definition at line 323 of file ThreadCallGraph.h.

    {
        callinstToThreadForkEdgesMap[cs];
        return forksites.insert(cs).second;
    }

◆ addHareParForEdgeSetMap()

void SVF::ThreadCallGraph::addHareParForEdgeSetMap	(	const CallICFGNode *	cs,
		HareParForEdge *	edge
	)

inline

map call instruction to its PTACallGraphEdge map

Definition at line 373 of file ThreadCallGraph.h.

    {
        if(edge!=nullptr)
        {
            callinstToHareParForEdgesMap[cs].insert(edge);
            callinstToCallGraphEdgesMap[cs].insert(edge);
        }
    }

◆ addIndirectForkEdge()

bool ThreadCallGraph::addIndirectForkEdge	(	const CallICFGNode *	cs,
		const FunObjVar *	calleefun
	)

Add indirect fork edge to update call graph

Definition at line 186 of file ThreadCallGraph.cpp.

{
    CallGraphNode* caller = getCallGraphNode(cs->getCaller());
    CallGraphNode* callee = getCallGraphNode(calleefun);
 
    CallSiteID csId = addCallSite(cs, callee->getFunction());
 
    if (!hasGraphEdge(caller, callee, CallGraphEdge::TDForkEdge, csId))
    {
        assert(cs->getCaller() == caller->getFunction() && "callee instruction not inside caller??");
 
        ThreadForkEdge* edge = new ThreadForkEdge(caller, callee, csId);
        edge->addInDirectCallSite(cs);
 
        addEdge(edge);
        addThreadForkEdgeSetMap(cs, edge);
        return true;
    }
    else
        return false;
}

◆ addJoinsite()

bool SVF::ThreadCallGraph::addJoinsite ( const CallICFGNode * cs )

inline

Definition at line 328 of file ThreadCallGraph.h.

    {
        callinstToThreadJoinEdgesMap[cs];
        return joinsites.insert(cs).second;
    }

◆ addParForSite()

bool SVF::ThreadCallGraph::addParForSite ( const CallICFGNode * cs )

inline

Definition at line 333 of file ThreadCallGraph.h.

    {
        callinstToHareParForEdgesMap[cs];
        return parForSites.insert(cs).second;
    }

◆ addThreadForkEdgeSetMap()

void SVF::ThreadCallGraph::addThreadForkEdgeSetMap	(	const CallICFGNode *	cs,
		ThreadForkEdge *	edge
	)

inline

map call instruction to its PTACallGraphEdge map

Definition at line 353 of file ThreadCallGraph.h.

    {
        if(edge!=nullptr)
        {
            callinstToThreadForkEdgesMap[cs].insert(edge);
            callinstToCallGraphEdgesMap[cs].insert(edge);
        }
    }

◆ addThreadJoinEdgeSetMap()

void SVF::ThreadCallGraph::addThreadJoinEdgeSetMap	(	const CallICFGNode *	cs,
		ThreadJoinEdge *	edge
	)

inline

map call instruction to its PTACallGraphEdge map

Definition at line 363 of file ThreadCallGraph.h.

    {
        if(edge!=nullptr)
        {
            callinstToThreadJoinEdgesMap[cs].insert(edge);
            callinstToCallGraphEdgesMap[cs].insert(edge);
        }
    }

◆ classof() [1/2]

static bool SVF::ThreadCallGraph::classof ( const CallGraph * g )

inlinestatic

Definition at line 180 of file ThreadCallGraph.h.

    {
        return g->getKind() == CallGraph::ThdCallGraph;
    }

◆ classof() [2/2]

static bool SVF::ThreadCallGraph::classof ( const ThreadCallGraph * )

inlinestatic

ClassOf.

Definition at line 176 of file ThreadCallGraph.h.

    {
        return true;
    }

◆ forksitesBegin()

CallSiteSet::const_iterator SVF::ThreadCallGraph::forksitesBegin ( ) const

inline

Fork sites iterators.

Definition at line 265 of file ThreadCallGraph.h.

    {
        return forksites.begin();
    }

◆ forksitesEnd()

CallSiteSet::const_iterator SVF::ThreadCallGraph::forksitesEnd ( ) const

inline

Definition at line 269 of file ThreadCallGraph.h.

    {
        return forksites.end();
    }

◆ getForkEdgeBegin()

ForkEdgeSet::const_iterator SVF::ThreadCallGraph::getForkEdgeBegin ( const CallICFGNode * cs ) const

inline

Definition at line 200 of file ThreadCallGraph.h.

    {
        CallInstToForkEdgesMap::const_iterator it = callinstToThreadForkEdgesMap.find(cs);
        assert(it != callinstToThreadForkEdgesMap.end() && "call instruction not found");
        return it->second.begin();
    }

◆ getForkEdgeEnd()

ForkEdgeSet::const_iterator SVF::ThreadCallGraph::getForkEdgeEnd ( const CallICFGNode * cs ) const

inline

Definition at line 206 of file ThreadCallGraph.h.

    {
        CallInstToForkEdgesMap::const_iterator it = callinstToThreadForkEdgesMap.find(cs);
        assert(it != callinstToThreadForkEdgesMap.end() && "call instruction not found");
        return it->second.end();
    }

◆ getJoinEdgeBegin()

JoinEdgeSet::const_iterator SVF::ThreadCallGraph::getJoinEdgeBegin ( const CallICFGNode * cs ) const

inline

Definition at line 220 of file ThreadCallGraph.h.

    {
        CallInstToJoinEdgesMap::const_iterator it = callinstToThreadJoinEdgesMap.find(cs);
        assert(it != callinstToThreadJoinEdgesMap.end() && "call instruction does not have a valid callee");
        return it->second.begin();
    }

◆ getJoinEdgeEnd()

JoinEdgeSet::const_iterator SVF::ThreadCallGraph::getJoinEdgeEnd ( const CallICFGNode * cs ) const

inline

Definition at line 226 of file ThreadCallGraph.h.

    {
        CallInstToJoinEdgesMap::const_iterator it = callinstToThreadJoinEdgesMap.find(cs);
        assert(it != callinstToThreadJoinEdgesMap.end() && "call instruction does not have a valid callee");
        return it->second.end();
    }

◆ getJoinSites()

void SVF::ThreadCallGraph::getJoinSites	(	const CallGraphNode *	routine,
		InstSet &	csSet
	)

inline

Definition at line 232 of file ThreadCallGraph.h.

    {
        for(CallInstToJoinEdgesMap::const_iterator it = callinstToThreadJoinEdgesMap.begin(), eit = callinstToThreadJoinEdgesMap.end(); it!=eit; ++it)
        {
            for(JoinEdgeSet::const_iterator jit = it->second.begin(), ejit = it->second.end(); jit!=ejit; ++jit)
            {
                if((*jit)->getDstNode() == routine)
                {
                    csSet.insert(it->first);
                }
            }
        }
    }

◆ getNumOfForksite()

u32_t SVF::ThreadCallGraph::getNumOfForksite ( ) const

inline

Num of fork/join sites.

Definition at line 301 of file ThreadCallGraph.h.

    {
        return forksites.size();
    }

◆ getNumOfJoinsite()

u32_t SVF::ThreadCallGraph::getNumOfJoinsite ( ) const

inline

Definition at line 305 of file ThreadCallGraph.h.

    {
        return joinsites.size();
    }

◆ getNumOfParForSite()

u32_t SVF::ThreadCallGraph::getNumOfParForSite ( ) const

inline

Definition at line 309 of file ThreadCallGraph.h.

    {
        return parForSites.size();
    }

◆ getThreadAPI()

ThreadAPI * SVF::ThreadCallGraph::getThreadAPI ( ) const

inline

Thread API.

Definition at line 316 of file ThreadCallGraph.h.

    {
        return tdAPI;
    }

◆ hasThreadForkEdge()

bool SVF::ThreadCallGraph::hasThreadForkEdge ( const CallICFGNode * cs ) const

inline

Get call graph edge via call instruction.

whether this call instruction has a valid call graph edge

Definition at line 195 of file ThreadCallGraph.h.

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

◆ hasThreadJoinEdge() [1/2]

ThreadJoinEdge * SVF::ThreadCallGraph::hasThreadJoinEdge	(	const CallICFGNode *	call,
		CallGraphNode *	joinFunNode,
		CallGraphNode *	threadRoutineFunNode,
		CallSiteID	csId
	)		const

inline

has thread join edge

Definition at line 383 of file ThreadCallGraph.h.

    {
        ThreadJoinEdge joinEdge(joinFunNode,threadRoutineFunNode, csId);
        CallInstToJoinEdgesMap::const_iterator it = callinstToThreadJoinEdgesMap.find(call);
        if(it != callinstToThreadJoinEdgesMap.end())
        {
            JoinEdgeSet::const_iterator jit = it->second.find(&joinEdge);
            if(jit!=it->second.end())
                return *jit;
        }
        return nullptr;
    }

◆ hasThreadJoinEdge() [2/2]

bool SVF::ThreadCallGraph::hasThreadJoinEdge ( const CallICFGNode * cs ) const

inline

Get call graph edge via call instruction.

whether this call instruction has a valid call graph edge

Definition at line 216 of file ThreadCallGraph.h.

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

◆ isForksite()

bool SVF::ThreadCallGraph::isForksite ( const CallICFGNode * csInst )

inline

Whether a callsite is a fork or join or hare_parallel_for

Definition at line 249 of file ThreadCallGraph.h.

    {
        return forksites.find(csInst) != forksites.end();
    }

◆ isJoinsite()

bool SVF::ThreadCallGraph::isJoinsite ( const CallICFGNode * csInst )

inline

Definition at line 253 of file ThreadCallGraph.h.

    {
        return joinsites.find(csInst) != joinsites.end();
    }

◆ isParForSite()

bool SVF::ThreadCallGraph::isParForSite ( const CallICFGNode * csInst )

inline

Definition at line 257 of file ThreadCallGraph.h.

    {
        return parForSites.find(csInst) != parForSites.end();
    }

◆ joinsitesBegin()

CallSiteSet::const_iterator SVF::ThreadCallGraph::joinsitesBegin ( ) const

inline

Join sites iterators.

Definition at line 277 of file ThreadCallGraph.h.

    {
        return joinsites.begin();
    }

◆ joinsitesEnd()

CallSiteSet::const_iterator SVF::ThreadCallGraph::joinsitesEnd ( ) const

inline

Definition at line 281 of file ThreadCallGraph.h.

    {
        return joinsites.end();
    }

◆ parForSitesBegin()

CallSiteSet::const_iterator SVF::ThreadCallGraph::parForSitesBegin ( ) const

inline

hare_parallel_for sites iterators

Definition at line 289 of file ThreadCallGraph.h.

    {
        return parForSites.begin();
    }

◆ parForSitesEnd()

CallSiteSet::const_iterator SVF::ThreadCallGraph::parForSitesEnd ( ) const

inline

Definition at line 293 of file ThreadCallGraph.h.

    {
        return parForSites.end();
    }

◆ updateCallGraph()

void ThreadCallGraph::updateCallGraph ( PointerAnalysis * pta )

Update call graph using pointer results.

Definition at line 84 of file ThreadCallGraph.cpp.

{
 
    PointerAnalysis::CallEdgeMap::const_iterator iter = pta->getIndCallMap().begin();
    PointerAnalysis::CallEdgeMap::const_iterator eiter = pta->getIndCallMap().end();
    for (; iter != eiter; iter++)
    {
        const CallICFGNode* cs = iter->first;
        const CallGraph::FunctionSet &functions = iter->second;
        for (CallGraph::FunctionSet::const_iterator func_iter =
                    functions.begin(); func_iter != functions.end(); func_iter++)
        {
            const FunObjVar* callee = *func_iter;
            this->addIndirectCallGraphEdge(cs, cs->getCaller(), callee);
        }
    }
 
    // Fork sites
    for (CallSiteSet::const_iterator it = forksitesBegin(), eit = forksitesEnd(); it != eit; ++it)
    {
        const ValVar* forkedval = tdAPI->getForkedFun(*it);
        if(SVFUtil::dyn_cast<FunValVar>(forkedval)==nullptr)
        {
            SVFIR* pag = pta->getPAG();
            const NodeBS targets = pta->getPts(forkedval->getId()).toNodeBS();
            for (NodeBS::iterator ii = targets.begin(), ie = targets.end(); ii != ie; ii++)
            {
                if(const ObjVar* objPN = pag->getObjVar(*ii))
                {
                    const BaseObjVar* obj = pag->getBaseObject(objPN->getId());
                    if(obj->isFunction())
                    {
                        const FunObjVar* svfCallee = SVFUtil::cast<FunObjVar>(obj)->getFunction();
                        this->addIndirectForkEdge(*it, svfCallee);
                    }
                }
            }
        }
    }
}

◆ updateJoinEdge()

void ThreadCallGraph::updateJoinEdge ( PointerAnalysis * pta )

Update join edge using pointer analysis results.

Update join edge using pointer analysis results

A join may have no statically-matchable fork site (e.g. the pthread_t alias cannot be resolved by the pre-analysis). Skip such joins rather than aborting – they simply get no join-related def-use edge.

Definition at line 129 of file ThreadCallGraph.cpp.

{
    ThreadAPI::ForkJoinAliasCache aliasCache;
 
    for (CallSiteSet::const_iterator it = joinsitesBegin(), eit = joinsitesEnd(); it != eit; ++it)
    {
        const SVFVar* jointhread = tdAPI->getJoinedThread(*it);
        // find its corresponding fork sites first
        CallSiteSet forkset;
        for (CallSiteSet::const_iterator it = forksitesBegin(), eit = forksitesEnd(); it != eit; ++it)
        {
            const SVFVar* forkthread = tdAPI->getForkedThread(*it);
            if (tdAPI->isAliasedForkJoin(pta, forkthread, jointhread, aliasCache))
            {
                forkset.insert(*it);
            }
        }
        if (forkset.empty())
            continue;
        addDirectJoinEdge(*it,forkset);
    }
}

Member Data Documentation

◆ callinstToHareParForEdgesMap

CallInstToParForEdgesMap SVF::ThreadCallGraph::callinstToHareParForEdgesMap

private

Map a call instruction to its corresponding hare_parallel_for edges.

Definition at line 403 of file ThreadCallGraph.h.

◆ callinstToThreadForkEdgesMap

CallInstToForkEdgesMap SVF::ThreadCallGraph::callinstToThreadForkEdgesMap

private

Map a call instruction to its corresponding fork edges.

Definition at line 401 of file ThreadCallGraph.h.

◆ callinstToThreadJoinEdgesMap

CallInstToJoinEdgesMap SVF::ThreadCallGraph::callinstToThreadJoinEdgesMap

private

Map a call instruction to its corresponding join edges.

Definition at line 402 of file ThreadCallGraph.h.

◆ forksites

CallSiteSet SVF::ThreadCallGraph::forksites

private

all thread fork sites

Definition at line 398 of file ThreadCallGraph.h.

◆ joinsites

CallSiteSet SVF::ThreadCallGraph::joinsites

private

all thread fork sites

Definition at line 399 of file ThreadCallGraph.h.

◆ parForSites

CallSiteSet SVF::ThreadCallGraph::parForSites

private

all parallel for sites

Definition at line 400 of file ThreadCallGraph.h.

◆ tdAPI

ThreadAPI* SVF::ThreadCallGraph::tdAPI

private

Thread API.

Definition at line 397 of file ThreadCallGraph.h.

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

/home/runner/work/SVF/SVF/svf/include/Graphs/ThreadCallGraph.h
/home/runner/work/SVF/SVF/svf/lib/Graphs/ThreadCallGraph.cpp

Classes

Public Types

Public Member Functions

Static Public Member Functions

Additional Inherited Members

Detailed Description

Member Typedef Documentation

◆ CallInstToForkEdgesMap

◆ CallInstToJoinEdgesMap

◆ CallInstToParForEdgesMap

◆ CallSiteSet

◆ CtxSet

◆ ForkEdgeSet

◆ InstSet

◆ JoinEdgeSet

◆ ParForEdgeSet

Constructor & Destructor Documentation

◆ ThreadCallGraph() [1/2]

◆ ThreadCallGraph() [2/2]

◆ ~ThreadCallGraph()

Member Function Documentation

◆ addDirectForkEdge()

◆ addDirectJoinEdge()

◆ addForksite()

◆ addHareParForEdgeSetMap()

◆ addIndirectForkEdge()

◆ addJoinsite()

◆ addParForSite()

◆ addThreadForkEdgeSetMap()

◆ addThreadJoinEdgeSetMap()

◆ classof() [1/2]

◆ classof() [2/2]

◆ forksitesBegin()

◆ forksitesEnd()

◆ getForkEdgeBegin()

◆ getForkEdgeEnd()

◆ getJoinEdgeBegin()

◆ getJoinEdgeEnd()

◆ getJoinSites()

◆ getNumOfForksite()

◆ getNumOfJoinsite()

◆ getNumOfParForSite()

◆ getThreadAPI()

◆ hasThreadForkEdge()

◆ hasThreadJoinEdge() [1/2]

◆ hasThreadJoinEdge() [2/2]

◆ isForksite()

◆ isJoinsite()

◆ isParForSite()

◆ joinsitesBegin()

◆ joinsitesEnd()

◆ parForSitesBegin()

◆ parForSitesEnd()

◆ updateCallGraph()

◆ updateJoinEdge()

Member Data Documentation

◆ callinstToHareParForEdgesMap

◆ callinstToThreadForkEdgesMap

◆ callinstToThreadJoinEdgesMap

◆ forksites

◆ joinsites

◆ parForSites

◆ tdAPI