SVF::SVFBugReport Class Reference

#include <SVFBugReport.h>

Public Types
typedef SVF::Set< const GenericBug * >	BugSet

Public Member Functions
	SVFBugReport ()=default
	~SVFBugReport ()
void	setStat (double time, std::string mem, double coverage)
void	addSaberBug (GenericBug::BugType bugType, const GenericBug::EventStack &eventStack)
void	addAbsExecBug (GenericBug::BugType bugType, const GenericBug::EventStack &eventStack, s64_t allocLowerBound, s64_t allocUpperBound, s64_t accessLowerBound, s64_t accessUpperBound)
void	dumpToJsonFile (const std::string &filePath) const
const BugSet &	getBugSet () const

Protected Attributes
BugSet	bugSet
double	time
std::string	mem
double	coverage

Detailed Description

Definition at line 288 of file SVFBugReport.h.

Member Typedef Documentation

BugSet

typedef SVF::Set<const GenericBug *> SVF::SVFBugReport::BugSet

Definition at line 293 of file SVFBugReport.h.

Constructor & Destructor Documentation

SVFBugReport()

SVF::SVFBugReport::SVFBugReport ( )

default

~SVFBugReport()

SVFBugReport::~SVFBugReport

(

)

Definition at line 331 of file SVFBugReport.cpp.

{
    for(auto bugIt: bugSet)
    {
        delete bugIt;
    }
}

Member Function Documentation

addAbsExecBug()

void SVF::SVFBugReport::addAbsExecBug ( GenericBug::BugType  bugType, const GenericBug::EventStack &  eventStack, s64_t  allocLowerBound, s64_t  allocUpperBound, s64_t  accessLowerBound, s64_t  accessUpperBound  )

inline

add bugs

Definition at line 367 of file SVFBugReport.h.

    {
        GenericBug *newBug = nullptr;
        switch(bugType)
        {
        case GenericBug::FULLBUFOVERFLOW:
        {
            newBug = new FullBufferOverflowBug(eventStack, allocLowerBound, allocUpperBound, accessLowerBound, accessUpperBound);
            bugSet.insert(newBug);
            break;
        }
        case GenericBug::PARTIALBUFOVERFLOW:
        {
            newBug = new PartialBufferOverflowBug(eventStack, allocLowerBound, allocUpperBound, accessLowerBound, accessUpperBound);
            bugSet.insert(newBug);
            break;
        }
        case GenericBug::FULLNULLPTRDEREFERENCE:
        {
            newBug = new FullNullPtrDereferenceBug(eventStack);
            bugSet.insert(newBug);
            break;
        }
        case GenericBug::PARTIALNULLPTRDEREFERENCE:
        {
            newBug = new PartialNullPtrDereferenceBug(eventStack);
            bugSet.insert(newBug);
            break;
        }
        default:
        {
            assert(false && "Abstract Execution does NOT have this bug type!");
            break;
        }
        }
 
        // when add a bug, also print it to terminal
        //newBug->printBugToTerminal();
    }

addSaberBug()

void SVF::SVFBugReport::addSaberBug ( GenericBug::BugType  bugType, const GenericBug::EventStack &  eventStack  )

inline

create and add the bug

Definition at line 315 of file SVFBugReport.h.

    {
        GenericBug *newBug = nullptr;
        switch(bugType)
        {
        case GenericBug::NEVERFREE:
        {
            newBug = new NeverFreeBug(eventStack);
            bugSet.insert(newBug);
            break;
        }
        case GenericBug::PARTIALLEAK:
        {
            newBug = new PartialLeakBug(eventStack);
            bugSet.insert(newBug);
            break;
        }
        case GenericBug::DOUBLEFREE:
        {
            newBug = new DoubleFreeBug(eventStack);
            bugSet.insert(newBug);
            break;
        }
        case GenericBug::FILENEVERCLOSE:
        {
            newBug = new FileNeverCloseBug(eventStack);
            bugSet.insert(newBug);
            break;
        }
        case GenericBug::FILEPARTIALCLOSE:
        {
            newBug = new FilePartialCloseBug(eventStack);
            bugSet.insert(newBug);
            break;
        }
        default:
        {
            assert(false && "saber does NOT have this bug type!");
            break;
        }
        }
 
        // when add a bug, also print it to terminal
        newBug->printBugToTerminal();
    }

dumpToJsonFile()

void SVFBugReport::dumpToJsonFile

(

const std::string &

filePath

)

const

Add defects

Add bug information to JSON

Add event information to JSON

Dump single bug to JSON string and write to file

Destroy the cJSON object

Add program information

Definition at line 339 of file SVFBugReport.cpp.

{
    std::map<u32_t, std::string> eventType2Str =
    {
        {SVFBugEvent::CallSite, "call site"},
        {SVFBugEvent::Caller, "caller"},
        {SVFBugEvent::Loop, "loop"},
        {SVFBugEvent::Branch, "branch"}
    };
 
    ofstream jsonFile(filePath, ios::out);
 
    jsonFile << "{\n";
 
    jsonFile << "\"Defects\": [\n";
    size_t commaCounter = bugSet.size() - 1;
    for (auto bugPtr : bugSet)
    {
        cJSON *singleDefect = cJSON_CreateObject();
 
        cJSON *bugType = cJSON_CreateString(
                             GenericBug::BugType2Str.at(bugPtr->getBugType()).c_str());
        cJSON_AddItemToObject(singleDefect, "DefectType", bugType);
 
        cJSON *bugLoc = cJSON_Parse(bugPtr->getLoc().c_str());
        if (bugLoc == nullptr)
        {
            bugLoc = cJSON_CreateObject();
        }
        cJSON_AddItemToObject(singleDefect, "Location", bugLoc);
 
        cJSON *bugFunction = cJSON_CreateString(
                                 bugPtr->getFuncName().c_str());
        cJSON_AddItemToObject(singleDefect, "Function", bugFunction);
 
        cJSON_AddItemToObject(singleDefect, "Description",
                              bugPtr->getBugDescription());
 
        cJSON *eventList = cJSON_CreateArray();
        const GenericBug::EventStack &bugEventStack = bugPtr->getEventStack();
        if (BufferOverflowBug::classof(bugPtr))
        {
            // Add only when bug is context sensitive
            for (const SVFBugEvent &event : bugEventStack)
            {
                if (event.getEventType() == SVFBugEvent::SourceInst)
                {
                    continue;
                }
 
                cJSON *singleEvent = cJSON_CreateObject();
                // Event type
                cJSON *eventType = cJSON_CreateString(
                                       eventType2Str[event.getEventType()].c_str());
                cJSON_AddItemToObject(singleEvent, "EventType", eventType);
                // Function name
                cJSON *eventFunc = cJSON_CreateString(
                                       event.getFuncName().c_str());
                cJSON_AddItemToObject(singleEvent, "Function", eventFunc);
                // Event loc
                cJSON *eventLoc = cJSON_Parse(event.getEventLoc().c_str());
                if (eventLoc == nullptr)
                {
                    eventLoc = cJSON_CreateObject();
                }
                cJSON_AddItemToObject(singleEvent, "Location", eventLoc);
                // Event description
                cJSON *eventDescription = cJSON_CreateString(
                                              event.getEventDescription().c_str());
                cJSON_AddItemToObject(singleEvent, "Description", eventDescription);
 
                cJSON_AddItemToArray(eventList, singleEvent);
            }
        }
        cJSON_AddItemToObject(singleDefect, "Events", eventList);
 
        char *singleDefectStr = cJSON_Print(singleDefect);
        jsonFile << singleDefectStr;
        if (commaCounter != 0)
        {
            jsonFile << ",\n";
        }
        commaCounter--;
 
        cJSON_Delete(singleDefect);
    }
    jsonFile << "\n],\n";
 
    jsonFile << "\"Time\": " << time << ",\n";
    jsonFile << "\"Memory\": \"" << mem << "\",\n";
    jsonFile << "\"Coverage\": " << coverage << "\n";
 
    jsonFile << "}";
    jsonFile.close();
}

getBugSet()

const BugSet & SVF::SVFBugReport::getBugSet ( ) const

inline

Definition at line 419 of file SVFBugReport.h.

    {
        return bugSet;
    }

setStat()

void SVF::SVFBugReport::setStat ( double  time, std::string  mem, double  coverage  )

inline

Definition at line 303 of file SVFBugReport.h.

    {
        this->time = time;
        this->mem = mem;
        this->coverage = coverage;
    }

Member Data Documentation

bugSet

BugSet SVF::SVFBugReport::bugSet

protected

Definition at line 296 of file SVFBugReport.h.

coverage

double SVF::SVFBugReport::coverage

protected

Definition at line 299 of file SVFBugReport.h.

mem

std::string SVF::SVFBugReport::mem

protected

Definition at line 298 of file SVFBugReport.h.

time

double SVF::SVFBugReport::time

protected

Definition at line 297 of file SVFBugReport.h.

---

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

• /home/runner/work/SVF/SVF/svf/include/Util/SVFBugReport.h
• /home/runner/work/SVF/SVF/svf/lib/Util/SVFBugReport.cpp