SVF::ThreadCallGraph Class Reference

#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< CallGraphNode, CallGraphEdge >
typedef CallGraphNode	NodeType
typedef CallGraphEdge	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< CallGraphNode, CallGraphEdge >
	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< CallGraphNode, CallGraphEdge >
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< CallGraphNode, CallGraphEdge >
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]

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

inlinestatic

Definition at line 180 of file ThreadCallGraph.h.

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

classof() [2/2]

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