SVF::PAGBuilderFromFile Class Reference

#include <PAGBuilderFromFile.h>

Public Member Functions
	PAGBuilderFromFile (std::string f)
	Constructor. More...
	~PAGBuilderFromFile ()
	Destructor. More...
SVFIR *	getPAG () const
	Return SVFIR. More...
std::string	getFileName () const
	Return file name. More...
SVFIR *	build ()
	Start building. More...
void	addEdge (NodeID nodeSrc, NodeID nodeDst, APOffset offset, std::string edge)

Private Attributes
SVFIR *	pag
std::string	file

Detailed Description

Build SVFIR from a user specified file (for debugging purpose)

Definition at line 41 of file PAGBuilderFromFile.h.

Constructor & Destructor Documentation

PAGBuilderFromFile()

SVF::PAGBuilderFromFile::PAGBuilderFromFile ( std::string  f )

inline

Constructor.

Definition at line 49 of file PAGBuilderFromFile.h.

                                    :
        pag(SVFIR::getPAG(true)), file(f)
    {
    }

~PAGBuilderFromFile()

SVF::PAGBuilderFromFile::~PAGBuilderFromFile ( )

inline

Destructor.

Definition at line 54 of file PAGBuilderFromFile.h.

    {
    }

Member Function Documentation

addEdge()

void PAGBuilderFromFile::addEdge	(	NodeID	srcID,
		NodeID	dstID,
		APOffset	offsetOrCSId,
		std::string	edge
	)

Add SVFIR edge according to a file format

sanity check for SVFIR from txt

Definition at line 148 of file PAGBuilderFromFile.cpp.

{
 
    //check whether these two nodes available
    PAGNode* srcNode = pag->getGNode(srcID);
    PAGNode* dstNode = pag->getGNode(dstID);
 
    assert(SVFUtil::isa<ValVar>(dstNode) && "dst not an value node?");
    if(edge=="addr")
        assert(SVFUtil::isa<ObjVar>(srcNode) && "src not an value node?");
    else
        assert(!SVFUtil::isa<ObjVar>(srcNode) && "src not an object node?");
 
    if (edge == "addr")
    {
        pag->addAddrStmt(srcID, dstID);
    }
    if (edge.rfind("copy-", 0) == 0)
    {
        // the enum is COPYVAL, ZEXT, SEXT, BITCAST, TRUNC, FPTRUNC,
        std::string opType = edge.substr(5); // start substring from 5th char
 
        if (opType == "COPYVAL")
        {
            pag->addCopyStmt(srcID, dstID, CopyStmt::COPYVAL);
        }
        else if (opType == "ZEXT")
        {
            pag->addCopyStmt(srcID, dstID, CopyStmt::ZEXT);
        }
        else if (opType == "SEXT")
        {
            pag->addCopyStmt(srcID, dstID, CopyStmt::SEXT);
        }
        else if (opType == "BITCAST")
        {
            pag->addCopyStmt(srcID, dstID, CopyStmt::BITCAST);
        }
        else if (opType == "TRUNC")
        {
            pag->addCopyStmt(srcID, dstID, CopyStmt::TRUNC);
        }
        else if (opType == "FPTRUNC")
        {
            pag->addCopyStmt(srcID, dstID, CopyStmt::FPTRUNC);
        }
        else if (opType == "FPTOUI")
        {
            pag->addCopyStmt(srcID, dstID, CopyStmt::FPTOUI);
        }
        else if (opType == "FPTOSI")
        {
            pag->addCopyStmt(srcID, dstID, CopyStmt::FPTOSI);
        }
        else if (opType == "UITOFP")
        {
            pag->addCopyStmt(srcID, dstID, CopyStmt::UITOFP);
        }
        else if (opType == "SITOFP")
        {
            pag->addCopyStmt(srcID, dstID, CopyStmt::SITOFP);
        }
        else if (opType == "INTTOPTR")
        {
            pag->addCopyStmt(srcID, dstID, CopyStmt::INTTOPTR);
        }
        else if (opType == "PTRTOINT")
        {
            pag->addCopyStmt(srcID, dstID, CopyStmt::PTRTOINT);
        }
        else
        {
            assert(false && "format not support, can not create such edge");
        }
    }
    else if (edge == "load")
        pag->addLoadStmt(srcID, dstID);
    else if (edge == "store")
        pag->addStoreStmt(srcID, dstID, nullptr);
    else if (edge == "gep")
        pag->addNormalGepStmt(srcID, dstID, AccessPath(offsetOrCSId));
    else if (edge == "variant-gep")
        pag->addVariantGepStmt(srcID, dstID, AccessPath(offsetOrCSId));
    else if (edge == "call")
        pag->addEdge(srcNode, dstNode, new CallPE(srcNode, dstNode, nullptr, nullptr));
    else if (edge == "ret")
        pag->addEdge(srcNode, dstNode, new RetPE(srcNode, dstNode, nullptr,nullptr));
    else if (edge == "cmp")
        pag->addCmpStmt(srcID, dstID, dstID, dstID);
    else if (edge == "binary-op")
        pag->addBinaryOPStmt(srcID, dstID, dstID, dstID);
    else if (edge == "unary-op")
        pag->addUnaryOPStmt(srcID, dstID, dstID);
    else if (edge == "phi")
        assert(false && "fix phi here!");
    else if (edge == "select")
        assert(false && "fix select here!");
    else if (edge == "branch")
    {
        assert(false && "fix successors here!");
        //pag->addBranchStmt(srcID, dstID, nullptr);
    }
    else
        assert(false && "format not support, can not create such edge");
}

build()

SVFIR * PAGBuilderFromFile::build

(

)

Start building.

new gep node's id from lower bound, nodeNum may not reflect the total nodes.

Definition at line 61 of file PAGBuilderFromFile.cpp.

{
 
    string line;
    ifstream myfile(file.c_str());
    if (myfile.is_open())
    {
        while (myfile.good())
        {
            getline(myfile, line);
 
            u32_t token_count = 0;
            string tmps;
            istringstream ss(line);
            while (ss.good())
            {
                ss >> tmps;
                token_count++;
            }
 
            if (token_count == 0)
                continue;
 
            else if (token_count == 2)
            {
                NodeID nodeId;
                string nodetype;
                istringstream ss(line);
                ss >> nodeId;
                ss >> nodetype;
                outs() << "reading node :" << nodeId << "\n";
                if (nodetype == "v")
                    pag->addDummyValNode(nodeId);
                else if (nodetype == "o")
                {
                    const MemObj* mem = pag->addDummyMemObj(nodeId, nullptr);
                    pag->addFIObjNode(mem);
                }
                else
                    assert(false && "format not support, pls specify node type");
            }
 
            // do consider gep edge
            else if (token_count == 4)
            {
                NodeID nodeSrc;
                NodeID nodeDst;
                APOffset offsetOrCSId;
                string edge;
                istringstream ss(line);
                ss >> nodeSrc;
                ss >> edge;
                ss >> nodeDst;
                ss >> offsetOrCSId;
                outs() << "reading edge :" << nodeSrc << " " << edge << " "
                       << nodeDst << " offsetOrCSId=" << offsetOrCSId << " \n";
                addEdge(nodeSrc, nodeDst, offsetOrCSId, edge);
            }
            else
            {
                if (!line.empty())
                {
                    outs() << "format not supported, token count = "
                           << token_count << "\n";
                    assert(false && "format not supported");
                }
            }
        }
        myfile.close();
    }
 
    else
        outs() << "Unable to open file\n";
 
    u32_t lower_bound = gepNodeNumIndex;
    for(u32_t i = 0; i < lower_bound; i++)
        pag->incNodeNum();
 
    pag->setNodeNumAfterPAGBuild(pag->getTotalNodeNum());
 
    return pag;
}

getFileName()

std::string SVF::PAGBuilderFromFile::getFileName ( ) const

inline

Return file name.

Definition at line 65 of file PAGBuilderFromFile.h.

    {
        return file;
    }

getPAG()

SVFIR* SVF::PAGBuilderFromFile::getPAG ( ) const

inline

Return SVFIR.

Definition at line 59 of file PAGBuilderFromFile.h.

    {
        return pag;
    }

Member Data Documentation

file

std::string SVF::PAGBuilderFromFile::file

private

Definition at line 46 of file PAGBuilderFromFile.h.

pag

SVFIR* SVF::PAGBuilderFromFile::pag

private

Definition at line 45 of file PAGBuilderFromFile.h.

---

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

• /home/runner/work/SVF/SVF/svf/include/SVFIR/PAGBuilderFromFile.h
• /home/runner/work/SVF/SVF/svf/lib/SVFIR/PAGBuilderFromFile.cpp