SVF::VFCFLGraphBuilder Class Reference

VFCFLGraphBuilder: a CFLGraphBuilder specialized for handling value-flow. More...

#include <CFLGraphBuilder.h>

Inheritance diagram for SVF::VFCFLGraphBuilder:

Public Member Functions
CFLGraph *	buildBigraph (SVFG *graph, Kind startKind, GrammarBase *grammar)
	Builds a bidirectional CFL graph by copying nodes and edges from a const graph that inherits from SVFG.
CFLGraph *	buildBiPEGgraph (ConstraintGraph *graph, Kind startKind, GrammarBase *grammar, SVFIR *pag)
Public Member Functions inherited from SVF::CFLGraphBuilder
template<class N , class E >
CFLGraph *	build (GenericGraph< N, E > *graph, GrammarBase *grammar, BuildDirection direction=BuildDirection::plain)
CFLGraph *	build (std::string fileName, GrammarBase *grammar, BuildDirection direction=BuildDirection::plain)
	Method to build a CFL graph from external file.
Map< std::string, Kind > &	getLabelToKindMap ()
	Returns a reference to the map that associates string labels with their corresponding Kind.
Map< Kind, std::string > &	getKindToLabelMap ()
	Returns a reference to the map that associates Kinds with their corresponding string labels.
Map< CFGrammar::Kind, Set< CFGrammar::Attribute > > &	getKindToAttrsMap ()
	Returns a reference to the map that associates Kinds with their corresponding attributes.

Private Member Functions
void	connectVGep (CFLGraph *cflGraph, ConstraintGraph *graph, ConstraintNode *src, ConstraintNode *dst, u32_t level, SVFIR *pag)
	Connects VGep (Variable GEP)
void	addBiCFLEdge (CFLGraph *cflGraph, ConstraintNode *src, ConstraintNode *dst, CFGrammar::Kind label)
	Handles edges, with the exception of the GEP.
void	addBiGepCFLEdge (CFLGraph *cflGraph, ConstraintNode *src, ConstraintNode *dst, CFGrammar::Attribute attri)
	Adds bidirectional GEP edges with attributes.

Additional Inherited Members
Protected Types inherited from SVF::CFLGraphBuilder
typedef CFGrammar::Kind	Kind
typedef CFGrammar::Symbol	Symbol
Protected Member Functions inherited from SVF::CFLGraphBuilder
void	addAttribute (CFGrammar::Kind kind, CFGrammar::Attribute attribute)
	Method to add an attribute to a specific kind.
void	buildlabelToKindMap (GrammarBase *grammar)
	build label and kind connect from the grammar
CFLNode *	addGNode (u32_t NodeID)
	add src and dst node from file
CFLGraph *	buildFromText (std::string fileName, GrammarBase *grammar, BuildDirection direction=BuildDirection::plain)
	Method to build a CFL graph from a Text file.
CFLGraph *	buildFromDot (std::string filename, GrammarBase *grammar, BuildDirection direction=BuildDirection::plain)
	Method to build a CFL graph from a Dot file.
CFLGraph *	buildFromJson (std::string filename, GrammarBase *grammar, BuildDirection direction=BuildDirection::plain)
	Method to build a CFL graph from a Json file.
Protected Attributes inherited from SVF::CFLGraphBuilder
Map< std::string, Kind >	labelToKindMap
	Maps to maintain mapping between labels and kinds.
Map< Kind, std::string >	kindToLabelMap
Map< CFGrammar::Kind, Set< CFGrammar::Attribute > >	kindToAttrsMap
	Map to maintain attributes associated with each kind.
Kind	current
CFLGraph *	cflGraph

Detailed Description

VFCFLGraphBuilder: a CFLGraphBuilder specialized for handling value-flow.

Definition at line 142 of file CFLGraphBuilder.h.

Member Function Documentation

addBiCFLEdge()

void SVF::VFCFLGraphBuilder::addBiCFLEdge ( CFLGraph *  cflGraph, ConstraintNode *  src, ConstraintNode *  dst, CFGrammar::Kind  label  )

private

Handles edges, with the exception of the GEP.

addBiGepCFLEdge()

void SVF::VFCFLGraphBuilder::addBiGepCFLEdge ( CFLGraph *  cflGraph, ConstraintNode *  src, ConstraintNode *  dst, CFGrammar::Attribute  attri  )

private

Adds bidirectional GEP edges with attributes.

buildBigraph()

CFLGraph * SVF::VFCFLGraphBuilder::buildBigraph	(	SVFG *	graph,
		Kind	startKind,
		GrammarBase *	grammar
	)

Builds a bidirectional CFL graph by copying nodes and edges from a const graph that inherits from SVFG.

Definition at line 481 of file CFLGraphBuilder.cpp.

{
    cflGraph = new CFLGraph(startKind);
 
    buildlabelToKindMap(grammar);
    for(auto it = graph->begin(); it!= graph->end(); it++)
    {
        CFLNode* node = new CFLNode((*it).first);
        cflGraph->addCFLNode((*it).first, node);
    }
    for(auto it = graph->begin(); it!= graph->end(); it++)
    {
        VFGNode* node = (*it).second;
        for(VFGEdge* edge : node->getOutEdges())
        {
            CFGrammar::Kind edgeLabel;
            // Get 'a' edge : IntraDirectVF || IntraIndirectVF
            if (edge->getEdgeKind() == VFGEdge::IntraDirectVF || edge->getEdgeKind() == VFGEdge::IntraIndirectVF || edge->getEdgeKind() == VFGEdge::TheadMHPIndirectVF )
            {
                edgeLabel = 0;
                cflGraph->addCFLEdge(cflGraph->getGNode(edge->getSrcID()), cflGraph->getGNode(edge->getDstID()), edgeLabel);
                cflGraph->addCFLEdge(cflGraph->getGNode(edge->getSrcID()), cflGraph->getGNode(edge->getDstID()), edgeLabel);
                std::string label = kindToLabelMap[edge->getEdgeKind()];
                label.append("bar");
                cflGraph->addCFLEdge(cflGraph->getGNode(edge->getDstID()), cflGraph->getGNode(edge->getSrcID()), labelToKindMap[label]);
            }
            // Get 'call' edge : CallDirVF || CallIndVF
            else if ( edge->getEdgeKind() == VFGEdge::CallDirVF )
            {
                edgeLabel = 1;
                CallDirSVFGEdge *attributedEdge = SVFUtil::dyn_cast<CallDirSVFGEdge>(edge);
                CFGrammar::Attribute attr =  attributedEdge->getCallSiteId();
                addAttribute(edgeLabel, attr);
                edgeLabel = CFGrammar::getAttributedKind(attr, edgeLabel);
                cflGraph->addCFLEdge(cflGraph->getGNode(edge->getSrcID()), cflGraph->getGNode(edge->getDstID()), edgeLabel);
                std::string label = kindToLabelMap[edgeLabel];
                label.append("bar");   // for example Gep_i should be Gepbar_i, not Gep_ibar
                cflGraph->addCFLEdge(cflGraph->getGNode(edge->getDstID()), cflGraph->getGNode(edge->getSrcID()), CFGrammar::getAttributedKind(attr, labelToKindMap[label]));
                addAttribute(labelToKindMap[label], attr);
            }
            // Get 'call' edge : CallIndVF
            else if ( edge->getEdgeKind() == VFGEdge::CallIndVF )
            {
                edgeLabel = 1;
                CallIndSVFGEdge *attributedEdge = SVFUtil::dyn_cast<CallIndSVFGEdge>(edge);
                CFGrammar::Attribute attr =  attributedEdge->getCallSiteId();
                addAttribute(edgeLabel, attr);
                edgeLabel = CFGrammar::getAttributedKind(attr, edgeLabel);
                cflGraph->addCFLEdge(cflGraph->getGNode(edge->getSrcID()), cflGraph->getGNode(edge->getDstID()), edgeLabel);
                std::string label = kindToLabelMap[edgeLabel];
                label.append("bar");   // for example Gep_i should be Gepbar_i, not Gep_ibar
                cflGraph->addCFLEdge(cflGraph->getGNode(edge->getDstID()), cflGraph->getGNode(edge->getSrcID()), CFGrammar::getAttributedKind(attr, labelToKindMap[label]));
                addAttribute(labelToKindMap[label], attr);
            }
            // Get 'ret' edge : RetDirVF
            else if ( edge->getEdgeKind() == VFGEdge::RetDirVF )
            {
                edgeLabel = 2;
                RetDirSVFGEdge *attributedEdge = SVFUtil::dyn_cast<RetDirSVFGEdge>(edge);
                CFGrammar::Attribute attr =  attributedEdge->getCallSiteId();
                addAttribute(edgeLabel, attr);
                edgeLabel = CFGrammar::getAttributedKind(attr, edgeLabel);
                cflGraph->addCFLEdge(cflGraph->getGNode(edge->getSrcID()), cflGraph->getGNode(edge->getDstID()), edgeLabel);
                std::string label = kindToLabelMap[edgeLabel];
                label.append("bar");   // for example Gep_i should be Gepbar_i, not Gep_ibar
                cflGraph->addCFLEdge(cflGraph->getGNode(edge->getDstID()), cflGraph->getGNode(edge->getSrcID()), CFGrammar::getAttributedKind(attr, labelToKindMap[label]));
                addAttribute(labelToKindMap[label], attr);
            }
            // Get 'ret' edge : RetIndVF
            else if ( edge->getEdgeKind() == VFGEdge::RetIndVF )
            {
                edgeLabel = 2;
                RetIndSVFGEdge *attributedEdge = SVFUtil::dyn_cast<RetIndSVFGEdge>(edge);
                CFGrammar::Attribute attr =  attributedEdge->getCallSiteId();
                addAttribute(edgeLabel, attr);
                edgeLabel = CFGrammar::getAttributedKind(attr, edgeLabel);
                cflGraph->addCFLEdge(cflGraph->getGNode(edge->getSrcID()), cflGraph->getGNode(edge->getDstID()), edgeLabel);
                std::string label = kindToLabelMap[edgeLabel];
                label.append("bar");   // for example Gep_i should be Gepbar_i, not Gep_ibar
                cflGraph->addCFLEdge(cflGraph->getGNode(edge->getDstID()), cflGraph->getGNode(edge->getSrcID()), CFGrammar::getAttributedKind(attr, labelToKindMap[label]));
                addAttribute(labelToKindMap[label], attr);
            }
        }
    }
    return cflGraph;
}

buildBiPEGgraph()

CFLGraph * SVF::VFCFLGraphBuilder::buildBiPEGgraph	(	ConstraintGraph *	graph,
		Kind	startKind,
		GrammarBase *	grammar,
		SVFIR *	pag
	)

Builds a bidirectional CFL graph by copying nodes and edges from any graph that inherits from GenericGraph Transfers Load and Store to copy edge and address edge to construct PEG style CFLGraph

Definition at line 568 of file CFLGraphBuilder.cpp.

{
    CFLGraph *cflGraph = new CFLGraph(startKind);
    return cflGraph;
}

connectVGep()

void SVF::VFCFLGraphBuilder::connectVGep ( CFLGraph *  cflGraph, ConstraintGraph *  graph, ConstraintNode *  src, ConstraintNode *  dst, u32_t  level, SVFIR *  pag  )

private

Connects VGep (Variable GEP)

---

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

• /home/runner/work/SVF/SVF/svf/include/CFL/CFLGraphBuilder.h
• /home/runner/work/SVF/SVF/svf/lib/CFL/CFLGraphBuilder.cpp