SVF::SlicedThreadCallGraphView Class Reference

#include <SlicedGraphs.h>

Public Member Functions
	SlicedThreadCallGraphView (ThreadCallGraph *tcg, const OrderedSet< const FunObjVar * > &keptFunctions, const OrderedSet< const ICFGNode * > &extendedKeptNodes)
void	getOutEdgesOf (const CallGraphNode *node, std::vector< const CallGraphEdge * > &out) const
	Get out edges of a node (only returns kept edges and target nodes).
void	getInEdgesOf (const CallGraphNode *node, std::vector< const CallGraphEdge * > &out) const
	Get in edges of a node (only returns kept edges and source nodes).
void	getDirectCallsOf (const CallGraphEdge *edge, std::vector< const CallICFGNode * > &out) const
	Retained callsites carried by an aggregated call-graph edge.
void	getIndirectCallsOf (const CallGraphEdge *edge, std::vector< const CallICFGNode * > &out) const
bool	containsCallSite (const CallGraphEdge *edge, const CallICFGNode *callSite) const
	Whether this precise callsite-to-callee relation is retained.
void	getCalleesOf (const CallICFGNode *callSite, CallGraph::FunctionSet &callees) const
	Retained callees of a callsite.
void	getForkEdgesOf (const CallICFGNode *callSite, std::vector< const CallGraphEdge * > &out) const
void	getJoinEdgesOf (const CallICFGNode *callSite, std::vector< const CallGraphEdge * > &out) const
bool	isKeptNode (const CallGraphNode *node) const
	Check if a node is in the sliced view.
const OrderedSet< const CallGraphNode * > &	getKeptNodes () const
	Get all kept nodes.
const Set< const FunObjVar * > &	getKeptFunctions () const
bool	isKeptEdge (const CallGraphEdge *e) const
const Set< const CallICFGNode * > &	getIndirectSitesWithEmptyTargets () const
	Indirect call sites that lost all targets after filtering.
void	dump (const std::string &filename) const
	Dump sliced ThreadCallGraph to dot file.
CallGraph *	getBackingCallGraph () const

Private Member Functions
void	buildKeptNodes ()
void	buildCallGraphSets ()

Private Attributes
ThreadCallGraph *	tcg
OrderedSet< const CallGraphNode * >	keptNodes
Set< const CallGraphEdge * >	keptEdges
Map< const CallGraphEdge *, CallGraphEdge::CallInstSet >	keptDirectCalls
Map< const CallGraphEdge *, CallGraphEdge::CallInstSet >	keptIndirectCalls
Set< const FunObjVar * >	keptFunctionsSet
Set< const CallICFGNode * >	indirectSitesWithEmptyTargets
OrderedSet< const ICFGNode * >	extendedKeptNodes

Detailed Description

Definition at line 176 of file SlicedGraphs.h.

Constructor & Destructor Documentation

SlicedThreadCallGraphView()

SVF::SlicedThreadCallGraphView::SlicedThreadCallGraphView	(	ThreadCallGraph *	tcg,
		const OrderedSet< const FunObjVar * > &	keptFunctions,
		const OrderedSet< const ICFGNode * > &	extendedKeptNodes )

Definition at line 591 of file SlicedGraphs.cpp.

    : tcg(tcg)
{
    for (const FunObjVar* fun : keptFunctions)
    {
        keptFunctionsSet.insert(fun);
    }
    this->extendedKeptNodes = extendedKeptNodes;
    buildKeptNodes();
    // The input already contains the slicing targets and control-flow anchors;
    // buildCallGraphSets filters edges whose callsites were pruned.
    buildCallGraphSets();
}

Member Function Documentation

buildCallGraphSets()

void SVF::SlicedThreadCallGraphView::buildCallGraphSets ( )

private

Definition at line 741 of file SlicedGraphs.cpp.

{
    // rebuild kept edges, accounting for whether the call site is kept
    keptEdges.clear();
    keptDirectCalls.clear();
    keptIndirectCalls.clear();
    indirectSitesWithEmptyTargets.clear();
 
    // CallGraph edge: src/dst both in kept functions and the call site still in the kept ICFG node set
    for (const CallGraphNode* srcNode : keptNodes)
    {
        for (const CallGraphEdge* edge : srcNode->getOutEdges())
        {
            const CallGraphNode* dstNode = edge ? edge->getDstNode() : nullptr;
            if (dstNode == nullptr || !keptNodes.count(dstNode))
            {
                continue;
            }
 
            CallGraphEdge::CallInstSet& retainedDirect = keptDirectCalls[edge];
            for (const CallICFGNode* callSite : edge->getDirectCalls())
                if (extendedKeptNodes.count(callSite))
                    retainedDirect.insert(callSite);
 
            CallGraphEdge::CallInstSet& retainedIndirect = keptIndirectCalls[edge];
            for (const CallICFGNode* callSite : edge->getIndirectCalls())
                if (extendedKeptNodes.count(callSite))
                    retainedIndirect.insert(callSite);
 
            const bool hasOriginalCallSites =
                !edge->getDirectCalls().empty() || !edge->getIndirectCalls().empty();
            if (hasOriginalCallSites && retainedDirect.empty() && retainedIndirect.empty())
            {
                keptDirectCalls.erase(edge);
                keptIndirectCalls.erase(edge);
                continue;
            }
 
            keptEdges.insert(edge);
        }
    }
 
    // An indirect callsite is empty only when none of its original targets is
    // represented by a retained callsite-to-callee relation.
    for (const ICFGNode* node : extendedKeptNodes)
    {
        const CallICFGNode* callSite = SVFUtil::dyn_cast<CallICFGNode>(node);
        if (callSite == nullptr || !tcg->hasIndCSCallees(callSite))
            continue;
        CallGraph::FunctionSet callees;
        getCalleesOf(callSite, callees);
        if (callees.empty())
            indirectSitesWithEmptyTargets.insert(callSite);
    }
}

buildKeptNodes()

void SVF::SlicedThreadCallGraphView::buildKeptNodes ( )

private

Definition at line 607 of file SlicedGraphs.cpp.

{
    for (CallGraph::iterator it = tcg->begin(), eit = tcg->end();
            it != eit; ++it)
    {
        const CallGraphNode* node = it->second;
        if (node != nullptr && node->getFunction() != nullptr &&
                keptFunctionsSet.count(node->getFunction()))
        {
            keptNodes.insert(node);
        }
    }
}

containsCallSite()

bool SVF::SlicedThreadCallGraphView::containsCallSite	(	const CallGraphEdge *	edge,
		const CallICFGNode *	callSite ) const

Whether this precise callsite-to-callee relation is retained.

Definition at line 668 of file SlicedGraphs.cpp.

{
    const auto direct = keptDirectCalls.find(edge);
    if (direct != keptDirectCalls.end() && direct->second.count(callSite))
        return true;
    const auto indirect = keptIndirectCalls.find(edge);
    return indirect != keptIndirectCalls.end() &&
           indirect->second.count(callSite);
}

dump()

void SVF::SlicedThreadCallGraphView::dump

(

const std::string &

filename

)

const

Dump sliced ThreadCallGraph to dot file.

Definition at line 797 of file SlicedGraphs.cpp.

{
    // Kept nodes + canonical kept edges via GenericGraphTraits; join edges are
    // not in the normal adjacency, so they are not drawn here.
    GraphPrinter::WriteGraphToFile(SVFUtil::outs(), filename, this);
}

getBackingCallGraph()

CallGraph * SVF::SlicedThreadCallGraphView::getBackingCallGraph ( ) const

inline

Backing graph access for the graph-traits implementation only. Analysis traversal must use this view's filtered methods above.

Definition at line 242 of file SlicedGraphs.h.

    {
        return tcg;
    }

getCalleesOf()

void SVF::SlicedThreadCallGraphView::getCalleesOf	(	const CallICFGNode *	callSite,
		CallGraph::FunctionSet &	callees ) const

Retained callees of a callsite.

Definition at line 679 of file SlicedGraphs.cpp.

{
    callees.clear();
    const CallGraphNode* caller = tcg->getCallGraphNode(callSite->getFun());
    if (!isKeptNode(caller))
    {
        return;
    }
    std::vector<const CallGraphEdge*> outEdges;
    getOutEdgesOf(caller, outEdges);
    for (const CallGraphEdge* edge : outEdges)
    {
        if (containsCallSite(edge, callSite))
        {
            callees.insert(edge->getDstNode()->getFunction());
        }
    }
}

getDirectCallsOf()

void SVF::SlicedThreadCallGraphView::getDirectCallsOf	(	const CallGraphEdge *	edge,
		std::vector< const CallICFGNode * > &	out ) const

Retained callsites carried by an aggregated call-graph edge.

Definition at line 650 of file SlicedGraphs.cpp.

{
    out.clear();
    const auto found = keptDirectCalls.find(edge);
    if (found != keptDirectCalls.end())
        out.insert(out.end(), found->second.begin(), found->second.end());
}

getForkEdgesOf()

void SVF::SlicedThreadCallGraphView::getForkEdgesOf	(	const CallICFGNode *	callSite,
		std::vector< const CallGraphEdge * > &	out ) const

Retained thread relations indexed by their fork/join callsite. Join relations are deliberately separate from normal CallGraph adjacency.

Definition at line 699 of file SlicedGraphs.cpp.

{
    out.clear();
    if (!extendedKeptNodes.count(callSite) ||
            !tcg->hasThreadForkEdge(callSite))
        return;
    for (auto it = tcg->getForkEdgeBegin(callSite),
            end = tcg->getForkEdgeEnd(callSite); it != end; ++it)
    {
        const CallGraphEdge* edge = *it;
        if (isKeptNode(edge->getSrcNode()) &&
                isKeptNode(edge->getDstNode()) &&
                containsCallSite(edge, callSite))
            out.push_back(edge);
    }
}

getIndirectCallsOf()

void SVF::SlicedThreadCallGraphView::getIndirectCallsOf	(	const CallGraphEdge *	edge,
		std::vector< const CallICFGNode * > &	out ) const

Definition at line 659 of file SlicedGraphs.cpp.

{
    out.clear();
    const auto found = keptIndirectCalls.find(edge);
    if (found != keptIndirectCalls.end())
        out.insert(out.end(), found->second.begin(), found->second.end());
}

getIndirectSitesWithEmptyTargets()

const Set< const CallICFGNode * > & SVF::SlicedThreadCallGraphView::getIndirectSitesWithEmptyTargets ( ) const

inline

Indirect call sites that lost all targets after filtering.

Definition at line 232 of file SlicedGraphs.h.

    {
        return indirectSitesWithEmptyTargets;
    }

getInEdgesOf()

void SVF::SlicedThreadCallGraphView::getInEdgesOf	(	const CallGraphNode *	node,
		std::vector< const CallGraphEdge * > &	out ) const

Get in edges of a node (only returns kept edges and source nodes).

Definition at line 636 of file SlicedGraphs.cpp.

{
    out.clear();
    if (!isKeptNode(node))
    {
        return;
    }
    using GT = GenericGraphTraits<Inverse<const SlicedThreadCallGraphView*>>;
    const SlicedCallGraphNodeRef n{this, node};
    for (auto it = GT::child_edge_begin(n), e = GT::child_edge_end(n); it != e; ++it)
        out.push_back((*it).underlying);
}

getJoinEdgesOf()

void SVF::SlicedThreadCallGraphView::getJoinEdgesOf	(	const CallICFGNode *	callSite,
		std::vector< const CallGraphEdge * > &	out ) const

Definition at line 718 of file SlicedGraphs.cpp.

{
    out.clear();
    if (!extendedKeptNodes.count(callSite) ||
            !tcg->hasThreadJoinEdge(callSite))
        return;
    for (auto it = tcg->getJoinEdgeBegin(callSite),
            end = tcg->getJoinEdgeEnd(callSite); it != end; ++it)
    {
        const CallGraphEdge* edge = *it;
        if (isKeptNode(edge->getSrcNode()) &&
                isKeptNode(edge->getDstNode()))
            out.push_back(edge);
    }
}

getKeptFunctions()

const Set< const FunObjVar * > & SVF::SlicedThreadCallGraphView::getKeptFunctions ( ) const

inline

Definition at line 219 of file SlicedGraphs.h.

    {
        return keptFunctionsSet;
    }

getKeptNodes()

const OrderedSet< const CallGraphNode * > & SVF::SlicedThreadCallGraphView::getKeptNodes ( ) const

inline

Get all kept nodes.

Definition at line 214 of file SlicedGraphs.h.

    {
        return keptNodes;
    }

getOutEdgesOf()

void SVF::SlicedThreadCallGraphView::getOutEdgesOf	(	const CallGraphNode *	node,
		std::vector< const CallGraphEdge * > &	out ) const

Get out edges of a node (only returns kept edges and target nodes).

Definition at line 621 of file SlicedGraphs.cpp.

{
    out.clear();
    if (!isKeptNode(node))
    {
        return;
    }
 
    using GT = GenericGraphTraits<const SlicedThreadCallGraphView*>;
    const SlicedCallGraphNodeRef n{this, node};
    for (auto it = GT::child_edge_begin(n), e = GT::child_edge_end(n); it != e; ++it)
        out.push_back((*it).underlying);
}

isKeptEdge()

bool SVF::SlicedThreadCallGraphView::isKeptEdge ( const CallGraphEdge * e ) const

inline

Canonical edge membership: keptEdges excludes edges whose call site was pruned, so endpoint checks alone are not enough (queries/traits use this).

Definition at line 226 of file SlicedGraphs.h.

    {
        return keptEdges.find(e) != keptEdges.end();
    }

isKeptNode()

bool SVF::SlicedThreadCallGraphView::isKeptNode

(

const CallGraphNode *

node

)

const

Check if a node is in the sliced view.

Definition at line 736 of file SlicedGraphs.cpp.

{
    return keptNodes.count(node) > 0;
}

Member Data Documentation

extendedKeptNodes

OrderedSet<const ICFGNode*> SVF::SlicedThreadCallGraphView::extendedKeptNodes

private

Definition at line 255 of file SlicedGraphs.h.

indirectSitesWithEmptyTargets

Set<const CallICFGNode*> SVF::SlicedThreadCallGraphView::indirectSitesWithEmptyTargets

private

Definition at line 254 of file SlicedGraphs.h.

keptDirectCalls

Map<const CallGraphEdge*, CallGraphEdge::CallInstSet> SVF::SlicedThreadCallGraphView::keptDirectCalls

private

Definition at line 251 of file SlicedGraphs.h.

keptEdges

Set<const CallGraphEdge*> SVF::SlicedThreadCallGraphView::keptEdges

private

Definition at line 250 of file SlicedGraphs.h.

keptFunctionsSet

Set<const FunObjVar*> SVF::SlicedThreadCallGraphView::keptFunctionsSet

private

Definition at line 253 of file SlicedGraphs.h.

keptIndirectCalls

Map<const CallGraphEdge*, CallGraphEdge::CallInstSet> SVF::SlicedThreadCallGraphView::keptIndirectCalls

private

Definition at line 252 of file SlicedGraphs.h.

keptNodes

OrderedSet<const CallGraphNode*> SVF::SlicedThreadCallGraphView::keptNodes

private

Definition at line 249 of file SlicedGraphs.h.

tcg

ThreadCallGraph* SVF::SlicedThreadCallGraphView::tcg

private

Definition at line 248 of file SlicedGraphs.h.

---

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

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