SVF::LockResultValidator Class Reference

#include <LockResultValidator.h>

Public Types
typedef Set< std::string >	CxtLockSetStr
typedef Map< const SVFInstruction *, CxtLockSetStr >	CxtStmtToCxtLockS
typedef unsigned	LOCK_FLAG

Public Member Functions
	LockResultValidator (LockAnalysis *la)
	~LockResultValidator ()
void	analyze ()
SVFModule *	getModule () const

Private Member Functions
CallICFGNode *	getCBN (const SVFInstruction *inst)
const Instruction *	getPreviousMemoryAccessInst (const Instruction *I)
bool	inFilter (const std::string &name)
bool	match (const std::string &lockName, CxtLockSetStr LS)
Set< std::string > &	split (const std::string &s, char delim, Set< std::string > &elems)
Set< std::string >	split (const std::string &s, char delim)
std::string	getOutput (const char *scenario, LOCK_FLAG analysisRes)
Set< std::string >	getStringArg (const Instruction *inst, unsigned int arg_num)
bool	collectLockTargets ()
LOCK_FLAG	validateStmtInLock ()

Private Attributes
CxtStmtToCxtLockS	instToCxtLockSet
LockAnalysis::CxtStmtToCxtLockSet	cxtStmtToCxtLockSet
LockAnalysis::CxtLockSet	cxtLockSet
LockAnalysis *	_la
SVFModule *	_mod
Set< std::string >	filterFun = {"LOCK", "INTERLEV_ACCESS", "PAUSE", "CXT_THREAD", "TCT_ACCESS"}

Static Private Attributes
static const LOCK_FLAG	LOCK_TRUE = 0x01
static const LOCK_FLAG	LOCK_IMPRECISE = 0x02
static const LOCK_FLAG	LOCK_UNSOUND = 0x04
static constexpr char const *	LOCK = "LOCK"

Detailed Description

Definition at line 19 of file LockResultValidator.h.

Member Typedef Documentation

CxtLockSetStr

typedef Set<std::string> SVF::LockResultValidator::CxtLockSetStr

Definition at line 22 of file LockResultValidator.h.

CxtStmtToCxtLockS

typedef Map<const SVFInstruction*, CxtLockSetStr> SVF::LockResultValidator::CxtStmtToCxtLockS

Definition at line 23 of file LockResultValidator.h.

LOCK_FLAG

typedef unsigned SVF::LockResultValidator::LOCK_FLAG

Definition at line 25 of file LockResultValidator.h.

Constructor & Destructor Documentation

LockResultValidator()

SVF::LockResultValidator::LockResultValidator ( LockAnalysis *  la )

inline

Definition at line 27 of file LockResultValidator.h.

                                          : _la(la)
    {
        _mod = _la->getTCT()->getSVFModule();
    }

~LockResultValidator()

SVF::LockResultValidator::~LockResultValidator ( )

inline

Definition at line 32 of file LockResultValidator.h.

{}

Member Function Documentation

analyze()

void LockResultValidator::analyze

(

)

Definition at line 202 of file LockResultValidator.cpp.

{
    outs() << SVFUtil::pasMsg(" --- Lock Analysis Result Validation ---\n");
    if(!collectLockTargets())
        return;
    std::string errstring;
    errstring = getOutput("Validate Lock Analysis :", validateStmtInLock());
    outs() << "======" << errstring << "======\n";
 
    RaceValidator validator(_la);
    validator.init(_la->getTCT()->getSVFModule());
    validator.analyze();
}

collectLockTargets()

bool LockResultValidator::collectLockTargets ( )

private

Definition at line 95 of file LockResultValidator.cpp.

{
    const Function* F = nullptr;
    for (Module &M : LLVMModuleSet::getLLVMModuleSet()->getLLVMModules())
    {
        for(auto it = M.begin(); it != M.end(); it++)
        {
            const std::string fName = (*it).getName().str();
            if(fName.find(LOCK) != std::string::npos)
            {
                F = &(*it);
                break;
            }
        }
    }
    if (!F)
        return false;
    for(Value::const_use_iterator it = F->use_begin(), ie = F->use_end(); it!=ie; it++)
    {
        const Use *u = &*it;
        const Value* user = u->getUser();
        const Instruction* inst = SVFUtil::dyn_cast<Instruction>(user);
        CxtLockSetStr y = getStringArg(inst, 0);
        const Instruction* memInst = getPreviousMemoryAccessInst(inst);
        const SVFInstruction* svfMemInst = LLVMModuleSet::getLLVMModuleSet()->getSVFInstruction(memInst);
 
        instToCxtLockSet[svfMemInst] = y;
        if(const StoreInst* store = SVFUtil::dyn_cast<StoreInst> (memInst))
        {
            if(const BinaryOperator* bop = SVFUtil::dyn_cast<BinaryOperator> (store->getValueOperand()))
            {
                const Value* v = bop->getOperand(0);
                const Instruction* prevInst = SVFUtil::dyn_cast<LoadInst> (v);
                const SVFInstruction* svfPrevInst = LLVMModuleSet::getLLVMModuleSet()->getSVFInstruction(prevInst);
                instToCxtLockSet[svfPrevInst] = y;
            }
        }
    }
    return true;
}

getCBN()

CallICFGNode* SVF::LockResultValidator::getCBN ( const SVFInstruction *  inst )

inlineprivate

Definition at line 42 of file LockResultValidator.h.

    {
        return _la->getTCT()->getCallICFGNode(inst);
    }

getModule()

SVFModule* SVF::LockResultValidator::getModule ( ) const

inline

Definition at line 36 of file LockResultValidator.h.

    {
        return _mod;
    }

getOutput()

std::string LockResultValidator::getOutput ( const char *  scenario, LOCK_FLAG  analysisRes  )

inlineprivate

Definition at line 74 of file LockResultValidator.cpp.

{
    std::string ret(scenario);
    ret += "\t";
    switch (analysisRes)
    {
    case LOCK_TRUE:
        ret += SVFUtil::sucMsg("SUCCESS");
        break;
    case LOCK_UNSOUND:
        ret += SVFUtil::bugMsg2("UNSOUND");
        break;
    case LOCK_IMPRECISE:
        ret += SVFUtil::bugMsg1("IMPRECISE");
        break;
    default:
        ret += SVFUtil::errMsg("FAILURE");
    }
    return ret;
}

getPreviousMemoryAccessInst()

const Instruction * LockResultValidator::getPreviousMemoryAccessInst ( const Instruction *  I )

private

Definition at line 216 of file LockResultValidator.cpp.

{
    I = I->getPrevNode();
    while (I)
    {
        if (SVFUtil::isa<LoadInst>(I) || SVFUtil::isa<StoreInst>(I))
            return I;
        SVFFunction* callee = nullptr;
 
        if(LLVMUtil::isCallSite(I))
        {
            PTACallGraph::FunctionSet callees;
            const SVFInstruction* svfInst = LLVMModuleSet::getLLVMModuleSet()->getSVFInstruction(I);
            _la->getTCT()->getThreadCallGraph()->getCallees(getCBN(svfInst), callees);
 
            for(PTACallGraph::FunctionSet::const_iterator cit = callees.begin(),
                    ecit = callees.end(); cit!=ecit; cit++)
            {
                if(*cit != nullptr)
                {
                    callee = const_cast<SVFFunction*> (*cit);
                    break;
                }
 
            }
        }
 
        if (callee)
        {
            if (callee->getName().find("llvm.memset") != std::string::npos)
                return I;
        }
        I = I->getPrevNode();
    }
    return nullptr;
}

getStringArg()

Set< std::string > LockResultValidator::getStringArg ( const Instruction *  inst, unsigned int  arg_num  )

private

Definition at line 39 of file LockResultValidator.cpp.

{
    assert(LLVMUtil::isCallSite(inst) && "getFirstIntArg: inst is not a callsite");
    const CallBase* cs = LLVMUtil::getLLVMCallSite(inst);
    assert((arg_num < cs->arg_size()) && "Does not has this argument");
    const GetElementPtrInst* gepinst = SVFUtil::dyn_cast<GetElementPtrInst>(cs->getArgOperand(arg_num));
    const Constant* arrayinst = SVFUtil::dyn_cast<Constant>(gepinst->getOperand(0));
    const ConstantDataArray* cxtarray = SVFUtil::dyn_cast<ConstantDataArray>(arrayinst->getOperand(0));
    if (!cxtarray)
    {
        Set<std::string> strvec;
        return strvec;
    }
    const std::string vthdcxtstring = cxtarray->getAsCString().str();
    return split(vthdcxtstring, ',');
}

inFilter()

bool SVF::LockResultValidator::inFilter ( const std::string &  name )

inlineprivate

Definition at line 48 of file LockResultValidator.h.

    {
        return filterFun.find(name) != filterFun.end();
    }

match()

bool SVF::LockResultValidator::match ( const std::string &  lockName, CxtLockSetStr  LS  )

inlineprivate

Definition at line 53 of file LockResultValidator.h.

    {
        return LS.find(lockName) != LS.end();
    }

split() [1/2]

Set< std::string > LockResultValidator::split ( const std::string &  s, char  delim  )

private

Definition at line 67 of file LockResultValidator.cpp.

{
    Set<std::string> elems;
    split(s, delim, elems);
    return elems;
}

split() [2/2]

Set< std::string > & LockResultValidator::split ( const std::string &  s, char  delim, Set< std::string > &  elems  )

private

Definition at line 56 of file LockResultValidator.cpp.

{
    std::stringstream ss(s);
    std::string item;
    while (std::getline(ss, item, delim))
    {
        elems.insert(item);
    }
    return elems;
}

validateStmtInLock()

LockResultValidator::LOCK_FLAG LockResultValidator::validateStmtInLock ( )

private

Definition at line 136 of file LockResultValidator.cpp.

{
    SVFIR* pag = SVFIR::getPAG();
    LockResultValidator::LOCK_FLAG res = LockResultValidator::LOCK_TRUE;
    LockAnalysis::CxtStmtToCxtLockSet analyedLS = _la->getCSTCLS();
    for(LockAnalysis::CxtStmtToCxtLockSet::iterator it = analyedLS.begin(),
            eit = analyedLS.end(); it!=eit; it++)
    {
        const SVFInstruction* inst = ((*it).first).getStmt();
        bool interestedInst = true;
        for(const SVFStmt* stmt : pag->getSVFStmtList(pag->getICFG()->getICFGNode(inst)))
        {
            if(!SVFUtil::isa<LoadStmt>(stmt) && !SVFUtil::isa<StoreStmt>(stmt))
                interestedInst = false;
        }
        if(interestedInst==false)
            continue;
        const SVFFunction* F = inst->getFunction();
        if(inFilter(F->getName()))
            continue;
        CxtLockSetStr LS = instToCxtLockSet[inst];
        if(LS.size() != (*it).second.size())
        {
            if (Options::PrintValidRes())
            {
                outs() << errMsg("\nValidate Stmt's Lock : Wrong at: ") << inst->toString() << "\n";
                outs() << "Reason: The number of lock on current stmt is wrong\n";
                outs() << "\n----Given locks:\n";
                for (CxtLockSetStr::iterator it1 = LS.begin(),eit1 = LS.end(); it1 != eit1; it++)
                {
                    outs() << "Lock  " << *it1 << " ";
                }
                outs() << "\n----Analysis locks:\n";
                for (LockAnalysis::CxtLockSet::iterator it2 = (*it).second.begin(),
                        eit2 = (*it).second.end(); it2 != eit2; ++it)
                {
                    const SVFInstruction* call = (*it2).getStmt();
                    outs()<<"Lock  " << call->toString() << " ";
                }
                outs() << "\n";
            }
            res = LockResultValidator::LOCK_UNSOUND;
        }
        LockAnalysis::CxtLockSet LSA = (*it).second;
 
        for(LockAnalysis::CxtLockSet::iterator it3 = LSA.begin(), eit3=LSA.end(); it3!=eit3; it3++)
        {
            const SVFInstruction* call = (*it3).getStmt();
            if(SVFUtil::isCallSite(call) == false)
                continue;
            std::string lockName = SVFUtil::getSVFCallSite(call).getArgOperand(0)->getName();
            if(!match(lockName, LS))
            {
                if(Options::PrintValidRes())
                {
                    outs() << "\nValidate Stmt's Lock : Wrong at (" << inst->toString() << ")\n";
                    outs() << "Reason: The number of lock on current stmt is wrong\n";
                    outs() << "\n Lock " << lockName << " should not protect current instruction\n";
                    res = LockResultValidator::LOCK_IMPRECISE;
                }
            }
        }
    }
    return res;
}

Member Data Documentation

_la

LockAnalysis* SVF::LockResultValidator::_la

private

Definition at line 72 of file LockResultValidator.h.

_mod

SVFModule* SVF::LockResultValidator::_mod

private

Definition at line 73 of file LockResultValidator.h.

cxtLockSet

LockAnalysis::CxtLockSet SVF::LockResultValidator::cxtLockSet

private

Definition at line 70 of file LockResultValidator.h.

cxtStmtToCxtLockSet

LockAnalysis::CxtStmtToCxtLockSet SVF::LockResultValidator::cxtStmtToCxtLockSet

private

Definition at line 69 of file LockResultValidator.h.

filterFun

Set<std::string> SVF::LockResultValidator::filterFun = {"LOCK", "INTERLEV_ACCESS", "PAUSE", "CXT_THREAD", "TCT_ACCESS"}

private

Definition at line 81 of file LockResultValidator.h.

instToCxtLockSet

CxtStmtToCxtLockS SVF::LockResultValidator::instToCxtLockSet

private

Definition at line 68 of file LockResultValidator.h.

LOCK

constexpr char const* SVF::LockResultValidator::LOCK = "LOCK"

staticconstexprprivate

Definition at line 79 of file LockResultValidator.h.

LOCK_IMPRECISE

const LOCK_FLAG SVF::LockResultValidator::LOCK_IMPRECISE = 0x02

staticprivate

Definition at line 76 of file LockResultValidator.h.

LOCK_TRUE

const LOCK_FLAG SVF::LockResultValidator::LOCK_TRUE = 0x01

staticprivate

Definition at line 75 of file LockResultValidator.h.

LOCK_UNSOUND

const LOCK_FLAG SVF::LockResultValidator::LOCK_UNSOUND = 0x04

staticprivate

Definition at line 77 of file LockResultValidator.h.

---

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

• /home/runner/work/SVF/SVF/svf-llvm/tools/MTA/LockResultValidator.h
• /home/runner/work/SVF/SVF/svf-llvm/tools/MTA/LockResultValidator.cpp