svf-tools 1.0.976 → 1.0.978

package/svf/lib/MTA/PCG.cpp

@@ -1,364 +0,0 @@
-//===- PCG.cpp -- Procedure creation graph-------------//
-//
-//                     SVF: Static Value-Flow Analysis
-//
-// Copyright (C) <2013->  <Yulei Sui>
-//
-
-// This program is free software: you can redistribute it and/or modify
-// it under the terms of the GNU Affero General Public License as published by
-// the Free Software Foundation, either version 3 of the License, or
-// (at your option) any later version.
-
-// This program is distributed in the hope that it will be useful,
-// but WITHOUT ANY WARRANTY; without even the implied warranty of
-// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-// GNU Affero General Public License for more details.
-
-// You should have received a copy of the GNU Affero General Public License
-// along with this program.  If not, see <http://www.gnu.org/licenses/>.
-//
-//===----------------------------------------------------------------------===//
-
-/*
- * PCG.cpp
- *
- *  Created on: Jun 24, 2015
- *      Author: Yulei Sui, Peng Di
- */
-
-#include "Util/CommandLine.h"
-#include "Util/Options.h"
-#include "MTA/PCG.h"
-#include "Util/SVFUtil.h"
-
-using namespace SVF;
-using namespace SVFUtil;
-
-//=====================================================//
-/*!
- * Whether two functions may happen in parallel
- */
-
-//static Option<bool> TDPrint(
-//    "print-td",
-//    true,
-//    "Print Thread Analysis Results"
-//);
-
-bool PCG::analyze()
-{
-
-    //callgraph = new CallGraph(mod);
-
-    DBOUT(DMTA, outs() << pasMsg("Starting MHP analysis\n"));
-
-    initFromThreadAPI(mod);
-
-    inferFromCallGraph();
-
-    //interferenceAnalysis();
-
-    //if (Options::TDPrint()) {
-    //printResults();
-    //tdAPI->performAPIStat(mod);
-    //}
-    return false;
-}
-
-bool PCG::mayHappenInParallelBetweenFunctions(const SVFFunction* fun1, const SVFFunction* fun2) const
-{
-    // if neither of functions are spawnees, then they won't happen in parallel
-    if (isSpawneeFun(fun1) == false && isSpawneeFun(fun2) == false)
-        return false;
-    // if there exit one of the function are not spawner, spawnee or follower, then they won't happen in parallel
-    if (isSpawnerFun(fun1) == false && isSpawneeFun(fun1) == false && isFollowerFun(fun1) == false)
-        return false;
-    if (isSpawnerFun(fun2) == false && isSpawneeFun(fun2) == false && isFollowerFun(fun2) == false)
-        return false;
-
-    return true;
-}
-
-bool PCG::mayHappenInParallel(const SVFInstruction* i1, const SVFInstruction* i2) const
-{
-    const SVFFunction* fun1 = i1->getFunction();
-    const SVFFunction* fun2 = i2->getFunction();
-    return mayHappenInParallelBetweenFunctions(fun1, fun2);
-}
-
-
-/*!
- * Initialize thread spawners and spawnees from threadAPI functions
- * a procedure is a spawner if it creates a thread and the created thread is still existent on its return
- * a procedure is a spawnee if it is created by fork call
- */
-void PCG::initFromThreadAPI(SVFModule* module)
-{
-    for (const SVFFunction* fun : module->getFunctionSet())
-    {
-        for (const SVFBasicBlock* svfbb : fun->getBasicBlockList())
-        {
-            for (const SVFInstruction* inst : svfbb->getInstructionList())
-            {
-                if (tdAPI->isTDFork(inst))
-                {
-                    const SVFValue* forkVal = tdAPI->getForkedFun(inst);
-                    if (const SVFFunction* svForkfun = SVFUtil::dyn_cast<SVFFunction>(forkVal))
-                    {
-                        addSpawnsite(inst);
-                        spawners.insert(fun);
-                        spawnees.insert(svForkfun);
-                    }
-                    /// TODO: handle indirect call here for the fork Fun
-                    else
-                    {
-                        writeWrnMsg("pthread create");
-                        outs() << inst->toString() << "\n";
-                        writeWrnMsg("invoke spawnee indirectly");
-                    }
-                }
-            }
-        }
-    }
-}
-
-/*!
- * 	Infer spawners and spawnees from call graph. The inference are recursively done
- * 	spawners: procedures may create a thread and return with the created thread still running
- * 	spawnees: procedures may be executed as a spawned thread
- * 	followers: procedures may be invoked by a thread after the thread returns from a spawner
- * 	(procedure may be called after pthread_creat is called).
- */
-void PCG::inferFromCallGraph()
-{
-
-    collectSpawners();
-
-    collectSpawnees();
-
-    collectFollowers();
-}
-
-/*!
- * spawner: given a spawner, all its callers on callgraph are spawners
- */
-void PCG::collectSpawners()
-{
-
-    /// find all the spawners recursively on call graph
-    FunWorkList worklist;
-    for (FunSet::iterator it = spawners.begin(), eit = spawners.end(); it != eit; ++it)
-    {
-        worklist.push(*it);
-    }
-    while (!worklist.empty())
-    {
-        const SVFFunction* svffun = worklist.pop();
-        CallGraphNode* funNode = callgraph->getCallGraphNode(svffun);
-        for (CallGraphNode::const_iterator it = funNode->InEdgeBegin(), eit = funNode->InEdgeEnd(); it != eit;
-                ++it)
-        {
-            CallGraphEdge* callEdge = (*it);
-            const SVFFunction* caller = callEdge->getSrcNode()->getFunction();
-            if (isSpawnerFun(caller) == false)
-            {
-                worklist.push(caller);
-                addSpawnerFun(caller);
-            }
-            /// add all the callsites from callers to callee (spawner) as a spawn site.
-            for (CallGraphEdge::CallInstSet::const_iterator dit = callEdge->directCallsBegin(), deit =
-                        callEdge->directCallsEnd(); dit != deit; ++dit)
-            {
-                addSpawnsite((*dit)->getCallSite());
-            }
-            for (CallGraphEdge::CallInstSet::const_iterator dit = callEdge->indirectCallsBegin(), deit =
-                        callEdge->indirectCallsEnd(); dit != deit; ++dit)
-            {
-                addSpawnsite((*dit)->getCallSite());
-            }
-        }
-    }
-}
-
-/*!
- * spawnee: given a spawnee, all its callees on callgraph are spawnees
- */
-void PCG::collectSpawnees()
-{
-
-    /// find all the spawnees recursively on call graph
-    FunWorkList worklist;
-    for (FunSet::iterator it = spawnees.begin(), eit = spawnees.end(); it != eit; ++it)
-    {
-        worklist.push(*it);
-    }
-    while (!worklist.empty())
-    {
-        const SVFFunction* svffun = worklist.pop();
-        CallGraphNode* funNode = callgraph->getCallGraphNode(svffun);
-        for (CallGraphNode::const_iterator it = funNode->OutEdgeBegin(), eit = funNode->OutEdgeEnd(); it != eit;
-                ++it)
-        {
-            const SVFFunction* caller = (*it)->getDstNode()->getFunction();
-            if (isSpawneeFun(caller) == false)
-            {
-                worklist.push(caller);
-                addSpawneeFun(caller);
-            }
-        }
-    }
-}
-
-/*!
- * Identify initial followers
- * a procedure whose callsite lies in a control flow path that starts just after a spawner's callsite
- */
-void PCG::identifyFollowers()
-{
-
-    for (CallInstSet::const_iterator sit = spawnSitesBegin(), esit = spawnSitesEnd(); sit != esit; ++sit)
-    {
-        const SVFInstruction* inst = *sit;
-        BBWorkList bb_worklist;
-        Set<const SVFBasicBlock*> visitedBBs;
-        bb_worklist.push(inst->getParent());
-        while (!bb_worklist.empty())
-        {
-            const SVFBasicBlock* bb = bb_worklist.pop();
-            for (SVFBasicBlock::const_iterator it = bb->begin(), eit = bb->end(); it != eit; ++it)
-            {
-                const SVFInstruction* inst = *it;
-                // mark the callee of this callsite as follower
-                // if this is an call/invoke instruction but not a spawn site
-                if ((SVFUtil::isCallSite(inst)) && !isSpawnsite(inst) && !SVFUtil::isIntrinsicInst(inst))
-                {
-                    CallICFGNode* cbn = getCallICFGNode(inst);
-                    if (callgraph->hasCallGraphEdge(cbn))
-                    {
-                        for (CallGraph::CallGraphEdgeSet::const_iterator cgIt = callgraph->getCallEdgeBegin(cbn),
-                                ecgIt = callgraph->getCallEdgeEnd(cbn); cgIt != ecgIt; ++cgIt)
-                        {
-                            const CallGraphEdge* edge = *cgIt;
-                            addFollowerFun(edge->getDstNode()->getFunction());
-                        }
-                    }
-                }
-            }
-            for (const SVFBasicBlock* svf_scc_bb : bb->getSuccessors())
-            {
-                if (visitedBBs.count(svf_scc_bb) == 0)
-                {
-                    visitedBBs.insert(svf_scc_bb);
-                    bb_worklist.push(svf_scc_bb);
-                }
-            }
-        }
-    }
-
-}
-
-/*!
- * collect follower procedures which may be called after pthread_create is invoked directly or indirectly
- * a procedure which is called from a follower is also a follower.
- */
-void PCG::collectFollowers()
-{
-
-    /// identify initial followers
-    identifyFollowers();
-
-    /// find all the followers recursively on call graph
-    FunWorkList worklist;
-    for (FunSet::iterator it = followers.begin(), eit = followers.end(); it != eit; ++it)
-    {
-        worklist.push(*it);
-    }
-    while (!worklist.empty())
-    {
-        const SVFFunction* svffun = worklist.pop();
-        CallGraphNode* funNode = callgraph->getCallGraphNode(svffun);
-        for (CallGraphNode::const_iterator it = funNode->OutEdgeBegin(), eit = funNode->OutEdgeEnd(); it != eit;
-                ++it)
-        {
-            const SVFFunction* caller = (*it)->getDstNode()->getFunction();
-            if (isFollowerFun(caller) == false)
-            {
-                worklist.push(caller);
-                addFollowerFun(caller);
-            }
-        }
-    }
-}
-
-/*!
- * Thread interference analysis,
- * Suppose we have a undirected graph G = {F,E,I}
- * F denotes procedure,
- * E represents interference edge (x,y) \in E, x \in F, y \in F
- * means execution of x in one thread may overlap execution of y in another thread
- * I(x,y) is a set of memory locations for this interference edge
- */
-void PCG::interferenceAnalysis()
-{
-
-//	DBOUT(DMTA, outs() << pasMsg("Starting Race Detection\n"));
-
-    PCG::FunVec worklist;
-    for (SVFModule::const_iterator F = mod->begin(), E = mod->end(); F != E; ++F)
-    {
-        const SVFFunction* fun = *F;
-        if (isExtCall(fun))
-            continue;
-        worklist.push_back(fun);
-    }
-
-    while (!worklist.empty())
-    {
-        const SVFFunction* fun1 = worklist.back();
-        worklist.pop_back();
-
-        bool ismhpfun = false;
-        for (PCG::FunVec::iterator it = worklist.begin(), eit = worklist.end(); it != eit; ++it)
-        {
-            const SVFFunction* fun2 = *it;
-            if (mayHappenInParallelBetweenFunctions(fun1, fun2))
-            {
-                ismhpfun = true;
-                mhpfuns.insert(fun2);
-            }
-        }
-        if (ismhpfun)
-        {
-            mhpfuns.insert(fun1);
-        }
-    }
-}
-
-/*!
- * Print analysis results
- */
-void PCG::printResults()
-{
-
-    printTDFuns();
-}
-
-/*!
- * Print Thread sensitive properties for each function
- */
-void PCG::printTDFuns()
-{
-
-    for (SVFModule::const_iterator fi = mod->begin(), efi = mod->end(); fi != efi; ++fi)
-    {
-        const SVFFunction* fun = (*fi);
-        if (fun->isDeclaration())
-            continue;
-
-        std::string isSpawner = isSpawnerFun(fun) ? " SPAWNER " : "";
-        std::string isSpawnee = isSpawneeFun(fun) ? " CHILDREN " : "";
-        std::string isFollower = isFollowerFun(fun) ? " FOLLOWER " : "";
-        outs() << fun->getName() << " [" << isSpawner << isSpawnee << isFollower << "]\n";
-    }
-}

package/svf-llvm/tools/MTA/LockResultValidator.cpp

@@ -1,251 +0,0 @@
-/*
- * LOCKResultValidator.cpp
- *
- *  Created on: 24/07/2021
- */
-
-#include "Util/Options.h"
-#include <string>
-#include <sstream>
-#include "LockResultValidator.h"
-#include "MTAResultValidator.h"
-#include "SVF-LLVM/LLVMModule.h"
-
-using namespace SVF;
-using namespace SVFUtil;
-
-namespace SVF
-{
-
-// Subclassing RCResultValidator to define the abstract methods.
-class RaceValidator : public RaceResultValidator
-{
-public:
-    RaceValidator(LockAnalysis* lockAnalysis) :lsa(lockAnalysis)
-    {
-    }
-    bool protectedByCommonLocks(const Instruction* I1, const Instruction* I2)
-    {
-        const SVFInstruction* inst1 = LLVMModuleSet::getLLVMModuleSet()->getSVFInstruction(I1);
-        const SVFInstruction* inst2 = LLVMModuleSet::getLLVMModuleSet()->getSVFInstruction(I2);
-        return lsa->isProtectedByCommonLock(inst1, inst2);
-    }
-private:
-    LockAnalysis *lsa;
-};
-
-} // End namespace SVF
-
-Set<std::string> LockResultValidator::getStringArg(const Instruction* inst, unsigned int arg_num)
-{
-    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, ',');
-}
-
-Set<std::string> &LockResultValidator::split(const std::string &s, char delim, Set<std::string> &elems)
-{
-    std::stringstream ss(s);
-    std::string item;
-    while (std::getline(ss, item, delim))
-    {
-        elems.insert(item);
-    }
-    return elems;
-}
-
-Set<std::string> LockResultValidator::split(const std::string &s, char delim)
-{
-    Set<std::string> elems;
-    split(s, delim, elems);
-    return elems;
-}
-
-inline std::string LockResultValidator::getOutput(const char *scenario, LOCK_FLAG analysisRes)
-{
-    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;
-}
-
-bool LockResultValidator::collectLockTargets()
-{
-    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;
-}
-
-LockResultValidator::LOCK_FLAG LockResultValidator::validateStmtInLock()
-{
-    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;
-}
-
-void LockResultValidator::analyze()
-{
-    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();
-}
-
-const Instruction* LockResultValidator::getPreviousMemoryAccessInst( const Instruction* I)
-{
-    I = I->getPrevNode();
-    while (I)
-    {
-        if (SVFUtil::isa<LoadInst>(I) || SVFUtil::isa<StoreInst>(I))
-            return I;
-        SVFFunction* callee = nullptr;
-
-        if(LLVMUtil::isCallSite(I))
-        {
-            CallGraph::FunctionSet callees;
-            const SVFInstruction* svfInst = LLVMModuleSet::getLLVMModuleSet()->getSVFInstruction(I);
-            _la->getTCT()->getThreadCallGraph()->getCallees(getCBN(svfInst), callees);
-
-            for(CallGraph::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;
-}

package/svf-llvm/tools/MTA/LockResultValidator.h

@@ -1,84 +0,0 @@
-/*
- * LOCKResultValidator.h
- *
- *  Created on: 24/07/2021
- */
-
-
-
-#ifndef LOCKRESULTVALIDATOR_H_
-#define LOCKRESULTVALIDATOR_H_
-
-#include "MTA/LockAnalysis.h"
-#include "SVF-LLVM/LLVMUtil.h"
-
-/* Validate the result of lock analysis */
-
-namespace SVF
-{
-class LockResultValidator
-{
-public:
-    typedef Set<std::string> CxtLockSetStr;
-    typedef Map<const SVFInstruction*, CxtLockSetStr> CxtStmtToCxtLockS;
-
-    typedef unsigned LOCK_FLAG;
-
-    LockResultValidator(LockAnalysis* la) : _la(la)
-    {
-        _mod = _la->getTCT()->getSVFModule();
-    }
-
-    ~LockResultValidator() {}
-
-    void analyze();
-
-    inline SVFModule* getModule() const
-    {
-        return _mod;
-    }
-private:
-    // Get CallICFGNode
-    inline CallICFGNode* getCBN(const SVFInstruction* inst)
-    {
-        return _la->getTCT()->getCallICFGNode(inst);
-    }
-    const Instruction* getPreviousMemoryAccessInst( const Instruction* I);
-
-    inline bool inFilter(const std::string& name)
-    {
-        return filterFun.find(name) != filterFun.end();
-    }
-
-    inline bool match(const std::string& lockName, CxtLockSetStr LS)
-    {
-        return LS.find(lockName) != LS.end();
-    }
-
-    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();
-
-    CxtStmtToCxtLockS instToCxtLockSet;
-    LockAnalysis::CxtStmtToCxtLockSet cxtStmtToCxtLockSet;
-    LockAnalysis::CxtLockSet cxtLockSet;
-
-    LockAnalysis* _la;
-    SVFModule* _mod;
-
-    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";
-
-    Set<std::string> filterFun = {"LOCK", "INTERLEV_ACCESS", "PAUSE", "CXT_THREAD", "TCT_ACCESS"};
-};
-}	// End namespace SVF
-#endif /* LOCKRESULTVALIDATOR_H_ */